Add runtime and native entry tags

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"
@@ skipping 17 matching lines @@
 #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 255.");
 DEFINE_FLAG(bool, profile_verify_stack_walk, false,
             "Verify instruction addresses while walking the stack.");
+DEFINE_FLAG(bool, profile_native_stack, true,
+            "Use native stack in profiler.");
 
 bool Profiler::initialized_ = false;
 SampleBuffer* Profiler::sample_buffer_ = NULL;
 
 void Profiler::InitOnce() {
   // Place some sane restrictions on user controlled flags.
   SetSamplePeriod(FLAG_profile_period);
   SetSampleDepth(FLAG_profile_depth);
   if (!FLAG_profile) {
     return;
@@ skipping 871 matching lines @@
 
   void VisitSample(Sample* sample) {
     int64_t timestamp = sample->timestamp();
     if (timestamp > max_time_) {
       max_time_ = timestamp;
     }
     if (timestamp < min_time_) {
       min_time_ = timestamp;
     }
     // Make sure VM tag is created.
+    if (VMTag::IsNativeEntryTag(sample->vm_tag())) {
+      CreateTag(VMTag::kNativeTagId);
+    } else if (VMTag::IsRuntimeEntryTag(sample->vm_tag())) {
+      CreateTag(VMTag::kRuntimeTagId);
+    }
     CreateTag(sample->vm_tag());
     // Exclusive tick for bottom frame.
     Tick(sample->At(0), true, timestamp);
     // Inclusive tick for all frames.
     for (intptr_t i = 0; i < FLAG_profile_depth; i++) {
       if (sample->At(i) == 0) {
         break;
       }
       frames_++;
       Tick(sample->At(i), false, timestamp);
@@ skipping 155 matching lines @@
     root_ = new CodeRegionTrieNode(tag_code_table_offset_ + root_index);
     // Use tags by default.
     set_use_tags(true);
   }
 
   void VisitSample(Sample* sample) {
     // Give the root a tick.
     root_->Tick();
     CodeRegionTrieNode* current = root_;
     if (use_tags()) {
+      if (VMTag::IsNativeEntryTag(sample->vm_tag())) {
+        // Insert a dummy kNativeTagId node.
+        intptr_t tag_index = FindTagIndex(VMTag::kNativeTagId);
+        current = current->GetChild(tag_index);
+        // Give the tag a tick.
+        current->Tick();
+      } else if (VMTag::IsRuntimeEntryTag(sample->vm_tag())) {
+        // Insert a dummy kRuntimeTagId node.
+        intptr_t tag_index = FindTagIndex(VMTag::kRuntimeTagId);
+        current = current->GetChild(tag_index);
+        // Give the tag a tick.
+        current->Tick();
+      }
       intptr_t tag_index = FindTagIndex(sample->vm_tag());
       current = current->GetChild(tag_index);
       // Give the tag a tick.
       current->Tick();
     }
     // Walk the sampled PCs.
     for (intptr_t i = 0; i < FLAG_profile_depth; i++) {
       if (sample->At(i) == 0) {
         break;
       }
@@ skipping 285 matching lines @@
 
 
 Sample* SampleBuffer::ReserveSample() {
   ASSERT(samples_ != NULL);
   uintptr_t cursor = AtomicOperations::FetchAndIncrement(&cursor_);
   // Map back into sample buffer range.
   cursor = cursor % capacity_;
   return At(cursor);
 }
 
+class ProfilerDartStackWalker : public ValueObject {
+ public:
+  explicit ProfilerDartStackWalker(Sample* sample)
+      : sample_(sample),
+        frame_iterator_() {
+    ASSERT(sample_ != NULL);
+  }
+
+  ProfilerDartStackWalker(Sample* sample, uword pc, uword fp, uword sp)
+      : sample_(sample),
+        frame_iterator_(fp, sp, pc) {
+    ASSERT(sample_ != NULL);
+  }
+
+  ProfilerDartStackWalker(Sample* sample, uword fp)
+      : sample_(sample),
+        frame_iterator_(fp) {
+    ASSERT(sample_ != NULL);
+  }
+
+  int walk() {
+    intptr_t frame_index = 0;
+    StackFrame* frame = frame_iterator_.NextFrame();
+    while (frame != NULL) {
+      sample_->SetAt(frame_index, frame->pc());
+      frame_index++;
+      if (frame_index >= FLAG_profile_depth) {
+        break;
+      }
+      frame = frame_iterator_.NextFrame();
+    }
+    return frame_index;
+  }
+
+ private:
+  Sample* sample_;
+  DartFrameIterator frame_iterator_;
+};
+
 // 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).
 //
-class ProfilerSampleStackWalker : public ValueObject {
+class ProfilerNativeStackWalker : public ValueObject {
  public:
-  ProfilerSampleStackWalker(Sample* sample,
+  ProfilerNativeStackWalker(Sample* sample,
                             uword stack_lower,
                             uword stack_upper,
                             uword pc,
                             uword fp,
                             uword sp)
       : sample_(sample),
         stack_upper_(stack_upper),
         original_pc_(pc),
         original_fp_(fp),
         original_sp_(sp),
         lower_bound_(stack_lower) {
     ASSERT(sample_ != NULL);
   }
 
-  int walk(Heap* heap, uword vm_tag) {
+  int walk(Heap* heap) {
     const intptr_t kMaxStep = 0x1000;  // 4K.
     const bool kWalkStack = true;  // Walk the stack.
     // Always store the exclusive PC.
     sample_->SetAt(0, original_pc_);
-    // Always store the vm tag.
-    sample_->set_vm_tag(vm_tag);
     if (!kWalkStack) {
       // Not walking the stack, only took exclusive sample.
       return 1;
     }
     uword* pc = reinterpret_cast<uword*>(original_pc_);
     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;
@@ skipping 76 matching lines @@
   const uword original_fp_;
   const uword original_sp_;
   uword lower_bound_;
 };
 
 
 void Profiler::RecordSampleInterruptCallback(
     const InterruptedThreadState& state,
     void* data) {
   Isolate* isolate = reinterpret_cast<Isolate*>(data);
-  if (isolate == NULL) {
+  if ((isolate == NULL) || (Dart::vm_isolate() == NULL)) {
+    return;
+  }
+  if (isolate == Dart::vm_isolate()) {
+    // Never sample the vm_isolate.
+    return;
+  }

[siva, 2014/04/08 16:27:54]

Does it make sense to start the profiler before the VM isolate is ready as we
are not recording any VM isolate samples.

[Cutch, 2014/04/09 17:40:59]

Isolate::SetCurrent expects the profiler to have been initialized. I'd rather
not make SetCurrent check if the profiler is initialized.

[siva, 2014/04/09 23:28:11]

I agree we don't want to make Isolate::SetCurrent have to check if the profiler
is initialized.

Maybe we should have a private 'BaseSetCurrent' method (the name could be
something more meaningful), this would have just the ThreadLocal setting
functionality. We call this in Isolate::Init() and then start the profiler once
the isolate is setup. 

On 2014/04/09 17:40:59, Cutch wrote:

[Cutch, 2014/04/10 15:30:27]

Done.

+  if (!FLAG_profile_native_stack && (isolate->stub_code() == NULL)) {
+    // ProfilerDartStackWalker requires stub code setup to be completed.
     return;
   }

[siva, 2014/04/08 16:27:54]

Instead of checking like this wouldn't it be more safe to start the profiler
only after all the initialization is done if FLAG_profile_native_stack is false?

[Cutch, 2014/04/09 17:40:59]

See above.

   VMTagCounters* counters = isolate->vm_tag_counters();
   ASSERT(counters != NULL);
   counters->Increment(isolate->vm_tag());
   IsolateProfilerData* profiler_data = isolate->profiler_data();
   if (profiler_data == NULL) {
     return;
   }
   SampleBuffer* sample_buffer = profiler_data->sample_buffer();
   if (sample_buffer == NULL) {
     return;
   }
   Sample* sample = sample_buffer->ReserveSample();
   sample->Init(isolate, OS::GetCurrentTimeMicros(), state.tid);
-  uword stack_lower = 0;
-  uword stack_upper = 0;
-  isolate->GetStackBounds(&stack_lower, &stack_upper);
-  if ((stack_lower == 0) || (stack_upper == 0)) {
-    stack_lower = 0;
-    stack_upper = 0;
+  sample->set_vm_tag(isolate->vm_tag());
+  if (FLAG_profile_native_stack) {
+    // Collect native and Dart frames.
+    uword stack_lower = 0;
+    uword stack_upper = 0;
+    isolate->GetStackBounds(&stack_lower, &stack_upper);
+    if ((stack_lower == 0) || (stack_upper == 0)) {
+      stack_lower = 0;
+      stack_upper = 0;
+    }
+    ProfilerNativeStackWalker stackWalker(sample, stack_lower, stack_upper,
+                                          state.pc, state.fp, state.sp);
+    stackWalker.walk(isolate->heap());
+  } else {
+    if (isolate->top_exit_frame_info() != 0) {
+      ProfilerDartStackWalker stackWalker(sample);
+      stackWalker.walk();
+    } else {
+      // TODO(johnmccutchan): StackFrameIterator that is resilient to native
+      // frames.

[siva, 2014/04/08 16:27:54]

what does this TODO mean (for pure Dart frame walking we must have the last exit
frame info and native frames are not traversed at all).

[Cutch, 2014/04/09 17:40:59]

Slightly misworded but I want to support only collecting Dart frames even
without top_exit_frame_info.

+    }
   }
-  ProfilerSampleStackWalker stackWalker(sample, stack_lower, stack_upper,
-                                        state.pc, state.fp, state.sp);
-  stackWalker.walk(isolate->heap(), isolate->vm_tag());
 }
 
 }  // namespace dart