projects / folly.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Refactors folly test cases to use gtest
[folly.git] / folly / stress-test / stress-sequential-folly-queue.cpp
diff --git a/folly/stress-test/stress-sequential-folly-queue.cpp b/folly/stress-test/stress-sequential-folly-queue.cpp
index d3c3906a5dcdb16213e4307ebc959a0dc599f696..70bcb15d5641715786635d5a7861c6af89ed35fc 100644 (file)
--- a/folly/stress-test/stress-sequential-folly-queue.cpp
+++ b/folly/stress-test/stress-sequential-folly-queue.cpp
@@ -3,25 +3,18 @@
 #include <folly/AtomicLinkedList.h>
 #include <folly/MPMCQueue.h>
 
-#include <chrono>
-#include <cassert>
-#include <iostream>
+#include <gtest/gtest.h>
+
 #include <memory>
 
 namespace {
 
-const char* kTestName = "EnqueueDequeue";
-
 // Unbounded queue
 size_t kUnboundedQueueEnqueueStride = 10000;
 size_t kUSPSCQueueEnqueueCount = 1200000000;
-const char* kUSPSCQueueBenchmarkName = "FollyUnboundedQueue_SPSC";
 size_t kUMPSCQueueEnqueueCount = 320000000;
-const char* kUMPSCQueueBenchmarkName = "FollyUnboundedQueue_MPSC";
 size_t kUSPMCQueueEnqueueCount = 320000000;
-const char* kUSPMCQueueBenchmarkName = "FollyUnboundedQueue_SPMC";
 size_t kUMPMCQueueEnqueueCount = 320000000;
-const char* kUMPMCQueueBenchmarkName = "FollyUnboundedQueue_MPMC";
 
 typedef folly::USPSCQueue<size_t, false> USPSCQueue;
 typedef folly::UMPSCQueue<size_t, false> UMPSCQueue;
@@ -32,13 +25,9 @@ typedef folly::UMPMCQueue<size_t, false> UMPMCQueue;
 size_t kDynamicBoundedQueueEnqueueStride = 50000;
 size_t kDynamicBoundedQueueCapacity = 200000;
 size_t kDSPSCQueueEnqueueCount = 1200000000;
-const char* kDSPSCQueueBenchmarkName = "FollyDynamicBoundedQueue_SPSC";
 size_t kDMPSCQueueEnqueueCount = 320000000;
-const char* kDMPSCQueueBenchmarkName = "FollyDynamicBoundedQueue_MPSC";
 size_t kDSPMCQueueEnqueueCount = 320000000;
-const char* kDSPMCQueueBenchmarkName = "FollyDynamicBoundedQueue_SPMC";
 size_t kDMPMCQueueEnqueueCount = 320000000;
-const char* kDMPMCQueueBenchmarkName = "FollyDynamicBoundedQueue_MPMC";
 
 typedef folly::DSPSCQueue<size_t, false> DSPSCQueue;
 typedef folly::DMPSCQueue<size_t, false> DMPSCQueue;
@@ -48,22 +37,17 @@ typedef folly::DMPMCQueue<size_t, false> DMPMCQueue;
 // AtomicLinkedList
 size_t kAtomicLinkedListSize = 50000;
 size_t kAtomicLinkedListPassCount = 10000;
-const char* kAtomicLinkedListBenchmarkName = "FollyAtomicLinkedList";
 typedef folly::AtomicLinkedList<size_t> AtomicLinkedList;
 
 // MPMC Queue (linearizable)
 size_t kMPMCQueueEnqueueStride = 10000;
 size_t kMPMCQueueCapacity = 50000;
 size_t kMPMCQueueEnqueueCount = 500000000;
-const char* kMPMCQueueBenchmarkName = "FollyMPMCQueue";
 typedef folly::MPMCQueue<size_t> MPMCQueue;
 
 }
 
 void run_atomic_linkedlist() {
-  std::cout << "[ RUN      ] " << kTestName << "."
-            << kAtomicLinkedListBenchmarkName << std::endl;
-  auto start_time = std::chrono::system_clock::now();
   for (size_t pass = 0; pass < kAtomicLinkedListPassCount; pass++) {
     std::unique_ptr<AtomicLinkedList> list(new AtomicLinkedList());
     bool in_order = true;
@@ -80,30 +64,12 @@ void run_atomic_linkedlist() {
     in_order = !in_order;
 
     size_t supposed_sum = kAtomicLinkedListSize * (kAtomicLinkedListSize - 1) / 2;
-    if (nSum != supposed_sum) {
-      std::cout << "Sequential linked list pop sum: " << nSum
-                << " != " << supposed_sum << "\n";
-      auto finish_time = std::chrono::system_clock::now();
-      auto dur = finish_time - start_time;
-      auto milisecs = std::chrono::duration_cast<std::chrono::milliseconds>(dur);
-      std::cout << "[       FAILED ] " << kTestName << "." << kAtomicLinkedListBenchmarkName
-                << " (" << milisecs.count() << " ms)" << std::endl;
-      assert(false && "Folly AtomicLinkedList ERROR");
-    }
+    EXPECT_EQ(nSum, supposed_sum);
   }
-  auto finish_time = std::chrono::system_clock::now();
-  auto dur = finish_time - start_time;
-  auto milisecs = std::chrono::duration_cast<std::chrono::milliseconds>(dur);
-  std::cout << "[       OK ] " << kTestName << "." << kAtomicLinkedListBenchmarkName
-            << " (" << milisecs.count() << " ms)" << std::endl;
 }
 
 template <typename Queue>
-void run_queue(Queue* q, size_t enqueue_count, const char* bench_name,
-               size_t enqueue_stride) {
-    std::cout << "[ RUN      ] " << kTestName << "." << bench_name << std::endl;
-    auto start_time = std::chrono::system_clock::now();
-
+void run_queue(Queue* q, size_t enqueue_count, size_t enqueue_stride) {
     size_t nNo = 0;
     size_t pop_sum = 0;
     while (nNo < enqueue_count) {
@@ -118,31 +84,13 @@ void run_queue(Queue* q, size_t enqueue_count, const char* bench_name,
         pop_sum += res;
       }
     }
-
-    auto finish_time = std::chrono::system_clock::now();
-    auto dur = finish_time - start_time;
-    auto milisecs = std::chrono::duration_cast<std::chrono::milliseconds>(dur);
-
     size_t supposed_sum = enqueue_count * (enqueue_count - 1) / 2;
-    if (pop_sum != supposed_sum) {
-      std::cout << "Sequential queue pop sum: " << pop_sum
-                << " != " << supposed_sum << "\n";
-      std::cout << "[       FAILED ] " << kTestName << "." << bench_name
-                << " (" << milisecs.count() << " ms)" << std::endl;
-      assert(false && "Folly concurrent queue ERROR");
-    } else {
-        std::cout << "[       OK ] " << kTestName << "." << bench_name
-                  << " (" << milisecs.count() << " ms)" << std::endl;
-    }
+    EXPECT_EQ (pop_sum, supposed_sum);
 }
 
 // MPMC Specialization.
 template <>
-void run_queue(MPMCQueue* q, size_t enqueue_count, const char* bench_name,
-               size_t enqueue_stride) {
-    std::cout << "[ RUN      ] " << kTestName << "." << bench_name << std::endl;
-    auto start_time = std::chrono::system_clock::now();
-
+void run_queue(MPMCQueue* q, size_t enqueue_count, size_t enqueue_stride) {
     size_t nNo = 0;
     size_t push_sum = 0;
     size_t pop_sum = 0;
@@ -161,86 +109,88 @@ void run_queue(MPMCQueue* q, size_t enqueue_count, const char* bench_name,
       }
     }
 
-    auto finish_time = std::chrono::system_clock::now();
-    auto dur = finish_time - start_time;
-    auto milisecs = std::chrono::duration_cast<std::chrono::milliseconds>(dur);
-
     size_t supposed_sum = enqueue_count * (enqueue_count - 1) / 2;
-    if (pop_sum != supposed_sum) {
-      std::cout << "Sequential queue pop sum: " << pop_sum
-                << " != " << supposed_sum << "\n";
-      std::cout << "[       FAILED ] " << kTestName << "." << bench_name
-                << " (" << milisecs.count() << " ms)" << std::endl;
-      assert(false && "Folly concurrent queue ERROR");
-    } else {
-        std::cout << "[       OK ] " << kTestName << "." << bench_name
-                  << " (" << milisecs.count() << " ms)" << std::endl;
-    }
+    EXPECT_EQ(pop_sum, supposed_sum);
 }
 
 template <typename Queue>
-void run_without_initial_capacity(size_t enqueue_count, const char* bench_name,
-                                  size_t enqueue_stride) {
+void run_without_initial_capacity(size_t enqueue_count, size_t enqueue_stride) {
   std::unique_ptr<Queue> q(new Queue());
-  run_queue(q.get(), enqueue_count, bench_name, enqueue_stride);
+  run_queue(q.get(), enqueue_count, enqueue_stride);
 }
 
 template <typename Queue>
 void run_with_initial_capacity(size_t queue_capacity, size_t enqueue_count,
-                               const char* bench_name, size_t enqueue_stride) {
+                               size_t enqueue_stride) {
   std::unique_ptr<Queue> q(new Queue(queue_capacity));
-  run_queue(q.get(), enqueue_count, bench_name, enqueue_stride);
+  run_queue(q.get(), enqueue_count, enqueue_stride);
 }
 
-int main() {
-  // MPMCQueue
+class FollyQueueEnqueueDequeueTest : public ::testing::Test {
+
+};
+
+TEST_F(FollyQueueEnqueueDequeueTest, FollyMPMCQueue) {
   run_with_initial_capacity<MPMCQueue>(
-      kMPMCQueueCapacity ,
-      kMPMCQueueEnqueueCount,
-      kMPMCQueueBenchmarkName,
-      kMPMCQueueEnqueueStride);
+      kMPMCQueueCapacity, kMPMCQueueEnqueueCount, kMPMCQueueEnqueueStride);
+}
 
-  // AtomicLinkedList
+TEST_F(FollyQueueEnqueueDequeueTest, FollyAtomicLinkedList) {
   run_atomic_linkedlist();
+}
 
-  // UnboundedQueue
+TEST_F(FollyQueueEnqueueDequeueTest, FollyUnboundedQueue_SPSC) {
   run_without_initial_capacity<USPSCQueue>(
-      kUSPSCQueueEnqueueCount,
-      kUSPSCQueueBenchmarkName,
-      kUnboundedQueueEnqueueStride);
+      kUSPSCQueueEnqueueCount, kUnboundedQueueEnqueueStride);
+}
+
+TEST_F(FollyQueueEnqueueDequeueTest, FollyUnboundedQueue_MPSC) {
   run_without_initial_capacity<UMPSCQueue>(
-      kUMPSCQueueEnqueueCount,
-      kUMPSCQueueBenchmarkName,
-      kUnboundedQueueEnqueueStride);
+      kUMPSCQueueEnqueueCount, kUnboundedQueueEnqueueStride);
+}
+
+TEST_F(FollyQueueEnqueueDequeueTest, FollyUnboundedQueue_SPMC) {
   run_without_initial_capacity<USPMCQueue>(
-      kUSPMCQueueEnqueueCount,
-      kUSPMCQueueBenchmarkName,
-      kUnboundedQueueEnqueueStride);
+      kUSPMCQueueEnqueueCount, kUnboundedQueueEnqueueStride);
+}
+
+TEST_F(FollyQueueEnqueueDequeueTest, FollyUnboundedQueue_MPMC) {
   run_without_initial_capacity<UMPMCQueue>(
       kUMPMCQueueEnqueueCount,
-      kUMPMCQueueBenchmarkName,
       kUnboundedQueueEnqueueStride);
+}
 
