Added page to Observatory to display native memory allocation information.

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"
@@ skipping 128 matching lines @@
   if (function_.IsNull()) {
     // Some synthetic function.
     return true;
   }
   return FLAG_show_invisible_frames || function_.is_visible();
 }
 
 
 void ProfileFunction::Tick(bool exclusive,
                            intptr_t inclusive_serial,
-                           TokenPosition token_position) {
+                           TokenPosition token_position,
+                           ProcessedSample* sample) {
   if (exclusive) {
     exclusive_ticks_++;
+    AccumulateAllocation(sample->native_allocation_size_bytes(), true);
     TickSourcePosition(token_position, exclusive);
   }
   // Fall through and tick inclusive count too.
   if (inclusive_serial_ == inclusive_serial) {
     // Already ticked.
     return;
   }
   inclusive_serial_ = inclusive_serial;
   inclusive_ticks_++;
+  AccumulateAllocation(sample->native_allocation_size_bytes(), false);
   TickSourcePosition(token_position, false);
 }
 
 
 void ProfileFunction::TickSourcePosition(TokenPosition token_position,
                                          bool exclusive) {
   intptr_t i = 0;
   for (; i < source_position_ticks_.length(); i++) {
     ProfileFunctionSourcePosition& position = source_position_ticks_[i];
     if (position.token_pos().value() == token_position.value()) {
@@ skipping 21 matching lines @@
   pfsp.Tick(exclusive);
 
   if (i < source_position_ticks_.length()) {
     source_position_ticks_.InsertAt(i, pfsp);
   } else {
     source_position_ticks_.Add(pfsp);
   }
 }
 
 
+static intptr_t SumAllocations(const AllocationHashMap& map) {
+  uintptr_t sum = 0;
+  AllocationHashMap::Iterator iter = map.GetIterator();
+  AllocationKeyValueTrait::Pair* pair = iter.Next();
+
+  while (pair != NULL) {
+    sum += pair->value * pair->key;
+    pair = iter.Next();
+  }
+
+  return sum;
+}
+
+
+static void AccumulateAllocationHelper(AllocationHashMap* map,

[Cutch, 2017/03/16 20:38:16]

I don't see why this code is necessary?

[bkonyi, 2017/03/16 20:48:40]

So, currently, I'm tracking the inclusive/exclusive allocation values in both
the trie and the Profile(Code|Function). The values in the trie are the ones
that are being displayed, but you had mentioned it might be worth keeping the
values in the Profile(Code|Function) objects as well. I meant to leave a comment
asking if we should leave this or not, but I think it might just make more sense
to take it out.

[bkonyi, 2017/03/21 01:53:23]

Removed.

+                                       intptr_t allocation_size) {
+  ASSERT(map != NULL);
+  AllocationKeyValueTrait::Pair* allocation = map->Lookup(allocation_size);
+  if (allocation == NULL) {
+    map->Insert(AllocationKeyValueTrait::Pair(allocation_size, 1));
+    return;
+  }
+  ++allocation->value;
+}
+
+
+void ProfileFunction::AccumulateAllocation(intptr_t allocation_size,
+                                           bool exclusive) {
+  if (exclusive) {
+    AccumulateAllocationHelper(&exclusive_native_allocations_, allocation_size);
+  } else {
+    AccumulateAllocationHelper(&inclusive_native_allocations_, allocation_size);
+  }
+}
+
+
 const char* ProfileFunction::KindToCString(Kind kind) {
   switch (kind) {
     case kDartFunction:
       return "Dart";
     case kNativeFunction:
       return "Native";
     case kTagFunction:
       return "Tag";
     case kStubFunction:
       return "Stub";
@@ skipping 11 matching lines @@
   func->AddProperty("name", name());
   func->AddProperty("_kind", KindToCString(kind()));
 }
 
 
 void ProfileFunction::PrintToJSONArray(JSONArray* functions) {
   JSONObject obj(functions);
   obj.AddProperty("kind", KindToCString(kind()));
   obj.AddPropertyF("inclusiveTicks", "%" Pd "", inclusive_ticks());
   obj.AddPropertyF("exclusiveTicks", "%" Pd "", exclusive_ticks());
+
+  obj.AddPropertyF("inclusiveNativeAllocations", "%" Pd "",
+                   SumAllocations(inclusive_native_allocations_));
+  obj.AddPropertyF("exclusiveNativeAllocations", "%" Pd "",
+                   SumAllocations(exclusive_native_allocations_));
+
   if (kind() == kDartFunction) {
     ASSERT(!function_.IsNull());
     obj.AddProperty("function", function_);
   } else {
     JSONObject func(&obj, "function");
     PrintToJSONObject(&func);
   }
   {
     JSONArray codes(&obj, "codes");
     for (intptr_t i = 0; i < profile_codes_.length(); i++) {
@@ skipping 94 matching lines @@
 
 void ProfileCode::GenerateAndSetSymbolName(const char* prefix) {
   const intptr_t kBuffSize = 512;
   char buff[kBuffSize];
   OS::SNPrint(&buff[0], kBuffSize - 1, "%s [%" Px ", %" Px ")", prefix, start(),
               end());
   SetName(buff);
 }
 
 
-void ProfileCode::Tick(uword pc, bool exclusive, intptr_t serial) {
+void ProfileCode::Tick(uword pc,
+                       bool exclusive,
+                       intptr_t serial,
+                       ProcessedSample* sample) {
   // If exclusive is set, tick it.
   if (exclusive) {
     exclusive_ticks_++;
+    AccumulateAllocation(sample->native_allocation_size_bytes(), true);
     TickAddress(pc, true);
   }
   // Fall through and tick inclusive count too.
   if (inclusive_serial_ == serial) {
     // Already gave inclusive tick for this sample.
     return;
   }
+
+  AccumulateAllocation(sample->native_allocation_size_bytes(), false);
+
   inclusive_serial_ = serial;
   inclusive_ticks_++;
   TickAddress(pc, false);
 }
 
 
 void ProfileCode::TickAddress(uword pc, bool exclusive) {
   const intptr_t length = address_ticks_.length();
 
   intptr_t i = 0;
@@ skipping 17 matching lines @@
   if (i < length) {
     // Insert at i.
     address_ticks_.InsertAt(i, entry);
   } else {
     // Add to end.
     address_ticks_.Add(entry);
   }
 }
 
 
+void ProfileCode::AccumulateAllocation(intptr_t allocation_size,
+                                       bool exclusive) {
+  if (exclusive) {
+    AccumulateAllocationHelper(&exclusive_native_allocations_, allocation_size);
+  } else {
+    AccumulateAllocationHelper(&inclusive_native_allocations_, allocation_size);
+  }
+}
+
+
 void ProfileCode::PrintNativeCode(JSONObject* profile_code_obj) {
   ASSERT(kind() == kNativeCode);
   JSONObject obj(profile_code_obj, "code");
   obj.AddProperty("type", "@Code");
   obj.AddProperty("kind", "Native");
   obj.AddProperty("name", name());
   obj.AddProperty("_optimized", false);
   obj.AddPropertyF("start", "%" Px "", start());
   obj.AddPropertyF("end", "%" Px "", end());
   {
@@ skipping 75 matching lines @@
   UNREACHABLE();
   return NULL;
 }
 
 
 void ProfileCode::PrintToJSONArray(JSONArray* codes) {
   JSONObject obj(codes);
   obj.AddProperty("kind", ProfileCode::KindToCString(kind()));
   obj.AddPropertyF("inclusiveTicks", "%" Pd "", inclusive_ticks());
   obj.AddPropertyF("exclusiveTicks", "%" Pd "", exclusive_ticks());
+  obj.AddPropertyF("inclusiveNativeAllocations", "%" Pd "",
+                   SumAllocations(inclusive_native_allocations_));
+  obj.AddPropertyF("exclusiveNativeAllocations", "%" Pd "",
+                   SumAllocations(exclusive_native_allocations_));
   if (kind() == kDartCode) {
     ASSERT(!code_.IsNull());
     obj.AddProperty("code", code_);
   } else if (kind() == kCollectedCode) {
     PrintCollectedCode(&obj);
   } else if (kind() == kReusedCode) {
     PrintOverwrittenCode(&obj);
   } else if (kind() == kTagCode) {
     PrintTagCode(&obj);
   } else {
@@ skipping 356 matching lines @@
                !b->Contains(a->start()) && !b->Contains(a->end() - 1));
       }
     }
   }
 
   ZoneGrowableArray<ProfileCode*> table_;
 };
 
 
 ProfileTrieNode::ProfileTrieNode(intptr_t table_index)
-    : table_index_(table_index), count_(0), children_(0), frame_id_(-1) {
+    : table_index_(table_index),
+      count_(0),
+      exclusive_allocations_(0),
+      inclusive_allocations_(0),
+      children_(0),
+      frame_id_(-1) {
   ASSERT(table_index_ >= 0);
 }
 
 
 ProfileTrieNode::~ProfileTrieNode() {}
 
 
 void ProfileTrieNode::SortChildren() {
   children_.Sort(ProfileTrieNodeCompare);
   // Recurse.
@@ skipping 20 matching lines @@
 
   void PrintToJSONArray(JSONArray* array) const {
     ASSERT(array != NULL);
     // Write CodeRegion index.
     array->AddValue(table_index());
     // Write count.
     array->AddValue(count());
     // Write number of children.
     intptr_t child_count = NumChildren();
     array->AddValue(child_count);
+    // Write inclusive allocations.
+    array->AddValue64(inclusive_allocations_);
+    // Write exclusive allocations.
+    array->AddValue64(exclusive_allocations_);
     // Recurse.
     for (intptr_t i = 0; i < child_count; i++) {
       children_[i]->PrintToJSONArray(array);
     }
   }
 
   ProfileCodeTrieNode* GetChild(intptr_t child_table_index) {
     const intptr_t length = NumChildren();
     intptr_t i = 0;
     while (i < length) {
@@ skipping 41 matching lines @@
  public:
   explicit ProfileFunctionTrieNode(intptr_t table_index)
       : ProfileTrieNode(table_index), code_objects_(1) {}
 
   void PrintToJSONArray(JSONArray* array) const {
     ASSERT(array != NULL);
     // Write CodeRegion index.
     array->AddValue(table_index());
     // Write count.
     array->AddValue(count());
+    // Write inclusive allocations.
+    array->AddValue64(inclusive_allocations_);
+    // Write exclusive allocations.
+    array->AddValue64(exclusive_allocations_);
     // Write number of code objects.
     intptr_t code_count = code_objects_.length();
     array->AddValue(code_count);
     // Write each code object index and ticks.
     for (intptr_t i = 0; i < code_count; i++) {
       array->AddValue(code_objects_[i].index());
       array->AddValue(code_objects_[i].ticks());
     }
     // Write number of children.
     intptr_t child_count = children_.length();
@@ skipping 335 matching lines @@
       RegisterProfileCodeTag(sample->user_tag());
 
       // Make sure that a ProfileCode objects exist for all pcs in the sample
       // 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);
+        code->Tick(pc, IsExecutingFrame(sample, frame_index), sample_index,
+                   sample);
       }
 
-      TickExitFrame(sample->vm_tag(), sample_index);
+      TickExitFrame(sample->vm_tag(), sample_index, sample);
     }
     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 66 matching lines @@
   void BuildInclusiveCodeTrie(ProfileCodeTrieNode* root) {
     ScopeTimer sw("ProfileBuilder::BuildInclusiveCodeTrie",
                   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();
+      current->IncrementAllocation(sample->native_allocation_size_bytes(),

[Cutch, 2017/03/16 20:38:16]

Refactor this so it follows the pattern you set elsewhere:

ProfileCodeTrieNode::Tick takes the ProcessedSample and does the call to
IncrementaAllocation.

[bkonyi, 2017/03/21 01:53:24]

Done.

+                                   false);
 
       // VM & User tags.
-      current = AppendTags(sample->vm_tag(), sample->user_tag(), current);
+      current =
+          AppendTags(sample->vm_tag(), sample->user_tag(), current, sample);
 
       ResetKind();
 
       // Truncated tag.
       if (sample->truncated()) {
-        current = AppendTruncatedTag(current);
+        current = AppendTruncatedTag(current, sample);
       }
 
       // 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 = AppendKind(code, current, sample);
         current = current->GetChild(index);
         current->Tick();
+        current->IncrementAllocation(sample->native_allocation_size_bytes(),

[Cutch, 2017/03/16 20:38:16]

ditto

[bkonyi, 2017/03/21 01:53:23]

Done.

+                                     (frame_index == 0));
       }
 
       if (!sample->first_frame_executing()) {
-        current = AppendExitFrame(sample->vm_tag(), current);
+        current = AppendExitFrame(sample->vm_tag(), current, sample);
       }
     }
   }
 
   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();
-
+      current->IncrementAllocation(sample->native_allocation_size_bytes(),

[Cutch, 2017/03/16 20:38:16]

ditto

[bkonyi, 2017/03/21 01:53:23]

Done.

+                                   false);
       // VM & User tags.
-      current = AppendTags(sample->vm_tag(), sample->user_tag(), current);
+      current =
+          AppendTags(sample->vm_tag(), sample->user_tag(), current, sample);
 
       ResetKind();
 
       if (!sample->first_frame_executing()) {
-        current = AppendExitFrame(sample->vm_tag(), current);
+        current = AppendExitFrame(sample->vm_tag(), current, sample);
       }
 
       // 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->IncrementAllocation(sample->native_allocation_size_bytes(),

[Cutch, 2017/03/16 20:38:16]

ditto

[bkonyi, 2017/03/21 01:53:24]

Done.

+                                       (frame_index == 0));
         }
-        current = AppendKind(code, current);
+        current = AppendKind(code, current, sample);
       }
       // Truncated tag.
       if (sample->truncated()) {
-        current = AppendTruncatedTag(current);
+        current = AppendTruncatedTag(current, sample);
       }
     }
   }
 
   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 the exclusive trie.
     inclusive_tree_ = IsInclusiveTrie(kind);
@@ skipping 11 matching lines @@
     ScopeTimer sw("ProfileBuilder::BuildInclusiveFunctionTrie",
                   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();
-
+      current->IncrementAllocation(sample->native_allocation_size_bytes(),
+                                   false);
       // VM & User tags.
-      current = AppendTags(sample->vm_tag(), sample->user_tag(), current);
+      current =
+          AppendTags(sample->vm_tag(), sample->user_tag(), current, sample);
 
       // Truncated tag.
       if (sample->truncated()) {
-        current = AppendTruncatedTag(current);
+        current = AppendTruncatedTag(current, sample);
       }
 
       // 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);
+        current = AppendExitFrame(sample->vm_tag(), current, sample);
       }
 
       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();
-
+      current->IncrementAllocation(sample->native_allocation_size_bytes(),
+                                   false);
       // VM & User tags.
-      current = AppendTags(sample->vm_tag(), sample->user_tag(), current);
+      current =
+          AppendTags(sample->vm_tag(), sample->user_tag(), current, sample);
 
       ResetKind();
 
       if (!sample->first_frame_executing()) {
-        current = AppendExitFrame(sample->vm_tag(), current);
+        current = AppendExitFrame(sample->vm_tag(), current, sample);
       }
 
       // 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);
+      TickExitFrameFunction(sample->vm_tag(), sample_index, sample);
 
       // Truncated tag.
       if (sample->truncated()) {
-        current = AppendTruncatedTag(current);
-        InclusiveTickTruncatedTag();
+        current = AppendTruncatedTag(current, sample);
+        InclusiveTickTruncatedTag(sample);
       }
     }
   }
 
   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());
