chapter 4 code

ch4/Makefile

@@ -0,0 +1,22 @@
+CPP = g++
+CPPFLAGS = -g -std=c++0x
+OFLAG = -o
+.SUFFIXES : .o .cpp .c
+.cpp.o :
+	$(CPP) $(CPPFLAGS) -c $<
+.c.o :
+	$(CPP) $(CPPFLAGS) -c $<
+
+PROGS = queue quicksort
+
+all: $(PROGS)
+
+queue: queue.o 
+	$(CPP) $(OFLAG) queue queue.o -lpthread
+
+quicksort: quicksort.o 
+	$(CPP) $(OFLAG) quicksort quicksort.o -lpthread
+
+clean:
+	rm -f ${PROGS} *.o
+

ch4/queue.cpp

@@ -0,0 +1,104 @@
+#include <iostream>
+#include <cstdio>
+#include <queue>
+#include <thread>
+#include <memory>
+#include <mutex>
+#include <condition_variable>
+
+template <typename T>
+class queue
+{
+  private:
+    mutable std::mutex mut;
+    std::queue<T> data_queue;
+    std::condition_variable data_cond;
+
+  public:
+    queue(){}
+
+    queue(const queue& other)
+    {
+        std::lock_guard<std::mutex> lk(other.mut);
+        data_queue = other.data_queue;
+    }
+
+    void push(T new_value)
+    {
+        std::lock_guard<std::mutex> lk(mut);
+        data_queue.push(new_value);
+        data_cond.notify_one();
+    }
+
+    void wait_and_pop(T& value)
+    {
+        std::unique_lock<std::mutex> lk(mut);
+        data_cond.wait(lk, [this]{return !data_queue.empty();});
+        value = data_queue.front();
+        data_queue.pop();
+    }
+
+    std::shared_ptr<T> wait_and_pop()
+    {
+        std::unique_lock<std::mutex> lk(mut);
+        data_cond.wait(lk, [this]{return !data_queue.empty();});
+        std::shared_ptr<T> res(std::make_shared<T>(data_queue.front()));
+        data_queue.pop();
+        return res;
+    }
+
+    bool try_pop(T& value)
+    {
+        std::lock_guard<std::mutex> lk(mut);
+        if (data_queue.empty()) { 
+            return false;
+        }
+        value = data_queue.front();
+        data_queue.pop();
+        return true;
+    }
+
+    std::shared_ptr<T> try_pop()
+    {
+        std::lock_guard<std::mutex> lk(mut);
+        if (data_queue.empty()) {
+            return std::shared_ptr<T>();
+        }
+        std::shared_ptr<T> res(std::make_shared<T>(data_queue.front()));
+        data_queue.pop();
+        return res;
+    }
+
+    bool empty() const
+    {
+        std::lock_guard<std::mutex> lk(mut);
+        return data_queue.empty();
+    }
+};
+
+void push(queue<int>* q)
+{
+    for (int i = 0; i < 10; ++i) {
+        //std::cout << "pushing " << i << std::endl;
+        printf("pushing %d\n", i);
+        q->push(i);
+    }
+}
+
+void pop(queue<int>* q)
+{
+    for (int i = 0; i < 10; ++i) {
+        printf("poping %d\n", *q->wait_and_pop());
+    }
+}
+    
+int main()
+{
+    queue<int> q;
+    std::thread t1(push,&q);
+    std::thread t2(pop,&q);
+    t1.join();
+    t2.join();
+    return 0;
+}
+

ch4/quicksort.cpp

@@ -0,0 +1,74 @@
+#include <iostream>
+#include <cstdio>
+#include <list>
+#include <thread>
+#include <memory>
+#include <algorithm>
+#include <future>
+
+std::ostream& operator<<(std::ostream& ostr, const std::list<int>& list)
+{
+    for (auto &i : list) {
+        ostr << " " << i;
+    }
+    return ostr;
+}
+
+template<typename T>
+std::list<T> sequential_quick_sort(std::list<T> input)
+{
+    if(input.empty())
+    {
+        return input;
+    }
+    std::list<T> result;
+    result.splice(result.begin(),input,input.begin());
+    T const& pivot=*result.begin();
+    auto divide_point=std::partition(input.begin(),input.end(),
+        [&](T const& t){return t<pivot;});
+    std::list<T> lower_part;
+    lower_part.splice(lower_part.end(),input,input.begin(),
+        divide_point);
+    auto new_lower(
+        sequential_quick_sort(std::move(lower_part)));
+    auto new_higher(
+        sequential_quick_sort(std::move(input)));
+    result.splice(result.end(),new_higher);
+    result.splice(result.begin(),new_lower);
+    return result;
+}
+
+template<typename T>
+std::list<T> parallel_quick_sort(std::list<T> input)
+{
+    if(input.empty())
+    {
+        return input;
+    }
+    std::list<T> result;
+    result.splice(result.begin(),input,input.begin());
+    T const& pivot=*result.begin();
+    auto divide_point=std::partition(input.begin(),input.end(),
+        [&](T const& t){return t<pivot;});
+    std::list<T> lower_part;
+    lower_part.splice(lower_part.end(),input,input.begin(),
+        divide_point);
+    std::future<std::list<T> > new_lower(
+        std::async(&parallel_quick_sort<T>,std::move(lower_part)));
+    auto new_higher(
+        parallel_quick_sort(std::move(input)));
+    result.splice(result.end(),new_higher);
+    result.splice(result.begin(),new_lower.get());
+    return result;
+}
+
+int main()
+{
+    std::list<int> list1 = {4, 2, 1, 5, 8, 9, 7};
+    std::list<int> sorted1 = sequential_quick_sort(list1);
+    std::list<int> sorted2 = parallel_quick_sort(list1);
+    std::cout << "sorted1: " << sorted1 << std::endl;
+    std::cout << "sorted2: " << sorted2 << std::endl;
+    return 0;
+}
+