added object_pool test

tsung-wei-huang · tsung-wei-huang · commit 1a19fe33515c · 2019-06-14T00:03:24.000-05:00
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -160,6 +160,7 @@ add_executable(utility unittest/utility.cpp)
 target_link_libraries(utility ${PROJECT_NAME} Threads::Threads)
 target_include_directories(utility PRIVATE ${PROJECT_SOURCE_DIR}/doctest)
 add_test(passive_vector ${TF_UTEST_DIR}/utility -tc=PassiveVector)
+add_test(object_pool    ${TF_UTEST_DIR}/utility -tc=ObjectPool)
 add_test(singular_alloc ${TF_UTEST_DIR}/utility -tc=SingularAllocator)
 
 # unittest for taskflow
@@ -168,6 +169,7 @@ target_link_libraries(taskflow_test_tmp ${PROJECT_NAME} Threads::Threads)
 target_include_directories(taskflow_test_tmp PRIVATE ${PROJECT_SOURCE_DIR}/doctest)
 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(parallel_for     ${TF_UTEST_DIR}/taskflow -tc=ParallelFor)
diff --git a/taskflow/core/executor.hpp b/taskflow/core/executor.hpp
@@ -1,6 +1,7 @@
 // 2019/06/11 - modified by Tsung-Wei Huang
 //  - fixed the bug in calling observer while the user
 //    may clear the data
+//  - added object pool for nodes
 //
 // 2019/05/17 - modified by Chun-Xun Lin
 //  - moved topology to taskflow
diff --git a/unittest/taskflow.cpp b/unittest/taskflow.cpp
@@ -176,6 +176,44 @@ TEST_CASE("Builder" * doctest::timeout(300)) {
   }
 }
 
+// --------------------------------------------------------
+// Testcase: Creation
+// --------------------------------------------------------
+TEST_CASE("Creation" * doctest::timeout(300)) {
+
+  std::vector<int> dummy(1024, -1);
+
+  auto create_taskflow = [&] () {
+    for(int i=0; i<1024; ++i) {
+      tf::Taskflow tf;
+      tf.parallel_for(dummy.begin(), dummy.end(), [] (int) {});
+    }
+  };
+
+  SUBCASE("One") {
+    create_taskflow();
+  }
+
+  SUBCASE("Two") {
+    std::thread t1(create_taskflow);
+    std::thread t2(create_taskflow);
+    t1.join();
+    t2.join();
+  }
+  
+  SUBCASE("Four") {
+    std::thread t1(create_taskflow); 
+    std::thread t2(create_taskflow); 
+    std::thread t3(create_taskflow); 
+    std::thread t4(create_taskflow); 
+    t1.join();
+    t2.join();
+    t3.join();
+    t4.join();
+  }
+
+}
+
 // --------------------------------------------------------
 // Testcase: Run
 // --------------------------------------------------------
diff --git a/unittest/utility.cpp b/unittest/utility.cpp
@@ -183,6 +183,81 @@ TEST_CASE("PassiveVector" * doctest::timeout(300)) {
   }
 }
 
+// --------------------------------------------------------
+// Testcase: Pool
+// --------------------------------------------------------
+TEST_CASE("ObjectPool" * doctest::timeout(300)) {
+
+  auto fork = [&] (unsigned N) {
+    const int M = 2048 * N;
+    std::atomic<int> counter = M;
+    std::atomic<int> recycle = M;
+    std::mutex mutex;
+    std::vector<int*> objects;
+    std::vector<std::thread> threads; 
+
+    // allocate
+    for(unsigned t=1; t<=N; ++t) {
+      threads.emplace_back([&] () {
+        while(1) {
+          if(int c = --counter; c < 0) {
+            break;
+          }
+          else {
+            auto ptr = tf::per_thread_object_pool<int>().get(c);
+            std::scoped_lock lock(mutex);
+            objects.push_back(ptr);
+          }
+        }
+      });
+    }
+    for(auto& thread : threads) {
+      thread.join();
+    }
+    threads.clear();
+
+    REQUIRE(objects.size() == M);
+
+    auto sum = std::accumulate(objects.begin(), objects.end(), 0,
+      [] (int s, int* v) { return s + *v; }
+    );
+
+    REQUIRE(sum == (M-1)*M / 2);
+
+    // recycle
+    for(unsigned t=1; t<=N; ++t) {
+      threads.emplace_back([&] () {
+        while(1) {
+          if(int r = --recycle; r < 0) {
+            break;
+          }
+          else {
+            std::scoped_lock lock(mutex);
+            REQUIRE(!objects.empty());
+            tf::per_thread_object_pool<int>().recycle(objects.back());
+            objects.pop_back();
+          }
+        }
+      });
+    }
+    for(auto& thread : threads) {
+      thread.join();
+    }
+    threads.clear();
+
+    REQUIRE(objects.size() == 0);
+  };
+
+  SUBCASE("OneThread")    { fork(1); }
+  SUBCASE("TwoThread")    { fork(2); }
+  SUBCASE("ThreeThreads") { fork(3); }
+  SUBCASE("FourThreads")  { fork(4); }
+  SUBCASE("FiveThreads")  { fork(5); }
+  SUBCASE("SixThreads")   { fork(6); }
+  SUBCASE("SevenThreads") { fork(7); }
+  SUBCASE("EightThreads") { fork(8); }
+}
+
 // --------------------------------------------------------
 // Testcase: SingularAllocator
 // --------------------------------------------------------
