Updated MallocHooks to collect stack traces when memory is allocated.

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"
@@ skipping 150 matching lines @@
 
 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->Init(previous->port(), 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.
@@ skipping 132 matching lines @@
 }
 
 
 bool SampleFilter::TaskFilterSample(Sample* sample) {
   const intptr_t task = static_cast<intptr_t>(sample->thread_task());
   return (task & thread_task_mask_) != 0;
 }
 
 
 ClearProfileVisitor::ClearProfileVisitor(Isolate* isolate)
-    : SampleVisitor(isolate) {}
+    : SampleVisitor(isolate->main_port()) {}
 
 
 void ClearProfileVisitor::VisitSample(Sample* sample) {
   sample->Clear();
 }
 
 
 static void DumpStackFrame(intptr_t frame_index, uword pc) {
   Isolate* isolate = Isolate::Current();
   if ((isolate != NULL) && isolate->is_runnable()) {
@@ skipping 15 matching lines @@
     OS::PrintErr("  [0x%" Pp "] Unknown symbol\n", pc);
   } else {
     OS::PrintErr("  [0x%" Pp "] %s\n", pc, native_symbol_name);
     NativeSymbolResolver::FreeSymbolName(native_symbol_name);
   }
 }
 
 
 class ProfilerStackWalker : public ValueObject {
  public:
-  ProfilerStackWalker(Isolate* isolate,
+  ProfilerStackWalker(Dart_Port port_id,
                       Sample* head_sample,
-                      SampleBuffer* sample_buffer)
-      : isolate_(isolate),
+                      SampleBuffer* sample_buffer,
+                      intptr_t skip_count = 0)
+      : port_id_(port_id),
         sample_(head_sample),
         sample_buffer_(sample_buffer),
+        skip_count_(skip_count),
+        frames_skipped_(0),
         frame_index_(0),
         total_frames_(0) {
-    ASSERT(isolate_ != NULL);
     if (sample_ == NULL) {
       ASSERT(sample_buffer_ == NULL);
     } else {
       ASSERT(sample_buffer_ != NULL);
       ASSERT(sample_->head_sample());
     }
   }
 
   bool Append(uword pc) {
+    if (frames_skipped_ < skip_count_) {
+      frames_skipped_++;
+      return true;
+    }
+
     if (sample_ == NULL) {
       DumpStackFrame(frame_index_, pc);
       frame_index_++;
       total_frames_++;
       return true;
     }
     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_;
+  Dart_Port port_id_;
   Sample* sample_;
   SampleBuffer* sample_buffer_;
+  intptr_t skip_count_;
+  intptr_t frames_skipped_;
   intptr_t frame_index_;
   intptr_t total_frames_;
 };
 
 
 // Executing Dart code, walk the stack.
 class ProfilerDartStackWalker : public ProfilerStackWalker {
  public:
   ProfilerDartStackWalker(Thread* thread,
                           Sample* sample,
                           SampleBuffer* sample_buffer,
                           uword stack_lower,
                           uword stack_upper,
                           uword pc,
                           uword fp,
                           uword sp,
                           bool exited_dart_code,
-                          bool allocation_sample)
-      : ProfilerStackWalker(thread->isolate(), sample, sample_buffer),
+                          bool allocation_sample,
+                          intptr_t skip_count = 0)
+      : ProfilerStackWalker((thread->isolate() != NULL)
+                                ? thread->isolate()->main_port()
+                                : ILLEGAL_PORT,
+                            sample,
+                            sample_buffer,
+                            skip_count),
         pc_(reinterpret_cast<uword*>(pc)),
         fp_(reinterpret_cast<uword*>(fp)),
         sp_(reinterpret_cast<uword*>(sp)),
         stack_upper_(stack_upper),
         stack_lower_(stack_lower),
         has_exit_frame_(exited_dart_code) {
     if (exited_dart_code) {
       StackFrameIterator iterator(StackFrameIterator::kDontValidateFrames,
                                   thread);
       pc_ = NULL;
@@ skipping 151 matching lines @@
   bool has_exit_frame_;
 };
 
 
 // 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 ProfilerStackWalker {
  public:
-  ProfilerNativeStackWalker(Isolate* isolate,
+  ProfilerNativeStackWalker(Dart_Port port_id,
                             Sample* sample,
                             SampleBuffer* sample_buffer,
                             uword stack_lower,
                             uword stack_upper,
                             uword pc,
                             uword fp,
-                            uword sp)
-      : ProfilerStackWalker(isolate, sample, sample_buffer),
+                            uword sp,
+                            intptr_t skip_count = 0)
+      : ProfilerStackWalker(port_id, sample, sample_buffer, skip_count),
         stack_upper_(stack_upper),
         original_pc_(pc),
         original_fp_(fp),
         original_sp_(sp),
         lower_bound_(stack_lower) {}
 
   void walk() {
     const uword kMaxStep = VirtualMemory::PageSize();
+
     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.
@@ skipping 162 matching lines @@
         VirtualProtect(reinterpret_cast<void*>(fault_address),
                        sizeof(fault_address), new_protect, &old_protect);
     USE(success);
     ASSERT(success);
     ASSERT(old_protect == PAGE_READWRITE);
   }
 #endif
 }
 
 
+static bool ValidateThreadStackBounds(uintptr_t fp,
+                                      uintptr_t sp,
+                                      uword stack_lower,
+                                      uword stack_upper) {
+  if (stack_lower >= stack_upper) {
+    // Stack boundary is invalid.
+    return false;
+  }
+
+  if ((sp < stack_lower) || (sp >= stack_upper)) {
+    // Stack pointer is outside thread's stack boundary.
+    return false;
+  }
+
+  if ((fp < stack_lower) || (fp >= stack_upper)) {
+    // Frame pointer is outside threads's stack boundary.
+    return false;
+  }
+
+  return true;
+}
+
+
 // Get |isolate|'s stack boundary and verify that |sp| and |fp| are within
 // it. If |get_os_thread_bounds| is true then if |isolate| stackbounds are
 // not available we fallback to using underlying OS thread bounds. This only
 // works for the current thread.
 // Return |false| if anything looks suspicious.
 static bool GetAndValidateThreadStackBounds(Thread* thread,
                                             uintptr_t fp,
                                             uintptr_t sp,
                                             uword* stack_lower,
                                             uword* stack_upper,
                                             bool get_os_thread_bounds = false) {
-  ASSERT(thread != NULL);
-  OSThread* os_thread = thread->os_thread();
+  OSThread* os_thread = NULL;
+  if (thread != NULL) {
+    os_thread = thread->os_thread();
+  } else {
+    os_thread = OSThread::Current();
+  }
   ASSERT(os_thread != NULL);
   ASSERT(stack_lower != NULL);
   ASSERT(stack_upper != NULL);
   ASSERT(!get_os_thread_bounds || (Thread::Current() == thread));
 
 #if defined(USING_SIMULATOR)
   const bool use_simulator_stack_bounds = thread->IsExecutingDartCode();
   if (use_simulator_stack_bounds) {
     Isolate* isolate = thread->isolate();
     ASSERT(isolate != NULL);
@@ skipping 15 matching lines @@
 
   if ((*stack_lower == 0) || (*stack_upper == 0)) {
     return false;
   }
 
   if (!use_simulator_stack_bounds && (sp > *stack_lower)) {
     // The stack pointer gives us a tighter lower bound.
     *stack_lower = sp;
   }
 
-  if (*stack_lower >= *stack_upper) {
-    // Stack boundary is invalid.
-    return false;
-  }
-
-  if ((sp < *stack_lower) || (sp >= *stack_upper)) {
-    // Stack pointer is outside thread's stack boundary.
-    return false;
-  }
-
-  if ((fp < *stack_lower) || (fp >= *stack_upper)) {
-    // Frame pointer is outside threads's stack boundary.
-    return false;
-  }
-
-  return true;
+  return ValidateThreadStackBounds(fp, sp, *stack_lower, *stack_upper);
 }
 
 
 // Some simple sanity checking of |pc|, |fp|, and |sp|.
 static bool InitialRegisterCheck(uintptr_t pc, uintptr_t fp, uintptr_t sp) {
   if ((sp == 0) || (fp == 0) || (pc == 0)) {
     // None of these registers should be zero.
     return false;
   }
 
   if (sp > fp) {
     // Assuming the stack grows down, we should never have a stack pointer above
     // the frame pointer.
     return false;
   }
 
   return true;
 }
 
 
 static Sample* SetupSample(Thread* thread,
                            SampleBuffer* sample_buffer,
                            ThreadId tid) {
   ASSERT(thread != NULL);
   Isolate* isolate = thread->isolate();
   ASSERT(sample_buffer != NULL);
   Sample* sample = sample_buffer->ReserveSample();
-  sample->Init(isolate, OS::GetCurrentMonotonicMicros(), tid);
+  sample->Init(isolate->main_port(), OS::GetCurrentMonotonicMicros(), tid);
   uword vm_tag = thread->vm_tag();
 #if defined(USING_SIMULATOR) && !defined(TARGET_ARCH_DBC)
   // When running in the simulator, the runtime entry function address
   // (stored as the vm tag) is the address of a redirect function.
   // Attempt to find the real runtime entry function address and use that.
   uword redirect_vm_tag = Simulator::FunctionForRedirect(vm_tag);
   if (redirect_vm_tag != 0) {
     vm_tag = redirect_vm_tag;
   }
 #endif
   sample->set_vm_tag(vm_tag);
   sample->set_user_tag(isolate->user_tag());
   sample->set_thread_task(thread->task_kind());
   return sample;
 }
 
 
+static Sample* SetupSampleNative(SampleBuffer* sample_buffer, ThreadId tid) {
+  Sample* sample = sample_buffer->ReserveSample();
+  sample->Init(ILLEGAL_PORT, OS::GetCurrentMonotonicMicros(), tid);
+
+  Thread* thread = Thread::Current();
+
+  // TODO(bkonyi) Any samples created while a current thread doesn't exist are
+  // ignored by the NativeAllocationSampleFilter since the default task is
+  // kUnknownTask. Is this what we want to do?
+  if (thread != NULL) {
+    sample->set_thread_task(thread->task_kind());
+  }
+  return sample;
+}
+
+
 static bool CheckIsolate(Isolate* isolate) {
   if ((isolate == NULL) || (Dart::vm_isolate() == NULL)) {
     // No isolate.
     return false;
   }
   return isolate != Dart::vm_isolate();
 }
 
 
-#if defined(TARGET_OS_WINDOWS)
-__declspec(noinline) static uintptr_t GetProgramCounter() {
-  return reinterpret_cast<uintptr_t>(_ReturnAddress());
-}
-#else
-static uintptr_t __attribute__((noinline)) GetProgramCounter() {
-  return reinterpret_cast<uintptr_t>(
-      __builtin_extract_return_addr(__builtin_return_address(0)));
-}
-#endif
-
-
 void Profiler::DumpStackTrace(void* context) {
 #if defined(TARGET_OS_LINUX) || defined(TARGET_OS_MACOS)
   ucontext_t* ucontext = reinterpret_cast<ucontext_t*>(context);
   mcontext_t mcontext = ucontext->uc_mcontext;
   uword pc = SignalHandler::GetProgramCounter(mcontext);
   uword fp = SignalHandler::GetFramePointer(mcontext);
   uword sp = SignalHandler::GetCStackPointer(mcontext);
   DumpStackTrace(sp, fp, pc);
 #else
 // TODO(fschneider): Add support for more platforms.
 // Do nothing on unsupported platforms.
 #endif
 }
 
 
 void Profiler::DumpStackTrace() {
   uintptr_t sp = Thread::GetCurrentStackPointer();
   uintptr_t fp = 0;
-  uintptr_t pc = GetProgramCounter();
+  uintptr_t pc = OS::GetProgramCounter();
 
   COPY_FP_REGISTER(fp);
 
   DumpStackTrace(sp, fp, pc);
 }
 
 
 void Profiler::DumpStackTrace(uword sp, uword fp, uword pc) {
   // Allow only one stack trace to prevent recursively printing stack traces if
   // we hit an assert while printing the stack.
@@ skipping 27 matching lines @@
 
   if (!GetAndValidateThreadStackBounds(thread, fp, sp, &stack_lower,
                                        &stack_upper,
                                        /*get_os_thread_bounds=*/true)) {
     OS::PrintErr(
         "Stack dump aborted because GetAndValidateThreadStackBounds.\n");
     return;
   }
 
   ProfilerNativeStackWalker native_stack_walker(
-      isolate, NULL, NULL, stack_lower, stack_upper, pc, fp, sp);
+      (isolate != NULL) ? isolate->main_port() : ILLEGAL_PORT, NULL, NULL,
+      stack_lower, stack_upper, pc, fp, sp);
   native_stack_walker.walk();
   OS::PrintErr("-- End of DumpStackTrace\n");
 }
 
 
 void Profiler::SampleAllocation(Thread* thread, intptr_t cid) {
   ASSERT(thread != NULL);
   OSThread* os_thread = thread->os_thread();
   ASSERT(os_thread != NULL);
   Isolate* isolate = thread->isolate();
   if (!CheckIsolate(isolate)) {
     return;
   }
 
   const bool exited_dart_code = thread->HasExitedDartCode();
 
   SampleBuffer* sample_buffer = Profiler::sample_buffer();
   if (sample_buffer == NULL) {
     // Profiler not initialized.
     return;
   }
 
   uintptr_t sp = Thread::GetCurrentStackPointer();
   uintptr_t fp = 0;
-  uintptr_t pc = GetProgramCounter();
+  uintptr_t pc = OS::GetProgramCounter();
 
   COPY_FP_REGISTER(fp);
 
   uword stack_lower = 0;
   uword stack_upper = 0;
 
   if (!InitialRegisterCheck(pc, fp, sp)) {
     return;
   }
 
   if (!GetAndValidateThreadStackBounds(thread, fp, sp, &stack_lower,
                                        &stack_upper)) {
     // Could not get stack boundary.
     return;
   }
 
   Sample* sample = SetupSample(thread, sample_buffer, os_thread->trace_id());
   sample->SetAllocationCid(cid);
 
   if (FLAG_profile_vm) {
     ProfilerNativeStackWalker native_stack_walker(
-        isolate, sample, sample_buffer, stack_lower, stack_upper, pc, fp, sp);
+        (isolate != NULL) ? isolate->main_port() : ILLEGAL_PORT, sample,
+        sample_buffer, stack_lower, stack_upper, pc, fp, sp);
     native_stack_walker.walk();
   } else if (exited_dart_code) {
     ProfilerDartStackWalker dart_exit_stack_walker(
         thread, sample, sample_buffer, stack_lower, stack_upper, pc, fp, sp,
         exited_dart_code, true);
     dart_exit_stack_walker.walk();
   } else {
     // Fall back.
-    uintptr_t pc = GetProgramCounter();
+    uintptr_t pc = OS::GetProgramCounter();
     Sample* sample = SetupSample(thread, sample_buffer, os_thread->trace_id());
     sample->SetAllocationCid(cid);
     sample->SetAt(0, pc);
   }
 }
 
 
