Begin transition to ProcessedSample in Profiler

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 366 matching lines @@
              int64_t timestamp,
              const Code& code)
       : kind_(kind),
         start_(start),
         end_(end),
         inclusive_ticks_(0),
         exclusive_ticks_(0),
         inclusive_tick_serial_(0),
         name_(NULL),
         compile_timestamp_(timestamp),
-        creation_serial_(0),
         code_(Code::ZoneHandle(code.raw())),
         profile_function_(NULL),
         code_table_index_(-1) {
     ASSERT(start_ < end_);
     // Ensure all kDartCode have a valid code_ object.
     ASSERT((kind != kDartCode) || (!code_.IsNull()));
   }
 
   uword start() const { return start_; }
   void set_start(uword start) {
@@ skipping 20 matching lines @@
   }
 
   bool overlaps(const CodeRegion* other) const {
     ASSERT(other != NULL);
     return other->contains(start_)   ||
            other->contains(end_ - 1) ||
            contains(other->start())  ||
            contains(other->end() - 1);
   }
 
-  intptr_t creation_serial() const { return creation_serial_; }
-  void set_creation_serial(intptr_t serial) {
-    creation_serial_ = serial;
-  }
   int64_t compile_timestamp() const { return compile_timestamp_; }
   void set_compile_timestamp(int64_t timestamp) {
     compile_timestamp_ = timestamp;
   }
 
   intptr_t inclusive_ticks() const { return inclusive_ticks_; }
   void set_inclusive_ticks(intptr_t inclusive_ticks) {
     inclusive_ticks_ = inclusive_ticks;
   }
   void inc_inclusive_ticks() {
@@ skipping 114 matching lines @@
       case kReusedCode:
         return "Overwritten";
       case kTagCode:
         return "Tag";
     }
     UNREACHABLE();
     return NULL;
   }
 
   void DebugPrint() const {
-    OS::Print("%s [%" Px ", %" Px ") %" Pd " %" Pd64 "\n",
+    OS::Print("%s [%" Px ", %" Px ") %" Pd64 "\n",
               KindToCString(kind_),
               start(),
               end(),
-              creation_serial_,
               compile_timestamp_);
   }
 
   void Tick(uword pc, bool exclusive, intptr_t serial) {
     // Assert that exclusive ticks are never passed a valid serial number.
     ASSERT((exclusive && (serial == -1)) || (!exclusive && (serial != -1)));
     if (!exclusive && (inclusive_tick_serial_ == serial)) {
       // We've already given this code object an inclusive tick for this sample.
       return;
     }
@@ skipping 151 matching lines @@
   intptr_t inclusive_ticks_;
   // Exclusive ticks.
   intptr_t exclusive_ticks_;
   // Inclusive tick serial number, ensures that each CodeRegion is only given
   // a single inclusive tick per sample.
   intptr_t inclusive_tick_serial_;
   // Name of code region.
   const char* name_;
   // The compilation timestamp associated with this code region.
   int64_t compile_timestamp_;
-  // Serial number at which this CodeRegion was created.
-  intptr_t creation_serial_;
   // Dart code object (may be null).
   const Code& code_;
   // Pointer to ProfileFunction.
   ProfileFunction* profile_function_;
   // Final code table index.
   intptr_t code_table_index_;
   ZoneGrowableArray<AddressEntry> address_table_;
   DISALLOW_COPY_AND_ASSIGN(CodeRegion);
 };
 
@@ skipping 189 matching lines @@
                !b->contains(a->start()) &&
                !b->contains(a->end() - 1));
       }
     }
   }
 
   ZoneGrowableArray<CodeRegion*>* code_region_table_;
 };
 
 