@@ skipping 17 matching lines @@
                     name.ToCString(),
                     (*inlined_token_positions)[i].ToCString());
         }
       }
     }
 
     if (code.IsNull() || (inlined_functions == NULL) ||
         (inlined_functions->length() <= 1)) {
       // No inlined functions.
       if (inclusive_tree_) {
-        current = AppendKind(code, current);
+        current = AppendKind(code, current, sample);
       }
       current = ProcessFunction(current, sample_index, sample, frame_index,
                                 function, token_position, code_index);
       if (!inclusive_tree_) {
-        current = AppendKind(code, current);
+        current = AppendKind(code, current, sample);
       }
       return current;
     }
 
+    // TODO(bkonyi) deal with this

[bkonyi, 2017/03/16 19:50:57]

What needs to be done here again John?

[Cutch, 2017/03/16 20:38:16]

You should figure out why the assumption that the code is optimized is no longer
the case :)

[bkonyi, 2017/03/21 01:53:24]

Acknowledged.

     ASSERT(code.is_optimized());
 
     if (inclusive_tree_) {
       for (intptr_t i = 0; i < inlined_functions->length(); i++) {
         const Function* inlined_function = (*inlined_functions)[i];
         ASSERT(inlined_function != NULL);
         ASSERT(!inlined_function->IsNull());
         TokenPosition inlined_token_position = (*inlined_token_positions)[i];
         const bool inliner = i == 0;
         if (inliner) {
-          current = AppendKind(code, current);
+          current = AppendKind(code, current, sample);
         }
         current = ProcessInlinedFunction(current, sample_index, sample,
                                          frame_index, inlined_function,
                                          inlined_token_position, code_index);
         if (inliner) {
-          current = AppendKind(kInlineStart, current);
+          current = AppendKind(kInlineStart, current, sample);
         }
       }
-      current = AppendKind(kInlineFinish, current);
+      current = AppendKind(kInlineFinish, current, sample);
     } else {
       // Append the inlined children.
-      current = AppendKind(kInlineFinish, current);
+      current = AppendKind(kInlineFinish, current, sample);
       for (intptr_t i = inlined_functions->length() - 1; i >= 0; i--) {
         const Function* inlined_function = (*inlined_functions)[i];
         ASSERT(inlined_function != NULL);
         ASSERT(!inlined_function->IsNull());
         TokenPosition inlined_token_position = (*inlined_token_positions)[i];
         const bool inliner = i == 0;
         if (inliner) {
-          current = AppendKind(kInlineStart, current);
+          current = AppendKind(kInlineStart, current, sample);
         }
         current = ProcessInlinedFunction(current, sample_index, sample,
                                          frame_index + i, inlined_function,
                                          inlined_token_position, code_index);
         if (inliner) {
-          current = AppendKind(code, current);
+          current = AppendKind(code, current, sample);
         }
       }
     }
 
     return current;
   }
 
   ProfileFunctionTrieNode* ProcessInlinedFunction(
       ProfileFunctionTrieNode* current,
       intptr_t sample_index,
@@ skipping 29 matching lines @@
     if (!function->is_visible()) {
       return current;
     }
     if (tick_functions_) {
       if (FLAG_trace_profiler_verbose) {
         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);
+                     token_position, sample);
     }
     function->AddProfileCode(code_index);
     current = current->GetChild(function->table_index());
     if (ShouldTickNode(sample, frame_index)) {
       current->Tick();
+      current->IncrementAllocation(sample->native_allocation_size_bytes(),
+                                   (frame_index == 0));
     }
     current->AddCodeObjectIndex(code_index);
     return current;
   }
 
   // Tick the truncated tag's inclusive tick count.
