test/stress/misc/deque_driver.cpp

   1 #include "common.h"
   2 #include <cds/container/chase-lev-deque.h>
   3 #include <cds_test/stress_test.h>
   4 #include <cstdlib>
   5 #include <ctime>
   6 #include <iostream>
   7 #include <memory>
   8 #include <thread>
   9
  10 using namespace std;
  11
  12 namespace {
  13
  14 typedef cds_others::ChaseLevDeque Deque;
  15 static size_t s_nDequeStealerThreadCount = 5;
  16 static size_t s_nDequeMainPassCount = 100000000;
  17
  18 class ChaseLevDequeTest : public cds_test::stress_fixture {
  19 protected:
  20   static Deque *deque;
  21   static atomic_int terminate_stealer;
  22   static ullong *sums;
  23   static ullong *succ_counts;
  24   static ullong push_sum;
  25   static ullong push_count;
  26
  27   static void SetUpTestCase() {
  28     cds_test::config const &cfg = get_config("Misc");
  29     GetConfig(DequeStealerThreadCount);
  30     GetConfig(DequeMainPassCount);
  31   }
  32
  33   static void StealerThread(int index) {
  34     while (!terminate_stealer.load(memory_order_relaxed)) {
  35       int res = deque->steal();
  36       if (res != EMPTY && res != ABORT) {
  37         sums[index] += res;
  38         succ_counts[index]++;
  39       }
  40     }
  41   }
  42
  43   static void MainThread(int index, int push_percentage) {
  44     for (ullong i = 0; i < s_nDequeMainPassCount; i++) {
  45       if ((::rand() % 100) < push_percentage) {
  46         int item = ::rand() % 100;
  47         deque->push(item);
  48         push_sum += item;
  49         push_count++;
  50       } else {
  51         int res = deque->take();
  52         if (res != EMPTY) {
  53           sums[index] += res;
  54           succ_counts[index]++;
  55         }
  56       }
  57     }
  58     while (true) {
  59       int res = deque->take();
  60       if (res != EMPTY) {
  61         sums[index] += res;
  62         succ_counts[index]++;
  63       } else {
  64         break;
  65       }
  66     }
  67   }
  68 };
  69
  70 atomic_int ChaseLevDequeTest::terminate_stealer;
  71 ullong *ChaseLevDequeTest::sums;
  72 ullong *ChaseLevDequeTest::succ_counts;
  73 ullong ChaseLevDequeTest::push_count;
  74 ullong ChaseLevDequeTest::push_sum;
  75 Deque *ChaseLevDequeTest::deque;
  76
  77 TEST_F(ChaseLevDequeTest, DequePushPopTake) {
  78   deque = new Deque();
  79   push_sum = 0;
  80   sums = (ullong *)calloc(1, sizeof(ullong) * (s_nDequeStealerThreadCount + 1));
  81   succ_counts =
  82       (ullong *)calloc(1, sizeof(ullong) * (s_nDequeStealerThreadCount + 1));
  83   srand(time(NULL));
  84
  85   // Stealer threads
  86   std::unique_ptr<std::thread[]> threads(
  87       new std::thread[s_nDequeStealerThreadCount]);
  88   for (ullong i = 0; i < s_nDequeStealerThreadCount; i++) {
  89     threads[i] = std::thread(StealerThread, i);
  90   }
  91
  92   for (int i = 90; i > 0; i -= 10) {
  93     MainThread(s_nDequeStealerThreadCount, i);
  94   }
  95
  96   terminate_stealer.store(1, memory_order_relaxed);
  97   for (ullong i = 0; i < s_nDequeStealerThreadCount; i++) {
  98     threads[i].join();
  99   }
 100
 101   // Result analysis
 102   ullong received_sum = 0;
 103   ullong overall_count = 0;
 104   for (ullong i = 0; i <= s_nDequeStealerThreadCount; i++) {
 105     received_sum += sums[i];
 106     overall_count += succ_counts[i];
 107   }
 108   if (overall_count != push_count || received_sum != push_sum) {
 109     cout << "Incorrect deque\n";
 110     cout << "Push sum: " << push_sum << "\n";
 111     cout << "Received sum:" << received_sum << "\n";
 112     cout << "Push count=" << push_count << "\n";
 113     cout << "Received count:" << overall_count << "\n";
 114   }
 115 }
 116
 117 } // namespace