Send SIGPROF signals on the profiler event processor thread

src/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 17 matching lines @@
 #include "v8.h"
 
 #include "circular-queue-inl.h"
 
 namespace v8 {
 namespace internal {
 
 
 SamplingCircularQueue::SamplingCircularQueue(int record_size_in_bytes,
                                              int desired_chunk_size_in_bytes,
-                                             int buffer_size_in_chunks)
+                                             int buffer_size_in_chunks,
+                                             int producer_consumer_distance)

[loislo, 2013/02/21 12:42:39]

I'd pass a boolean or enum flag instead of a magic variable.

[yurys, 2013/02/21 12:45:48]

Done.

     : record_size_(record_size_in_bytes / sizeof(Cell)),
       chunk_size_in_bytes_(desired_chunk_size_in_bytes / record_size_in_bytes *
                         record_size_in_bytes),
       chunk_size_(chunk_size_in_bytes_ / sizeof(Cell)),
       buffer_size_(chunk_size_ * buffer_size_in_chunks),
-      // The distance ensures that producer and consumer never step on
-      // each other's chunks and helps eviction of produced data from
-      // the CPU cache (having that chunk size is bigger than the cache.)
-      producer_consumer_distance_(2 * chunk_size_),
       buffer_(NewArray<Cell>(buffer_size_ + 1)) {
   ASSERT(buffer_size_in_chunks > 2);
   // Clean up the whole buffer to avoid encountering a random kEnd
   // while enqueuing.
   for (int i = 0; i < buffer_size_; ++i) {
     buffer_[i] = kClear;
   }
   buffer_[buffer_size_] = kEnd;
 
   // Layout producer and consumer position pointers each on their own
   // cache lines to avoid cache lines thrashing due to simultaneous
   // updates of positions by different processor cores.
   const int positions_size =
       RoundUp(1, kProcessorCacheLineSize) +
       RoundUp(static_cast<int>(sizeof(ProducerPosition)),
               kProcessorCacheLineSize) +
       RoundUp(static_cast<int>(sizeof(ConsumerPosition)),
               kProcessorCacheLineSize);
   positions_ = NewArray<byte>(positions_size);
 
   producer_pos_ = reinterpret_cast<ProducerPosition*>(
       RoundUp(positions_, kProcessorCacheLineSize));
   producer_pos_->enqueue_pos = buffer_;
 
   consumer_pos_ = reinterpret_cast<ConsumerPosition*>(
       reinterpret_cast<byte*>(producer_pos_) + kProcessorCacheLineSize);
   ASSERT(reinterpret_cast<byte*>(consumer_pos_ + 1) <=
          positions_ + positions_size);
   consumer_pos_->dequeue_chunk_pos = buffer_;
-  consumer_pos_->dequeue_chunk_poll_pos = buffer_ + producer_consumer_distance_;
+  // The distance ensures that producer and consumer never step on
+  // each other's chunks and helps eviction of produced data from
+  // the CPU cache (having that chunk size is bigger than the cache.)
+  producer_consumer_distance *= chunk_size_;
+  consumer_pos_->dequeue_chunk_poll_pos = buffer_ + producer_consumer_distance;
   consumer_pos_->dequeue_pos = NULL;
 }
 
 
 SamplingCircularQueue::~SamplingCircularQueue() {
   DeleteArray(positions_);
   DeleteArray(buffer_);
 }
 
 
@@ skipping 25 matching lines @@
 }
 
 
 void SamplingCircularQueue::FlushResidualRecords() {
   // Eliminate producer / consumer distance.
   consumer_pos_->dequeue_chunk_poll_pos = consumer_pos_->dequeue_chunk_pos;
 }
 
 
 } }  // namespace v8::internal