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_depth, 8,
+            "Maximum number stack frames walked. Minimum 1. Maximum 128.");
 
 bool Profiler::initialized_ = false;
-Monitor* Profiler::monitor_ = NULL;
 SampleBuffer* Profiler::sample_buffer_ = NULL;
 
 void Profiler::InitOnce() {
   const int kMinimumProfilePeriod = 250;
+  const int kMinimumDepth = 1;
+  const int kMaximumDepth = 128;
   if (!FLAG_profile) {
     return;
   }
   ASSERT(!initialized_);
-  initialized_ = true;
-  monitor_ = new Monitor();
+  // Place some sane restrictions on user controlled flags.
+  if (FLAG_profile_period < kMinimumProfilePeriod) {
+    FLAG_profile_period = kMinimumProfilePeriod;
+  }
+  if (FLAG_profile_depth < kMinimumDepth) {
+    FLAG_profile_depth = kMinimumDepth;
+  } else if (FLAG_profile_depth > kMaximumDepth) {
+    FLAG_profile_depth = kMaximumDepth;
+  }
+  Sample::InitOnce();
   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) {
+  if (sample->type() != Sample::kIsolateSample) {
     return 0;
   }
-  if (sample->pcs[0] == 0) {
+  if (sample->At(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);
+  code_region_table->AddTick(sample->At(0), true, false);
   // Give all frames an inclusive tick and tick the address.
-  for (; i < Sample::kNumStackFrames; i++) {
-    if (sample->pcs[i] == 0) {
+  for (intptr_t i = 0; i < FLAG_profile_depth; i++) {
+    if (sample->At(i) == 0) {
       break;
     }
-    code_region_table->AddTick(sample->pcs[i], false, true);
+    code_region_table->AddTick(sample->At(i), false, true);
   }
   return 1;
 }
 
 
 void Profiler::WriteProfile(Isolate* isolate) {
   if (isolate == NULL) {
     return;
   }
   if (!FLAG_profile) {
@@ skipping 43 matching lines @@
 
 IsolateProfilerData::~IsolateProfilerData() {
   if (own_sample_buffer_) {
     delete sample_buffer_;
     sample_buffer_ = NULL;
     own_sample_buffer_ = false;
   }
 }
 
 
+intptr_t Sample::instance_size_ = 0;
+
+void Sample::InitOnce() {
+  ASSERT(FLAG_profile_depth >= 1);
+  instance_size_ =
+     sizeof(Sample) + (sizeof(intptr_t) * FLAG_profile_depth);  // NOLINT.
+}
+
+
+uintptr_t Sample::At(intptr_t i) const {
+  ASSERT(i >= 0);
+  ASSERT(i < FLAG_profile_depth);
+  return pcs_[i];
+}
+
+
+void Sample::SetAt(intptr_t i, uintptr_t pc) {
+  ASSERT(i >= 0);
+  ASSERT(i < FLAG_profile_depth);
+  pcs_[i] = pc;
+}
+
+
 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;
+  timestamp_ = timestamp;
+  tid_ = tid;
+  isolate_ = isolate;
+  type_ = type;
+  for (int i = 0; i < FLAG_profile_depth; i++) {
+    pcs_[i] = 0;
   }
-  this->type = type;
-  vm_tags = 0;
-  runtime_tags = 0;
 }
 
+
+void Sample::CopyInto(Sample* dst) const {
+  ASSERT(dst != NULL);
+  dst->timestamp_ = timestamp_;
+  dst->tid_ = tid_;
+  dst->isolate_ = isolate_;
+  dst->type_ = type_;
+  for (intptr_t i = 0; i < FLAG_profile_depth; i++) {
+    dst->pcs_[i] = pcs_[i];
+  }
+}
+
+
+Sample* Sample::Allocate() {
+  return reinterpret_cast<Sample*>(malloc(instance_size()));
+}
+
+
 SampleBuffer::SampleBuffer(intptr_t capacity) {
   capacity_ = capacity;
-  samples_ = reinterpret_cast<Sample*>(calloc(capacity, sizeof(Sample)));
+  samples_ = reinterpret_cast<Sample*>(
+      calloc(capacity, Sample::instance_size()));
   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::instance_size();
+  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.
+  const bool kWalkStack = true;  // Walk the stack.
+  // Always store the exclusive PC.
+  sample_->SetAt(0, original_pc_);
+  if (!kWalkStack) {
+    // Not walking the stack, only took exclusive sample.
+    return 1;
+  }
   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++) {
-    sample_->pcs[i] = reinterpret_cast<uintptr_t>(pc);
+  for (; i < FLAG_profile_depth; i++) {
+    sample_->SetAt(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.
       // Frame pointer did not move to a higher address.
       // Frame pointer is outside of isolate stack bounds.
       return i + 1;
     }
     // Move the lower bound up.
     lower_bound_ = reinterpret_cast<uintptr_t>(fp);
   }
   return i;
-#else
-  sample_->pcs[0] = reinterpret_cast<uintptr_t>(pc);
-  return 0;
-#endif
 }
 
 
 uword* ProfilerSampleStackWalker::CallerPC(uword* fp) {
   ASSERT(fp != NULL);
   return reinterpret_cast<uword*>(*(fp + 1));
 }
 
 
 uword* ProfilerSampleStackWalker::CallerFP(uword* fp) {
   ASSERT(fp != NULL);
   return reinterpret_cast<uword*>(*fp);
 }
 
 
 bool ProfilerSampleStackWalker::ValidFramePointer(uword* fp) {
   if (fp == NULL) {
     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