Support profiler code transition tags

runtime/vm/profiler_service.cc

 // Copyright (c) 2015, 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 "vm/profiler_service.h"
 
 #include "vm/growable_array.h"
 #include "vm/native_symbol.h"
 #include "vm/object.h"
 #include "vm/os.h"
@@ skipping 563 matching lines @@
         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 {
-        if (start() == VMTag::kRootTagId) {
-          SetName("Root");
-        } else {
-          ASSERT(start() == VMTag::kTruncatedTagId);
-          SetName("[Truncated]");
+        switch (start()) {
+          case VMTag::kRootTagId:
+            SetName("Root");
+            break;
+          case VMTag::kTruncatedTagId:
+            SetName("[Truncated]");
+            break;
+          case VMTag::kNoneCodeTagId:
+            SetName("[No Code]");
+            break;
+          case VMTag::kOptimizedCodeTagId:
+            SetName("[Optimized Code]");
+            break;
+          case VMTag::kUnoptimizedCodeTagId:
+            SetName("[Unoptimized Code]");
+            break;
+          case VMTag::kNativeCodeTagId:
+            SetName("[Native Code]");
+            break;
+          case VMTag::kInlineStartCodeTagId:
+            SetName("[Inline Start]");
+            break;
+          case VMTag::kInlineEndCodeTagId:
+            SetName("[Inline End]");
+            break;
+          default:
+            UNIMPLEMENTED();
+          break;
         }
       }
     }
     function = table->AddTag(start(), name());
   } else {
     UNREACHABLE();
   }
   ASSERT(function != NULL);
 
   function->AddProfileCode(code_table_index());
