2018_03_16

Author: wintel2014

C++/Boost/Coroutine.tar

@@ -1,7 +1,7 @@
 LIB_DIR=/home/jz/boost_install_dir/lib/
 INCLUDE=-I/home/jz/boost_install_dir/include/
 
-all:same_fringe fibonacci callcc task
+all:same_fringe fibonacci callcc task_object
 
 same_fringe: same_fringe.cpp
 	g++ $^ -std=c++14 $(INCLUDE) /home/jz/boost_install_dir/lib/libboost_context.a    /home/jz/boost_install_dir/lib/libboost_thread.a -g3 -o $@
@@ -14,5 +14,8 @@ fibonacci: fibonacci.cpp
 callcc:callcc.cpp	
 	g++ $^ -std=c++14 $(INCLUDE) /home/jz/boost_install_dir/lib/libboost_context.a    /home/jz/boost_install_dir/lib/libboost_thread.a -g3 -o $@
 
-task:task.cpp
-	g++ $^ -std=c++14 $(INCLUDE) /home/jz/boost_install_dir/lib/libboost_context.a    /home/jz/boost_install_dir/lib/libboost_thread.a -g3 -o $@
+task_object:task_object.cpp
+	g++ $^ -std=c++14 $(INCLUDE) /home/jz/boost_install_dir/lib/libboost_context.a    /home/jz/boost_install_dir/lib/libboost_thread.a -g3 -o $@ -lpthread
+
+clean:
+	find . -name  '*' -executable | egrep -v '\.$$' |xargs rm

C++/Boost/Coroutine/Makefile