-  void InclusiveTickTruncatedTag() {
+  void InclusiveTickTruncatedTag(ProcessedSample* sample) {
     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();
     ASSERT(code != NULL);
     ProfileFunction* function = code->function();
     function->IncInclusiveTicks();
+
+    code->AccumulateAllocation(sample->native_allocation_size_bytes(), false);
+    function->AccumulateAllocation(sample->native_allocation_size_bytes(),
+                                   false);
   }
 
 
   // Tag append functions are overloaded for |ProfileCodeTrieNode| and
   // |ProfileFunctionTrieNode| types.
 
   // ProfileCodeTrieNode
   ProfileCodeTrieNode* AppendUserTag(uword user_tag,
-                                     ProfileCodeTrieNode* current) {
+                                     ProfileCodeTrieNode* current,
+                                     ProcessedSample* sample) {
     intptr_t user_tag_index = GetProfileCodeTagIndex(user_tag);
     if (user_tag_index >= 0) {
       current = current->GetChild(user_tag_index);
       current->Tick();
+      current->IncrementAllocation(sample->native_allocation_size_bytes(),
+                                   false);
     }
     return current;
   }
 
-  ProfileCodeTrieNode* AppendTruncatedTag(ProfileCodeTrieNode* current) {
+  ProfileCodeTrieNode* AppendTruncatedTag(ProfileCodeTrieNode* current,
+                                          ProcessedSample* sample) {
     intptr_t truncated_tag_index =
         GetProfileCodeTagIndex(VMTag::kTruncatedTagId);
     ASSERT(truncated_tag_index >= 0);
     current = current->GetChild(truncated_tag_index);
     current->Tick();
+    current->IncrementAllocation(sample->native_allocation_size_bytes(), false);
     return current;
   }
 
-  ProfileCodeTrieNode* AppendVMTag(uword vm_tag, ProfileCodeTrieNode* current) {
+  ProfileCodeTrieNode* AppendVMTag(uword vm_tag,
+                                   ProfileCodeTrieNode* current,
+                                   ProcessedSample* sample) {
     if (VMTag::IsNativeEntryTag(vm_tag)) {
       // Insert a dummy kNativeTagId node.
       intptr_t tag_index = GetProfileCodeTagIndex(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 = GetProfileCodeTagIndex(VMTag::kRuntimeTagId);
       current = current->GetChild(tag_index);
       // Give the tag a tick.
       current->Tick();
     } else {
       intptr_t tag_index = GetProfileCodeTagIndex(vm_tag);
       current = current->GetChild(tag_index);
       // Give the tag a tick.
       current->Tick();
     }
+    current->IncrementAllocation(sample->native_allocation_size_bytes(), false);
     return current;
   }
 
   ProfileCodeTrieNode* AppendSpecificNativeRuntimeEntryVMTag(
       uword vm_tag,
-      ProfileCodeTrieNode* current) {
+      ProfileCodeTrieNode* current,
+      ProcessedSample* sample) {
     // Only Native and Runtime entries have a second VM tag.
     if (!VMTag::IsNativeEntryTag(vm_tag) && !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();
+    current->IncrementAllocation(sample->native_allocation_size_bytes(), false);
     return current;
   }
 
   uword ProfileInfoKindToVMTag(ProfileInfoKind kind) {
     switch (kind) {
       case kNone:
         return VMTag::kNoneCodeTagId;
       case kOptimized:
         return VMTag::kOptimizedCodeTagId;
       case kUnoptimized:
         return VMTag::kUnoptimizedCodeTagId;
       case kNative:
         return VMTag::kNativeCodeTagId;
       case kInlineStart:
         return VMTag::kInlineStartCodeTagId;
       case kInlineFinish:
         return VMTag::kInlineEndCodeTagId;
       default:
         UNIMPLEMENTED();
         return VMTag::kInvalidTagId;
     }
   }
 
   ProfileCodeTrieNode* AppendKind(ProfileInfoKind kind,
-                                  ProfileCodeTrieNode* current) {
+                                  ProfileCodeTrieNode* current,
+                                  ProcessedSample* sample) {
     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();
+      current->IncrementAllocation(sample->native_allocation_size_bytes(),
+                                   false);
     }
     return current;
   }
 
   ProfileCodeTrieNode* AppendKind(const Code& code,
-                                  ProfileCodeTrieNode* current) {
+                                  ProfileCodeTrieNode* current,
+                                  ProcessedSample* sample) {
     if (code.IsNull()) {
-      return AppendKind(kNone, current);
+      return AppendKind(kNone, current, sample);
     } else if (code.is_optimized()) {
-      return AppendKind(kOptimized, current);
+      return AppendKind(kOptimized, current, sample);
     } else {
-      return AppendKind(kUnoptimized, current);
+      return AppendKind(kUnoptimized, current, sample);
     }
   }
 
   ProfileCodeTrieNode* AppendVMTags(uword vm_tag,
-                                    ProfileCodeTrieNode* current) {
-    current = AppendVMTag(vm_tag, current);
-    current = AppendSpecificNativeRuntimeEntryVMTag(vm_tag, current);
+                                    ProfileCodeTrieNode* current,
+                                    ProcessedSample* sample) {
+    current = AppendVMTag(vm_tag, current, sample);
+    current = AppendSpecificNativeRuntimeEntryVMTag(vm_tag, current, sample);
     return current;
   }
 
-  void TickExitFrame(uword vm_tag, intptr_t serial) {
+  void TickExitFrame(uword vm_tag, intptr_t serial, ProcessedSample* sample) {
     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);
+    code->Tick(vm_tag, true, serial, sample);
   }
 
-  void TickExitFrameFunction(uword vm_tag, intptr_t serial) {
+  void TickExitFrameFunction(uword vm_tag,
+                             intptr_t serial,
+                             ProcessedSample* sample) {
     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);
+    function->Tick(true, serial, TokenPosition::kNoSource, sample);
   }
 
   ProfileCodeTrieNode* AppendExitFrame(uword vm_tag,
-                                       ProfileCodeTrieNode* current) {
+                                       ProfileCodeTrieNode* current,
+                                       ProcessedSample* sample) {
     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);
+      current = AppendSpecificNativeRuntimeEntryVMTag(vm_tag, current, sample);
     } else {
       intptr_t tag_index = GetProfileCodeTagIndex(vm_tag);
       current = current->GetChild(tag_index);
       // Give the tag a tick.
       current->Tick();
+      current->IncrementAllocation(sample->native_allocation_size_bytes(),
+                                   false);
     }
     return current;
   }
 
   ProfileCodeTrieNode* AppendTags(uword vm_tag,
                                   uword user_tag,
-                                  ProfileCodeTrieNode* current) {
+                                  ProfileCodeTrieNode* current,
+                                  ProcessedSample* sample) {
     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);
+        current = AppendUserTag(user_tag, current, sample);
         // Only user.
         if (tag_order() == Profile::kUser) {
           return current;
         }
-        return AppendVMTags(vm_tag, current);
+        return AppendVMTags(vm_tag, current, sample);
       }
       // VM first.
       ASSERT((tag_order() == Profile::kVMUser) ||
              (tag_order() == Profile::kVM));
-      current = AppendVMTags(vm_tag, current);
+      current = AppendVMTags(vm_tag, current, sample);
       // Only VM.
       if (tag_order() == Profile::kVM) {
         return current;
       }
-      return AppendUserTag(user_tag, current);
+      return AppendUserTag(user_tag, current, sample);
     }
 
     if (tag_order() == Profile::kNoTags) {
       return current;
     }
 