@@ skipping 345 matching lines @@
     code_objects_.Add(code_object);
   }
 
  private:
   ZoneGrowableArray<ProfileFunctionTrieNodeCode> code_objects_;
 };
 
 
 class ProfileBuilder : public ValueObject {
  public:
+  enum ProfileInfoKind {
+    kNone,
+    kOptimized,
+    kUnoptimized,
+    kNative,
+    kInlineStart,
+    kInlineFinish,
+    kNumProfileInfoKind,
+  };
+
   ProfileBuilder(Isolate* isolate,
                  SampleFilter* filter,
                  Profile::TagOrder tag_order,
+                 intptr_t extra_tags,
                  Profile* profile)
       : isolate_(isolate),
         vm_isolate_(Dart::vm_isolate()),
         filter_(filter),
         tag_order_(tag_order),
+        extra_tags_(extra_tags),
         profile_(profile),
         deoptimized_code_(new DeoptimizedCodeSet(isolate)),
         null_code_(Code::ZoneHandle()),
         null_function_(Function::ZoneHandle()),
         tick_functions_(false),
         inclusive_tree_(false),
-        samples_(NULL) {
+        samples_(NULL),
+        info_kind_(kNone) {
     ASSERT(profile_ != NULL);
   }
 
   void Build() {
     ScopeTimer sw("ProfileBuilder::Build", FLAG_trace_profiler);
     FilterSamples();
 
     Setup();
     BuildCodeTable();
     FinalizeCodeIndexes();
@@ skipping 19 matching lines @@
   }
 
   void Setup() {
     profile_->live_code_ = new ProfileCodeTable();
     profile_->dead_code_ = new ProfileCodeTable();
     profile_->tag_code_ = new ProfileCodeTable();
     profile_->functions_ = new ProfileFunctionTable();
     // Register some synthetic tags.
     RegisterProfileCodeTag(VMTag::kRootTagId);
     RegisterProfileCodeTag(VMTag::kTruncatedTagId);
+    RegisterProfileCodeTag(VMTag::kNoneCodeTagId);
+    RegisterProfileCodeTag(VMTag::kOptimizedCodeTagId);
+    RegisterProfileCodeTag(VMTag::kUnoptimizedCodeTagId);
+    RegisterProfileCodeTag(VMTag::kNativeCodeTagId);
+    RegisterProfileCodeTag(VMTag::kInlineStartCodeTagId);
+    RegisterProfileCodeTag(VMTag::kInlineEndCodeTagId);
   }
 
   void FilterSamples() {
     ScopeTimer sw("ProfileBuilder::FilterSamples", FLAG_trace_profiler);
     MutexLocker profiler_data_lock(isolate_->profiler_data_mutex());
     IsolateProfilerData* profiler_data = isolate_->profiler_data();
     if (profiler_data == NULL) {
       return;
     }
     SampleBuffer* sample_buffer = profiler_data->sample_buffer();
@@ skipping 127 matching lines @@
          sample_index++) {
       ProcessedSample* sample = samples_->At(sample_index);
 
       // Tick the root.
       ProfileCodeTrieNode* current = root;
       current->Tick();
 
       // VM & User tags.
       current = AppendTags(sample->vm_tag(), sample->user_tag(), current);
 
+      ResetKind();
+
       // Truncated tag.
       if (sample->truncated()) {
         current = AppendTruncatedTag(current);
       }
 
       // Walk the sampled PCs.
+      Code& code = Code::Handle();
       for (intptr_t frame_index = sample->length() - 1;
            frame_index >= 0;
            frame_index--) {
         ASSERT(sample->At(frame_index) != 0);
         intptr_t index =
             GetProfileCodeIndex(sample->At(frame_index), sample->timestamp());
         ASSERT(index >= 0);
+        ProfileCode* profile_code =
+            GetProfileCode(sample->At(frame_index), sample->timestamp());
+        ASSERT(profile_code->code_table_index() == index);
+        code ^= profile_code->code();
+        current = AppendKind(code, current);
         current = current->GetChild(index);
         current->Tick();
       }
     }
   }
 
   void BuildExclusiveCodeTrie(ProfileCodeTrieNode* root) {
     ScopeTimer sw("ProfileBuilder::BuildExclusiveCodeTrie",
                   FLAG_trace_profiler);
     for (intptr_t sample_index = 0;
          sample_index < samples_->length();
          sample_index++) {
       ProcessedSample* sample = samples_->At(sample_index);
 
       // Tick the root.
       ProfileCodeTrieNode* current = root;
       current->Tick();
 
       // VM & User tags.
       current = AppendTags(sample->vm_tag(), sample->user_tag(), current);
 
+      ResetKind();
+
       // Walk the sampled PCs.
+      Code& code = Code::Handle();
       for (intptr_t frame_index = 0;
            frame_index < sample->length();
            frame_index++) {
         ASSERT(sample->At(frame_index) != 0);
         intptr_t index =
             GetProfileCodeIndex(sample->At(frame_index), sample->timestamp());
         ASSERT(index >= 0);
+        ProfileCode* profile_code =
+            GetProfileCode(sample->At(frame_index), sample->timestamp());
+        ASSERT(profile_code->code_table_index() == index);
+        code ^= profile_code->code();
         current = current->GetChild(index);
         if (ShouldTickNode(sample, frame_index)) {
           current->Tick();
         }
+        current = AppendKind(code, current);
       }
       // Truncated tag.
       if (sample->truncated()) {
         current = AppendTruncatedTag(current);
       }
     }
   }
 
   void BuildFunctionTrie(Profile::TrieKind kind) {
     ProfileFunctionTrieNode* root =
@@ skipping 52 matching lines @@
          sample_index++) {
       ProcessedSample* sample = samples_->At(sample_index);
 
       // Tick the root.
       ProfileFunctionTrieNode* current = root;
       current->Tick();
 
       // VM & User tags.
       current = AppendTags(sample->vm_tag(), sample->user_tag(), current);
 
+      ResetKind();
+
       // Walk the sampled PCs.
       for (intptr_t frame_index = 0;
            frame_index < sample->length();
            frame_index++) {
         ASSERT(sample->At(frame_index) != 0);
         current = ProcessFrame(current, sample_index, sample, frame_index);
       }
 
       // Truncated tag.
       if (sample->truncated()) {
@@ skipping 16 matching lines @@
     const intptr_t code_index = profile_code->code_table_index();
     ASSERT(profile_code != NULL);
     const Code& code = Code::ZoneHandle(profile_code->code());
     GrowableArray<Function*> inlined_functions;
     if (!code.IsNull()) {
       intptr_t offset = pc - code.EntryPoint();
       code.GetInlinedFunctionsAt(offset, &inlined_functions);
     }
     if (code.IsNull() || (inlined_functions.length() == 0)) {
       // No inlined functions.
+      if (inclusive_tree_) {
+        current = AppendKind(code, current);
+      }
       current = ProcessFunction(current,
                                 sample_index,
                                 sample,
                                 frame_index,
                                 function,
                                 code_index);
+      if (!inclusive_tree_) {
+        current = AppendKind(code, current);
+      }
       return current;
     }
 
+    ASSERT(code.is_optimized());
+
     if (inclusive_tree_) {
-      // Append the inlined children.
       for (intptr_t i = inlined_functions.length() - 1; i >= 0; i--) {
         Function* inlined_function = inlined_functions[i];
         ASSERT(inlined_function != NULL);
         ASSERT(!inlined_function->IsNull());
+        const bool inliner = i == (inlined_functions.length() - 1);
+        if (inliner) {
+          current = AppendKind(code, current);
+        }
         current = ProcessInlinedFunction(current,
                                          sample_index,
                                          sample,
                                          frame_index,
                                          inlined_function,
                                          code_index);
+        if (inliner) {
+          current = AppendKind(kInlineStart, current);
+        }
       }
+      current = AppendKind(kInlineFinish, current);
     } else {
       // Append the inlined children.
+      current = AppendKind(kInlineFinish, current);
       for (intptr_t i = 0; i < inlined_functions.length(); i++) {
         Function* inlined_function = inlined_functions[i];
         ASSERT(inlined_function != NULL);
         ASSERT(!inlined_function->IsNull());
+        const bool inliner = i == (inlined_functions.length() - 1);
+        if (inliner) {
+          current = AppendKind(kInlineStart, current);
+        }
         current = ProcessInlinedFunction(current,
                                          sample_index,
                                          sample,
                                          frame_index + i,
                                          inlined_function,
                                          code_index);
+        if (inliner) {
+          current = AppendKind(code, current);
+        }
       }
     }
 
     return current;
   }
 
   ProfileFunctionTrieNode* ProcessInlinedFunction(
       ProfileFunctionTrieNode* current,
       intptr_t sample_index,
       ProcessedSample* sample,
@@ skipping 104 matching lines @@
         !VMTag::IsRuntimeEntryTag(vm_tag)) {
       return current;
     }
     intptr_t tag_index = GetProfileCodeTagIndex(vm_tag);
     current = current->GetChild(tag_index);
     // Give the tag a tick.
     current->Tick();
     return current;
   }
 
+  uword ProfileInfoKindToVMTag(ProfileInfoKind kind) {
+    ASSERT(kNone == 0);
+    ASSERT(kOptimized == 1);
+    ASSERT(kUnoptimized == 2);
+    ASSERT(kNative == 3);
+    ASSERT(kInlineStart == 4);
+    ASSERT(kInlineFinish == 5);
+    ASSERT(kNumProfileInfoKind == 6);
+    uword tag_map[] = {

[srdjan, 2015/08/04 21:24:46]

'static uword tag_map', so that it does not get computed/assigned every time?

Is this better than having a switch statement? Switch statement would remove the
need for ASSERT's and may be actually compiled to a table lookup.

[Cutch, 2015/08/04 22:00:58]

Done.

+      VMTag::kNoneCodeTagId,
+      VMTag::kOptimizedCodeTagId,
+      VMTag::kUnoptimizedCodeTagId,
+      VMTag::kNativeCodeTagId,
+      VMTag::kInlineStartCodeTagId,
+      VMTag::kInlineEndCodeTagId,
+      VMTag::kInvalidTagId
+    };
+    return tag_map[kind];
+  }
+
+  ProfileCodeTrieNode* AppendKind(ProfileInfoKind kind,
+                                  ProfileCodeTrieNode* current) {
+    if (!TagsEnabled(ProfilerService::kCodeTransitionTagsBit)) {
+      // Only emit if debug tags are requested.
+      return current;
+    }
+    if (kind != info_kind_) {
+      info_kind_ = kind;
+      intptr_t tag_index = GetProfileCodeTagIndex(ProfileInfoKindToVMTag(kind));
+      ASSERT(tag_index >= 0);
+      current = current->GetChild(tag_index);
+      current->Tick();
+    }
+    return current;
+  }
+
+  ProfileCodeTrieNode* AppendKind(const Code& code,
+                                  ProfileCodeTrieNode* current) {
+    if (code.IsNull()) {
+      return AppendKind(kNone, current);
+    } else if (code.is_optimized()) {
+      return AppendKind(kOptimized, current);
+    } else {
+      return AppendKind(kUnoptimized, current);
+    }
+  }
+
   ProfileCodeTrieNode* AppendVMTags(uword vm_tag,
                                     ProfileCodeTrieNode* current) {
     current = AppendVMTag(vm_tag, current);
     current = AppendSpecificNativeRuntimeEntryVMTag(vm_tag, current);
     return current;
   }
 
   ProfileCodeTrieNode* AppendTags(uword vm_tag,
                                   uword user_tag,
                                   ProfileCodeTrieNode* current) {
@@ skipping 16 matching lines @@
            (tag_order() == Profile::kVM));
     current = AppendVMTags(vm_tag, current);
     // Only VM.
     if (tag_order() == Profile::kVM) {
       return current;
     }
     return AppendUserTag(user_tag, current);
   }
 
   // ProfileFunctionTrieNode
