Refactors junction parallel map

[junction.git] / test / junction_parallel_driver.cpp

diff --git a/test/junction_parallel_driver.cpp b/test/junction_parallel_driver.cpp
index dd1bda270bac8bf6647901fbe930a85958a11637..8dadf63bd30e3b337997a6c4f5c05f17d3924fc2 100644 (file)
--- a/test/junction_parallel_driver.cpp
+++ b/test/junction_parallel_driver.cpp
@@ -46,7 +46,9 @@ protected:
     GetConfigNonZeroExpected(DeletePercentage, 5);
     GetConfigNonZeroExpected(ThreadCount, 4);
     GetConfigNonZeroExpected(MapKeyRange, 20000);
-    GetConfigNonZeroExpected(CrudeMapCapacity, s_nMapKeyRange * 64);
+    // CrudeMap may need a big enough capacity in case may insertion operations
+    // got jammed up.
+    GetConfigNonZeroExpected(CrudeMapCapacity, s_nMapKeyRange * 1024);
     GetConfigNonZeroExpected(GCFrequency, 1500);
     GetConfigNonZeroExpected(CrudePassCount, 1500000000);
     GetConfigNonZeroExpected(GrampaPassCount, 650000000);
@@ -54,7 +56,9 @@ protected:
     GetConfigNonZeroExpected(LeapfrogPassCount, 850000000);
   }
 
-  template <typename Map> static void run_test(Map* map, size_t pass_count) {
+  template <typename Map>
+  static void run_test(Map* map, size_t pass_count, size_t* inserted_num,
+                       size_t* deleted_num) {
     auto qsbrContext = junction::DefaultQSBR.createContext();
 
     std::random_device rd;
@@ -63,6 +67,7 @@ protected:
 
     unsigned action_index = 0;
     size_t nInsertedNum = 0;
+    size_t nDeletedNum = 0;
     size_t nFindSuccess = 0;
     size_t nOperations = 0;
 
@@ -78,7 +83,9 @@ protected:
           break;
         }
         case do_delete: {
-          map_delete(map, key);
+          if (map_delete(map, key)) {
+            nDeletedNum++;
+          }
           break;
         }
         case do_find: {
@@ -99,6 +106,27 @@ protected:
     }
     junction::DefaultQSBR.update(qsbrContext);
     junction::DefaultQSBR.destroyContext(qsbrContext);
+    *inserted_num = nInsertedNum;
+    *deleted_num = nDeletedNum;
+  }
+
+  template <typename Map>
+  void JunctionThreading(Map* map, size_t pass_count) {
+    std::unique_ptr<std::thread[]> threads(new std::thread[s_nThreadCount]);
+    std::unique_ptr<size_t[]> inserted_nums(new size_t[s_nThreadCount]);
+    std::unique_ptr<size_t[]> deleted_nums(new size_t[s_nThreadCount]);
+    for (size_t i = 0; i < s_nThreadCount; i++) {
+      threads[i] = std::thread(run_test<Map>, map, pass_count,
+                               &inserted_nums[i], &deleted_nums[i]);
+    }
+    size_t inserted_sum = 0;
+    size_t deleted_sum = 0;
+    for (size_t i = 0; i < s_nThreadCount; i++) {
+      threads[i].join();
+      inserted_sum += inserted_nums[i];
+      deleted_sum += deleted_nums[i];
+    }
+    EXPECT_LE(deleted_sum, inserted_sum);
   }
 };
 
@@ -116,33 +144,24 @@ size_t JunctionMapInsDelFindTest_Parallel::s_nGrampaPassCount;
 size_t JunctionMapInsDelFindTest_Parallel::s_nLinearPassCount;
 size_t JunctionMapInsDelFindTest_Parallel::s_nLeapfrogPassCount;
 
-#define JunctionThreading(map_type, pass_count)                                \
-  std::unique_ptr<std::thread[]> threads(new std::thread[s_nThreadCount]);       \
-  for (size_t i = 0; i < s_nThreadCount; i++) {                                  \
-    threads[i] = std::thread(run_test<map_type>, map.get(), pass_count);       \
-  }                                                                            \
-  for (size_t i = 0; i < s_nThreadCount; i++) {                                  \
-    threads[i].join();                                                         \
-  }
-
 TEST_F(JunctionMapInsDelFindTest_Parallel, JunctionMapCrude) {
   std::unique_ptr<CrudeMap> map(new CrudeMap(s_nCrudeMapCapacity));
-  JunctionThreading(CrudeMap, s_nCrudePassCount);
+  JunctionThreading(map.get(), s_nCrudePassCount);
 }
 
 TEST_F(JunctionMapInsDelFindTest_Parallel, JunctionMapLeapfrog) {
   std::unique_ptr<LeapfrogMap> map(new LeapfrogMap());
-  JunctionThreading(LeapfrogMap, s_nLeapfrogPassCount);
+  JunctionThreading(map.get(), s_nLeapfrogPassCount);
 }
 
 TEST_F(JunctionMapInsDelFindTest_Parallel, JunctionMapLinear) {
   std::unique_ptr<LinearMap> map(new LinearMap());
-  JunctionThreading(LinearMap, s_nLinearPassCount);
+  JunctionThreading(map.get(), s_nLinearPassCount);
 }
 
 TEST_F(JunctionMapInsDelFindTest_Parallel, JunctionMapGrampa) {
   std::unique_ptr<GrampaMap> map(new GrampaMap());
-  JunctionThreading(GrampaMap, s_nGrampaPassCount);
+  JunctionThreading(map.get(), s_nGrampaPassCount);
 }
 
 } // namespace junction_test