Improve CPU Profile View

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/hash_map.h"
 #include "vm/log.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/scope_timer.h"
 
 namespace dart {
 
 DECLARE_FLAG(int, max_profile_depth);
 DECLARE_FLAG(int, profile_period);
 DECLARE_FLAG(bool, show_invisible_frames);
+DECLARE_FLAG(bool, profile_vm);
 
 #ifndef PRODUCT
 
 class DeoptimizedCodeSet : public ZoneAllocated {
  public:
   explicit DeoptimizedCodeSet(Isolate* isolate)
       : previous_(
             GrowableObjectArray::ZoneHandle(isolate->deoptimized_code_array())),
         current_(GrowableObjectArray::ZoneHandle(
             previous_.IsNull() ? GrowableObjectArray::null() :
@@ skipping 1336 matching lines @@
       // and tick each one.
       for (intptr_t frame_index = 0;
            frame_index < sample->length();
            frame_index++) {
         const uword pc = sample->At(frame_index);
         ASSERT(pc != 0);
         ProfileCode* code = FindOrRegisterProfileCode(pc, timestamp);
         ASSERT(code != NULL);
         code->Tick(pc, IsExecutingFrame(sample, frame_index), sample_index);
       }
+
+      TickExitFrame(sample->vm_tag(), sample_index);
     }
     SanitizeMinMaxTimes();
   }
 
   void FinalizeCodeIndexes() {
     ScopeTimer sw("ProfileBuilder::FinalizeCodeIndexes", FLAG_trace_profiler);
     ProfileCodeTable* live_table = profile_->live_code_;
     ProfileCodeTable* dead_table = profile_->dead_code_;
     ProfileCodeTable* tag_table = profile_->tag_code_;
     const intptr_t dead_code_index_offset = live_table->length();
@@ skipping 95 matching lines @@
             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();
       }
+
+      if (!sample->first_frame_executing()) {
+        current = AppendExitFrame(sample->vm_tag(), current);
+      }
     }
   }
 
   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();
 
+      if (!sample->first_frame_executing()) {
+        current = AppendExitFrame(sample->vm_tag(), current);
+      }
+
       // 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 =
@@ skipping 52 matching lines @@
       }
 
       // Walk the sampled PCs.
       for (intptr_t frame_index = sample->length() - 1;
            frame_index >= 0;
            frame_index--) {
         ASSERT(sample->At(frame_index) != 0);
         current = ProcessFrame(current, sample_index, sample, frame_index);
       }
 
+      if (!sample->first_frame_executing()) {
+        current = AppendExitFrame(sample->vm_tag(), current);
+      }
+
       sample->set_timeline_trie(current);
     }
   }
 
   void BuildExclusiveFunctionTrie(ProfileFunctionTrieNode* root) {
     ScopeTimer sw("ProfileBuilder::BuildExclusiveFunctionTrie",
                   FLAG_trace_profiler);
     ASSERT(tick_functions_);
     for (intptr_t sample_index = 0;
          sample_index < samples_->length();
          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();
 
+      if (!sample->first_frame_executing()) {
+        current = AppendExitFrame(sample->vm_tag(), current);
+      }
+
       // 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);
       }
 
+      TickExitFrameFunction(sample->vm_tag(), sample_index);
+
       // Truncated tag.
       if (sample->truncated()) {
         current = AppendTruncatedTag(current);
         InclusiveTickTruncatedTag();
       }
     }
   }
 
   ProfileFunctionTrieNode* ProcessFrame(
       ProfileFunctionTrieNode* current,
@@ skipping 118 matching lines @@
                            inlined_token_position,
                            code_index);
   }
 
   bool ShouldTickNode(ProcessedSample* sample, intptr_t frame_index) {
     if (frame_index != 0) {
       return true;
     }
     // Only tick the first frame's node, if we are executing OR
     // vm tags have been emitted.
-    return IsExecutingFrame(sample, frame_index) || vm_tags_emitted();
+    return IsExecutingFrame(sample, frame_index) ||
+           !FLAG_profile_vm || vm_tags_emitted();
   }
 
   ProfileFunctionTrieNode* ProcessFunction(ProfileFunctionTrieNode* current,
                                            intptr_t sample_index,
                                            ProcessedSample* sample,
                                            intptr_t frame_index,
                                            ProfileFunction* function,
                                            TokenPosition token_position,
                                            intptr_t code_index) {
     if (!function->is_visible()) {
@@ skipping 141 matching lines @@
     }
   }
 
   ProfileCodeTrieNode* AppendVMTags(uword vm_tag,
                                     ProfileCodeTrieNode* current) {
     current = AppendVMTag(vm_tag, current);
     current = AppendSpecificNativeRuntimeEntryVMTag(vm_tag, current);
     return current;
   }
 
