updated object pool

tsung-wei-huang · tsung-wei-huang · commit c65b0c50a679 · 2019-07-13T00:41:19.000-05:00
diff --git a/taskflow/core/executor.hpp b/taskflow/core/executor.hpp
@@ -637,7 +637,12 @@ inline void Executor::_invoke(unsigned me, Node* node) {
     
     // Clear the subgraph before the task execution
     if(!node->is_spawned()) {
-      node->_subgraph.emplace();
+      if(node->_subgraph) {
+        node->_subgraph->clear();
+      }
+      else {
+        node->_subgraph.emplace();
+      }
     }
    
     Subflow fb(*(node->_subgraph));
@@ -668,7 +673,7 @@ inline void Executor::_invoke(unsigned me, Node* node) {
 
         _schedule(src);
 
-        if(!fb.detached()) {
+        if(fb.joined()) {
           return;
         }
       }
@@ -682,7 +687,7 @@ inline void Executor::_invoke(unsigned me, Node* node) {
   if(!node->is_subtask()) {
     // Only dynamic tasking needs to restore _dependents
     // TODO:
-    if(node->_work.index() == 1 &&  !node->_subgraph->empty()) {
+    if(node->_work.index() == 1 && !node->_subgraph->empty()) {
       while(!node->_dependents.empty() && node->_dependents.back()->is_subtask()) {
         node->_dependents.pop_back();
       }
diff --git a/taskflow/core/graph.hpp b/taskflow/core/graph.hpp
@@ -259,7 +259,7 @@ inline Graph& Graph::operator = (Graph&& other) {
 // clear and recycle the nodes
 inline void Graph::clear() {
   for(auto& node : _nodes) {
-    NodePool.enstack(std::move(node));
+    NodePool.release(std::move(node));
   }
   _nodes.clear();
 }
@@ -294,10 +294,7 @@ inline const std::vector<std::unique_ptr<Node>>& Graph::nodes() const {
 // create a node from a give argument; constructor is called if necessary
 template <typename... ArgsT>
 Node& Graph::emplace_back(ArgsT&&... args) {
-  //_nodes.push_back(
-  //  per_thread_object_pool<Node>().get(std::forward<ArgsT>(args)...)
-  //);
-  _nodes.push_back(NodePool.destack(std::forward<ArgsT>(args)...));
+  _nodes.push_back(NodePool.acquire(std::forward<ArgsT>(args)...));
   return *(_nodes.back());
 }
 
diff --git a/taskflow/utility/object_pool.hpp b/taskflow/utility/object_pool.hpp
@@ -27,10 +27,10 @@ class ObjectPool {
   
     size_t size() const;
 
-    void enstack(std::unique_ptr<T>&& obj);
+    void release(std::unique_ptr<T>&& obj);
 
     template <typename... ArgsT>
-    std::unique_ptr<T> destack(ArgsT&&... args);
+    std::unique_ptr<T> acquire(ArgsT&&... args);
 
   private:
     
@@ -56,10 +56,10 @@ size_t ObjectPool<T>::size() const {
   return _stack.size();
 }
 
-// Function: destack
+// Function: acquire
 template <typename T>
 template <typename... ArgsT>
-std::unique_ptr<T> ObjectPool<T>::destack(ArgsT&&... args) {
+std::unique_ptr<T> ObjectPool<T>::acquire(ArgsT&&... args) {
   if(_stack.empty()) {
     return std::make_unique<T>(std::forward<ArgsT>(args)...);
   }
@@ -71,13 +71,11 @@ std::unique_ptr<T> ObjectPool<T>::destack(ArgsT&&... args) {
   }
 }
 
-// Procedure: enstack
+// Procedure: release
 template <typename T>
-void ObjectPool<T>::enstack(std::unique_ptr<T>&& obj) {
-  if(_stack.size() < 4096) {
-    obj->recycle();
-    _stack.push_back(std::move(obj));
-  }
+void ObjectPool<T>::release(std::unique_ptr<T>&& obj) {
+  obj->recycle();
+  _stack.push_back(std::move(obj));
 }
 
 }  // end of namespace tf -----------------------------------------------------
diff --git a/unittest/utility.cpp b/unittest/utility.cpp
@@ -224,7 +224,7 @@ TEST_CASE("ObjectPool" * doctest::timeout(300)) {
             break;
           }
           else {
-            auto ptr = TestObjectPool.destack(c);
+            auto ptr = TestObjectPool.acquire(c);
             std::scoped_lock lock(mutex);
             objects.push_back(std::move(ptr));
           }
@@ -254,7 +254,7 @@ TEST_CASE("ObjectPool" * doctest::timeout(300)) {
           else {
             std::scoped_lock lock(mutex);
             REQUIRE(!objects.empty());
-            TestObjectPool.enstack(std::move(objects.back()));
+            TestObjectPool.release(std::move(objects.back()));
             objects.pop_back();
           }
         }

Original file line number	Diff line number	Diff line change
`@@ -259,7 +259,7 @@ inline Graph& Graph::operator = (Graph&& other) {`
`259`	`259`	`// clear and recycle the nodes`
`260`	`260`	`inline void Graph::clear() {`
`261`	`261`	`for(auto& node : _nodes) {`
`262`		`- NodePool.enstack(std::move(node));`
	`262`	`+ NodePool.release(std::move(node));`
`263`	`263`	`}`
`264`	`264`	`_nodes.clear();`
`265`	`265`	`}`
`@@ -294,10 +294,7 @@ inline const std::vector<std::unique_ptr<Node>>& Graph::nodes() const {`
`294`	`294`	`// create a node from a give argument; constructor is called if necessary`
`295`	`295`	`template <typename... ArgsT>`
`296`	`296`	`Node& Graph::emplace_back(ArgsT&&... args) {`
`297`		`- //_nodes.push_back(`
`298`		`- // per_thread_object_pool<Node>().get(std::forward<ArgsT>(args)...)`
`299`		`- //);`
`300`		`- _nodes.push_back(NodePool.destack(std::forward<ArgsT>(args)...));`
	`297`	`+ _nodes.push_back(NodePool.acquire(std::forward<ArgsT>(args)...));`
`301`	`298`	`return *(_nodes.back());`
`302`	`299`	`}`
`303`	`300`
Original file line number	Diff line number	Diff line change
`@@ -224,7 +224,7 @@ TEST_CASE("ObjectPool" * doctest::timeout(300)) {`
`224`	`224`	`break;`
`225`	`225`	`}`
`226`	`226`	`else {`
`227`		`- auto ptr = TestObjectPool.destack(c);`
	`227`	`+ auto ptr = TestObjectPool.acquire(c);`
`228`	`228`	`std::scoped_lock lock(mutex);`
`229`	`229`	`objects.push_back(std::move(ptr));`
`230`	`230`	`}`
`@@ -254,7 +254,7 @@ TEST_CASE("ObjectPool" * doctest::timeout(300)) {`
`254`	`254`	`else {`
`255`	`255`	`std::scoped_lock lock(mutex);`
`256`	`256`	`REQUIRE(!objects.empty());`
`257`		`- TestObjectPool.enstack(std::move(objects.back()));`
	`257`	`+ TestObjectPool.release(std::move(objects.back()));`
`258`	`258`	`objects.pop_back();`
`259`	`259`	`}`
`260`	`260`	`}`