-    return AppendUserTag(user_tag, current);
+    return AppendUserTag(user_tag, current, sample);
   }
 
   // ProfileFunctionTrieNode
   void ResetKind() { info_kind_ = kNone; }
 
   ProfileFunctionTrieNode* AppendKind(ProfileInfoKind kind,
-                                      ProfileFunctionTrieNode* current) {
+                                      ProfileFunctionTrieNode* current,
+                                      ProcessedSample* sample) {
     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();
+      current->IncrementAllocation(sample->native_allocation_size_bytes(),
+                                   false);
     }
     return current;
   }
 
   ProfileFunctionTrieNode* AppendKind(const Code& code,
-                                      ProfileFunctionTrieNode* current) {
+                                      ProfileFunctionTrieNode* current,
+                                      ProcessedSample* sample) {
     if (code.IsNull()) {
-      return AppendKind(kNone, current);
+      return AppendKind(kNone, current, sample);
     } else if (code.is_optimized()) {
-      return AppendKind(kOptimized, current);
+      return AppendKind(kOptimized, current, sample);
     } else {
-      return AppendKind(kUnoptimized, current);
+      return AppendKind(kUnoptimized, current, sample);
     }
   }
 
   ProfileFunctionTrieNode* AppendUserTag(uword user_tag,
-                                         ProfileFunctionTrieNode* current) {
+                                         ProfileFunctionTrieNode* current,
+                                         ProcessedSample* sample) {
     intptr_t user_tag_index = GetProfileFunctionTagIndex(user_tag);
     if (user_tag_index >= 0) {
       current = current->GetChild(user_tag_index);
       current->Tick();
+      current->IncrementAllocation(sample->native_allocation_size_bytes(),
+                                   false);
     }
     return current;
   }
 