@@ -19,7 +19,7 @@ int main() {
         [&a](ctx::continuation && sink){
             a=0;
             long int b=1;
-            std::cout<<"main<lambda>\n";
+            std::cout<<"main::<lambda>\n";
             for(;;){
                 sink=sink.resume();
                 std::cout <<"callcc: "<< a << "\n";

C++/Boost/Coroutine/callcc

@@ -0,0 +1 @@
+task_object_multi_thread.cpp

C++/Boost/Coroutine/callcc.cpp

@@ -0,0 +1,102 @@
+#include <cstdlib>
+#include <iostream>
+#include <string>
+#include <boost/coroutine2/all.hpp>
+
+template <typename T>
+using coroutine = boost::coroutines2::coroutine<T>;
+namespace ctx=boost::context;
+
+class Task {
+public:
+    Task(std::string);
+    ~Task() {mRun=false;}
+    void Process()
+    {
+        std::cout<<"Task::Process\n";
+    }
+
+    void Suspend()
+    {
+        if(mFromContext)
+            mFromContext = mFromContext.resume();
+    }
+    void Resume()
+    {
+        if(mTaskContext)
+            mTaskContext = mTaskContext.resume(); 
+    }
+
+    void Stop()
+    {
+        mRun = false;
+    }
+private:
+    bool mRun;
+    std::string mName;
+    boost::context::continuation mTaskContext;
+    boost::context::continuation mFromContext;
+
+};
+
+
+Task::Task(std::string name):
+    mRun(true),
+    mName(name),
+    mTaskContext( 
+        ctx::callcc(  [this](ctx::continuation && from)->ctx::continuation &&
+             {
+                mFromContext = from.resume();
+                while(mRun)
+                {
+                    std::cout<<"Enter Task-"<<mName<<std::endl;
+                    this->Process();
+                    sleep(1);
+                    std::cout<<"Exit Task-"<<mName<<std::endl;
+                    //mFromContext = mFromContext.resume();
+                }
+
+                std::cout<<"Exit Task-"<<mName<<std::endl;
+                return std::move(mFromContext);
+            }
+        )
+    )
+{
+}
+
+
+int main()
+{
+    Task T1("1");
+    Task T2("2");
+    Task T3("3");
+    Task T4("4");
+    Task T5("5");
+    
+    size_t loop = 0;
+    while(loop++ < 20)
+    {
+        std::cout<<"=================Main::Loop"<<loop<<"================="<<std::endl;
+        T1.Resume();
+/*
+        T2.Resume();
+    
+        if(loop == 5)
+        {
+            std::cout<<"T1 stop\n";
+            T1.Stop();
+        }
+        T3.Resume();
+        if(loop == 10)
+        {
+            std::cout<<"T2 stop\n";
+            T2.Stop();
+            T4.Resume();
+            T5.Resume();
+        }
+*/
+
+    }
+}
+
+

C++/Boost/Coroutine/fibonacci

@@ -36,19 +36,19 @@ class Task {
     }
     void Construct(DEventNode *pNode)
     {
-        mTaskContext =  ctx::callcc(  [this, pNode](ctx::continuation && from)->ctx::continuation &&
+        mTaskContext =  ctx::callcc(  [this, pNode](ctx::continuation && from)
                  {
                     mFromContext = from.resume();
                     while(mRun)
                     {
                         std::cout<<"Enter Task-"<<mName<<std::endl;
                         pNode->Process();
-                        std::cout<<"Exit Task-"<<mName<<std::endl;
                         sleep(1);
+                        std::cout<<"Exit Task-"<<mName<<std::endl;
                         BackToMainContext();
                     }
 
-                    std::cout<<"Exit Task-"<<mName<<std::endl;
+                    std::cout<<"!!!!!!!!!!!Task-"<<mName<<std::endl;
                     return std::move(mFromContext);
                 }
             );
@@ -59,7 +59,7 @@ class Task {
         if(mFromContext)
             mFromContext = mFromContext.resume();
         else
-            std::cout<<"FromContext is null!!!!!!\n";
+            std::cout<<"MainContext is null!!!!!!\n";
     }
     void Resume()
     {
@@ -105,14 +105,27 @@ int main()
     Task* pT3 = &v[2];
 
     pT1->Construct(&Node);
+
+    std::thread T1(
+        [pT1]()
+        {pT1->BackToMainContext();}
+    );
 
 
     size_t loop = 0;
     while(loop++ < 10)
     {
-        std::cout<<"Thread-"<<gettid()<<"=================1 Main::Loop"<<loop<<"================="<<std::endl;
+        if(loop == 9)
+        {
+            pT1->Stop();
+            std::cout<<"Stop T1\n";
+        }
+
+        std::cout<<"Thread-"<<gettid()<<"=================A Main::Loop"<<loop<<"================="<<std::endl;
         pT1->Resume();
-        std::cout<<"Thread-"<<gettid()<<"=================2 Main::Loop"<<loop<<"================="<<"\n\n";
+        std::cout<<"Thread-"<<gettid()<<"=================B Main::Loop"<<loop<<"================="<<"\n\n";
     }
+
+    T1.join();
 }
 

C++/Boost/Coroutine/same_fringe

@@ -0,0 +1,3 @@
+spsc_consume_all:spsc_consume_all.cpp
+	g++ $^ -std=c++14 -g3 -lpthread -lboost_system -lboost_thread -o $@
+

C++/Boost/Coroutine/task_object

@@ -0,0 +1,71 @@
+#include <iostream>  
+#include <time.h>    
+#include <thread>  
+#include <list>   
+  
+#include <boost/lockfree/spsc_queue.hpp>    
+#include <boost/thread/mutex.hpp>  
+#include <boost/thread/condition_variable.hpp>  
+#include <boost/circular_buffer.hpp>  
+  
+  
+  
+#define LOOP_COUNT 10000000  
+#define QUEUE_CAPACITY 10000000  
+  
+  
+boost::lockfree::spsc_queue<int, boost::lockfree::capacity<QUEUE_CAPACITY>> spscq;  
+  
+int count = 0;  
+  
+void nonblocking_productor()  
+{  
+    for (int i = 0; i < LOOP_COUNT; i++)  
+    {  
+        spscq.push(i);  
+    }  
+}  
+  
+void nonblocking_customer()  
+{  
+    int value = 0;
+    while (1)  
+    {  
+        if (spscq.pop(value))  
+        {  
+            ++count;  
+        }  
+        else  
+        {  
+            sleep(1);  
+        }  
+  
+        if (count >= LOOP_COUNT)  
+        {  
+            break;  
+        }  
+    }  
+}  
+  
+  
+void test_nonblocking()  
+{  
+    clock_t start = clock();  
+  
+    std::thread *nc_t = new std::thread((&nonblocking_customer));  
+    std::thread *np_t = new std::thread((&nonblocking_productor));  
+    nc_t->join();  
+    np_t->join();  
+  
+    clock_t end = clock();  
+    printf("[test_nonblocking]\nQUEUE_CAPACITY:%d\ncost:%dms\n", QUEUE_CAPACITY, end - start);  
+    printf("count:%d\n", count);  
+  
+    delete nc_t;  
+    delete np_t;  
+}  
+  
+int main()  
+{  
+    test_nonblocking();  
+}