+  void ResetKind() {
+    info_kind_ = kNone;
+  }
+
+  ProfileFunctionTrieNode* AppendKind(ProfileInfoKind kind,
+                                      ProfileFunctionTrieNode* current) {
+    if (!TagsEnabled(ProfilerService::kCodeTransitionTagsBit)) {
+      // Only emit if debug tags are requested.
+      return current;
+    }
+    if (kind != info_kind_) {
+      info_kind_ = kind;
+      intptr_t tag_index =
+          GetProfileFunctionTagIndex(ProfileInfoKindToVMTag(kind));
+      ASSERT(tag_index >= 0);
+      current = current->GetChild(tag_index);
+      current->Tick();
+    }
+    return current;
+  }
+
+  ProfileFunctionTrieNode* AppendKind(const Code& code,
+                                      ProfileFunctionTrieNode* current) {
+    if (code.IsNull()) {
+      return AppendKind(kNone, current);
+    } else if (code.is_optimized()) {
+      return AppendKind(kOptimized, current);
+    } else {
+      return AppendKind(kUnoptimized, current);
+    }
+  }
+
   ProfileFunctionTrieNode* AppendUserTag(uword user_tag,
                                          ProfileFunctionTrieNode* current) {
     intptr_t user_tag_index = GetProfileFunctionTagIndex(user_tag);
     if (user_tag_index >= 0) {
       current = current->GetChild(user_tag_index);
       current->Tick();
     }
     return current;
   }
 