+Sample* Profiler::SampleNativeAllocation(intptr_t skip_count) {
+  SampleBuffer* sample_buffer = Profiler::sample_buffer();
+  if (sample_buffer == NULL) {
+    return NULL;
+  }
+
+  uintptr_t sp = Thread::GetCurrentStackPointer();
+  uintptr_t fp = 0;
+  uintptr_t pc = OS::GetProgramCounter();
+
+  COPY_FP_REGISTER(fp);
+
+  uword stack_lower = 0;
+  uword stack_upper = 0;
+  if (!InitialRegisterCheck(pc, fp, sp)) {
+    return NULL;

[Cutch, 2017/02/22 23:15:55]

You might want to add some code like:

AtomicOperations::IncrementInt64By(
        &counters_.single_frame_sample_register_check, 1);

but with your own counter here and in the next return NULL block.

This will let you diagnose why the stack walker isn't working (someday in the
future)

[bkonyi, 2017/02/23 00:25:20]

Done (I think).

+  }
+
+  if (!(OSThread::GetCurrentStackBounds(&stack_lower, &stack_upper) &&
+        ValidateThreadStackBounds(fp, sp, stack_lower, stack_upper))) {
+    // Could not get stack boundary.
+    return NULL;
+  }
+
+  OSThread* os_thread = OSThread::Current();
+  Sample* sample = SetupSampleNative(sample_buffer, os_thread->trace_id());
+  ProfilerNativeStackWalker native_stack_walker(
+      ILLEGAL_PORT, sample, sample_buffer, stack_lower, stack_upper, pc, fp, sp,
+      skip_count);
+  native_stack_walker.walk();
+  return sample;
+}
+
+
 void Profiler::SampleThreadSingleFrame(Thread* thread, uintptr_t pc) {
   ASSERT(thread != NULL);
   OSThread* os_thread = thread->os_thread();
   ASSERT(os_thread != NULL);
   Isolate* isolate = thread->isolate();
 
   SampleBuffer* sample_buffer = Profiler::sample_buffer();
   if (sample_buffer == NULL) {
     // Profiler not initialized.
     return;
@@ skipping 105 matching lines @@
   // Setup sample.
   Sample* sample = SetupSample(thread, sample_buffer, os_thread->trace_id());
   // Increment counter for vm tag.
   VMTagCounters* counters = isolate->vm_tag_counters();
   ASSERT(counters != NULL);
   if (thread->IsMutatorThread()) {
     counters->Increment(sample->vm_tag());
   }
 
   ProfilerNativeStackWalker native_stack_walker(
-      isolate, sample, sample_buffer, stack_lower, stack_upper, pc, fp, sp);
+      (isolate != NULL) ? isolate->main_port() : ILLEGAL_PORT, sample,
+      sample_buffer, stack_lower, stack_upper, pc, fp, sp);
   const bool exited_dart_code = thread->HasExitedDartCode();
   ProfilerDartStackWalker dart_stack_walker(thread, sample, sample_buffer,
                                             stack_lower, stack_upper, pc, fp,
                                             sp, exited_dart_code, false);
 
   // All memory access is done inside CollectSample.
   CollectSample(isolate, exited_dart_code, in_dart_code, sample,
                 &native_stack_walker, &dart_stack_walker, pc, fp, sp,
                 &counters_);
 }
