Refactor function tick code and add test

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 99 matching lines @@
   }
   ASSERT(!function_.IsNull());
   const String& func_name =
       String::Handle(function_.QualifiedUserVisibleName());
   return func_name.ToCString();
 }
 
 void ProfileFunction::Tick(bool exclusive, intptr_t inclusive_serial) {
   if (exclusive) {
     exclusive_ticks_++;
-  } else {
-    if (inclusive_serial_ == inclusive_serial) {
-      // Already ticket.
-      return;
-    }
-    inclusive_serial_ = inclusive_serial;
-    inclusive_ticks_++;
   }
+  // Fall through and tick inclusive count too.
+  if (inclusive_serial_ == inclusive_serial) {
+    // Already ticked.
+    return;
+  }
+  inclusive_serial_ = inclusive_serial;
+  inclusive_ticks_++;
 }
 
 
 const char* ProfileFunction::KindToCString(Kind kind) {
   switch (kind) {
     case kDartFunction:
       return "Dart";
     case kNativeFunction:
       return "Native";
     case kTagFunction:
@@ skipping 818 matching lines @@
                  Profile* profile)
       : isolate_(isolate),
         vm_isolate_(Dart::vm_isolate()),
         filter_(filter),
         tag_order_(tag_order),
         profile_(profile),
         deoptimized_code_(new DeoptimizedCodeSet(isolate)),
         null_code_(Code::ZoneHandle()),
         null_function_(Function::ZoneHandle()),
         tick_functions_(false),
+        inclusive_tree_(false),
         samples_(NULL) {
     ASSERT(profile_ != NULL);
   }
 
   void Build() {
     ScopeTimer sw("ProfileBuilder::Build", FLAG_trace_profiler);
     FilterSamples();
 
     Setup();
     BuildCodeTable();
@@ skipping 46 matching lines @@
 
   void UpdateMinMaxTimes(int64_t timestamp) {
     profile_->min_time_ =
         timestamp < profile_->min_time_ ? timestamp : profile_->min_time_;
     profile_->max_time_ =
         timestamp > profile_->max_time_ ? timestamp : profile_->max_time_;
   }
 
   void BuildCodeTable() {
     ScopeTimer sw("ProfileBuilder::BuildCodeTable", FLAG_trace_profiler);
-    for (intptr_t i = 0; i < samples_->length(); i++) {
-      ProcessedSample* sample = samples_->At(i);
+    for (intptr_t sample_index = 0;
+         sample_index < samples_->length();
+         sample_index++) {
+      ProcessedSample* sample = samples_->At(sample_index);
       const int64_t timestamp = sample->timestamp();
 
       // This is our first pass over the sample buffer, use this as an
       // opportunity to determine the min and max time ranges of this profile.
       UpdateMinMaxTimes(timestamp);
 
       // Make sure VM tag exists.
       if (VMTag::IsNativeEntryTag(sample->vm_tag())) {
         RegisterProfileCodeTag(VMTag::kNativeTagId);
       } else if (VMTag::IsRuntimeEntryTag(sample->vm_tag())) {
         RegisterProfileCodeTag(VMTag::kRuntimeTagId);
       }
       RegisterProfileCodeTag(sample->vm_tag());
       // Make sure user tag exists.
       RegisterProfileCodeTag(sample->user_tag());
 
       // Make sure that a ProfileCode objects exist for all pcs in the sample
       // and tick each one.
-      for (intptr_t j = 0; j < sample->length(); j++) {
-        const uword pc = sample->At(j);
+      for (intptr_t frame_index = 0;
+           frame_index < sample->length();
+           frame_index++) {
+        const uword pc = sample->At(frame_index);
         ASSERT(pc != 0);
         ProfileCode* code = RegisterProfileCode(pc, timestamp);
         ASSERT(code != NULL);
-        code->Tick(pc, IsExecutingFrame(sample, j), i);
+        code->Tick(pc, IsExecutingFrame(sample, frame_index), sample_index);
       }
     }
   }
 
   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 46 matching lines @@
     for (intptr_t i = 0; i < tag_table->length(); i++) {
       ProfileCode* code = tag_table->At(i);
       ASSERT(code != NULL);
       code->SetFunctionAndName(function_table);
     }
   }
 
   void BuildCodeTrie(Profile::TrieKind kind) {
     ProfileCodeTrieNode* root =
         new ProfileCodeTrieNode(GetProfileCodeTagIndex(VMTag::kRootTagId));
-    if (IsInclusiveTrie(kind)) {
+    inclusive_tree_ = IsInclusiveTrie(kind);
+    if (inclusive_tree_) {
       BuildInclusiveCodeTrie(root);
     } else {
       BuildExclusiveCodeTrie(root);
     }
     root->SortChildren();
     profile_->roots_[static_cast<intptr_t>(kind)] = root;
   }
 
   void BuildInclusiveCodeTrie(ProfileCodeTrieNode* root) {
     ScopeTimer sw("ProfileBuilder::BuildInclusiveCodeTrie",
                   FLAG_trace_profiler);
-    for (intptr_t i = 0; i < samples_->length(); i++) {
-      ProcessedSample* sample = samples_->At(i);
+    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);
 
       // Truncated tag.
       if (sample->truncated()) {
         current = AppendTruncatedTag(current);
       }
 
       // Walk the sampled PCs.
-      for (intptr_t j = sample->length() - 1; j >= 0; j--) {
-        ASSERT(sample->At(j) != 0);
+      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(j), sample->timestamp());
+            GetProfileCodeIndex(sample->At(frame_index), sample->timestamp());
         ASSERT(index >= 0);
         current = current->GetChild(index);
         current->Tick();
       }
     }
   }
 
   void BuildExclusiveCodeTrie(ProfileCodeTrieNode* root) {
     ScopeTimer sw("ProfileBuilder::BuildExclusiveCodeTrie",
                   FLAG_trace_profiler);
-    for (intptr_t i = 0; i < samples_->length(); i++) {
-      ProcessedSample* sample = samples_->At(i);
+    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);
 
       // Walk the sampled PCs.
-      for (intptr_t j = 0; j < sample->length(); j++) {
-        ASSERT(sample->At(j) != 0);
+      for (intptr_t frame_index = 0;
+           frame_index < sample->length();
+           frame_index++) {
+        ASSERT(sample->At(frame_index) != 0);
         intptr_t index =
-            GetProfileCodeIndex(sample->At(j), sample->timestamp());
+            GetProfileCodeIndex(sample->At(frame_index), sample->timestamp());
         ASSERT(index >= 0);
         current = current->GetChild(index);
         current->Tick();
       }
 
       // Truncated tag.
       if (sample->truncated()) {
         current = AppendTruncatedTag(current);
       }
     }
   }
 
   void BuildFunctionTrie(Profile::TrieKind kind) {
     ProfileFunctionTrieNode* root =
         new ProfileFunctionTrieNode(
             GetProfileFunctionTagIndex(VMTag::kRootTagId));
     // We tick the functions while building the trie, but, we don't want to do
-    // it for both tries, just one.
-    tick_functions_ = IsInclusiveTrie(kind);
-    if (IsInclusiveTrie(kind)) {
+    // it for both tries, just the exclusive trie.
+    inclusive_tree_ = IsInclusiveTrie(kind);
+    tick_functions_ = !inclusive_tree_;
+    if (inclusive_tree_) {
       BuildInclusiveFunctionTrie(root);
     } else {
       BuildExclusiveFunctionTrie(root);
     }
     root->SortChildren();
     profile_->roots_[static_cast<intptr_t>(kind)] = root;
   }
 
   void BuildInclusiveFunctionTrie(ProfileFunctionTrieNode* root) {
     ScopeTimer sw("ProfileBuilder::BuildInclusiveFunctionTrie",
                   FLAG_trace_profiler);
-    for (intptr_t i = 0; i < samples_->length(); i++) {
-      ProcessedSample* sample = samples_->At(i);
+    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);
 
       // Truncated tag.
       if (sample->truncated()) {
         current = AppendTruncatedTag(current);
-        InclusiveTickTruncatedTag();
       }
 
       // Walk the sampled PCs.
-      for (intptr_t j = sample->length() - 1; j >= 0; j--) {
-        ASSERT(sample->At(j) != 0);
-        current = ProcessFunctionPC(
-            sample->At(j),
-            sample->timestamp(),
-            current,
-            i,
-            (j == 0),
-            sample->first_frame_executing() || sample->IsAllocationSample(),
-            true);
+      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);
       }
     }
   }
 
   void BuildExclusiveFunctionTrie(ProfileFunctionTrieNode* root) {
     ScopeTimer sw("ProfileBuilder::BuildExclusiveFunctionTrie",
                   FLAG_trace_profiler);
-    for (intptr_t i = 0; i < samples_->length(); i++) {
-      ProcessedSample* sample = samples_->At(i);
+    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);
 
       // Walk the sampled PCs.
-      for (intptr_t j = 0; j < sample->length(); j++) {
-        ASSERT(sample->At(j) != 0);
-        current = ProcessFunctionPC(
-            sample->At(j),
-            sample->timestamp(),
-            current,
-            i,
-            (j == 0),
-            sample->first_frame_executing() || sample->IsAllocationSample(),
-            false);
+      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()) {
         current = AppendTruncatedTag(current);
+        InclusiveTickTruncatedTag();
       }
     }
   }
 
