Chain samples together to collect long stack traces in 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/address_sanitizer.h"
 #include "platform/memory_sanitizer.h"
 #include "platform/utils.h"
 
 #include "vm/allocation.h"
 #include "vm/atomic.h"
 #include "vm/code_patcher.h"
 #include "vm/instructions.h"
 #include "vm/isolate.h"
 #include "vm/json_stream.h"
 #include "vm/lockers.h"
 #include "vm/native_symbol.h"
 #include "vm/object.h"
 #include "vm/os.h"
 #include "vm/profiler.h"
 #include "vm/reusable_handles.h"
 #include "vm/signal_handler.h"
 #include "vm/simulator.h"
 #include "vm/stack_frame.h"
 
 namespace dart {
 
 
+static const intptr_t kSampleSize = 8;
+
 DECLARE_FLAG(bool, trace_profiler);
 
 DEFINE_FLAG(bool, profile, true, "Enable Sampling Profiler");
 DEFINE_FLAG(bool, trace_profiled_isolates, false, "Trace profiled isolates.");
 
 #if defined(TARGET_OS_ANDROID) || defined(TARGET_ARCH_ARM64) ||                \
     defined(TARGET_ARCH_ARM) || defined(TARGET_ARCH_MIPS)
   DEFINE_FLAG(int, profile_period, 10000,
               "Time between profiler samples in microseconds. Minimum 50.");
 #else
   DEFINE_FLAG(int, profile_period, 1000,
               "Time between profiler samples in microseconds. Minimum 50.");
 #endif
-DEFINE_FLAG(int, profile_depth, 8,
+DEFINE_FLAG(int, max_profile_depth, kSampleSize,
             "Maximum number stack frames walked. Minimum 1. Maximum 255.");
 #if defined(USING_SIMULATOR)
 DEFINE_FLAG(bool, profile_vm, true,
             "Always collect native stack traces.");
 #else
 DEFINE_FLAG(bool, profile_vm, false,
             "Always collect native stack traces.");
 #endif
 
 bool Profiler::initialized_ = false;
 SampleBuffer* Profiler::sample_buffer_ = NULL;
 
-static intptr_t NumberOfFramesToCollect() {
-  if (FLAG_profile_depth <= 0) {
-    return 0;
-  }
-  // Subtract to reserve space for the possible missing frame.
-  return FLAG_profile_depth - 1;
-}
 
 void Profiler::InitOnce() {
   // Place some sane restrictions on user controlled flags.
   SetSamplePeriod(FLAG_profile_period);
-  SetSampleDepth(FLAG_profile_depth);
+  SetSampleDepth(FLAG_max_profile_depth);
   Sample::InitOnce();
   if (!FLAG_profile) {
     return;
   }
   ASSERT(!initialized_);
   sample_buffer_ = new SampleBuffer();
   NativeSymbolResolver::InitOnce();
   ThreadInterrupter::SetInterruptPeriod(FLAG_profile_period);
   ThreadInterrupter::Startup();
   initialized_ = true;
 }
 
 
 void Profiler::Shutdown() {
   if (!FLAG_profile) {
     return;
   }
   ASSERT(initialized_);
   ThreadInterrupter::Shutdown();
   NativeSymbolResolver::ShutdownOnce();
 }
 
 
 void Profiler::SetSampleDepth(intptr_t depth) {
   const int kMinimumDepth = 2;
   const int kMaximumDepth = 255;
   if (depth < kMinimumDepth) {
-    FLAG_profile_depth = kMinimumDepth;
+    FLAG_max_profile_depth = kMinimumDepth;
   } else if (depth > kMaximumDepth) {
-    FLAG_profile_depth = kMaximumDepth;
+    FLAG_max_profile_depth = kMaximumDepth;
   } else {
-    FLAG_profile_depth = depth;
+    FLAG_max_profile_depth = depth;
   }
 }
 
 
 void Profiler::SetSamplePeriod(intptr_t period) {
   const int kMinimumProfilePeriod = 50;
   if (period < kMinimumProfilePeriod) {
     FLAG_profile_period = kMinimumProfilePeriod;
   } else {
     FLAG_profile_period = period;
@@ skipping 113 matching lines @@
     ThreadInterrupter::WakeUp();
   }
 }
 
 
 intptr_t Sample::pcs_length_ = 0;
 intptr_t Sample::instance_size_ = 0;
 
 
 void Sample::InitOnce() {
-  ASSERT(FLAG_profile_depth >= 2);
-  pcs_length_ = FLAG_profile_depth;
+  pcs_length_ = kSampleSize;
   instance_size_ =
       sizeof(Sample) + (sizeof(uword) * pcs_length_);  // NOLINT.
 }
 
 
 uword* Sample::GetPCArray() const {
   return reinterpret_cast<uword*>(
         reinterpret_cast<uintptr_t>(this) + sizeof(*this));
 }
 
@@ skipping 15 matching lines @@
 
 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);
 }
 
 