@@ skipping 263 matching lines @@
   Profile::TagOrder tag_order() const {
     return tag_order_;
   }
 
   bool vm_tags_emitted() const {
     return (tag_order_ == Profile::kUserVM) ||
            (tag_order_ == Profile::kVMUser) ||
            (tag_order_ == Profile::kVM);
   }
 
+  bool TagsEnabled(intptr_t extra_tags_bits) {

[srdjan, 2015/08/04 21:24:46]

const

[Cutch, 2015/08/04 22:00:58]

Done.

+    return (extra_tags_ & extra_tags_bits) != 0;
+  }
+
   Isolate* isolate_;
   Isolate* vm_isolate_;
   SampleFilter* filter_;
   Profile::TagOrder tag_order_;
+  intptr_t extra_tags_;
   Profile* profile_;
   DeoptimizedCodeSet* deoptimized_code_;
   const Code& null_code_;
   const Function& null_function_;
   bool tick_functions_;
   bool inclusive_tree_;
 
   ProcessedSampleBuffer* samples_;
+  ProfileInfoKind info_kind_;
 };
 
 
 Profile::Profile(Isolate* isolate)
     : isolate_(isolate),
       live_code_(NULL),
       dead_code_(NULL),
       tag_code_(NULL),
       functions_(NULL),
       dead_code_index_offset_(-1),
       tag_code_index_offset_(-1),
       min_time_(kMaxInt64),
       max_time_(0) {
   ASSERT(isolate_ != NULL);
   for (intptr_t i = 0; i < kNumTrieKinds; i++) {
     roots_[i] = NULL;
   }
 }
 
 