-  ProfileFunctionTrieNode* ProcessFunctionPC(
-      uword pc,
-      int64_t timestamp,
+  ProfileFunctionTrieNode* ProcessFrame(
       ProfileFunctionTrieNode* current,
-      intptr_t inclusive_serial,
-      bool top_frame,
-      bool top_frame_executing,
-      bool inclusive_tree) {
-    ProfileCode* profile_code = GetProfileCode(pc, timestamp);
+      intptr_t sample_index,
+      ProcessedSample* sample,
+      intptr_t frame_index) {
+    const uword pc = sample->At(frame_index);
+    ProfileCode* profile_code = GetProfileCode(pc,
+                                               sample->timestamp());
     ASSERT(profile_code != NULL);
-    const char* code_name = profile_code->name();
-    if (code_name == NULL) {
-      code_name = "";
-    }
-    intptr_t code_index = profile_code->code_table_index();
     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.
       ProfileFunction* function = profile_code->function();
       ASSERT(function != NULL);
-      current = ProcessFunction(function,
-                                current,
-                                inclusive_serial,
-                                top_frame,
-                                top_frame_executing,
-                                code_index);
+      current = ProcessFunction(current,
+                                sample_index,
+                                sample,
+                                frame_index,
+                                function);
       return current;
     }
 
-    if (inclusive_tree) {
+    if (inclusive_tree_) {
       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());
-        current = ProcessInlinedFunction(inlined_function,
-                                         current,
-                                         inclusive_serial,
-                                         top_frame,
-                                         top_frame_executing,
-                                         code_index);
-        top_frame = false;
+        current = ProcessInlinedFunction(current,
+                                         sample_index,
+                                         sample,
+                                         frame_index,
+                                         inlined_function);
       }
     } else {
       for (intptr_t i = 0; i < inlined_functions.length(); i++) {
         Function* inlined_function = inlined_functions[i];
         ASSERT(inlined_function != NULL);
         ASSERT(!inlined_function->IsNull());
-        current = ProcessInlinedFunction(inlined_function,
-                                         current,
-                                         inclusive_serial,
-                                         top_frame,
-                                         top_frame_executing,
-                                         code_index);
-        top_frame = false;
+        current = ProcessInlinedFunction(current,
+                                         sample_index,
+                                         sample,
+                                         frame_index + i,
+                                         inlined_function);
       }
     }
 
     return current;
   }
 
   ProfileFunctionTrieNode* ProcessInlinedFunction(
-      Function* inlined_function,
       ProfileFunctionTrieNode* current,
-      intptr_t inclusive_serial,
-      bool top_frame,
-      bool top_frame_executing,
-      intptr_t code_index) {
+      intptr_t sample_index,
+      ProcessedSample* sample,
+      intptr_t frame_index,
+      Function* inlined_function) {
     ProfileFunctionTable* function_table = profile_->functions_;
     ProfileFunction* function = function_table->LookupOrAdd(*inlined_function);
     ASSERT(function != NULL);
-    return ProcessFunction(function,
-                           current,
-                           inclusive_serial,
-                           top_frame,
-                           top_frame_executing,
-                           code_index);
+    return ProcessFunction(current,
+                           sample_index,
+                           sample,
+                           frame_index,
+                           function);
   }
 
