Initial UserTag and dart:profiler library

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 548 matching lines @@
       }
       PrintCollectedCode(&obj);
     } else if (kind() == kReusedCode) {
       if (name() == NULL) {
         // Lazily set generated name.
         GenerateAndSetSymbolName("[Reused]");
       }
       PrintOverwrittenCode(&obj);
     } else if (kind() == kTagCode) {
       if (name() == NULL) {
-        const char* tag_name = start() == 0 ? "root" : VMTag::TagName(start());
-        ASSERT(tag_name != NULL);
-        SetName(tag_name);
+        if (UserTags::IsUserTag(start())) {
+          const char* tag_name = UserTags::TagName(start());
+          ASSERT(tag_name != NULL);
+          SetName(tag_name);
+        } else if (VMTag::IsVMTag(start()) ||
+                   VMTag::IsRuntimeEntryTag(start()) ||
+                   VMTag::IsNativeEntryTag(start())) {
+          const char* tag_name = VMTag::TagName(start());
+          ASSERT(tag_name != NULL);
+          SetName(tag_name);
+        } else {
+          ASSERT(start() == 0);
+          SetName("root");
+        }
       }
       PrintTagCode(&obj);
     } else {
       ASSERT(kind() == kNativeCode);
       if (name() == NULL) {
         // Lazily set generated name.
         GenerateAndSetSymbolName("[Native]");
       }
       PrintNativeCode(&obj);
     }
@@ skipping 345 matching lines @@
     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());
+    // Make sure user tag is created.
+    CreateUserTag(sample->user_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 15 matching lines @@
     }
     CodeRegion* region = new CodeRegion(CodeRegion::kTagCode,
                                         tag,
                                         tag + 1,
                                         0);
     index = tag_code_table_->InsertCodeRegion(region);
     ASSERT(index >= 0);
     region->set_creation_serial(visited());
   }
 
+  void CreateUserTag(uword tag) {
+    if (tag == 0) {
+      // None set.
+      return;
+    }
+    intptr_t index = tag_code_table_->FindIndex(tag);
+    if (index >= 0) {
+      // Already created.
+      return;
+    }
+    CodeRegion* region = new CodeRegion(CodeRegion::kTagCode,
+                                        tag,
+                                        tag + 1,
+                                        0);
+    index = tag_code_table_->InsertCodeRegion(region);
+    ASSERT(index >= 0);
+    region->set_creation_serial(visited());
+  }
+
   void Tick(uword pc, bool exclusive, int64_t timestamp) {
     CodeRegionTable::TickResult r;
     intptr_t serial = exclusive ? -1 : visited();
     r = live_code_table_->Tick(pc, exclusive, serial, timestamp);
     if (r == CodeRegionTable::kTicked) {
       // Live code found and ticked.
       return;
     }
     if (r == CodeRegionTable::kNewerCode) {
       // Code has been overwritten by newer code.
@@ skipping 119 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()) {
+      intptr_t user_tag_index = FindTagIndex(sample->user_tag());
+      if (user_tag_index >= 0) {
+        current = current->GetChild(user_tag_index);
+        // Give the tag a tick.
+        current->Tick();
+      }
       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);
@@ skipping 23 matching lines @@
   bool use_tags() const {
     return use_tags_;
   }
 
   void set_use_tags(bool use_tags) {
     use_tags_ = use_tags;
   }
 
  private:
   intptr_t FindTagIndex(uword tag) const {
+    if (tag == 0) {
+      return -1;
+    }
     intptr_t index = tag_code_table_->FindIndex(tag);
+    if (index <= 0) {
+      return -1;
+    }
     ASSERT(index >= 0);
     ASSERT((tag_code_table_->At(index))->contains(tag));
     return tag_code_table_offset_ + index;
   }
 
   intptr_t FindFinalIndex(uword pc, int64_t timestamp) const {
     intptr_t index = live_code_table_->FindIndex(pc);
     ASSERT(index >= 0);
     CodeRegion* region = live_code_table_->At(index);
     ASSERT(region->contains(pc));
@@ skipping 351 matching lines @@
       // The stack pointer gives us a better lower bound than
       // the isolates stack limit.
       lower_bound_ = original_sp_;
     }
     int i = 0;
     for (; i < FLAG_profile_depth; i++) {
       if (FLAG_profile_verify_stack_walk) {
         VerifyCodeAddress(heap, i, reinterpret_cast<uword>(pc));
       }
       sample_->SetAt(i, reinterpret_cast<uword>(pc));
+      if (fp == NULL) {
+        return i + 1;
+      }
       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)) {
+      if (fp == NULL) {
+        return i + 1;
+      }
+      if ((step >= kMaxStep)) {
         // Frame pointer step is too large.
+        return i + 1;
+      }
+      if ((fp <= previous_fp)) {
         // Frame pointer did not move to a higher address.
+        return i + 1;
+      }
+      if (!ValidFramePointer(fp)) {
         // Frame pointer is outside of isolate stack bounds.
         return i + 1;
       }
       // Move the lower bound up.
       lower_bound_ = reinterpret_cast<uword>(fp);
     }
     return i;
   }
 
  private:
@@ skipping 57 matching lines @@
   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);
   sample->set_vm_tag(isolate->vm_tag());
+  sample->set_user_tag(isolate->user_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): Support collecting only Dart frames with
       // ProfilerNativeStackWalker.
     }
   }
 }
 
 }  // namespace dart