folly/stress-test/stress-sequential-folly-queue.cpp

   1 #include <folly/concurrency/UnboundedQueue.h>
   2
   3 #include <chrono>
   4 #include <cassert>
   5 #include <iostream>
   6 #include <memory>
   7
   8 namespace {
   9
  10 const char* kTestName = "EnqueueDequeue";
  11 size_t kEnqueueStride = 10000;
  12
  13 size_t kUSPSCQueueEnqueueCount = 1200000000;
  14 const char* kUSPSCQueueBenchmarkName = "FollyUSPSCQueue";
  15
  16 size_t kUMPSCQueueEnqueueCount = 320000000;
  17 const char* kUMPSCQueueBenchmarkName = "FollyUMPSCQueue";
  18
  19 size_t kUSPMCQueueEnqueueCount = 320000000;
  20 const char* kUSPMCQueueBenchmarkName = "FollyUSPMCQueue";
  21
  22 size_t kUMPMCQueueEnqueueCount = 320000000;
  23 const char* kUMPMCQueueBenchmarkName = "FollyMPMCQueue";
  24
  25 typedef folly::USPSCQueue<size_t, false> USPSCQueue;
  26 typedef folly::UMPSCQueue<size_t, false> UMPSCQueue;
  27 typedef folly::USPMCQueue<size_t, false> USPMCQueue;
  28 typedef folly::UMPMCQueue<size_t, false> UMPMCQueue;
  29
  30 }
  31
  32 template <typename Queue>
  33 void run_queue(size_t enqueue_count, const char* bench_name) {
  34     std::cout << "[ RUN      ] " << kTestName << "." << bench_name << std::endl;
  35     auto start_time = std::chrono::system_clock::now();
  36
  37     size_t nNo = 0;
  38     size_t push_failure = 0;
  39     size_t pop_sum = 0;
  40                 std::unique_ptr<Queue> q(new Queue());
  41     while (nNo < enqueue_count) {
  42       size_t curr_push_count =
  43           std::min(enqueue_count - nNo, kEnqueueStride);
  44       for (size_t i = 0; i < curr_push_count; i++) {
  45         q->enqueue(nNo++);
  46       }
  47       size_t res;
  48       for (size_t i = 0; i < curr_push_count; i++) {
  49         q->dequeue(res);
  50         pop_sum += res;
  51       }
  52     }
  53
  54     auto finish_time = std::chrono::system_clock::now();
  55     auto dur = finish_time - start_time;
  56     auto milisecs = std::chrono::duration_cast<std::chrono::milliseconds>(dur);
  57
  58     size_t supposed_sum = enqueue_count * (enqueue_count - 1) / 2;
  59     if (pop_sum != supposed_sum) {
  60       std::cout << "Sequential queue pop sum: " << pop_sum
  61                 << " != " << supposed_sum << "\n";
  62       std::cout << "[       FAILED ] " << kTestName << "." << bench_name
  63                 << " (" << milisecs.count() << " ms)" << std::endl;
  64       assert(false && "Folly unbounded queue ERROR");
  65     } else {
  66         std::cout << "[       OK ] " << kTestName << "." << bench_name
  67                   << " (" << milisecs.count() << " ms)" << std::endl;
  68     }
  69 }
  70
  71 int main() {
  72   run_queue<USPSCQueue>(kUSPSCQueueEnqueueCount, kUSPSCQueueBenchmarkName);
  73   run_queue<UMPSCQueue>(kUMPSCQueueEnqueueCount, kUMPSCQueueBenchmarkName);
  74   run_queue<USPMCQueue>(kUSPMCQueueEnqueueCount, kUSPMCQueueBenchmarkName);
  75   run_queue<UMPMCQueue>(kUMPMCQueueEnqueueCount, kUMPMCQueueBenchmarkName);
  76
  77   return 0;
  78 }