-  ProfileFunctionTrieNode* AppendTruncatedTag(
-      ProfileFunctionTrieNode* current) {
+  ProfileFunctionTrieNode* AppendTruncatedTag(ProfileFunctionTrieNode* current,
+                                              ProcessedSample* sample) {
     intptr_t truncated_tag_index =
         GetProfileFunctionTagIndex(VMTag::kTruncatedTagId);
     ASSERT(truncated_tag_index >= 0);
     current = current->GetChild(truncated_tag_index);
     current->Tick();
+    current->IncrementAllocation(sample->native_allocation_size_bytes(), false);
     return current;
   }
 
   ProfileFunctionTrieNode* AppendVMTag(uword vm_tag,
-                                       ProfileFunctionTrieNode* current) {
+                                       ProfileFunctionTrieNode* current,
+                                       ProcessedSample* sample) {
     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);
       // Give the tag a tick.
       current->Tick();
     } else {
       intptr_t tag_index = GetProfileFunctionTagIndex(vm_tag);
       current = current->GetChild(tag_index);
       // Give the tag a tick.
       current->Tick();
     }
+    current->IncrementAllocation(sample->native_allocation_size_bytes(), false);
     return current;
   }
 
   ProfileFunctionTrieNode* AppendSpecificNativeRuntimeEntryVMTag(
       uword vm_tag,
-      ProfileFunctionTrieNode* current) {
+      ProfileFunctionTrieNode* current,
+      ProcessedSample* sample) {
     // Only Native and Runtime entries have a second VM tag.
     if (!VMTag::IsNativeEntryTag(vm_tag) && !VMTag::IsRuntimeEntryTag(vm_tag)) {
       return current;
     }
     intptr_t tag_index = GetProfileFunctionTagIndex(vm_tag);
     current = current->GetChild(tag_index);
     // Give the tag a tick.
     current->Tick();
+    current->IncrementAllocation(sample->native_allocation_size_bytes(), false);
     return current;
   }
 
   ProfileFunctionTrieNode* AppendVMTags(uword vm_tag,
-                                        ProfileFunctionTrieNode* current) {
-    current = AppendVMTag(vm_tag, current);
-    current = AppendSpecificNativeRuntimeEntryVMTag(vm_tag, current);
+                                        ProfileFunctionTrieNode* current,
+                                        ProcessedSample* sample) {
+    current = AppendVMTag(vm_tag, current, sample);
+    current = AppendSpecificNativeRuntimeEntryVMTag(vm_tag, current, sample);
     return current;
   }
 
   ProfileFunctionTrieNode* AppendExitFrame(uword vm_tag,
-                                           ProfileFunctionTrieNode* current) {
+                                           ProfileFunctionTrieNode* current,
+                                           ProcessedSample* sample) {
     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);