-Sample* SampleBuffer::ReserveSample() {
+intptr_t SampleBuffer::ReserveSampleSlot() {
   ASSERT(samples_ != NULL);
   uintptr_t cursor = AtomicOperations::FetchAndIncrement(&cursor_);
   // Map back into sample buffer range.
   cursor = cursor % capacity_;
-  return At(cursor);
+  return cursor;
 }
 
+Sample* SampleBuffer::ReserveSample() {
+  return At(ReserveSampleSlot());
+}
+
+
+Sample* SampleBuffer::ReserveSampleAndLink(Sample* previous) {
+  ASSERT(previous != NULL);
+  intptr_t next_index = ReserveSampleSlot();
+  Sample* next = At(next_index);
+  next->Init(previous->isolate(), previous->timestamp(), previous->tid());
+  next->set_head_sample(false);
+  // Mark that previous continues at next.
+  previous->SetContinuationIndex(next_index);
+  return next;
+}
+
+
 // Attempts to find the true return address when a Dart frame is being setup
 // or torn down.
 // NOTE: Architecture specific implementations below.
 class ReturnAddressLocator : public ValueObject {
  public:
   ReturnAddressLocator(Sample* sample, const Code& code)
       : stack_buffer_(sample->GetStackBuffer()),
         pc_(sample->pc()),
         code_(Code::ZoneHandle(code.raw())) {
     ASSERT(!code_.IsNull());
@@ skipping 114 matching lines @@
 ClearProfileVisitor::ClearProfileVisitor(Isolate* isolate)
     : SampleVisitor(isolate) {
 }
 
 
 void ClearProfileVisitor::VisitSample(Sample* sample) {
   sample->Clear();
 }
 
 
+class ProfilerStackWalker : public ValueObject {
+ public:
+  ProfilerStackWalker(Isolate* isolate,
+                      Sample* head_sample,
+                      SampleBuffer* sample_buffer)
+    : isolate_(isolate),
+      sample_(head_sample),
+      sample_buffer_(sample_buffer),
+      frame_index_(0),
+      total_frames_(0) {
+    ASSERT(isolate_ != NULL);
+    ASSERT(sample_ != NULL);
+    ASSERT(sample_buffer_ != NULL);
+    ASSERT(sample_->head_sample());
+  }
+
+  bool Append(uword pc) {
+    if (total_frames_ >= FLAG_max_profile_depth) {
+      sample_->set_truncated_trace(true);
+      return false;
+    }
+    ASSERT(sample_ != NULL);
+    if (frame_index_ == kSampleSize) {
+      Sample* new_sample = sample_buffer_->ReserveSampleAndLink(sample_);
+      if (new_sample == NULL) {
+        // Could not reserve new sample- mark this as truncated.
+        sample_->set_truncated_trace(true);
+        return false;
+      }
+      frame_index_ = 0;
+      sample_ = new_sample;
+    }
+    ASSERT(frame_index_ < kSampleSize);
+    sample_->SetAt(frame_index_, pc);
+    frame_index_++;
+    total_frames_++;
+    return true;
+  }
+
+ protected:
+  Isolate* isolate_;
+  Sample* sample_;
+  SampleBuffer* sample_buffer_;
+  intptr_t frame_index_;
+  intptr_t total_frames_;
+};
+
+
 // Given an exit frame, walk the Dart stack.
-class ProfilerDartExitStackWalker : public ValueObject {
+class ProfilerDartExitStackWalker : public ProfilerStackWalker {
  public:
-  ProfilerDartExitStackWalker(Isolate* isolate, Sample* sample)
-      : sample_(sample),
+  ProfilerDartExitStackWalker(Isolate* isolate,
+                              Sample* sample,
+                              SampleBuffer* sample_buffer)
+      : ProfilerStackWalker(isolate, sample, sample_buffer),
         frame_iterator_(isolate) {
-    ASSERT(sample_ != NULL);
   }
 
   void walk() {
     // Mark that this sample was collected from an exit frame.
     sample_->set_exit_frame_sample(true);
-    intptr_t frame_index = 0;
+
     StackFrame* frame = frame_iterator_.NextFrame();
     while (frame != NULL) {
-      sample_->SetAt(frame_index, frame->pc());
-      frame_index++;
-      if (frame_index >= NumberOfFramesToCollect()) {
-        sample_->set_truncated_trace(true);
-        break;
+      if (!Append(frame->pc())) {
+        return;
       }
       frame = frame_iterator_.NextFrame();
     }
   }
 
  private:
-  Sample* sample_;
   DartFrameIterator frame_iterator_;
 };
 
 
 // Executing Dart code, walk the stack.
-class ProfilerDartStackWalker : public ValueObject {
+class ProfilerDartStackWalker : public ProfilerStackWalker {
  public:
-  ProfilerDartStackWalker(Sample* sample,
+  ProfilerDartStackWalker(Isolate* isolate,
+                          Sample* sample,
+                          SampleBuffer* sample_buffer,
                           uword stack_lower,
                           uword stack_upper,
                           uword pc,
                           uword fp,
                           uword sp)
-      : sample_(sample),
+      : ProfilerStackWalker(isolate, sample, sample_buffer),
         stack_upper_(stack_upper),
         stack_lower_(stack_lower) {
-    ASSERT(sample_ != NULL);
     pc_ = reinterpret_cast<uword*>(pc);
     fp_ = reinterpret_cast<uword*>(fp);
     sp_ = reinterpret_cast<uword*>(sp);
   }
 
   void walk() {
     sample_->set_exit_frame_sample(false);
     if (!ValidFramePointer()) {
       sample_->set_ignore_sample(true);
       return;
     }
     ASSERT(ValidFramePointer());
     uword return_pc = InitialReturnAddress();
     if (StubCode::InInvocationStub(return_pc)) {
       // Edge case- we have called out from the Invocation Stub but have not
       // created the stack frame of the callee. Attempt to locate the exit
       // frame before walking the stack.
       if (!NextExit() || !ValidFramePointer()) {
         // Nothing to sample.
         sample_->set_ignore_sample(true);
         return;
       }
     }
-    for (int i = 0; i < NumberOfFramesToCollect(); i++) {
-      sample_->SetAt(i, reinterpret_cast<uword>(pc_));
+    while (true) {
+      if (!Append(reinterpret_cast<uword>(pc_))) {
+        return;
+      }
       if (!Next()) {
         return;
       }
     }
-    sample_->set_truncated_trace(true);
   }
 
  private:
   bool Next() {
     if (!ValidFramePointer()) {
       return false;
     }
     if (StubCode::InInvocationStub(reinterpret_cast<uword>(pc_))) {
       // In invocation stub.
       return NextExit();
@@ skipping 82 matching lines @@
       return false;
     }
     uword cursor = reinterpret_cast<uword>(fp);
     cursor += sizeof(fp);
     return (cursor >= stack_lower_) && (cursor < stack_upper_);
   }
 
   uword* pc_;
   uword* fp_;
   uword* sp_;
-  Sample* sample_;
   const uword stack_upper_;
   uword stack_lower_;
 };
 
 
 // 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.
 //
-class ProfilerNativeStackWalker : public ValueObject {
+class ProfilerNativeStackWalker : public ProfilerStackWalker {
  public:
-  ProfilerNativeStackWalker(Sample* sample,
+  ProfilerNativeStackWalker(Isolate* isolate,
+                            Sample* sample,
+                            SampleBuffer* sample_buffer,
                             uword stack_lower,
                             uword stack_upper,
                             uword pc,
                             uword fp,
                             uword sp)
-      : sample_(sample),
+      : ProfilerStackWalker(isolate, sample, sample_buffer),
         stack_upper_(stack_upper),
         original_pc_(pc),
         original_fp_(fp),
         original_sp_(sp),
         lower_bound_(stack_lower) {
-    ASSERT(sample_ != NULL);
   }
 
   void walk() {
     const uword kMaxStep = VirtualMemory::PageSize();
 
-    sample_->SetAt(0, original_pc_);
+    Append(original_pc_);
 
     uword* pc = reinterpret_cast<uword*>(original_pc_);
     uword* fp = reinterpret_cast<uword*>(original_fp_);
     uword* previous_fp = fp;
 
     uword gap = original_fp_ - original_sp_;
     if (gap >= kMaxStep) {
       // Gap between frame pointer and stack pointer is
       // too large.
       return;
     }
 
     if (!ValidFramePointer(fp)) {
       return;
     }
 
-    for (int i = 0; i < NumberOfFramesToCollect(); i++) {
-      sample_->SetAt(i, reinterpret_cast<uword>(pc));
+    while (true) {
+      if (!Append(reinterpret_cast<uword>(pc))) {
+        return;
+      }
 
       pc = CallerPC(fp);
       previous_fp = fp;
       fp = CallerFP(fp);
 
       if (fp == NULL) {
         return;
       }
 
       if (fp <= previous_fp) {
         // Frame pointer did not move to a higher address.
         return;
       }
 
       gap = fp - previous_fp;
       if (gap >= kMaxStep) {
         // Frame pointer step is too large.
         return;
       }
 
       if (!ValidFramePointer(fp)) {
         // Frame pointer is outside of isolate stack boundary.
         return;
       }
 
       // Move the lower bound up.
       lower_bound_ = reinterpret_cast<uword>(fp);
     }
-
-    sample_->set_truncated_trace(true);
   }
 
  private:
   uword* CallerPC(uword* fp) const {
     ASSERT(fp != NULL);
     uword* caller_pc_ptr = fp + kSavedCallerPcSlotFromFp;
     // This may actually be uninitialized, by design (see class comment above).
     MSAN_UNPOISON(caller_pc_ptr, kWordSize);
     ASAN_UNPOISON(caller_pc_ptr, kWordSize);
     return reinterpret_cast<uword*>(*caller_pc_ptr);
@@ skipping 11 matching lines @@
   bool ValidFramePointer(uword* fp) const {
     if (fp == NULL) {
       return false;
     }
     uword cursor = reinterpret_cast<uword>(fp);
     cursor += sizeof(fp);
     bool r = (cursor >= lower_bound_) && (cursor < stack_upper_);
     return r;
   }
 
-  Sample* sample_;
   const uword stack_upper_;
   const uword original_pc_;
   const uword original_fp_;
   const uword original_sp_;
   uword lower_bound_;
 };
 
 
 static void CopyPCMarkerIfSafe(Sample* sample, uword fp_addr, uword sp_addr) {
   ASSERT(sample != NULL);
@@ skipping 286 matching lines @@
                                           &stack_lower,
                                           &stack_upper)) {
       // Could not get stack boundary.
       return;
     }
 
     Sample* sample = SetupSample(isolate,
                                  sample_buffer,
                                  OSThread::GetCurrentThreadId());
     sample->SetAllocationCid(cid);
-    ProfilerNativeStackWalker native_stack_walker(sample,
+    ProfilerNativeStackWalker native_stack_walker(isolate,
+                                                  sample,
+                                                  sample_buffer,
                                                   stack_lower,
                                                   stack_upper,
                                                   pc,
                                                   fp,
                                                   sp);
     native_stack_walker.walk();
   } else if (exited_dart_code) {
     Sample* sample = SetupSample(isolate,
                                  sample_buffer,
                                  OSThread::GetCurrentThreadId());
     sample->SetAllocationCid(cid);
-    ProfilerDartExitStackWalker dart_exit_stack_walker(isolate, sample);
+    ProfilerDartExitStackWalker dart_exit_stack_walker(isolate,
+                                                       sample,
+                                                       sample_buffer);
     dart_exit_stack_walker.walk();
   } else {
     // Fall back.
     uintptr_t pc = GetProgramCounter();
     Sample* sample = SetupSample(isolate,
                                  sample_buffer,
                                  OSThread::GetCurrentThreadId());
     sample->SetAllocationCid(cid);
     sample->set_vm_tag(VMTag::kEmbedderTagId);
     sample->SetAt(0, pc);
@@ skipping 69 matching lines @@
 
   // Setup sample.
   Sample* sample = SetupSample(isolate,
                                sample_buffer,
                                OSThread::GetCurrentThreadId());
   // Increment counter for vm tag.
   VMTagCounters* counters = isolate->vm_tag_counters();
   ASSERT(counters != NULL);
   counters->Increment(sample->vm_tag());
 
-  ProfilerNativeStackWalker native_stack_walker(sample,
+  ProfilerNativeStackWalker native_stack_walker(isolate,
+                                                sample,
+                                                sample_buffer,
                                                 stack_lower,
                                                 stack_upper,
                                                 pc,
                                                 fp,
                                                 sp);
 
-  ProfilerDartExitStackWalker dart_exit_stack_walker(isolate, sample);
+  ProfilerDartExitStackWalker dart_exit_stack_walker(isolate,
+                                                     sample,
+                                                     sample_buffer);
 
-  ProfilerDartStackWalker dart_stack_walker(sample,
+  ProfilerDartStackWalker dart_stack_walker(isolate,
+                                            sample,
+                                            sample_buffer,
                                             stack_lower,
                                             stack_upper,
                                             pc,
                                             fp,
                                             sp);
 
   // All memory access is done inside CollectSample.
   CollectSample(isolate,
                 exited_dart_code,
                 in_dart_code,
@@ skipping 15 matching lines @@
 
   ProcessedSampleBuffer* buffer = new(zone) ProcessedSampleBuffer();
 
   const intptr_t length = capacity();
   for (intptr_t i = 0; i < length; i++) {
     Sample* sample = At(i);
     if (sample->ignore_sample()) {
       // Bad sample.
       continue;
     }
+    if (!sample->head_sample()) {
+        // An inner sample in a chain of samples.
+        continue;
+      }
     if (sample->isolate() != filter->isolate()) {
       // Another isolate.
       continue;
     }
     if (sample->timestamp() == 0) {
       // Empty.
       continue;
     }
     if (sample->At(0) == 0) {
       // No frames.
@@ skipping 21 matching lines @@
   processed_sample->set_user_tag(sample->user_tag());
   if (sample->is_allocation_sample()) {
     processed_sample->set_allocation_cid(sample->allocation_cid());
   }
   processed_sample->set_first_frame_executing(!sample->exit_frame_sample());
 
   // Copy stack trace from sample(s).
   bool truncated = false;
   Sample* current = sample;
   while (current != NULL) {
-    for (intptr_t i = 0; i < FLAG_profile_depth; i++) {
+    for (intptr_t i = 0; i < kSampleSize; i++) {
       if (current->At(i) == 0) {
         break;
       }
       processed_sample->Add(current->At(i));
     }
 
     truncated = truncated || current->truncated_trace();
-    current = Next(sample);
+    current = Next(current);
   }
 
   if (!sample->exit_frame_sample()) {
     Isolate* isolate = thread->isolate();
     Isolate* vm_isolate = Dart::vm_isolate();
     processed_sample->FixupCaller(isolate,
                                   vm_isolate,
                                   sample->pc_marker(),
                                   sample->GetStackBuffer());
   }
 
   processed_sample->set_truncated(truncated);
   return processed_sample;
 }
 
 
 Sample* SampleBuffer::Next(Sample* sample) {
-  // TODO(johnmccutchan): Support chaining samples for complete stack traces.
-  return NULL;
+  if (!sample->is_continuation_sample())
+    return NULL;
+  Sample* next_sample = At(sample->continuation_index());
+  // Sanity check.
+  ASSERT(sample != next_sample);
+  // Detect invalid chaining.
+  if (sample->isolate() != next_sample->isolate()) {
+    return NULL;
+  }
+  if (sample->timestamp() != next_sample->timestamp()) {
+    return NULL;
+  }
+  if (sample->tid() != next_sample->tid()) {
+    return NULL;
+  }
+  return next_sample;
 }
 
 
 ProcessedSample::ProcessedSample()
-    : pcs_(FLAG_profile_depth),
+    : pcs_(kSampleSize),
       timestamp_(0),
       vm_tag_(0),
       user_tag_(0),
       allocation_cid_(-1),
       truncated_(false) {
 }
 
 
 void ProcessedSample::FixupCaller(Isolate* isolate,
                                   Isolate* vm_isolate,
@@ skipping 90 matching lines @@
                                                uword pc) {
   return vm_isolate->heap()->CodeContains(pc)
          || isolate->heap()->CodeContains(pc);
 }
 
 
 ProcessedSampleBuffer::ProcessedSampleBuffer() {
 }
 
 }  // namespace dart