merge with chun-xun

tsung-wei-huang · tsung-wei-huang · commit c061dec617d5 · 2018-08-27T17:05:46.000-05:00
diff --git a/README.md b/README.md
@@ -154,7 +154,8 @@ tf.linearize(A, B, C, D);  // A runs before B, B runs before C, and C runs befor
 
 ## Step 3: Execute the Tasks
 
-There are three methods to carry out a task dependency graph, `dispatch`, `silent_dispatch`, and `wait_for_all`.
+There are three methods to carry out a task dependency graph, 
+`dispatch`, `silent_dispatch`, and `wait_for_all`.
 
 ```cpp
 auto future = tf.dispatch();  // non-blocking, returns with a future immediately.
@@ -572,7 +573,7 @@ auto [S, T] = tf.transform_reduce(v.begin(), v.end(), min,
 
 By default, all reduce methods distribute the workload evenly across threads.
 
-### *dispatch/silent_dispatch/wait_for_all*
+### *dispatch/silent_dispatch/wait_for_topologies/wait_for_all*
 Dispatching a taskflow graph will schedule threads to execute the current graph and return immediately.
 The method `dispatch` gives you a future object to probe the execution progress while
 `silent_dispatch` doesn't.
@@ -586,13 +587,22 @@ future.get();
 std::cout << "all tasks complete" << '\n';
 ```
 
-If you need to block your program flow until all tasks finish, use `wait_for_all` instead.
+If you need to block your program flow until all tasks finish 
+(including the present taskflow graph), use `wait_for_all` instead.
 
 ```cpp
 tf.wait_for_all();
 std::cout << "all tasks complete" << '\n';
 ```
 
+If you only need to block your program flow until all dispatched taskflow graphs finish,
+use `wait_for_topologies`.
+
+```cpp
+tf.wait_for_topologies();
+std::cout << "all topologies complete" << '\n';
+```
+
 ## Task API
 
 Each `tf::Taskflow::Task` object is a lightweight handle for you to create dependencies in its associated graph. 
diff --git a/doc/faq.md b/doc/faq.md
@@ -5,13 +5,13 @@ If you cannot find a solution here, please post an issue [here][Github issues].
 
 ## General Questions
 
-### Q: How many tasks can Cpp-Taskflow handle?
+#### Q: How many tasks can Cpp-Taskflow handle?
 
 **A:** Cpp-Taskflow is a very lightweight and efficient tasking library.
 It has been applied in many academic and industry projects to scale up their existing workload.
 A research project [OpenTimer][OpenTimer] has used Cpp-Taskflow to deal with hundreds of millions of tasks.
 
-### Q: What are the differences between Cpp-Taskflow and other tasking libraries?
+#### Q: What are the differences between Cpp-Taskflow and other tasking libraries?
 
 **A:** From our humble opinion, Cpp-Taskflow is superior in its tasking API, interface, and performance.
 In most cases, users can quickly master Cpp-Taskflow to create large and complex dependency graphs
@@ -21,12 +21,12 @@ Of course, the judge is always left for users -:)
 
 ## Compile Issues
 
-### Q: I can't get Cpp-Taskflow compiled in my project!
+#### Q: I can't get Cpp-Taskflow compiled in my project!
 
 **A:** Please make sure your compile supports the latest version of C++17. 
 Make sure your project meets the System Requirements described at [README][README].
 
-### Q: Clang can't compile due to the use of std::variant.
+#### Q: Clang can't compile due to the use of std::variant.
 
 **A:** Cpp-Taskflow uses `std::variant` to enable uniform interface between static and dynamic tasking.
 However it has been reported in 
@@ -47,7 +47,7 @@ For clang users, you will need to use this patch in `taskflow.hpp` as follows:
 
 ## Programming Questions
 
-### Q: What is the difference between Cpp-Taskflow threads and workers?
+#### Q: What is the difference between Cpp-Taskflow threads and workers?
 
 **A:** The master thread owns the thread pool and can spawn workers to run tasks 
 or shutdown the pool. 
@@ -60,7 +60,11 @@ tf::Taskflow(N);    // N workers, N+1 threads in the program.
 
 If there is no worker threads in the pool, the master thread will do all the works by itself.
 
-### Q: My program hangs and never returns after dispatching a taskflow graph.
+#### Q: Is taskflow thread-safe?
+**A:** No, the taskflow object is not thread-safe. You can't create tasks from multiple threads
+at the same time.
+
+#### Q: My program hangs and never returns after dispatching a taskflow graph. What's wrong?
 
 **A:** When the program hangs forever it is very likely your taskflow graph has a cycle.
 Try the `dump` method to debug the graph before dispatching your taskflow graph.
diff --git a/taskflow/taskflow.hpp b/taskflow/taskflow.hpp
@@ -979,16 +979,20 @@ auto BasicFlowBuilder<NodeType>::emplace(C&& c) {
     auto fu = p.get_future();
 
     if constexpr(std::is_same_v<void, R>) {
-      auto& node = _nodes.emplace_front([p = MoC(std::move(p)), c = std::forward<C>(c)]() mutable {
-        c(); 
-        p.get().set_value();
-      });
+      auto& node = _nodes.emplace_front(
+        [p=MoC(std::move(p)), c=std::forward<C>(c)]() mutable {
+          c(); 
+          p.get().set_value();
+        }
+      );
       return std::make_pair(TaskType(node), std::move(fu));
     }
     else {
-      auto& node = _nodes.emplace_front([p = MoC(std::move(p)), c = std::forward<C>(c)]() mutable {
-        p.get().set_value(c());
-      });
+      auto& node = _nodes.emplace_front(
+        [p=MoC(std::move(p)), c=std::forward<C>(c)]() mutable {
+          p.get().set_value(c());
+        }
+      );
       return std::make_pair(TaskType(node), std::move(fu));
     }
   }
diff --git a/unittest/taskflow.cpp b/unittest/taskflow.cpp
@@ -13,8 +13,8 @@
 // --------------------------------------------------------
 TEST_CASE("Taskflow.Builder" * doctest::timeout(5)){
 
-  constexpr auto num_workers = 4;
-  constexpr auto num_tasks = 100;
+  auto num_workers = 4;
+  auto num_tasks = 100;
 
   tf::Taskflow tf(num_workers);
   REQUIRE(tf.num_workers() == num_workers);
@@ -181,8 +181,8 @@ TEST_CASE("Taskflow.Dispatch" * doctest::timeout(5)) {
     
   using namespace std::chrono_literals;
   
-  constexpr auto num_workers = 4;
-  constexpr auto num_tasks = 100;
+  auto num_workers = 4;
+  auto num_tasks = 100;
   
   tf::Taskflow tf(num_workers);
   REQUIRE(tf.num_workers() == num_workers);