-  ProfileFunctionTrieNode* ProcessFunction(ProfileFunction* function,
-                                           ProfileFunctionTrieNode* current,
-                                           intptr_t inclusive_serial,
-                                           bool top_frame,
-                                           bool top_frame_executing,
-                                           intptr_t code_index) {
-    const bool exclusive = top_frame && top_frame_executing;
+  ProfileFunctionTrieNode* ProcessFunction(ProfileFunctionTrieNode* current,
+                                           intptr_t sample_index,
+                                           ProcessedSample* sample,
+                                           intptr_t frame_index,
+                                           ProfileFunction* function) {
     if (tick_functions_) {
-      function->Tick(exclusive, exclusive ? -1 : inclusive_serial);
+      function->Tick(IsExecutingFrame(sample, frame_index), sample_index);
     }
-    function->AddProfileCode(code_index);
     current = current->GetChild(function->table_index());
-    current->AddCodeObjectIndex(code_index);
-    if (top_frame) {
-      if (top_frame_executing || vm_tags_emitted()) {
-        // Only tick if this function is using CPU time or VM tags are emitted.
-        current->Tick();
-      }
-    } else {
-      current->Tick();
-    }
+    current->Tick();
     return current;
   }
 
   // Tick the truncated tag's inclusive tick count.
   void InclusiveTickTruncatedTag() {
     ProfileCodeTable* tag_table = profile_->tag_code_;
     intptr_t index = tag_table->FindCodeIndexForPC(VMTag::kTruncatedTagId);
     ASSERT(index >= 0);
     ProfileCode* code = tag_table->At(index);
     code->IncInclusiveTicks();
@@ skipping 113 matching lines @@
       ProfileFunctionTrieNode* current) {
     intptr_t truncated_tag_index =
         GetProfileFunctionTagIndex(VMTag::kTruncatedTagId);
     ASSERT(truncated_tag_index >= 0);
     current = current->GetChild(truncated_tag_index);
     current->Tick();
     return current;
   }
 
   ProfileFunctionTrieNode* AppendVMTag(uword vm_tag,
-                                   ProfileFunctionTrieNode* current) {
+                                       ProfileFunctionTrieNode* current) {
     if (VMTag::IsNativeEntryTag(vm_tag)) {
       // Insert a dummy kNativeTagId node.
       intptr_t tag_index = GetProfileFunctionTagIndex(VMTag::kNativeTagId);
       current = current->GetChild(tag_index);
       // Give the tag a tick.
       current->Tick();
     } else if (VMTag::IsRuntimeEntryTag(vm_tag)) {
       // Insert a dummy kRuntimeTagId node.
       intptr_t tag_index = GetProfileFunctionTagIndex(VMTag::kRuntimeTagId);
       current = current->GetChild(tag_index);
@@ skipping 250 matching lines @@
 
   Isolate* isolate_;
   Isolate* vm_isolate_;
   SampleFilter* filter_;
   Profile::TagOrder tag_order_;
   Profile* profile_;
   DeoptimizedCodeSet* deoptimized_code_;
   const Code& null_code_;
   const Function& null_function_;
   bool tick_functions_;
+  bool inclusive_tree_;
 
   ProcessedSampleBuffer* samples_;
 };
 
 
 Profile::Profile(Isolate* isolate)
     : isolate_(isolate),
       live_code_(NULL),
       dead_code_(NULL),
       tag_code_(NULL),
@@ skipping 295 matching lines @@
   ASSERT(sample_buffer != NULL);
 
   ClearProfileVisitor clear_profile(isolate);
   sample_buffer->VisitSamples(&clear_profile);
 
   // Enable profile interrupts.
   Profiler::BeginExecution(isolate);
 }
 
 }  // namespace dart