updated unittest

twhuang-utah · twhuang-utah · commit dea5a35bc6e5 · 2019-08-03T23:31:43.000-06:00
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -261,6 +261,7 @@ add_test(builder          ${TF_UTEST_DIR}/taskflow -tc=Builder)
 add_test(creation         ${TF_UTEST_DIR}/taskflow -tc=Creation)
 add_test(dispatch         ${TF_UTEST_DIR}/taskflow -tc=Dispatch)
 add_test(multiple_runs    ${TF_UTEST_DIR}/taskflow -tc=MultipleRuns)
+add_test(parallel_runs    ${TF_UTEST_DIR}/taskflow -tc=ParallelRuns)
 add_test(parallel_for     ${TF_UTEST_DIR}/taskflow -tc=ParallelFor)
 add_test(parallel_for_idx ${TF_UTEST_DIR}/taskflow -tc=ParallelForOnIndex)
 add_test(reduce           ${TF_UTEST_DIR}/taskflow -tc=Reduce)
diff --git a/README.md b/README.md
@@ -216,6 +216,7 @@ The executor provides a rich set of methods to run a taskflow.
 You can run a taskflow one or multiple times, or until a stopping criteria is met.
 These methods are non-blocking and all return a [std::future][std::future] 
 to let you query the execution status.
+All methods are *thread-safe*.
 
 ```cpp 
 executor.run(taskflow);                                              // run the taskflow once
@@ -527,7 +528,7 @@ tf::Task B = taskflow.emplace([] (tf::Subflow& subflow) {
 
 A.precede(B);
 
-executor.run(tf).get();  // run the taskflow
+executor.run(tf).wait();  // run the taskflow
 tf.dump(std::cout);      // dump the graph including dynamic tasks
 ```
 
diff --git a/doxygen/releases/master-branch.dox b/doxygen/releases/master-branch.dox
@@ -19,6 +19,7 @@ To download the newest version of Cpp-Taskflow, please clone from <a href="https
 @li Discovering a scalable memory allocator to handle the taskflow graph
 @li Adding more benchmarks to compare Cpp-Taskflow with OpenMP and TBB
 @li Improving the partition policy of parallel_for
+@li Making executor thread-safe
 
 @section master-branch_bug_fixes Bug Fixes 
 
diff --git a/taskflow/core/executor.hpp b/taskflow/core/executor.hpp
@@ -1,3 +1,6 @@
+// 2019/08/03 - modified by Tsung-Wei Huang
+//  - made executor thread-safe
+//
 // 2019/07/26 - modified by Chun-Xun Lin
 //  - Combine explore_task & wait_for_task
 //  - Remove CAS operations 
diff --git a/unittest/taskflow.cpp b/unittest/taskflow.cpp
@@ -420,39 +420,67 @@ TEST_CASE("MultipleRuns" * doctest::timeout(300)) {
 // Testcase: ParallelRuns
 // --------------------------------------------------------
 TEST_CASE("ParallelRuns" * doctest::timeout(300)) {
- 
-  for(size_t w=0; w<=32; ++w) {
-
-    tf::Executor executor(w);
   
-    std::atomic<int> counter = 0;
+  std::atomic<int> counter;
+  std::vector<std::thread> threads;
 
-    auto make_taskflow = [&] (tf::Taskflow& tf) {
-      for(int i=0; i<1024; i++) {
-        auto A = tf.emplace([&] () { 
-          counter.fetch_add(1, std::memory_order_relaxed); 
-        });
-        auto B = tf.emplace([&] () {
-          counter.fetch_add(1, std::memory_order_relaxed); 
-        });
-        A.precede(B);
-      }
-    };
-    
-    std::vector<std::thread> threads;
-    for(int t=1; t<=32; t++) {
-      threads.emplace_back([&] () {
-        tf::Taskflow taskflow;
-        make_taskflow(taskflow);
-        executor.run(taskflow).wait();
+  auto make_taskflow = [&] (tf::Taskflow& tf) {
+    for(int i=0; i<1024; i++) {
+      auto A = tf.emplace([&] () { 
+        counter.fetch_add(1, std::memory_order_relaxed); 
       });
+      auto B = tf.emplace([&] () {
+        counter.fetch_add(1, std::memory_order_relaxed); 
+      });
+      A.precede(B);
     }
+  };
 
-    for(auto& t : threads) {
-      t.join();
-    }
+  SUBCASE("RunAndWait") {
+    for(size_t w=0; w<=32; ++w) {
+      tf::Executor executor(w);
+      counter = 0;
+      for(int t=0; t<32; t++) {
+        threads.emplace_back([&] () {
+          tf::Taskflow taskflow;
+          make_taskflow(taskflow);
+          executor.run(taskflow).wait();
+        });
+      }
 
-    REQUIRE(counter.load() == 32*1024*2);
+      for(auto& t : threads) {
+        t.join();
+      }
+      threads.clear();
+
+      REQUIRE(counter.load() == 32*1024*2);
+    }
+  }
+  
+  SUBCASE("RunAndWaitForAll") { 
+    for(size_t w=0; w<=32; ++w) {
+      tf::Executor executor(w);
+      counter = 0;
+      std::vector<std::unique_ptr<tf::Taskflow>> taskflows(32);
+      std::atomic<size_t> barrier(0);
+      for(int t=0; t<32; t++) {
+        threads.emplace_back([&, t=t] () {
+          taskflows[t] = std::make_unique<tf::Taskflow>();
+          make_taskflow(*taskflows[t]);
+          executor.run(*taskflows[t]);
+          ++barrier;    // make sure all runs are issued
+        });
+      }
+      
+      while(barrier != 32);
+      executor.wait_for_all();
+      REQUIRE(counter.load() == 32*1024*2);
+      
+      for(auto& t : threads) {
+        t.join();
+      }
+      threads.clear();
+    }
   }
 
 }
