Add profile data to getSourceReport

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/log.h"
 #include "vm/native_symbol.h"
 #include "vm/object.h"
@@ skipping 139 matching lines @@
     return;
   }
   inclusive_serial_ = inclusive_serial;
   inclusive_ticks_++;
   TickSourcePosition(token_position, false);
 }
 
 
 void ProfileFunction::TickSourcePosition(TokenPosition token_position,
                                          bool exclusive) {
-  for (intptr_t i = 0; i < source_position_ticks_.length(); i++) {
+  intptr_t i = 0;
+  for (; i < source_position_ticks_.length(); i++) {
     ProfileFunctionSourcePosition& position = source_position_ticks_[i];
-    if (position.token_pos() == token_position) {
+    if (position.token_pos().value() == token_position.value()) {
+      if (FLAG_trace_profiler) {
+        OS::Print("Ticking source position %s %s\n",
+                  exclusive ? "exclusive" : "inclusive",
+                  token_position.ToCString());
+      }
       // Found existing position, tick it.
       position.Tick(exclusive);
       return;
     }
+    if (position.token_pos().value() > token_position.value()) {
+      break;
+    }
   }
-  // Add new one.
+
+  // Add new one, sorted by token position value.
   ProfileFunctionSourcePosition pfsp(token_position);
+  if (FLAG_trace_profiler) {
+    OS::Print("Ticking source position %s %s\n",
+              exclusive ? "exclusive" : "inclusive",
+              token_position.ToCString());
+  }
   pfsp.Tick(exclusive);
-  source_position_ticks_.Add(pfsp);
+
+  if (i < source_position_ticks_.length()) {
+    source_position_ticks_.InsertAt(i, pfsp);
+  } else {
+    source_position_ticks_.Add(pfsp);
+  }
 }
 
 
 const char* ProfileFunction::KindToCString(Kind kind) {
   switch (kind) {
     case kDartFunction:
       return "Dart";
     case kNativeFunction:
       return "Native";
     case kTagFunction:
@@ skipping 1238 matching lines @@
       }
 
       // Truncated tag.
       if (sample->truncated()) {
         current = AppendTruncatedTag(current);
         InclusiveTickTruncatedTag();
       }
     }
   }
 
+  intptr_t OffsetForPC(uword pc,
+                       const Code& code,
+                       ProcessedSample* sample,
+                       intptr_t frame_index) {
+    intptr_t offset = pc - code.EntryPoint();
+    if (frame_index != 0) {
+      // The PC of frames below the top frame is a call's return address,
+      // which can belong to a different inlining interval than the call.
+      offset--;
+    } else if (sample->IsAllocationSample()) {
+      // Allocation samples skip the top frame, so the top frame's pc is
+      // also a call's return address.
+      offset--;
+    } else if (!sample->first_frame_executing()) {
+      // If the first frame wasn't executing code (i.e. we started to collect
+      // the stack trace at an exit frame), the top frame's pc is also a
+      // call's return address.
+      offset--;
+    }
+    return offset;
+  }
+
   ProfileFunctionTrieNode* ProcessFrame(
       ProfileFunctionTrieNode* current,
       intptr_t sample_index,
       ProcessedSample* sample,
       intptr_t frame_index) {
     const uword pc = sample->At(frame_index);
     ProfileCode* profile_code = GetProfileCode(pc,
                                                sample->timestamp());
     ProfileFunction* function = profile_code->function();
     ASSERT(function != NULL);
     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;
     GrowableArray<TokenPosition> inlined_token_positions;
     TokenPosition token_position = TokenPosition::kNoSource;
     if (!code.IsNull()) {
-      intptr_t offset = pc - code.EntryPoint();
-      if (frame_index != 0) {
-        // The PC of frames below the top frame is a call's return address,
-        // which can belong to a different inlining interval than the call.
-        offset--;
-      } else if (sample->IsAllocationSample()) {
-        // Allocation samples skip the top frame, so the top frame's pc is
-        // also a call's return address.
-        offset--;
-      } else if (!sample->first_frame_executing()) {
-        // If the first frame wasn't executing code (i.e. we started to collect
-        // the stack trace at an exit frame), the top frame's pc is also a
-        // call's return address.
-        offset--;
-      }
+      const intptr_t offset = OffsetForPC(pc, code, sample, frame_index);
       code.GetInlinedFunctionsAt(offset,
                                  &inlined_functions,
                                  &inlined_token_positions);
       token_position = code.GetTokenPositionAt(offset);
       if (inlined_functions.length() > 0) {
         // The inlined token position table does not include the token position
         // of the final call. Insert it at the beginning because the table.
         // is reversed.
         inlined_token_positions.InsertAt(0, token_position);
       }
@@ skipping 108 matching lines @@
     return IsExecutingFrame(sample, frame_index) || 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 (FLAG_trace_profiler) {
-      THR_Print("S[%" Pd "]F[%" Pd "] %s %s\n",
-                sample_index,
-                frame_index,
-                function->Name(), token_position.ToCString());
-    }
     if (tick_functions_) {
+      if (FLAG_trace_profiler) {
+        THR_Print("S[%" Pd "]F[%" Pd "] %s %s 0x%" Px "\n",
+                  sample_index,
+                  frame_index,
+                  function->Name(),
+                  token_position.ToCString(),
+                  sample->At(frame_index));
+      }
       function->Tick(IsExecutingFrame(sample, frame_index),
                      sample_index,
                      token_position);
     }
     function->AddProfileCode(code_index);
     current = current->GetChild(function->table_index());
     if (ShouldTickNode(sample, frame_index)) {
       current->Tick();
     }
     current->AddCodeObjectIndex(code_index);
@@ skipping 494 matching lines @@
 
 void Profile::Build(Thread* thread,
                     SampleFilter* filter,
                     TagOrder tag_order,
                     intptr_t extra_tags) {
   ProfileBuilder builder(thread, filter, tag_order, extra_tags, this);
   builder.Build();
 }
 
 
+intptr_t Profile::NumFunctions() const {
+  return functions_->length();
+}
+
 ProfileFunction* Profile::GetFunction(intptr_t index) {
   ASSERT(functions_ != NULL);
   return functions_->At(index);
 }
 
 
 ProfileCode* Profile::GetCode(intptr_t index) {
   ASSERT(live_code_ != NULL);
   ASSERT(dead_code_ != NULL);
   ASSERT(tag_code_ != NULL);
@@ skipping 96 matching lines @@
 
       ProfileTrieNode* trie = sample->timeline_trie();
       ASSERT(trie->frame_id() != -1);
       event.AddPropertyF("sf", "%" Pd "-%" Pd,
                          isolate_id, trie->frame_id());
     }
   }
 }
 
 
+ProfileFunction* Profile::FindFunction(const Function& function) {
+  const intptr_t index = functions_->LookupIndex(function);
+  if (index < 0) {
+    return NULL;
+  }
+  return functions_->At(index);
+}
+
+
 void Profile::PrintProfileJSON(JSONStream* stream) {
   ScopeTimer sw("Profile::PrintProfileJSON", FLAG_trace_profiler);
   JSONObject obj(stream);
   obj.AddProperty("type", "_CpuProfile");
   PrintHeaderJSON(&obj);
   {
     JSONArray codes(&obj, "codes");
     for (intptr_t i = 0; i < live_code_->length(); i++) {
       ProfileCode* code = live_code_->At(i);
       ASSERT(code != NULL);
@@ skipping 310 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