+  void TickExitFrame(uword vm_tag, intptr_t serial) {
+    if (FLAG_profile_vm) {
+      return;
+    }
+    if (!VMTag::IsExitFrameTag(vm_tag)) {
+      return;
+    }
+    ProfileCodeTable* tag_table = profile_->tag_code_;
+    ProfileCode* code = tag_table->FindCodeForPC(vm_tag);
+    ASSERT(code != NULL);
+    code->Tick(vm_tag, true, serial);
+  }
+
+  void TickExitFrameFunction(uword vm_tag, intptr_t serial) {
+    if (FLAG_profile_vm) {
+      return;
+    }
+    if (!VMTag::IsExitFrameTag(vm_tag)) {
+      return;
+    }
+    ProfileCodeTable* tag_table = profile_->tag_code_;
+    ProfileCode* code = tag_table->FindCodeForPC(vm_tag);
+    ASSERT(code != NULL);
+    ProfileFunction* function = code->function();
+    ASSERT(function != NULL);
+    function->Tick(true, serial, TokenPosition::kNoSource);
+  }
+
+  ProfileCodeTrieNode* AppendExitFrame(uword vm_tag,
+                                       ProfileCodeTrieNode* current) {
+    if (FLAG_profile_vm) {
+      return current;
+    }
+
+    if (!VMTag::IsExitFrameTag(vm_tag)) {
+      return current;
+    }
+
+    if (VMTag::IsNativeEntryTag(vm_tag) ||
+        VMTag::IsRuntimeEntryTag(vm_tag)) {
+      current = AppendSpecificNativeRuntimeEntryVMTag(vm_tag, current);
+    } else {
+      intptr_t tag_index = GetProfileCodeTagIndex(vm_tag);
+      current = current->GetChild(tag_index);
+      // Give the tag a tick.
+      current->Tick();
+    }
+    return current;
+  }
+
   ProfileCodeTrieNode* AppendTags(uword vm_tag,
                                   uword user_tag,
                                   ProfileCodeTrieNode* current) {
-    // None.
+    if (FLAG_profile_vm) {
+      // None.
+      if (tag_order() == Profile::kNoTags) {
+        return current;
+      }
+      // User first.
+      if ((tag_order() == Profile::kUserVM) ||
+          (tag_order() == Profile::kUser)) {
+        current = AppendUserTag(user_tag, current);
+        // Only user.
+        if (tag_order() == Profile::kUser) {
+          return current;
+        }
+        return AppendVMTags(vm_tag, current);
+      }
+      // VM first.
+      ASSERT((tag_order() == Profile::kVMUser) ||
+             (tag_order() == Profile::kVM));
+      current = AppendVMTags(vm_tag, current);
+      // Only VM.
+      if (tag_order() == Profile::kVM) {
+        return current;
+      }
+      return AppendUserTag(user_tag, current);
+    }
+
     if (tag_order() == Profile::kNoTags) {
       return current;
     }
-    // User first.
-    if ((tag_order() == Profile::kUserVM) ||
-        (tag_order() == Profile::kUser)) {
-      current = AppendUserTag(user_tag, current);
-      // Only user.
-      if (tag_order() == Profile::kUser) {
-        return current;
-      }
-      return AppendVMTags(vm_tag, current);
-    }
-    // VM first.
-    ASSERT((tag_order() == Profile::kVMUser) ||
-           (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) {
@@ skipping 74 matching lines @@
       return current;
     }
     intptr_t tag_index = GetProfileFunctionTagIndex(vm_tag);
     current = current->GetChild(tag_index);
     // Give the tag a tick.
     current->Tick();
     return current;
   }
 
   ProfileFunctionTrieNode* AppendVMTags(uword vm_tag,
-                                    ProfileFunctionTrieNode* current) {
+                                        ProfileFunctionTrieNode* current) {
     current = AppendVMTag(vm_tag, current);
     current = AppendSpecificNativeRuntimeEntryVMTag(vm_tag, current);
     return current;
   }
 
+  ProfileFunctionTrieNode* AppendExitFrame(uword vm_tag,
+                                           ProfileFunctionTrieNode* current) {
+    if (FLAG_profile_vm) {
+      return current;
+    }
+
+    if (!VMTag::IsExitFrameTag(vm_tag)) {
+      return current;
+    }
+    if (VMTag::IsNativeEntryTag(vm_tag) ||
+        VMTag::IsRuntimeEntryTag(vm_tag)) {
+      current = AppendSpecificNativeRuntimeEntryVMTag(vm_tag, current);
+    } else {
+      intptr_t tag_index = GetProfileFunctionTagIndex(vm_tag);
+      current = current->GetChild(tag_index);
+      // Give the tag a tick.
+      current->Tick();
+    }
+    return current;
+  }
+
   ProfileFunctionTrieNode* AppendTags(uword vm_tag,
                                       uword user_tag,
                                       ProfileFunctionTrieNode* current) {
-    // None.
+    if (FLAG_profile_vm) {
+      // None.
+      if (tag_order() == Profile::kNoTags) {
+        return current;
+      }
+      // User first.
+      if ((tag_order() == Profile::kUserVM) ||
+          (tag_order() == Profile::kUser)) {
+        current = AppendUserTag(user_tag, current);
+        // Only user.
+        if (tag_order() == Profile::kUser) {
+          return current;
+        }
+        return AppendVMTags(vm_tag, current);
+      }
+      // VM first.
+      ASSERT((tag_order() == Profile::kVMUser) ||
+             (tag_order() == Profile::kVM));
+      current = AppendVMTags(vm_tag, current);
+      // Only VM.
+      if (tag_order() == Profile::kVM) {
+        return current;
+      }
+      return AppendUserTag(user_tag, current);
+    }
+
     if (tag_order() == Profile::kNoTags) {
       return current;
     }
-    // User first.
-    if ((tag_order() == Profile::kUserVM) ||
-        (tag_order() == Profile::kUser)) {
-      current = AppendUserTag(user_tag, current);
-      // Only user.
-      if (tag_order() == Profile::kUser) {
-        return current;
-      }
-      return AppendVMTags(vm_tag, current);
-    }
-    // VM first.
-    ASSERT((tag_order() == Profile::kVMUser) ||
-           (tag_order() == Profile::kVM));
-    current = AppendVMTags(vm_tag, current);
-    // Only VM.
-    if (tag_order() == Profile::kVM) {
-      return current;
-    }
+
     return AppendUserTag(user_tag, current);
   }
 
   intptr_t GetProfileCodeTagIndex(uword tag) {
     ProfileCodeTable* tag_table = profile_->tag_code_;
     intptr_t index = tag_table->FindCodeIndexForPC(tag);
     ASSERT(index >= 0);
     ProfileCode* code = tag_table->At(index);
     ASSERT(code != NULL);
     return code->code_table_index();
@@ skipping 673 matching lines @@
   // Disable thread interrupts while processing the buffer.
   DisableThreadInterruptsScope dtis(thread);
 
   ClearProfileVisitor clear_profile(isolate);
   sample_buffer->VisitSamples(&clear_profile);
 }
 
 #endif  // !PRODUCT
 
 }  // namespace dart