Rewrite SamplingCircularQueue

test/cctest/test-circular-queue.cc

 // Copyright 2010 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 18 matching lines @@
 
 #include "v8.h"
 #include "circular-queue-inl.h"
 #include "cctest.h"
 
 using i::SamplingCircularQueue;
 
 
 TEST(SamplingCircularQueue) {
   typedef SamplingCircularQueue::Cell Record;
-  const int kRecordsPerChunk = 4;
-  SamplingCircularQueue scq(sizeof(Record),
-                            kRecordsPerChunk * sizeof(Record),
-                            3);
+  const int kMaxRecordsInQueue = 4;
+  SamplingCircularQueue scq(sizeof(Record), kMaxRecordsInQueue);
 
   // Check that we are using non-reserved values.
   // Fill up the first chunk.
   CHECK_EQ(NULL, scq.StartDequeue());
-  for (Record i = 1; i < 1 + kRecordsPerChunk; ++i) {
-    Record* rec = reinterpret_cast<Record*>(scq.Enqueue());
+  for (Record i = 1; i < 1 + kMaxRecordsInQueue; ++i) {
+    Record* rec = reinterpret_cast<Record*>(scq.StartEnqueue());
     CHECK_NE(NULL, rec);
     *rec = i;
-    CHECK_EQ(NULL, scq.StartDequeue());
+    scq.FinishEnqueue();
   }
 
-  // Fill up the second chunk. Consumption must still be unavailable.
-  CHECK_EQ(NULL, scq.StartDequeue());
-  for (Record i = 10; i < 10 + kRecordsPerChunk; ++i) {
-    Record* rec = reinterpret_cast<Record*>(scq.Enqueue());
-    CHECK_NE(NULL, rec);
-    *rec = i;
-    CHECK_EQ(NULL, scq.StartDequeue());
+  // The queue is full, enqueue is not allowed.
+  CHECK_EQ(NULL, scq.StartEnqueue());
+
+  // Try to enqueue when the the queue is full. Consumption must be available.
+  CHECK_NE(NULL, scq.StartDequeue());
+  for (int i = 0; i < 10; ++i) {
+    Record* rec = reinterpret_cast<Record*>(scq.StartEnqueue());
+    CHECK_EQ(NULL, rec);
+    CHECK_NE(NULL, scq.StartDequeue());
   }
 
-  Record* rec = reinterpret_cast<Record*>(scq.Enqueue());
-  CHECK_NE(NULL, rec);
-  *rec = 20;
-  // Now as we started filling up the third chunk, consumption
-  // must become possible.
-  CHECK_NE(NULL, scq.StartDequeue());
-
-  // Consume the first chunk.
-  for (Record i = 1; i < 1 + kRecordsPerChunk; ++i) {
+  // Consume all records.
+  for (Record i = 1; i < 1 + kMaxRecordsInQueue; ++i) {
     Record* rec = reinterpret_cast<Record*>(scq.StartDequeue());
     CHECK_NE(NULL, rec);
     CHECK_EQ(static_cast<int64_t>(i), static_cast<int64_t>(*rec));
     CHECK_EQ(rec, reinterpret_cast<Record*>(scq.StartDequeue()));
     scq.FinishDequeue();
     CHECK_NE(rec, reinterpret_cast<Record*>(scq.StartDequeue()));
   }
-  // Now consumption must not be possible, as consumer now polls
-  // the first chunk for emptinness.
+  // The queue is empty.
   CHECK_EQ(NULL, scq.StartDequeue());
 
-  scq.FlushResidualRecords();
-  // From now, consumer no more polls ahead of the current chunk,
-  // so it's possible to consume the second chunk.
+
+  CHECK_EQ(NULL, scq.StartDequeue());
+  for (Record i = 0; i < kMaxRecordsInQueue / 2; ++i) {
+    Record* rec = reinterpret_cast<Record*>(scq.StartEnqueue());
+    CHECK_NE(NULL, rec);
+    *rec = i;
+    scq.FinishEnqueue();
+  }
+
+  // Consume all available kMaxRecordsInQueue / 2 records.
   CHECK_NE(NULL, scq.StartDequeue());
-  // Consume the second chunk
-  for (Record i = 10; i < 10 + kRecordsPerChunk; ++i) {
+  for (Record i = 0; i < kMaxRecordsInQueue / 2; ++i) {
     Record* rec = reinterpret_cast<Record*>(scq.StartDequeue());
     CHECK_NE(NULL, rec);
     CHECK_EQ(static_cast<int64_t>(i), static_cast<int64_t>(*rec));
     CHECK_EQ(rec, reinterpret_cast<Record*>(scq.StartDequeue()));
     scq.FinishDequeue();
     CHECK_NE(rec, reinterpret_cast<Record*>(scq.StartDequeue()));
   }
-  // Consumption must still be possible as the first cell of the
-  // last chunk is not clean.
-  CHECK_NE(NULL, scq.StartDequeue());
+
+  // The queue is empty.
+  CHECK_EQ(NULL, scq.StartDequeue());
 }
 
 
 namespace {
 
 class ProducerThread: public i::Thread {
  public:
   typedef SamplingCircularQueue::Cell Record;
 
   ProducerThread(SamplingCircularQueue* scq,
                  int records_per_chunk,
                  Record value,
                  i::Semaphore* finished)
       : Thread("producer"),
         scq_(scq),
         records_per_chunk_(records_per_chunk),
         value_(value),
         finished_(finished) { }
 
   virtual void Run() {
     for (Record i = value_; i < value_ + records_per_chunk_; ++i) {
-      Record* rec = reinterpret_cast<Record*>(scq_->Enqueue());
+      Record* rec = reinterpret_cast<Record*>(scq_->StartEnqueue());
       CHECK_NE(NULL, rec);
       *rec = i;
+      scq_->FinishEnqueue();
     }
 
     finished_->Signal();
   }
 
  private:
   SamplingCircularQueue* scq_;
   const int records_per_chunk_;
   Record value_;
   i::Semaphore* finished_;
 };
 
 }  // namespace
 
 TEST(SamplingCircularQueueMultithreading) {
   // Emulate multiple VM threads working 'one thread at a time.'
   // This test enqueues data from different threads. This corresponds
   // to the case of profiling under Linux, where signal handler that
   // does sampling is called in the context of different VM threads.
 
   typedef ProducerThread::Record Record;
   const int kRecordsPerChunk = 4;
-  SamplingCircularQueue scq(sizeof(Record),
-                            kRecordsPerChunk * sizeof(Record),
-                            3);
+  const int kMaxRecordsInQueue = 12;
+  SamplingCircularQueue scq(sizeof(Record), kMaxRecordsInQueue);
   i::Semaphore* semaphore = i::OS::CreateSemaphore(0);
-  // Don't poll ahead, making possible to check data in the buffer
-  // immediately after enqueuing.
-  scq.FlushResidualRecords();
 
-  // Check that we are using non-reserved values.
   ProducerThread producer1(&scq, kRecordsPerChunk, 1, semaphore);
   ProducerThread producer2(&scq, kRecordsPerChunk, 10, semaphore);
   ProducerThread producer3(&scq, kRecordsPerChunk, 20, semaphore);
 
   CHECK_EQ(NULL, scq.StartDequeue());
   producer1.Start();
   semaphore->Wait();
   for (Record i = 1; i < 1 + kRecordsPerChunk; ++i) {
     Record* rec = reinterpret_cast<Record*>(scq.StartDequeue());
     CHECK_NE(NULL, rec);
@@ skipping 24 matching lines @@
     CHECK_EQ(static_cast<int64_t>(i), static_cast<int64_t>(*rec));
     CHECK_EQ(rec, reinterpret_cast<Record*>(scq.StartDequeue()));
     scq.FinishDequeue();
     CHECK_NE(rec, reinterpret_cast<Record*>(scq.StartDequeue()));
   }
 
   CHECK_EQ(NULL, scq.StartDequeue());
 
   delete semaphore;
 }