Fix memory leak in CPU Profile page

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 486 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 {
-          ASSERT(start() == 0);
-          SetName("root");
+          if (start() == VMTag::kRootTagId) {
+            SetName("Root");
+          } else {
+            ASSERT(start() == VMTag::kTruncatedTagId);
+            SetName("[Truncated]");
+          }
         }
       }
       function = table->AddTag(start(), name());
     } else {
       UNREACHABLE();
     }
     ASSERT(function != NULL);
     // Register this CodeRegion with this function.
     function->AddCodeObjectIndex(code_table_index());
     profile_function_ = function;
@@ skipping 644 matching lines @@
         dead_code_table_(dead_code_table),
         tag_code_table_(tag_code_table),
         function_table_(function_table) {
     ASSERT(isolate_ != NULL);
     ASSERT(live_code_table_ != NULL);
     ASSERT(dead_code_table_ != NULL);
     ASSERT(tag_code_table_ != NULL);
     dead_code_table_offset_ = live_code_table_->Length();
     tag_code_table_offset_ = dead_code_table_offset_ +
                              dead_code_table_->Length();
-    intptr_t root_index = tag_code_table_->FindIndex(0);
-    // Verify that the "0" tag does not exist.
+
+    const Code& null_code = Code::ZoneHandle();
+
+    // Create the truncated tag.
+    intptr_t truncated_index =
+        tag_code_table_->FindIndex(VMTag::kTruncatedTagId);
+    ASSERT(truncated_index < 0);
+    CodeRegion* truncated =
+        new CodeRegion(CodeRegion::kTagCode,
+                       VMTag::kTruncatedTagId,
+                       VMTag::kTruncatedTagId + 1,
+                       0,
+                       null_code);
+    truncated_index = tag_code_table_->InsertCodeRegion(truncated);
+    ASSERT(truncated_index >= 0);
+    truncated->set_creation_serial(0);
+
+    // Create the root tag.
+    intptr_t root_index = tag_code_table_->FindIndex(VMTag::kRootTagId);
     ASSERT(root_index < 0);
-    // Insert the dummy tag CodeRegion as the root.
-    const Code& null_code = Code::ZoneHandle();
-    CodeRegion* region =
-        new CodeRegion(CodeRegion::kTagCode, 0, 1, 0, null_code);
-    root_index = tag_code_table_->InsertCodeRegion(region);
+    CodeRegion* root = new CodeRegion(CodeRegion::kTagCode,
+                                      VMTag::kRootTagId,
+                                      VMTag::kRootTagId + 1,
+                                      0,
+                                      null_code);
+    root_index = tag_code_table_->InsertCodeRegion(root);
     ASSERT(root_index >= 0);
-    region->set_creation_serial(0);
+    root->set_creation_serial(0);
   }
 
   void Map() {
     // Calculate final indexes in code table for each CodeRegion.
     for (intptr_t i = 0; i < live_code_table_->Length(); i++) {
       const intptr_t index = i;
       CodeRegion* region = live_code_table_->At(i);
       ASSERT(region != NULL);
       region->set_code_table_index(index);
     }
@@ skipping 199 matching lines @@
         function_table_(function_table),
         inclusive_(false),
         trace_(false),
         trace_code_filter_(NULL) {
     ASSERT(live_code_table_ != NULL);
     ASSERT(dead_code_table_ != NULL);
     ASSERT(tag_code_table_ != NULL);
     ASSERT(function_table_ != NULL);
     set_tag_order(ProfilerService::kUserVM);
 
-    intptr_t root_index = tag_code_table_->FindIndex(0);
-    // Verify that the "0" tag does exist.
+    // Verify that the truncated tag exists.
+    ASSERT(tag_code_table_->FindIndex(VMTag::kTruncatedTagId) >= 0);
+
+    // Verify that the root tag exists.
+    intptr_t root_index = tag_code_table_->FindIndex(VMTag::kRootTagId);
     ASSERT(root_index >= 0);
+
+    // Setup root.
     CodeRegion* region = tag_code_table_->At(root_index);
     ASSERT(region != NULL);
     ProfileFunction* function = region->function();
     ASSERT(function != NULL);
 
     exclusive_root_ = new ProfileFunctionTrieNode(function->index());
     inclusive_root_ = new ProfileFunctionTrieNode(function->index());
   }
 
   void VisitSample(Sample* sample) {
@@ skipping 17 matching lines @@
 
   void set_tag_order(ProfilerService::TagOrder tag_order) {
     tag_order_ = tag_order;
   }
 
  private:
   void ProcessSampleInclusive(Sample* sample) {
     // Give the root a tick.
     inclusive_root_->Tick();
     ProfileFunctionTrieNode* current = inclusive_root_;
-    current = ProcessTags(sample, current);
+    current = AppendTags(sample, current);
+    if (sample->truncated_trace()) {
+      current = AppendTruncatedTag(current);
+    }
     // Walk the sampled PCs.
     for (intptr_t i = FLAG_profile_depth - 1; i >= 0; i--) {
       if (sample->At(i) == 0) {
         continue;
       }
       // If we aren't sampled out of an exit frame and this is the top
       // frame.
       bool exclusive_tick = (i == 0) && !sample->exit_frame_sample();
       current = ProcessPC(sample->At(i), sample->timestamp(), current,
                           visited(), exclusive_tick,
                           sample->missing_frame_inserted());
     }
   }
 
   void ProcessSampleExclusive(Sample* sample) {
     // Give the root a tick.
     exclusive_root_->Tick();
     ProfileFunctionTrieNode* current = exclusive_root_;
-    current = ProcessTags(sample, current);
+    current = AppendTags(sample, current);
     // Walk the sampled PCs.
     for (intptr_t i = 0; i < FLAG_profile_depth; i++) {
       if (sample->At(i) == 0) {
         break;
       }
       // If we aren't sampled out of an exit frame and this is the top
       // frame.
       bool exclusive_tick = (i == 0) && !sample->exit_frame_sample();
       current = ProcessPC(sample->At(i), sample->timestamp(), current,
                           visited(), exclusive_tick,
                           sample->missing_frame_inserted());
     }
+    if (sample->truncated_trace()) {
+      current = AppendTruncatedTag(current);
+    }
   }
 
-  ProfileFunctionTrieNode* ProcessUserTags(Sample* sample,
-                                           ProfileFunctionTrieNode* current) {
+  ProfileFunctionTrieNode* AppendUserTag(Sample* sample,
+                                         ProfileFunctionTrieNode* current) {
     intptr_t user_tag_index = FindTagIndex(sample->user_tag());
     if (user_tag_index >= 0) {
       current = current->GetChild(user_tag_index);
       // Give the tag a tick.
       current->Tick();
     }
     return current;
   }
 
-  ProfileFunctionTrieNode* ProcessVMTags(Sample* sample,
-                                         ProfileFunctionTrieNode* current) {
+
+  ProfileFunctionTrieNode* AppendTruncatedTag(
+      ProfileFunctionTrieNode* current) {
+    intptr_t truncated_tag_index = FindTagIndex(VMTag::kTruncatedTagId);
+    ASSERT(truncated_tag_index >= 0);
+    current = current->GetChild(truncated_tag_index);
+    current->Tick();
+    return current;
+  }
+
+
+  ProfileFunctionTrieNode* AppendVMTag(Sample* sample,
+                                       ProfileFunctionTrieNode* current) {
     if (VMTag::IsNativeEntryTag(sample->vm_tag())) {
       // Insert a dummy kNativeTagId node.
       intptr_t tag_index = FindTagIndex(VMTag::kNativeTagId);
       current = current->GetChild(tag_index);
       // Give the tag a tick.
       current->Tick();
     } else if (VMTag::IsRuntimeEntryTag(sample->vm_tag())) {
       // Insert a dummy kRuntimeTagId node.
       intptr_t tag_index = FindTagIndex(VMTag::kRuntimeTagId);
       current = current->GetChild(tag_index);
       // Give the tag a tick.
       current->Tick();
+    } else {
+      intptr_t tag_index = FindTagIndex(sample->vm_tag());
+      current = current->GetChild(tag_index);
+      // Give the tag a tick.
+      current->Tick();
     }
+    return current;
+  }
+
+  ProfileFunctionTrieNode* AppendSpecificNativeRuntimeEntryVMTag(
+      Sample* sample, ProfileFunctionTrieNode* current) {
+    // Only Native and Runtime entries have a second VM tag.
+    if (!VMTag::IsNativeEntryTag(sample->vm_tag()) &&
+        !VMTag::IsRuntimeEntryTag(sample->vm_tag())) {
+      return current;
+    }
     intptr_t tag_index = FindTagIndex(sample->vm_tag());
     current = current->GetChild(tag_index);
     // Give the tag a tick.
     current->Tick();
     return current;
   }
 
-  ProfileFunctionTrieNode* ProcessTags(Sample* sample,
-                                       ProfileFunctionTrieNode* current) {
+  ProfileFunctionTrieNode* AppendVMTags(Sample* sample,
+                                        ProfileFunctionTrieNode* current) {
+    current = AppendVMTag(sample, current);
+    current = AppendSpecificNativeRuntimeEntryVMTag(sample, current);
+    return current;
+  }
+
+  ProfileFunctionTrieNode* AppendTags(Sample* sample,
+                                      ProfileFunctionTrieNode* current) {
     // None.
     if (tag_order() == ProfilerService::kNoTags) {
       return current;
     }
     // User first.
     if ((tag_order() == ProfilerService::kUserVM) ||
         (tag_order() == ProfilerService::kUser)) {
-      current = ProcessUserTags(sample, current);
+      current = AppendUserTag(sample, current);
       // Only user.
       if (tag_order() == ProfilerService::kUser) {
         return current;
       }
-      return ProcessVMTags(sample, current);
+      return AppendVMTags(sample, current);
     }
     // VM first.
     ASSERT((tag_order() == ProfilerService::kVMUser) ||
            (tag_order() == ProfilerService::kVM));
-    current = ProcessVMTags(sample, current);
+    current = AppendVMTags(sample, current);
     // Only VM.
     if (tag_order() == ProfilerService::kVM) {
       return current;
     }
-    return ProcessUserTags(sample, current);
+    return AppendUserTag(sample, current);
   }
 
   intptr_t FindTagIndex(uword tag) const {
     if (tag == 0) {
       UNREACHABLE();
       return -1;
     }
     intptr_t index = tag_code_table_->FindIndex(tag);
     if (index < 0) {
       UNREACHABLE();
@@ skipping 245 matching lines @@
                         CodeRegionTable* tag_code_table)
       : SampleVisitor(isolate),
         live_code_table_(live_code_table),
         dead_code_table_(dead_code_table),
         tag_code_table_(tag_code_table) {
     ASSERT(live_code_table_ != NULL);
     ASSERT(dead_code_table_ != NULL);
     ASSERT(tag_code_table_ != NULL);
     set_tag_order(ProfilerService::kUserVM);
 
-    intptr_t root_index = tag_code_table_->FindIndex(0);
-    // Verify that the "0" (root) tag does exist.
+    // Verify that the truncated tag exists.
+    ASSERT(tag_code_table_->FindIndex(VMTag::kTruncatedTagId) >= 0);
+
+    // Verify that the root tag exists.
+    intptr_t root_index = tag_code_table_->FindIndex(VMTag::kRootTagId);
     ASSERT(root_index >= 0);
     CodeRegion* region = tag_code_table_->At(root_index);
     ASSERT(region != NULL);
 
     exclusive_root_ = new CodeRegionTrieNode(region->code_table_index());
     inclusive_root_ = new CodeRegionTrieNode(region->code_table_index());
   }
 
   void VisitSample(Sample* sample) {
     ProcessSampleExclusive(sample);
@@ skipping 14 matching lines @@
 
   void set_tag_order(ProfilerService::TagOrder tag_order) {
     tag_order_ = tag_order;
   }
 
  private:
   void ProcessSampleInclusive(Sample* sample) {
     // Give the root a tick.
     inclusive_root_->Tick();
     CodeRegionTrieNode* current = inclusive_root_;
-    current = ProcessTags(sample, current);
+    current = AppendTags(sample, current);
+    if (sample->truncated_trace()) {
+      current = AppendTruncatedTag(current);
+    }
     // Walk the sampled PCs.
     for (intptr_t i = FLAG_profile_depth - 1; i >= 0; i--) {
       if (sample->At(i) == 0) {
         continue;
       }
       intptr_t index = FindFinalIndex(sample->At(i), sample->timestamp());
       if (index < 0) {
         continue;
       }
       current = current->GetChild(index);
       current->Tick();
     }
   }
 
   void ProcessSampleExclusive(Sample* sample) {
     // Give the root a tick.
     exclusive_root_->Tick();
     CodeRegionTrieNode* current = exclusive_root_;
-    current = ProcessTags(sample, current);
+    current = AppendTags(sample, current);
     // Walk the sampled PCs.
     for (intptr_t i = 0; i < FLAG_profile_depth; i++) {
       if (sample->At(i) == 0) {
         break;
       }
       intptr_t index = FindFinalIndex(sample->At(i), sample->timestamp());
       if (index < 0) {
         continue;
       }
       current = current->GetChild(index);
       current->Tick();
     }
+    if (sample->truncated_trace()) {
+      current = AppendTruncatedTag(current);
+    }
   }
 
-  CodeRegionTrieNode* ProcessUserTags(Sample* sample,
-                                      CodeRegionTrieNode* current) {
+  CodeRegionTrieNode* AppendUserTag(Sample* sample,
+                                    CodeRegionTrieNode* current) {
     intptr_t user_tag_index = FindTagIndex(sample->user_tag());
     if (user_tag_index >= 0) {
       current = current->GetChild(user_tag_index);
       // Give the tag a tick.
       current->Tick();
     }
     return current;
   }
 
-  CodeRegionTrieNode* ProcessVMTags(Sample* sample,
-                                    CodeRegionTrieNode* current) {
+  CodeRegionTrieNode* AppendTruncatedTag(CodeRegionTrieNode* current) {
+    intptr_t truncated_tag_index = FindTagIndex(VMTag::kTruncatedTagId);
+    ASSERT(truncated_tag_index >= 0);
+    current = current->GetChild(truncated_tag_index);
+    current->Tick();
+    return current;
+  }
+
+  CodeRegionTrieNode* AppendVMTag(Sample* sample,
+                                  CodeRegionTrieNode* current) {
     if (VMTag::IsNativeEntryTag(sample->vm_tag())) {
       // Insert a dummy kNativeTagId node.
       intptr_t tag_index = FindTagIndex(VMTag::kNativeTagId);
       current = current->GetChild(tag_index);
       // Give the tag a tick.
       current->Tick();
     } else if (VMTag::IsRuntimeEntryTag(sample->vm_tag())) {
       // Insert a dummy kRuntimeTagId node.
       intptr_t tag_index = FindTagIndex(VMTag::kRuntimeTagId);
       current = current->GetChild(tag_index);
       // Give the tag a tick.
       current->Tick();
+    } else {
+      intptr_t tag_index = FindTagIndex(sample->vm_tag());
+      current = current->GetChild(tag_index);
+      // Give the tag a tick.
+      current->Tick();
     }
+    return current;
+  }
+
+  CodeRegionTrieNode* AppendSpecificNativeRuntimeEntryVMTag(
+      Sample* sample, CodeRegionTrieNode* current) {
+    // Only Native and Runtime entries have a second VM tag.
+    if (!VMTag::IsNativeEntryTag(sample->vm_tag()) &&
+        !VMTag::IsRuntimeEntryTag(sample->vm_tag())) {
+      return current;
+    }
     intptr_t tag_index = FindTagIndex(sample->vm_tag());
     current = current->GetChild(tag_index);
     // Give the tag a tick.
     current->Tick();
     return current;
   }
 
-  CodeRegionTrieNode* ProcessTags(Sample* sample, CodeRegionTrieNode* current) {
+  CodeRegionTrieNode* AppendVMTags(Sample* sample,
+                                   CodeRegionTrieNode* current) {
+    current = AppendVMTag(sample, current);
+    current = AppendSpecificNativeRuntimeEntryVMTag(sample, current);
+    return current;
+  }
+
+  CodeRegionTrieNode* AppendTags(Sample* sample, CodeRegionTrieNode* current) {
     // None.
     if (tag_order() == ProfilerService::kNoTags) {
       return current;
     }
     // User first.
     if ((tag_order() == ProfilerService::kUserVM) ||
         (tag_order() == ProfilerService::kUser)) {
-      current = ProcessUserTags(sample, current);
+      current = AppendUserTag(sample, current);
       // Only user.
       if (tag_order() == ProfilerService::kUser) {
         return current;
       }
-      return ProcessVMTags(sample, current);
+      return AppendVMTags(sample, current);
     }
     // VM first.
     ASSERT((tag_order() == ProfilerService::kVMUser) ||
            (tag_order() == ProfilerService::kVM));
-    current = ProcessVMTags(sample, current);
+    current = AppendVMTags(sample, current);
     // Only VM.
     if (tag_order() == ProfilerService::kVM) {
       return current;
     }
-    return ProcessUserTags(sample, current);
+    return AppendUserTag(sample, current);
   }
 
   intptr_t FindTagIndex(uword tag) const {
     if (tag == 0) {
       UNREACHABLE();
       return -1;
     }
     intptr_t index = tag_code_table_->FindIndex(tag);
     if (index < 0) {
       UNREACHABLE();
@@ skipping 236 matching lines @@
   ASSERT(sample_buffer != NULL);
 
   ClearProfileVisitor clear_profile(isolate);
   sample_buffer->VisitSamples(&clear_profile);
 
   // Enable profile interrupts.
   Profiler::BeginExecution(isolate);
 }
 
 }  // namespace dart