test/junction_sequential_driver.cpp

   1 #include "test.h"
   2
   3 namespace junction_test {
   4
   5 class JunctionMapInsDelFindTest_Sequential : public cds_test::stress_fixture {
   6 protected:
   7   static unsigned s_nInsertDeletePercentage;
   8   static size_t s_nGCFrequency; // Run GC after "s_nGCFrequency" operations.
   9   static size_t s_nMapKeyRange;
  10   static size_t s_nCrudeMapCapacity;
  11
  12   enum actions { do_find, do_insert, do_delete };
  13   static const unsigned int kShuffleSize = 100;
  14   static actions s_arrShuffle[kShuffleSize];
  15
  16   static size_t s_nCrudePassCount;
  17   static size_t s_nGrampaPassCount;
  18   static size_t s_nLinearPassCount;
  19   static size_t s_nLeapfrogPassCount;
  20
  21   static void SetUpTestCase() {
  22     const cds_test::config& cfg = get_config("SequentialJunction");
  23     GetConfigNonZeroExpected(InsertDeletePercentage, 5);
  24     GetConfigNonZeroExpected(MapKeyRange, 20000);
  25     GetConfigNonZeroExpected(CrudeMapCapacity, s_nMapKeyRange * 64);
  26     GetConfigNonZeroExpected(GCFrequency, 1500);
  27     GetConfigNonZeroExpected(CrudePassCount, 1500000000);
  28     GetConfigNonZeroExpected(GrampaPassCount, 650000000);
  29     GetConfigNonZeroExpected(LinearPassCount, 900000000);
  30     GetConfigNonZeroExpected(LeapfrogPassCount, 850000000);
  31   }
  32
  33   template <typename Map> static void run_test(Map* map, size_t pass_count) {
  34     auto qsbrContext = junction::DefaultQSBR.createContext();
  35     size_t nInsertedNum = 0;
  36     size_t nNotInsertedNum = 0;
  37     size_t nFindSuccess = 0;
  38     size_t nFindFailed = 0;
  39     size_t nDeletedNum = 0;
  40     size_t nOperations = 0;
  41
  42     // The number to operate on the map.
  43     size_t n = s_nMapKeyRange;
  44     for (size_t count = 0; count < pass_count; count++) {
  45       // Insert
  46       unsigned mod = count % kShuffleSize;
  47       if (mod < s_nInsertDeletePercentage && map_insert(map, n, n)) {
  48         nInsertedNum++;
  49       } else {
  50         nNotInsertedNum++;
  51       }
  52       // Find
  53       if (map_find(map, n)) {
  54         ++nFindSuccess;
  55       } else {
  56         ++nFindFailed;
  57       }
  58       // Delete
  59       if (mod < s_nInsertDeletePercentage && map_delete(map, n)) {
  60         nDeletedNum++;
  61       }
  62       if (++nOperations > s_nGCFrequency) {
  63         junction::DefaultQSBR.update(qsbrContext);
  64         nOperations = 0;
  65       }
  66       if (++n == 2 * s_nMapKeyRange) {
  67         n = s_nMapKeyRange;
  68       }
  69     }
  70     junction::DefaultQSBR.update(qsbrContext);
  71     junction::DefaultQSBR.destroyContext(qsbrContext);
  72     EXPECT_EQ(nInsertedNum, nDeletedNum);
  73     EXPECT_EQ(nInsertedNum, nFindSuccess);
  74     EXPECT_EQ(nFindFailed, nNotInsertedNum);
  75   }
  76 };
  77
  78 size_t JunctionMapInsDelFindTest_Sequential::s_nMapKeyRange;
  79 size_t JunctionMapInsDelFindTest_Sequential::s_nCrudeMapCapacity;
  80 size_t JunctionMapInsDelFindTest_Sequential::s_nGCFrequency;
  81 unsigned JunctionMapInsDelFindTest_Sequential::s_nInsertDeletePercentage;
  82 const unsigned int JunctionMapInsDelFindTest_Sequential::kShuffleSize;
  83 JunctionMapInsDelFindTest_Sequential::actions
  84     JunctionMapInsDelFindTest_Sequential::s_arrShuffle
  85         [JunctionMapInsDelFindTest_Sequential::kShuffleSize];
  86 size_t JunctionMapInsDelFindTest_Sequential::s_nCrudePassCount;
  87 size_t JunctionMapInsDelFindTest_Sequential::s_nGrampaPassCount;
  88 size_t JunctionMapInsDelFindTest_Sequential::s_nLinearPassCount;
  89 size_t JunctionMapInsDelFindTest_Sequential::s_nLeapfrogPassCount;
  90
  91 TEST_F(JunctionMapInsDelFindTest_Sequential, JunctionMapCrude) {
  92   std::unique_ptr<CrudeMap> map(new CrudeMap(s_nCrudeMapCapacity));
  93   run_test(map.get(), s_nCrudePassCount);
  94 }
  95
  96 TEST_F(JunctionMapInsDelFindTest_Sequential, JunctionMapLeapfrog) {
  97   std::unique_ptr<LeapfrogMap> map(new LeapfrogMap());
  98   run_test(map.get(), s_nLeapfrogPassCount);
  99 }
 100
 101 TEST_F(JunctionMapInsDelFindTest_Sequential, JunctionMapLinear) {
 102   std::unique_ptr<LinearMap> map(new LinearMap());
 103   run_test(map.get(), s_nLinearPassCount);
 104 }
 105
 106 TEST_F(JunctionMapInsDelFindTest_Sequential, JunctionMapGrampa) {
 107   std::unique_ptr<GrampaMap> map(new GrampaMap());
 108   run_test(map.get(), s_nGrampaPassCount);
 109 }
 110
 111 } // namespace junction_test