Rewrite SamplingCircularQueue

src/cpu-profiler.cc

 // Copyright 2012 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 22 matching lines @@
 #include "frames-inl.h"
 #include "hashmap.h"
 #include "log-inl.h"
 #include "vm-state-inl.h"
 
 #include "../include/v8-profiler.h"
 
 namespace v8 {
 namespace internal {
 
-static const int kTickSamplesBufferChunkSize = 64 * KB;
-static const int kTickSamplesBufferChunksCount = 16;
+static const size_t kTickSampleBufferSize = 1 * MB;
 static const int kProfilerStackSize = 64 * KB;
 
 
 ProfilerEventsProcessor::ProfilerEventsProcessor(ProfileGenerator* generator)
     : Thread(Thread::Options("v8:ProfEvntProc", kProfilerStackSize)),
       generator_(generator),
       running_(true),
       ticks_buffer_(sizeof(TickSampleEventRecord),
-                    kTickSamplesBufferChunkSize,
-                    kTickSamplesBufferChunksCount),
+                    kTickSampleBufferSize / sizeof(TickSampleEventRecord)),
       last_code_event_id_(0), last_processed_code_event_id_(0) {
 }
 
 
 void ProfilerEventsProcessor::Enqueue(const CodeEventsContainer& event) {
   event.generic.order = ++last_code_event_id_;
   events_buffer_.Enqueue(event);
 }
 
 
@@ skipping 42 matching lines @@
 bool ProfilerEventsProcessor::ProcessTicks() {
   while (true) {
     while (!ticks_from_vm_buffer_.IsEmpty()
         && ticks_from_vm_buffer_.Peek()->order ==
            last_processed_code_event_id_) {
       TickSampleEventRecord record;
       ticks_from_vm_buffer_.Dequeue(&record);
       generator_->RecordTickSample(record.sample);
     }
 
-    const TickSampleEventRecord* rec =
+    const TickSampleEventRecord* record =
         TickSampleEventRecord::cast(ticks_buffer_.StartDequeue());
-    if (rec == NULL) return !ticks_from_vm_buffer_.IsEmpty();
+    if (record == NULL) return !ticks_from_vm_buffer_.IsEmpty();
     // Make a local copy of tick sample record to ensure that it won't
     // be modified as we are processing it. This is possible as the
     // sampler writes w/o any sync to the queue, so if the processor
     // will get far behind, a record may be modified right under its
     // feet.

[Benedikt Meurer, 2013/08/13 09:31:32]

We do no longer make a local copy here, so this comment is obsolete.

[yurys, 2013/08/13 14:10:29]

Done.

-    TickSampleEventRecord record = *rec;
-    if (record.order != last_processed_code_event_id_) return true;
-
-    // A paranoid check to make sure that we don't get a memory overrun
-    // in case of frames_count having a wild value.
-    if (record.sample.frames_count < 0
-        || record.sample.frames_count > TickSample::kMaxFramesCount)
-      record.sample.frames_count = 0;
-    generator_->RecordTickSample(record.sample);
+    if (record->order != last_processed_code_event_id_) return true;
+    generator_->RecordTickSample(record->sample);
     ticks_buffer_.FinishDequeue();
   }
 }
 
 
 void ProfilerEventsProcessor::Run() {
   while (running_) {
     // Process ticks until we have any.
     if (ProcessTicks()) {
       // All ticks of the current last_processed_code_event_id_ are processed,
       // proceed to the next code event.
       ProcessCodeEvent();
     }
     YieldCPU();
   }
 
   // Process remaining tick events.
-  ticks_buffer_.FlushResidualRecords();
   do {
     ProcessTicks();
   } while (ProcessCodeEvent());
 }
 
 
 int CpuProfiler::GetProfilesCount() {
   // The count of profiles doesn't depend on a security token.
   return profiles_->profiles()->length();
 }
 
 
 CpuProfile* CpuProfiler::GetProfile(int index) {
   return profiles_->profiles()->at(index);
 }
 
 
-TickSample* CpuProfiler::TickSampleEvent() {
-  if (is_profiling_) return processor_->TickSampleEvent();
-  return NULL;
-}
-
-
 void CpuProfiler::DeleteAllProfiles() {
   if (is_profiling_) StopProcessor();
   ResetProfiles();
 }
 
 
 void CpuProfiler::DeleteProfile(CpuProfile* profile) {
   profiles_->RemoveProfile(profile);
   delete profile;
 }
@@ skipping 315 matching lines @@
     ReportBuiltinEventRecord* rec = &evt_rec.ReportBuiltinEventRecord_;
     Builtins::Name id = static_cast<Builtins::Name>(i);
     rec->start = builtins->builtin(id)->address();
     rec->builtin_id = id;
     processor_->Enqueue(evt_rec);
   }
 }
 
 
 } }  // namespace v8::internal