+      current = AppendSpecificNativeRuntimeEntryVMTag(vm_tag, current, sample);
     } else {
       intptr_t tag_index = GetProfileFunctionTagIndex(vm_tag);
       current = current->GetChild(tag_index);
       // Give the tag a tick.
       current->Tick();
+      current->IncrementAllocation(sample->native_allocation_size_bytes(),
+                                   false);
     }
     return current;
   }
 
   ProfileFunctionTrieNode* AppendTags(uword vm_tag,
                                       uword user_tag,
-                                      ProfileFunctionTrieNode* current) {
+                                      ProfileFunctionTrieNode* current,
+                                      ProcessedSample* sample) {
     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);
+        current = AppendUserTag(user_tag, current, sample);
         // Only user.
         if (tag_order() == Profile::kUser) {
           return current;
         }
-        return AppendVMTags(vm_tag, current);
+        return AppendVMTags(vm_tag, current, sample);
       }
       // VM first.
       ASSERT((tag_order() == Profile::kVMUser) ||
              (tag_order() == Profile::kVM));
-      current = AppendVMTags(vm_tag, current);
+      current = AppendVMTags(vm_tag, current, sample);
       // Only VM.
       if (tag_order() == Profile::kVM) {
         return current;
       }
-      return AppendUserTag(user_tag, current);
+      return AppendUserTag(user_tag, current, sample);
     }
 
     if (tag_order() == Profile::kNoTags) {
       return current;
     }
 
