Merge branch 'dev' of https://github.com/cpp-taskflow/cpp-taskflow into dev

tsung-wei-huang · tsung-wei-huang · commit 481a00b4ea68 · 2019-08-04T14:35:54.000-06:00
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -260,7 +260,8 @@ set_target_properties(taskflow_test_tmp PROPERTIES OUTPUT_NAME "taskflow")
 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(sequential_runs  ${TF_UTEST_DIR}/taskflow -tc=SequentialRuns)
+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/cookbook/Chapter2.dox b/doxygen/cookbook/Chapter2.dox
@@ -31,8 +31,8 @@ tf::Executor executor2(4);  // create an executor of 4 worker threads
 @endcode
 
 An executor can be reused to execute multiple taskflows.
-In most workloads, you may need only one executor but multiple taskflows
-to represent parts of a parallel decomposition.
+In most workloads, you may need only one executor to run multiple taskflows
+where each taskflow represents a part of a parallel decomposition.
 
 @section C2_ExecuteATaskflow Execute a Taskflow
 
@@ -78,7 +78,7 @@ Debrief:
 @li Line 20    keeps running the taskflow until the predicate returns true
 
 Issuing multiple runs on the same taskflow will automatically @em synchronize
-to a sequential chain of executions following the order of the run calls.
+to a sequential chain of executions in the order of run calls.
 
 @code{.cpp}
 executor.run(taskflow);         // execution 1
diff --git a/example/observer.cpp b/example/observer.cpp
@@ -4,7 +4,7 @@
 
 int main(){
   
-  tf::Executor executor(0);
+  tf::Executor executor;
   
   // Create a taskflow of eight tasks
   tf::Taskflow taskflow;
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 
@@ -999,8 +1002,10 @@ std::future<void> Executor::run_until(Taskflow& f, P&& pred, C&& c) {
 
   // Special case of predicate
   if(std::invoke(pred)) {
+    std::promise<void> promise;
+    promise.set_value();
     _decrement_topology_and_notify();
-    return std::async(std::launch::deferred, [](){});
+    return promise.get_future();
   }
   
   // Special case of zero workers requires:
@@ -1028,10 +1033,12 @@ std::future<void> Executor::run_until(Taskflow& f, P&& pred, C&& c) {
     if(tpg._call != nullptr) {
       std::invoke(tpg._call);
     }
+
+    tpg._promise.set_value();
     
     _decrement_topology_and_notify();
     
-    return std::async(std::launch::deferred, [](){});
+    return tpg._promise.get_future();
   }
   
   // Multi-threaded execution.
diff --git a/unittest/taskflow.cpp b/unittest/taskflow.cpp
