Refactor Framework

clin99 · clin99 · commit c087f1e60042 · 2019-01-18T18:09:55.000-06:00
diff --git a/taskflow/graph/basic_taskflow.hpp b/taskflow/graph/basic_taskflow.hpp
@@ -393,11 +393,15 @@ std::shared_future<void> BasicTaskflow<E>::run_n(Framework& f, size_t repeat, C&
 		for(auto& n: f._graph) {
 
       // TODO: swap this with the last and then pop_back
-      // Here we use "front" because users may add nodes to the graph
-      if(!n._successors.empty() && n._successors.front() == f._last_target) {
-        n._successors.erase(n._successors.begin());
+      if(!n._successors.empty()) {
+        for(size_t i=0; i<n._successors.size(); i++) {
+          if(n._successors[i] == f._last_target) {
+            std::swap(n._successors[i], n._successors.back());
+            n._successors.pop_back();
+            break;
+          }
+        }
       }
-      // remove_if std::vector
 
       // reset the dynamic tasking
       if(n._subgraph.has_value()) {
diff --git a/taskflow/graph/framework.hpp b/taskflow/graph/framework.hpp
@@ -6,7 +6,15 @@ namespace tf {
 
 // TODO: document the class
 
-// Class: Framework
+/**
+@class Framework 
+
+@brief A reusable task dependency graph.
+
+A framework can be executed by a taskflow object repetitively and thus 
+avoids the graph reconstruction overhead. 
+
+*/
 class Framework : public FlowBuilder {
 
   friend class Topology;
diff --git a/unittest/taskflow.cpp b/unittest/taskflow.cpp
@@ -956,7 +956,41 @@ TEST_CASE("Framework" * doctest::timeout(300)) {
   }
 
 
-  // TODO: test correctness when framework got changed between runs
+  // TODO: test correctness when framework got changed between runs 
+  for(unsigned W=0; W<=4; ++W) {
+
+    std::atomic<size_t> count {0};
+    tf::Framework f;
+    auto A = f.silent_emplace([&](){ count ++; });
+    auto B = f.silent_emplace([&](auto& subflow){ 
+      count ++; 
+      auto B1 = subflow.silent_emplace([&](){ count++; });
+      auto B2 = subflow.silent_emplace([&](){ count++; });
+      auto B3 = subflow.silent_emplace([&](){ count++; });
+      B1.precede(B3); B2.precede(B3);
+    });
+    auto C = f.silent_emplace([&](){ count ++; });
+    auto D = f.silent_emplace([&](){ count ++; });
+
+    A.precede(B, C);
+    B.precede(D); 
+    C.precede(D);
+
+    tf::Taskflow tf(W);
+    tf.run_n(f, 10).get();
+    REQUIRE(count == 70);    
+
+    auto E = f.silent_emplace([](){});
+    D.precede(E);
+    tf.run_n(f, 10).get();
+    REQUIRE(count == 140);    
+
+    auto F = f.silent_emplace([](){});
+    E.precede(F);
+    tf.silent_run_n(f, 10);
+    tf.wait_for_all();
+    REQUIRE(count == 210);    
+  }
 
 }
 
