Add flag to control number of stack frames collected by profiler

runtime/vm/profiler.cc

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "platform/utils.h"
 
 #include "vm/allocation.h"
 #include "vm/atomic.h"
 #include "vm/code_patcher.h"
 #include "vm/isolate.h"
 #include "vm/json_stream.h"
 #include "vm/native_symbol.h"
 #include "vm/object.h"
 #include "vm/os.h"
 #include "vm/profiler.h"
 #include "vm/signal_handler.h"
 #include "vm/simulator.h"
 
 namespace dart {
 
 
-// Notes on stack frame walking:
-//
-// The sampling profiler will collect up to Sample::kNumStackFrames stack frames
-// The stack frame walking code uses the frame pointer to traverse the stack.
-// If the VM is compiled without frame pointers (which is the default on
-// recent GCC versions with optimizing enabled) the stack walking code may
-// fail (sometimes leading to a crash).
-//
-
 #if defined(USING_SIMULATOR) || defined(TARGET_OS_WINDOWS) || \
     defined(TARGET_OS_MACOS) || defined(TARGET_OS_ANDROID)
   DEFINE_FLAG(bool, profile, false, "Enable Sampling Profiler");
 #else
   DEFINE_FLAG(bool, profile, true, "Enable Sampling Profiler");
 #endif
 DEFINE_FLAG(bool, trace_profiled_isolates, false, "Trace profiled isolates.");
 DEFINE_FLAG(charp, profile_dir, NULL,
             "Enable writing profile data into specified directory.");
 DEFINE_FLAG(int, profile_period, 1000,
             "Time between profiler samples in microseconds. Minimum 250.");
+DEFINE_FLAG(int, profile_frames, 8,
+            "Maximum number stack frames walked. Minimum 1.");

[siva, 2014/01/16 23:34:23]

maybe profile_frames_depth

[Cutch, 2014/01/17 16:02:25]

profile_depth.

 
 bool Profiler::initialized_ = false;
-Monitor* Profiler::monitor_ = NULL;
 SampleBuffer* Profiler::sample_buffer_ = NULL;
 
 void Profiler::InitOnce() {
   const int kMinimumProfilePeriod = 250;
+  const int kMinimumFrames = 1;

[siva, 2014/01/16 23:34:23]

We probably also want a max (not letting people arbitrarly collect huge stack
frames)

[Cutch, 2014/01/17 16:02:25]

Max of 128.

   if (!FLAG_profile) {
     return;
   }
   ASSERT(!initialized_);
-  initialized_ = true;
-  monitor_ = new Monitor();
+  if (FLAG_profile_period < kMinimumProfilePeriod) {
+    FLAG_profile_period = kMinimumProfilePeriod;
+  }
+  if (FLAG_profile_frames < kMinimumFrames) {
+    FLAG_profile_frames = kMinimumFrames;
+  }
   sample_buffer_ = new SampleBuffer();
   NativeSymbolResolver::InitOnce();
   ThreadInterrupter::InitOnce();
-  if (FLAG_profile_period < kMinimumProfilePeriod) {
-    FLAG_profile_period = kMinimumProfilePeriod;
-  }
   ThreadInterrupter::SetInterruptPeriod(FLAG_profile_period);
+  initialized_ = true;
 }
 
 
 void Profiler::Shutdown() {
   if (!FLAG_profile) {
     return;
   }
   ASSERT(initialized_);
   ThreadInterrupter::Shutdown();
   NativeSymbolResolver::ShutdownOnce();
 }
 
 
 void Profiler::InitProfilingForIsolate(Isolate* isolate, bool shared_buffer) {
   if (!FLAG_profile) {
     return;
   }
   ASSERT(isolate != NULL);
   ASSERT(sample_buffer_ != NULL);
-  MonitorLocker ml(monitor_);
   {
     MutexLocker profiler_data_lock(isolate->profiler_data_mutex());
     SampleBuffer* sample_buffer = sample_buffer_;
     if (!shared_buffer) {
       sample_buffer = new SampleBuffer();
     }
     IsolateProfilerData* profiler_data =
         new IsolateProfilerData(sample_buffer, !shared_buffer);
     ASSERT(profiler_data != NULL);
     isolate->set_profiler_data(profiler_data);
     if (FLAG_trace_profiled_isolates) {
       OS::Print("Profiler Setup %p %s\n", isolate, isolate->name());
     }
   }
 }
 
 
 void Profiler::ShutdownProfilingForIsolate(Isolate* isolate) {
   ASSERT(isolate != NULL);
   if (!FLAG_profile) {
     return;
   }
   // We do not have a current isolate.
   ASSERT(Isolate::Current() == NULL);
-  MonitorLocker ml(monitor_);
   {
     MutexLocker profiler_data_lock(isolate->profiler_data_mutex());
     IsolateProfilerData* profiler_data = isolate->profiler_data();
     if (profiler_data == NULL) {
       // Already freed.
       return;
     }
     isolate->set_profiler_data(NULL);
     delete profiler_data;
     if (FLAG_trace_profiled_isolates) {
@@ skipping 416 matching lines @@
   // Enable profile interrupts.
   BeginExecution(isolate);
 }
 
 
 intptr_t Profiler::ProcessSamples(Isolate* isolate,
                                   ProfilerCodeRegionTable* code_region_table,
                                   SampleBuffer* sample_buffer) {
   int64_t start = OS::GetCurrentTimeMillis();
   intptr_t samples = 0;
+  Sample* sample = Sample::Allocate();
   for (intptr_t i = 0; i < sample_buffer->capacity(); i++) {
-    Sample sample = sample_buffer->GetSample(i);
-    if (sample.isolate != isolate) {
+    sample_buffer->CopySample(i, sample);
+    if (sample->isolate != isolate) {
       continue;
     }
-    if (sample.timestamp == 0) {
+    if (sample->timestamp == 0) {
       continue;
     }
-    samples += ProcessSample(isolate, code_region_table, &sample);
+    samples += ProcessSample(isolate, code_region_table, sample);
   }
+  free(sample);
   int64_t end = OS::GetCurrentTimeMillis();
   if (FLAG_trace_profiled_isolates) {
     int64_t delta = end - start;
     OS::Print("Processed %" Pd " samples from %s in %" Pd64 " milliseconds.\n",
         samples,
         isolate->name(),
         delta);
   }
   return samples;
 }
 
 
 intptr_t Profiler::ProcessSample(Isolate* isolate,
                                  ProfilerCodeRegionTable* code_region_table,
                                 Sample* sample) {
   Sample::SampleType type = sample->type;
   if (type != Sample::kIsolateSample) {
     return 0;
   }
   if (sample->pcs[0] == 0) {
     // No frames in this sample.
     return 0;
   }
   intptr_t i = 0;
   // i points to the leaf (exclusive) PC sample. Do not tick the address.
   code_region_table->AddTick(sample->pcs[i], true, false);
   // Give all frames an inclusive tick and tick the address.
-  for (; i < Sample::kNumStackFrames; i++) {
+  for (; i < FLAG_profile_frames; i++) {
     if (sample->pcs[i] == 0) {
       break;
     }
     code_region_table->AddTick(sample->pcs[i], false, true);
   }
   return 1;
 }
 
 
 void Profiler::WriteProfile(Isolate* isolate) {
@@ skipping 47 matching lines @@
 
 IsolateProfilerData::~IsolateProfilerData() {
   if (own_sample_buffer_) {
     delete sample_buffer_;
     sample_buffer_ = NULL;
     own_sample_buffer_ = false;
   }
 }
 
 
+void Sample::CopyInto(Sample* dst) const {
+  ASSERT(dst != NULL);
+  dst->timestamp = timestamp;
+  dst->tid = tid;
+  dst->isolate = isolate;
+  dst->type = type;
+  dst->vm_tags = vm_tags;
+  dst->runtime_tags = runtime_tags;
+  for (intptr_t i = 0; i < FLAG_profile_frames; i++) {
+    dst->pcs[i] = pcs[i];
+  }
+}
+
+
+Sample* Sample::Allocate() {
+  return reinterpret_cast<Sample*>(malloc(InstanceSize()));
+}
+
+
+intptr_t Sample::InstanceSize() {
+  ASSERT(FLAG_profile_frames >= 1);
+  return sizeof(Sample) + (sizeof(intptr_t) * FLAG_profile_frames);  // NOLINT.

[siva, 2014/01/16 23:34:23]

Why did you choose this to be a function instead of just a static variable
instance_size_; that could be initialized in Profiler::InitOnce.

Not sure if all compilers will nicely constant fold the expression.

[Cutch, 2014/01/17 16:02:25]

Done.

+}
+
+
 void Sample::Init(SampleType type, Isolate* isolate, int64_t timestamp,
                   ThreadId tid) {
   this->timestamp = timestamp;
   this->tid = tid;
   this->isolate = isolate;
-  for (intptr_t i = 0; i < kNumStackFrames; i++) {
-    pcs[i] = 0;
-  }
   this->type = type;
   vm_tags = 0;
   runtime_tags = 0;
+  for (int i = 0; i < FLAG_profile_frames; i++) {
+    pcs[i] = 0;
+  }
 }
 
+
 SampleBuffer::SampleBuffer(intptr_t capacity) {
   capacity_ = capacity;
-  samples_ = reinterpret_cast<Sample*>(calloc(capacity, sizeof(Sample)));
+  samples_ = reinterpret_cast<Sample*>(
+      calloc(capacity, Sample::InstanceSize()));
   cursor_ = 0;
 }
 
 
 SampleBuffer::~SampleBuffer() {
   if (samples_ != NULL) {
     free(samples_);
     samples_ = NULL;
     cursor_ = 0;
     capacity_ = 0;
   }
 }
 
 
 Sample* SampleBuffer::ReserveSample() {
   ASSERT(samples_ != NULL);
   uintptr_t cursor = AtomicOperations::FetchAndIncrement(&cursor_);
   // Map back into sample buffer range.
   cursor = cursor % capacity_;
-  return &samples_[cursor];
+  return At(cursor);
 }
 
 
+void SampleBuffer::CopySample(intptr_t i, Sample* sample) const {
+  At(i)->CopyInto(sample);
+}
+
+
+Sample* SampleBuffer::At(intptr_t idx) const {
+  ASSERT(idx >= 0);
+  ASSERT(idx < capacity_);
+  intptr_t offset = idx * Sample::InstanceSize();
+  uint8_t* samples = reinterpret_cast<uint8_t*>(samples_);
+  return reinterpret_cast<Sample*>(samples + offset);
+}
+
+
 ProfilerSampleStackWalker::ProfilerSampleStackWalker(Sample* sample,
                                                      uintptr_t stack_lower,
                                                      uintptr_t stack_upper,
                                                      uintptr_t pc,
                                                      uintptr_t fp,
                                                      uintptr_t sp) :
     sample_(sample),
     stack_lower_(stack_lower),
     stack_upper_(stack_upper),
     original_pc_(pc),
     original_fp_(fp),
     original_sp_(sp),
     lower_bound_(stack_lower) {
   ASSERT(sample_ != NULL);
-  // Zero out the PCs before (re)using the sample.
-  for (int i = 0; i < Sample::kNumStackFrames; i++) {
-    sample_->pcs[i] = 0;
-  }
 }
 
 
+// Notes on stack frame walking:
+//
+// The sampling profiler will collect up to Sample::kNumStackFrames stack frames
+// The stack frame walking code uses the frame pointer to traverse the stack.
+// If the VM is compiled without frame pointers (which is the default on
+// recent GCC versions with optimizing enabled) the stack walking code may
+// fail (sometimes leading to a crash).
+//
+
 int ProfilerSampleStackWalker::walk() {
   const intptr_t kMaxStep = 0x1000;  // 4K.
   uword* pc = reinterpret_cast<uword*>(original_pc_);
   // Always store the exclusive PC.
   sample_->pcs[0] = original_pc_;
 #define WALK_STACK
 #if defined(WALK_STACK)
   uword* fp = reinterpret_cast<uword*>(original_fp_);
   uword* previous_fp = fp;
   if (original_sp_ > original_fp_) {
     // Stack pointer should not be above frame pointer.
     return 1;
   }
   intptr_t gap = original_fp_ - original_sp_;
   if (gap >= kMaxStep) {
     // Gap between frame pointer and stack pointer is
     // too large.
     return 1;
   }
   if (original_sp_ < lower_bound_) {
     // The stack pointer gives us a better lower bound than
     // the isolates stack limit.
     lower_bound_ = original_sp_;
   }
   int i = 0;
-  for (; i < Sample::kNumStackFrames; i++) {
+  for (; i < FLAG_profile_frames; i++) {
     sample_->pcs[i] = reinterpret_cast<uintptr_t>(pc);
     if (!ValidFramePointer(fp)) {
       return i + 1;
     }
     pc = CallerPC(fp);
     previous_fp = fp;
     fp = CallerFP(fp);
     intptr_t step = fp - previous_fp;
     if ((step >= kMaxStep) || (fp <= previous_fp) || !ValidFramePointer(fp)) {
       // Frame pointer step is too large.
@@ skipping 29 matching lines @@
     return false;
   }
   uintptr_t cursor = reinterpret_cast<uintptr_t>(fp);
   cursor += sizeof(fp);
   bool r = cursor >= lower_bound_ && cursor < stack_upper_;
   return r;
 }
 
 
 }  // namespace dart