-class CodeRegionTableBuilder : public SampleVisitor {
+class CodeRegionTableBuilder {
  public:
   CodeRegionTableBuilder(Isolate* isolate,
                          CodeRegionTable* live_code_table,
                          CodeRegionTable* dead_code_table,
                          CodeRegionTable* tag_code_table,
                          DeoptimizedCodeSet* deoptimized_code)
-      : SampleVisitor(isolate),
-        live_code_table_(live_code_table),
+      : live_code_table_(live_code_table),
         dead_code_table_(dead_code_table),
         tag_code_table_(tag_code_table),
         isolate_(isolate),
         vm_isolate_(Dart::vm_isolate()),
         null_code_(Code::ZoneHandle()),
         deoptimized_code_(deoptimized_code) {
     ASSERT(live_code_table_ != NULL);
     ASSERT(dead_code_table_ != NULL);
     ASSERT(tag_code_table_ != NULL);
     ASSERT(isolate_ != NULL);
     ASSERT(vm_isolate_ != NULL);
     ASSERT(null_code_.IsNull());
     frames_ = 0;
     min_time_ = kMaxInt64;
     max_time_ = 0;
   }
 
-  void VisitSample(Sample* sample) {
+  void VisitSample(intptr_t index, ProcessedSample* sample) {
     int64_t timestamp = sample->timestamp();
     if (timestamp > max_time_) {
       max_time_ = timestamp;
     }
     if (timestamp < min_time_) {
       min_time_ = timestamp;
     }
     // Make sure VM tag is created.
     if (VMTag::IsNativeEntryTag(sample->vm_tag())) {
       CreateTag(VMTag::kNativeTagId);
     } else if (VMTag::IsRuntimeEntryTag(sample->vm_tag())) {
       CreateTag(VMTag::kRuntimeTagId);
     }
     CreateTag(sample->vm_tag());
     // Make sure user tag is created.
     CreateUserTag(sample->user_tag());
     // Exclusive tick for top frame if we aren't sampled from an exit frame.
-    if (!sample->exit_frame_sample()) {
-      Tick(sample->At(0), true, timestamp);
+    if (!sample->first_frame_executing()) {
+      Tick(sample->At(0), true, index, timestamp);
     }
     // Inclusive tick for all frames.
-    for (intptr_t i = 0; i < FLAG_profile_depth; i++) {
+    for (intptr_t i = 0; i < sample->length(); i++) {
       if (sample->At(i) == 0) {
         break;
       }
       frames_++;
-      Tick(sample->At(i), false, timestamp);
+      Tick(sample->At(i), false, index, timestamp);
     }
   }
 
+  void Build(ProcessedSampleBuffer* buffer) {
+    for (intptr_t i = 0; i < buffer->length(); i++) {
+      ProcessedSample* sample = buffer->At(i);
+      VisitSample(i, sample);
+    }
+  }
+
   intptr_t frames() const { return frames_; }
 
   intptr_t  TimeDeltaMicros() const {
     return static_cast<intptr_t>(max_time_ - min_time_);
   }
   int64_t  max_time() const { return max_time_; }
 
  private:
   void CreateTag(uword tag) {
     intptr_t index = tag_code_table_->FindIndex(tag);
     if (index >= 0) {
       // Already created.
       return;
     }
     CodeRegion* region = new CodeRegion(CodeRegion::kTagCode,
                                         tag,
                                         tag + 1,
                                         0,
                                         null_code_);
     index = tag_code_table_->InsertCodeRegion(region);
     ASSERT(index >= 0);
-    region->set_creation_serial(visited());
   }
 
   void CreateUserTag(uword tag) {
     if (tag == 0) {
       // None set.
       return;
     }
     return CreateTag(tag);
   }
 
-  void Tick(uword pc, bool exclusive, int64_t timestamp) {
+  void Tick(uword pc, bool exclusive, intptr_t sample_idx, int64_t timestamp) {
     CodeRegionTable::TickResult r;
-    intptr_t serial = exclusive ? -1 : visited();
+    intptr_t serial = exclusive ? -1 : sample_idx;
     r = live_code_table_->Tick(pc, exclusive, serial, timestamp);
     if (r == CodeRegionTable::kTicked) {
       // Live code found and ticked.
       return;
     }
     if (r == CodeRegionTable::kNewerCode) {
       // Code has been overwritten by newer code.
       // Update shadow table of dead code regions.
       r = dead_code_table_->Tick(pc, exclusive, serial, timestamp);
       ASSERT(r != CodeRegionTable::kNewerCode);
       if (r == CodeRegionTable::kTicked) {
         // Dead code found and ticked.
         return;
       }
       ASSERT(r == CodeRegionTable::kNotFound);
       CreateAndTickDeadCodeRegion(pc, exclusive, serial);
       return;
     }
     // Create new live CodeRegion.
     ASSERT(r == CodeRegionTable::kNotFound);
     CodeRegion* region = CreateCodeRegion(pc);
-    region->set_creation_serial(visited());
     intptr_t index = live_code_table_->InsertCodeRegion(region);
     ASSERT(index >= 0);
     region = live_code_table_->At(index);
     if (region->compile_timestamp() <= timestamp) {
       region->Tick(pc, exclusive, serial);
       return;
     }
     // We have created a new code region but it's for a CodeRegion
     // compiled after the sample.
     ASSERT(region->kind() == CodeRegion::kDartCode);
     CreateAndTickDeadCodeRegion(pc, exclusive, serial);
   }
 
   void CreateAndTickDeadCodeRegion(uword pc, bool exclusive, intptr_t serial) {
     // Need to create dead code.
     CodeRegion* region = new CodeRegion(CodeRegion::kReusedCode,
                                         pc,
                                         pc + 1,
                                         0,
                                         null_code_);
     intptr_t index = dead_code_table_->InsertCodeRegion(region);
-    region->set_creation_serial(visited());
     ASSERT(index >= 0);
     dead_code_table_->At(index)->Tick(pc, exclusive, serial);
   }
 
   CodeRegion* CreateCodeRegion(uword pc) {
     const intptr_t kDartCodeAlignment = OS::PreferredCodeAlignment();
     const intptr_t kDartCodeAlignmentMask = ~(kDartCodeAlignment - 1);
     Code& code = Code::Handle(isolate_);
     // Check current isolate for pc.
     if (isolate_->heap()->CodeContains(pc)) {
@@ skipping 92 matching lines @@
         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);
     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);
-    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 178 matching lines @@
     return (*b)->count() - (*a)->count();
   }
 
   const intptr_t profile_function_table_index_;
   intptr_t count_;
   ZoneGrowableArray<ProfileFunctionTrieNode*> children_;
   ZoneGrowableArray<ProfileFunctionTrieNodeCode>* code_objects_;
 };
 
 
-class ProfileFunctionTrieBuilder : public SampleVisitor {
+class ProfileFunctionTrieBuilder {
  public:
-  ProfileFunctionTrieBuilder(Isolate* isolate,
-                             CodeRegionTable* live_code_table,
+  ProfileFunctionTrieBuilder(CodeRegionTable* live_code_table,
                              CodeRegionTable* dead_code_table,
                              CodeRegionTable* tag_code_table,
                              ProfileFunctionTable* function_table)
-      : SampleVisitor(isolate),
-        live_code_table_(live_code_table),
+      : live_code_table_(live_code_table),
         dead_code_table_(dead_code_table),
         tag_code_table_(tag_code_table),
         function_table_(function_table),
-        inclusive_tree_(false),
-        trace_(false),
-        trace_code_filter_(NULL) {
+        inclusive_tree_(false) {
     ASSERT(live_code_table_ != NULL);
     ASSERT(dead_code_table_ != NULL);
     ASSERT(tag_code_table_ != NULL);
     ASSERT(function_table_ != NULL);
     set_tag_order(ProfilerService::kUserVM);
 
     // 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) {
+  void VisitSample(intptr_t sample_idx, ProcessedSample* sample) {
     inclusive_tree_ = false;
-    ProcessSampleExclusive(sample);
+    ProcessSampleExclusive(sample_idx, sample);
     inclusive_tree_ = true;
-    ProcessSampleInclusive(sample);
+    ProcessSampleInclusive(sample_idx, sample);
+  }
+
+  void Build(ProcessedSampleBuffer* buffer) {
+    for (intptr_t i = 0; i < buffer->length(); i++) {
+      ProcessedSample* sample = buffer->At(i);
+      VisitSample(i, sample);
+    }
   }
 
   ProfileFunctionTrieNode* exclusive_root() const {
     return exclusive_root_;
   }
 
   ProfileFunctionTrieNode* inclusive_root() const {
     return inclusive_root_;
   }
 
   ProfilerService::TagOrder tag_order() const {
     return tag_order_;
   }
 
   bool vm_tags_emitted() const {
     return (tag_order_ == ProfilerService::kUserVM) ||
            (tag_order_ == ProfilerService::kVMUser) ||
            (tag_order_ == ProfilerService::kVM);
   }
 
   void set_tag_order(ProfilerService::TagOrder tag_order) {
     tag_order_ = tag_order;
   }
 
  private:
-  void ProcessSampleInclusive(Sample* sample) {
+  void ProcessSampleInclusive(intptr_t sample_idx, ProcessedSample* sample) {
     // Give the root a tick.
     inclusive_root_->Tick();
     ProfileFunctionTrieNode* current = inclusive_root_;
     current = AppendTags(sample, current);
-    if (sample->truncated_trace()) {
+    if (sample->truncated()) {
       InclusiveTickTruncatedTag();
       current = AppendTruncatedTag(current);
     }
     // Walk the sampled PCs.
-    for (intptr_t i = FLAG_profile_depth - 1; i >= 0; i--) {
+    for (intptr_t i = sample->length() - 1; i >= 0; i--) {
       if (sample->At(i) == 0) {
         continue;
       }
       current = ProcessPC(sample->At(i),
                           sample->timestamp(),
                           current,
-                          visited(),
+                          sample_idx,
                           (i == 0),
-                          sample->exit_frame_sample() && (i == 0),
-                          sample->missing_frame_inserted());
+                          !sample->first_frame_executing() && (i == 0));
     }
   }
 
-  void ProcessSampleExclusive(Sample* sample) {
+  void ProcessSampleExclusive(intptr_t sample_idx, ProcessedSample* sample) {
     // Give the root a tick.
     exclusive_root_->Tick();
     ProfileFunctionTrieNode* current = exclusive_root_;
     current = AppendTags(sample, current);
     // Walk the sampled PCs.
-    for (intptr_t i = 0; i < FLAG_profile_depth; i++) {
+    for (intptr_t i = 0; i < sample->length(); i++) {
       if (sample->At(i) == 0) {
         break;
       }
       current = ProcessPC(sample->At(i),
                           sample->timestamp(),
                           current,
-                          visited(),
+                          sample_idx,
                           (i == 0),
-                          sample->exit_frame_sample() && (i == 0),
-                          sample->missing_frame_inserted());
+                          !sample->first_frame_executing() && (i == 0));
     }
-    if (sample->truncated_trace()) {
+    if (sample->truncated()) {
       current = AppendTruncatedTag(current);
     }
   }
 
-  ProfileFunctionTrieNode* AppendUserTag(Sample* sample,
+  ProfileFunctionTrieNode* AppendUserTag(ProcessedSample* 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* 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;
   }
 
   void InclusiveTickTruncatedTag() {
     intptr_t index = tag_code_table_->FindIndex(VMTag::kTruncatedTagId);
     CodeRegion* region = tag_code_table_->At(index);
     ProfileFunction* function = region->function();
     function->inc_inclusive_ticks();
   }
 
-  ProfileFunctionTrieNode* AppendVMTag(Sample* sample,
+  ProfileFunctionTrieNode* AppendVMTag(ProcessedSample* 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) {
+      ProcessedSample* 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* AppendVMTags(Sample* sample,
+  ProfileFunctionTrieNode* AppendVMTags(ProcessedSample* sample,
                                         ProfileFunctionTrieNode* current) {
     current = AppendVMTag(sample, current);
     current = AppendSpecificNativeRuntimeEntryVMTag(sample, current);
     return current;
   }
 
-  ProfileFunctionTrieNode* AppendTags(Sample* sample,
+  ProfileFunctionTrieNode* AppendTags(ProcessedSample* sample,
                                       ProfileFunctionTrieNode* current) {
     // None.
     if (tag_order() == ProfilerService::kNoTags) {
       return current;
     }
     // User first.
     if ((tag_order() == ProfilerService::kUserVM) ||
         (tag_order() == ProfilerService::kUser)) {
       current = AppendUserTag(sample, current);
       // Only user.
@@ skipping 36 matching lines @@
     ProfileFunction* function = function_table_->At(current_index);
     function->Dump();
     OS::Print("\n");
   }
 
   ProfileFunctionTrieNode* ProcessPC(uword pc,
                                      int64_t timestamp,
                                      ProfileFunctionTrieNode* current,
                                      intptr_t inclusive_serial,
                                      bool top_frame,
-                                     bool exit_frame,
-                                     bool missing_frame_inserted) {
+                                     bool exit_frame) {
     CodeRegion* region = FindCodeObject(pc, timestamp);
     if (region == NULL) {
       return current;
     }
     const char* region_name = region->name();
     if (region_name == NULL) {
       region_name = "";
     }
     intptr_t code_index = region->code_table_index();
     const Code& code = Code::ZoneHandle(region->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 = region->function();
       ASSERT(function != NULL);
-      if (trace_) {
-        OS::Print("[%" Px "] X - %s (%s)\n",
-                  pc, function->name(), region_name);
-      }
       current = ProcessFunction(function,
                                 current,
                                 inclusive_serial,
                                 top_frame,
                                 exit_frame,
                                 code_index);
-      if ((trace_code_filter_ != NULL) &&
-          (strstr(region_name, trace_code_filter_) != NULL)) {
-        trace_ = true;
-        OS::Print("Tracing from: %" Px " [%s] ", pc,
-                  missing_frame_inserted ? "INSERTED" : "");
-        Dump(current);
-      }
       return current;
     }
 
     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,
                                          exit_frame,
                                          code_index);
         top_frame = false;
       }
     } 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());
-        const char* inline_name = inlined_function->ToQualifiedCString();
-        if (trace_) {
-          OS::Print("[%" Px "] %" Pd " - %s (%s)\n",
-                  pc, i, inline_name, region_name);
-        }
         current = ProcessInlinedFunction(inlined_function,
                                          current,
                                          inclusive_serial,
                                          top_frame,
                                          exit_frame,
                                          code_index);
         top_frame = false;
-        if ((trace_code_filter_ != NULL) &&
-            (strstr(region_name, trace_code_filter_) != NULL)) {
-          trace_ = true;
-          OS::Print("Tracing from: %" Px " [%s] ",
-                    pc, missing_frame_inserted ? "INSERTED" : "");
-          Dump(current);
-        }
       }
     }
 
     return current;
   }
 
   ProfileFunctionTrieNode* ProcessInlinedFunction(
       Function* inlined_function,
       ProfileFunctionTrieNode* current,
       intptr_t inclusive_serial,
@@ skipping 60 matching lines @@
   }
 
   ProfilerService::TagOrder tag_order_;
   ProfileFunctionTrieNode* exclusive_root_;
   ProfileFunctionTrieNode* inclusive_root_;
   CodeRegionTable* live_code_table_;
   CodeRegionTable* dead_code_table_;
   CodeRegionTable* tag_code_table_;
   ProfileFunctionTable* function_table_;
   bool inclusive_tree_;
-  bool trace_;
-  const char* trace_code_filter_;
 };
 
 
 class CodeRegionTrieNode : public ZoneAllocated {
  public:
   explicit CodeRegionTrieNode(intptr_t code_region_index)
       : code_region_index_(code_region_index),
         count_(0),
         children_(new ZoneGrowableArray<CodeRegionTrieNode*>()) {
   }
@@ skipping 75 matching lines @@
     ASSERT(b != NULL);
     return (*b)->count() - (*a)->count();
   }
 
   const intptr_t code_region_index_;
   intptr_t count_;
   ZoneGrowableArray<CodeRegionTrieNode*>* children_;
 };
 
 
-class CodeRegionTrieBuilder : public SampleVisitor {
+class CodeRegionTrieBuilder {
  public:
   CodeRegionTrieBuilder(Isolate* isolate,
                         CodeRegionTable* live_code_table,
                         CodeRegionTable* dead_code_table,
                         CodeRegionTable* tag_code_table)
-      : SampleVisitor(isolate),
-        live_code_table_(live_code_table),
+      : 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);
 
     // 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) {
+  void VisitSample(ProcessedSample* sample) {
     ProcessSampleExclusive(sample);
     ProcessSampleInclusive(sample);
   }
 
+  void Build(ProcessedSampleBuffer* buffer) {
+    for (intptr_t i = 0; i < buffer->length(); i++) {
+      ProcessedSample* sample = buffer->At(i);
+      VisitSample(sample);
+    }
+  }
+
   CodeRegionTrieNode* inclusive_root() const {
     return inclusive_root_;
   }
 
   CodeRegionTrieNode* exclusive_root() const {
     return exclusive_root_;
   }
 
   ProfilerService::TagOrder tag_order() const {
     return tag_order_;
   }
 
   bool vm_tags_emitted() const {
     return (tag_order_ == ProfilerService::kUserVM) ||
            (tag_order_ == ProfilerService::kVMUser) ||
            (tag_order_ == ProfilerService::kVM);
   }
 
   void set_tag_order(ProfilerService::TagOrder tag_order) {
     tag_order_ = tag_order;
   }
 
  private:
-  void ProcessSampleInclusive(Sample* sample) {
+  void ProcessSampleInclusive(ProcessedSample* sample) {
     // Give the root a tick.
     inclusive_root_->Tick();
     CodeRegionTrieNode* current = inclusive_root_;
     current = AppendTags(sample, current);
-    if (sample->truncated_trace()) {
+    if (sample->truncated()) {
       current = AppendTruncatedTag(current);
     }
     // Walk the sampled PCs.
-    for (intptr_t i = FLAG_profile_depth - 1; i >= 0; i--) {
+    for (intptr_t i = sample->length() - 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) {
+  void ProcessSampleExclusive(ProcessedSample* sample) {
     // Give the root a tick.
     exclusive_root_->Tick();
     CodeRegionTrieNode* current = exclusive_root_;
     current = AppendTags(sample, current);
     // Walk the sampled PCs.
-    for (intptr_t i = 0; i < FLAG_profile_depth; i++) {
+    for (intptr_t i = 0; i < sample->length(); i++) {
       if (sample->At(i) == 0) {
         break;
       }
       intptr_t index = FindFinalIndex(sample->At(i), sample->timestamp());
       if (index < 0) {
         continue;
       }
       current = current->GetChild(index);
       if (i == 0) {
         // Executing PC.
-        if (!sample->exit_frame_sample() || vm_tags_emitted()) {
+        if (!sample->first_frame_executing() || vm_tags_emitted()) {
           // Only tick if this isn't an exit frame or VM tags are emitted.
           current->Tick();
         }
       } else {
         // Caller PCs.
         current->Tick();
       }
     }
-    if (sample->truncated_trace()) {
+    if (sample->truncated()) {
       current = AppendTruncatedTag(current);
     }
   }
 
-  CodeRegionTrieNode* AppendUserTag(Sample* sample,
+  CodeRegionTrieNode* AppendUserTag(ProcessedSample* 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* 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* AppendVMTag(ProcessedSample* 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) {
+      ProcessedSample* 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* AppendVMTags(Sample* sample,
+  CodeRegionTrieNode* AppendVMTags(ProcessedSample* sample,
                                    CodeRegionTrieNode* current) {
     current = AppendVMTag(sample, current);
     current = AppendSpecificNativeRuntimeEntryVMTag(sample, current);
     return current;
   }
 
-  CodeRegionTrieNode* AppendTags(Sample* sample, CodeRegionTrieNode* current) {
+  CodeRegionTrieNode* AppendTags(ProcessedSample* sample,
+                                 CodeRegionTrieNode* current) {
     // None.
     if (tag_order() == ProfilerService::kNoTags) {
       return current;
     }
     // User first.
     if ((tag_order() == ProfilerService::kUserVM) ||
         (tag_order() == ProfilerService::kUser)) {
       current = AppendUserTag(sample, current);
       // Only user.
       if (tag_order() == ProfilerService::kUser) {
@@ skipping 74 matching lines @@
   if (profiler_data == NULL) {
     stream->PrintError(kFeatureDisabled, NULL);
     return;
   }
   SampleBuffer* sample_buffer = profiler_data->sample_buffer();
   ASSERT(sample_buffer != NULL);
   ScopeTimer sw("ProfilerService::PrintJSON", FLAG_trace_profiler);
   {
     StackZone zone(isolate);
     HANDLESCOPE(isolate);
+
+    ProcessedSampleBuffer* processed_samples = NULL;
+    {
+      ScopeTimer sw("BuildProcessedSampleBuffer", FLAG_trace_profiler);
+      SampleFilter filter(isolate);
+      processed_samples = sample_buffer->BuildProcessedSampleBuffer(&filter);
+    }
+
     {
       // Live code holds Dart, Native, and Collected CodeRegions.
       CodeRegionTable live_code_table;
       // Dead code holds Overwritten CodeRegions.
       CodeRegionTable dead_code_table;
       // Tag code holds Tag CodeRegions.
       CodeRegionTable tag_code_table;
       // Table holding all ProfileFunctions.
       ProfileFunctionTable function_table;
       // Set of deoptimized code still referenced by the profiler.
       DeoptimizedCodeSet* deoptimized_code = new DeoptimizedCodeSet(isolate);
 
-      {
-        ScopeTimer sw("PreprocessSamples", FLAG_trace_profiler);
-        // Preprocess samples.
-        PreprocessVisitor preprocessor(isolate);
-        sample_buffer->VisitSamples(&preprocessor);
-      }
-
       // Build CodeRegion tables.
       CodeRegionTableBuilder builder(isolate,
                                      &live_code_table,
                                      &dead_code_table,
                                      &tag_code_table,
                                      deoptimized_code);
       {
-        ScopeTimer sw("CodeRegionTableBuilder", FLAG_trace_profiler);
-        sample_buffer->VisitSamples(&builder);
+        ScopeTimer sw("CodeRegionTableBuilder::Build", FLAG_trace_profiler);
+        builder.Build(processed_samples);
       }
-      intptr_t samples = builder.visited();
+      intptr_t samples = processed_samples->length();
       intptr_t frames = builder.frames();
       if (FLAG_trace_profiler) {
         intptr_t total_live_code_objects = live_code_table.Length();
         intptr_t total_dead_code_objects = dead_code_table.Length();
         intptr_t total_tag_code_objects = tag_code_table.Length();
         OS::Print(
             "Processed %" Pd " samples with %" Pd " frames\n", samples, frames);
         OS::Print("CodeTables: live=%" Pd " dead=%" Pd " tag=%" Pd "\n",
                   total_live_code_objects,
                   total_dead_code_objects,
@@ skipping 19 matching lines @@
         intptr_t total_functions = function_table.Length();
         OS::Print("FunctionTable: size=%" Pd "\n", total_functions);
       }
       CodeRegionTrieBuilder code_trie_builder(isolate,
                                               &live_code_table,
                                               &dead_code_table,
                                               &tag_code_table);
       code_trie_builder.set_tag_order(tag_order);
       {
         // Build CodeRegion trie.
-        ScopeTimer sw("CodeRegionTrieBuilder", FLAG_trace_profiler);
-        sample_buffer->VisitSamples(&code_trie_builder);
+        ScopeTimer sw("CodeRegionTrieBuilder::Build", FLAG_trace_profiler);
+        code_trie_builder.Build(processed_samples);
         code_trie_builder.exclusive_root()->SortByCount();
         code_trie_builder.inclusive_root()->SortByCount();
       }
       if (FLAG_trace_profiler) {
         OS::Print("Code Trie Root Count: E: %" Pd " I: %" Pd "\n",
                   code_trie_builder.exclusive_root()->count(),
                   code_trie_builder.inclusive_root()->count());
       }
-      ProfileFunctionTrieBuilder function_trie_builder(isolate,
-                                                       &live_code_table,
+      ProfileFunctionTrieBuilder function_trie_builder(&live_code_table,
                                                        &dead_code_table,
                                                        &tag_code_table,
                                                        &function_table);
       function_trie_builder.set_tag_order(tag_order);
       {
         // Build ProfileFunction trie.
-        ScopeTimer sw("ProfileFunctionTrieBuilder",
+        ScopeTimer sw("ProfileFunctionTrieBuilder::Build",
                       FLAG_trace_profiler);
-        sample_buffer->VisitSamples(&function_trie_builder);
+        function_trie_builder.Build(processed_samples);
         function_trie_builder.exclusive_root()->SortByCount();
         function_trie_builder.inclusive_root()->SortByCount();
       }
       if (FLAG_trace_profiler) {
         OS::Print("Function Trie Root Count: E: %" Pd " I: %" Pd "\n",
                   function_trie_builder.exclusive_root()->count(),
                   function_trie_builder.inclusive_root()->count());
       }
       {
         ScopeTimer sw("CpuProfileJSONStream", FLAG_trace_profiler);
@@ skipping 84 matching lines @@
   ASSERT(sample_buffer != NULL);
 
   ClearProfileVisitor clear_profile(isolate);
   sample_buffer->VisitSamples(&clear_profile);
 
   // Enable profile interrupts.
   Profiler::BeginExecution(isolate);
 }
 
 }  // namespace dart