@@ skipping 139 matching lines @@
   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()) {
+    // If we're requesting all the native allocation samples, we don't care
+    // whether or not we're in the same isolate as the sample.
+    if ((sample->port() != filter->port()) &&
+        !(sample->port() == ILLEGAL_PORT)) {

[Cutch, 2017/02/22 23:15:55]

What I meant here was to write the code as follows:

if (sample->port() != filter->port()) {
  // Another isolate.
  continue;
}

This is sufficient because:

1) All native allocation samples have ILLEGAL_PORT.
2) The native allocation filter's port is ILLEGAL_PORT.
3) All other filters have a port that isn't ILLEGAL_PORT.

---

Also, Sample should still have an explicit bit in the state indicating it is a
native allocation sample.

[bkonyi, 2017/02/23 00:25:20]

Done.

       // Another isolate.
       continue;
     }
     if (sample->timestamp() == 0) {
       // Empty.
       continue;
     }
     if (sample->At(0) == 0) {
       // No frames.
       continue;
@@ skipping 58 matching lines @@
   return processed_sample;
 }
 
 
 Sample* SampleBuffer::Next(Sample* sample) {
   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()) {
+  if (sample->port() != next_sample->port()) {
     return NULL;
   }
   if (sample->timestamp() != next_sample->timestamp()) {
     return NULL;
   }
   if (sample->tid() != next_sample->tid()) {
     return NULL;
   }
   return next_sample;
 }
@@ skipping 81 matching lines @@
 
 
 ProcessedSampleBuffer::ProcessedSampleBuffer()
     : code_lookup_table_(new CodeLookupTable(Thread::Current())) {
   ASSERT(code_lookup_table_ != NULL);
 }
 
 #endif  // !PRODUCT
 
 }  // namespace dart