-void Profile::Build(SampleFilter* filter, TagOrder tag_order) {
-  ProfileBuilder builder(isolate_, filter, tag_order, this);
+void Profile::Build(SampleFilter* filter,
+                    TagOrder tag_order,
+                    intptr_t extra_tags) {
+  ProfileBuilder builder(isolate_, filter, tag_order, extra_tags, this);
   builder.Build();
 }
 
 
 ProfileFunction* Profile::GetFunction(intptr_t index) {
   ASSERT(functions_ != NULL);
   return functions_->At(index);
 }
 
 
@@ skipping 182 matching lines @@
 
 intptr_t ProfileTrieWalker::SiblingCount() {
   ASSERT(parent_ != NULL);
   return parent_->NumChildren();
 }
 
 
 void ProfilerService::PrintJSONImpl(Isolate* isolate,
                                     JSONStream* stream,
                                     Profile::TagOrder tag_order,
+                                    intptr_t extra_tags,
                                     SampleFilter* filter) {
   // Disable profile interrupts while processing the buffer.
   Profiler::EndExecution(isolate);
 
   {
     MutexLocker profiler_data_lock(isolate->profiler_data_mutex());
     IsolateProfilerData* profiler_data = isolate->profiler_data();
     if (profiler_data == NULL) {
       stream->PrintError(kFeatureDisabled, NULL);
       return;
     }
   }
 
   {
     StackZone zone(isolate);
     HANDLESCOPE(isolate);
     Profile profile(isolate);
-    profile.Build(filter, tag_order);
+    profile.Build(filter, tag_order, extra_tags);
     profile.PrintJSON(stream);
   }
 
   // Enable profile interrupts.
   Profiler::BeginExecution(isolate);
 }
 
 
 class NoAllocationSampleFilter : public SampleFilter {
  public:
   explicit NoAllocationSampleFilter(Isolate* isolate)
       : SampleFilter(isolate) {
   }
 
   bool FilterSample(Sample* sample) {
     return !sample->is_allocation_sample();
   }
 };
 
 
 void ProfilerService::PrintJSON(JSONStream* stream,
-                                Profile::TagOrder tag_order) {
+                                Profile::TagOrder tag_order,
+                                intptr_t extra_tags) {
   Isolate* isolate = Isolate::Current();
   NoAllocationSampleFilter filter(isolate);
-  PrintJSONImpl(isolate, stream, tag_order, &filter);
+  PrintJSONImpl(isolate, stream, tag_order, extra_tags, &filter);
 }
 
 
 class ClassAllocationSampleFilter : public SampleFilter {
  public:
   ClassAllocationSampleFilter(Isolate* isolate, const Class& cls)
       : SampleFilter(isolate),
         cls_(Class::Handle(cls.raw())) {
     ASSERT(!cls_.IsNull());
   }
 
   bool FilterSample(Sample* sample) {
     return sample->is_allocation_sample() &&
            (sample->allocation_cid() == cls_.id());
   }
 
  private:
   const Class& cls_;
 };
 
 
 void ProfilerService::PrintAllocationJSON(JSONStream* stream,
                                           Profile::TagOrder tag_order,
                                           const Class& cls) {
   Isolate* isolate = Isolate::Current();
   ClassAllocationSampleFilter filter(isolate, cls);
-  PrintJSONImpl(isolate, stream, tag_order, &filter);
+  PrintJSONImpl(isolate, stream, tag_order, 0, &filter);

[srdjan, 2015/08/04 21:24:46]

kNone instead of 0?

[Cutch, 2015/08/04 22:00:58]

Done.

 }
 
 
 void ProfilerService::ClearSamples() {
   Isolate* isolate = Isolate::Current();
 
   // Disable profile interrupts while processing the buffer.
   Profiler::EndExecution(isolate);
 
   MutexLocker profiler_data_lock(isolate->profiler_data_mutex());
   IsolateProfilerData* profiler_data = isolate->profiler_data();
   if (profiler_data == NULL) {
     return;
   }
   SampleBuffer* sample_buffer = profiler_data->sample_buffer();
   ASSERT(sample_buffer != NULL);
 
   ClearProfileVisitor clear_profile(isolate);
   sample_buffer->VisitSamples(&clear_profile);
 
   // Enable profile interrupts.
   Profiler::BeginExecution(isolate);
 }
 
 }  // namespace dart