+TEST_F(FollyQueueEnqueueDequeueTest, FollyDynamicBoundedQueue_SPSC) {
   // DynamicBoundedQueue
   run_with_initial_capacity<DSPSCQueue>(
-      kDynamicBoundedQueueCapacity ,
-      kDSPSCQueueEnqueueCount, kDSPSCQueueBenchmarkName,
-      kDynamicBoundedQueueEnqueueStride);
+      kDynamicBoundedQueueCapacity,
+      kDSPSCQueueEnqueueCount, kDynamicBoundedQueueEnqueueStride);
+}
+
+TEST_F(FollyQueueEnqueueDequeueTest, FollyDynamicBoundedQueue_MPSC) {
   run_with_initial_capacity<DMPSCQueue>(
       kDynamicBoundedQueueCapacity,
       kDMPSCQueueEnqueueCount,
-      kDMPSCQueueBenchmarkName,
       kDynamicBoundedQueueEnqueueStride);
+}
+
+TEST_F(FollyQueueEnqueueDequeueTest, FollyDynamicBoundedQueue_SPMC) {
   run_with_initial_capacity<DSPMCQueue>(
       kDynamicBoundedQueueCapacity,
       kDSPMCQueueEnqueueCount,
-      kDSPMCQueueBenchmarkName,
       kDynamicBoundedQueueEnqueueStride);
+}
+
+TEST_F(FollyQueueEnqueueDequeueTest, FollyDynamicBoundedQueue_MPMC) {
   run_with_initial_capacity<DMPMCQueue>(
       kDynamicBoundedQueueCapacity,
       kDMPMCQueueEnqueueCount,
-      kDMPMCQueueBenchmarkName,
       kDynamicBoundedQueueEnqueueStride);
+}
 
-  return 0;
+int main(int argc, char** argv) {
+  // Init Google test
+  ::testing::InitGoogleTest(&argc, argv);
+  int result = RUN_ALL_TESTS();
+  return result;
 }
Unnamed repository; edit this file 'description' to name the repository.