-    return AppendUserTag(user_tag, current);
+    return AppendUserTag(user_tag, current, sample);
   }
 
   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 629 matching lines @@
            (sample->allocation_cid() == cls_.id());
   }
 
  private:
   const Class& cls_;
 };
 
 
 class NativeAllocationSampleFilter : public SampleFilter {
  public:
-  NativeAllocationSampleFilter(intptr_t thread_task_mask,
-                               int64_t time_origin_micros,
+  NativeAllocationSampleFilter(int64_t time_origin_micros,
                                int64_t time_extent_micros)
       : SampleFilter(ILLEGAL_PORT,
-                     thread_task_mask,
+                     SampleFilter::kNoTaskFilter,
                      time_origin_micros,
                      time_extent_micros) {}
   bool FilterSample(Sample* sample) {
-    return sample->is_native_allocation_sample();
+    return sample->is_native_allocation_sample() &&
+           !sample->NativeAllocationFreed();
   }
 };
 
 
 void ProfilerService::PrintAllocationJSON(JSONStream* stream,
                                           Profile::TagOrder tag_order,
                                           const Class& cls,
                                           int64_t time_origin_micros,
                                           int64_t time_extent_micros) {
   Thread* thread = Thread::Current();
   Isolate* isolate = thread->isolate();
   ClassAllocationSampleFilter filter(isolate->main_port(), cls,
                                      Thread::kMutatorTask, time_origin_micros,
                                      time_extent_micros);
   const bool as_timeline = false;
   PrintJSONImpl(thread, stream, tag_order, kNoExtraTags, &filter, as_timeline);
 }
 
 
 void ProfilerService::PrintNativeAllocationJSON(JSONStream* stream,
                                                 Profile::TagOrder tag_order,
                                                 int64_t time_origin_micros,
                                                 int64_t time_extent_micros) {
   Thread* thread = Thread::Current();
-  const intptr_t thread_task_mask = Thread::kMutatorTask |
-                                    Thread::kCompilerTask |
-                                    Thread::kSweeperTask | Thread::kMarkerTask;
-  NativeAllocationSampleFilter filter(thread_task_mask, time_origin_micros,
-                                      time_extent_micros);
+  NativeAllocationSampleFilter filter(time_origin_micros, time_extent_micros);
   const bool as_timeline = false;
   PrintJSONImpl(thread, stream, tag_order, kNoExtraTags, &filter, as_timeline);
 }
 
 
 void ProfilerService::PrintTimelineJSON(JSONStream* stream,
                                         Profile::TagOrder tag_order,
                                         int64_t time_origin_micros,
                                         int64_t time_extent_micros) {
   Thread* thread = Thread::Current();
@@ skipping 20 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