Updated native memory allocation profiling to use its own sample buffer instead of sharing a sample…

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/malloc_hooks.h"
@@ skipping 1199 matching lines @@
     kOptimized,
     kUnoptimized,
     kNative,
     kInlineStart,
     kInlineFinish,
     kNumProfileInfoKind,
   };
 
   ProfileBuilder(Thread* thread,
                  SampleFilter* filter,
+                 SampleBuffer* sample_buffer,
                  Profile::TagOrder tag_order,
                  intptr_t extra_tags,
                  Profile* profile)
       : thread_(thread),
         vm_isolate_(Dart::vm_isolate()),
         filter_(filter),
+        sample_buffer_(sample_buffer),
         tag_order_(tag_order),
         extra_tags_(extra_tags),
         profile_(profile),
         deoptimized_code_(new DeoptimizedCodeSet(thread->isolate())),
         null_code_(Code::ZoneHandle()),
         null_function_(Function::ZoneHandle()),
         tick_functions_(false),
         inclusive_tree_(false),
         samples_(NULL),
         info_kind_(kNone) {
+    ASSERT((sample_buffer_ == Profiler::sample_buffer()) ||
+           (sample_buffer_ == Profiler::allocation_sample_buffer()));
     ASSERT(profile_ != NULL);
   }
 
   void Build() {
     ScopeTimer sw("ProfileBuilder::Build", FLAG_trace_profiler);
     if (!FilterSamples()) {
       return;
     }
 
     Setup();
@@ skipping 31 matching lines @@
     RegisterProfileCodeTag(VMTag::kNoneCodeTagId);
     RegisterProfileCodeTag(VMTag::kOptimizedCodeTagId);
     RegisterProfileCodeTag(VMTag::kUnoptimizedCodeTagId);
     RegisterProfileCodeTag(VMTag::kNativeCodeTagId);
     RegisterProfileCodeTag(VMTag::kInlineStartCodeTagId);
     RegisterProfileCodeTag(VMTag::kInlineEndCodeTagId);
   }
 
   bool FilterSamples() {
     ScopeTimer sw("ProfileBuilder::FilterSamples", FLAG_trace_profiler);
-    SampleBuffer* sample_buffer = Profiler::sample_buffer();
-    if (sample_buffer == NULL) {
-      return false;
-    }
-    samples_ = sample_buffer->BuildProcessedSampleBuffer(filter_);
+    ASSERT(sample_buffer_ != NULL);
+    samples_ = sample_buffer_->BuildProcessedSampleBuffer(filter_);
     profile_->samples_ = samples_;
     profile_->sample_count_ = samples_->length();
     return true;
   }
 
   void UpdateMinMaxTimes(int64_t timestamp) {
     profile_->min_time_ =
         timestamp < profile_->min_time_ ? timestamp : profile_->min_time_;
     profile_->max_time_ =
         timestamp > profile_->max_time_ ? timestamp : profile_->max_time_;
@@ skipping 1021 matching lines @@
            (tag_order_ == Profile::kVMUser) || (tag_order_ == Profile::kVM);
   }
 
   bool TagsEnabled(intptr_t extra_tags_bits) const {
     return (extra_tags_ & extra_tags_bits) != 0;
   }
 
   Thread* thread_;
   Isolate* vm_isolate_;
   SampleFilter* filter_;
+  SampleBuffer* sample_buffer_;
   Profile::TagOrder tag_order_;
   intptr_t extra_tags_;
   Profile* profile_;
   DeoptimizedCodeSet* deoptimized_code_;
   const Code& null_code_;
   const Function& null_function_;
   bool tick_functions_;
   bool inclusive_tree_;
   ProfileCodeInlinedFunctionsCache inlined_functions_cache_;
   ProcessedSampleBuffer* samples_;
@@ skipping 15 matching lines @@
       max_time_(0) {
   ASSERT(isolate_ != NULL);
   for (intptr_t i = 0; i < kNumTrieKinds; i++) {
     roots_[i] = NULL;
   }
 }
 
 
 void Profile::Build(Thread* thread,
                     SampleFilter* filter,
+                    SampleBuffer* sample_buffer,
                     TagOrder tag_order,
                     intptr_t extra_tags) {
-  ProfileBuilder builder(thread, filter, tag_order, extra_tags, this);
+  ProfileBuilder builder(thread, filter, sample_buffer, tag_order, extra_tags,
+                         this);
   builder.Build();
 }
 
 
 intptr_t Profile::NumFunctions() const {
   return functions_->length();
 }
 
 ProfileFunction* Profile::GetFunction(intptr_t index) {
   ASSERT(functions_ != NULL);
@@ skipping 360 matching lines @@
   ASSERT(parent_ != NULL);
   return parent_->NumChildren();
 }
 
 
 void ProfilerService::PrintJSONImpl(Thread* thread,
                                     JSONStream* stream,
                                     Profile::TagOrder tag_order,
                                     intptr_t extra_tags,
                                     SampleFilter* filter,
+                                    SampleBuffer* sample_buffer,
                                     bool as_timeline) {
   Isolate* isolate = thread->isolate();
   // Disable thread interrupts while processing the buffer.
   DisableThreadInterruptsScope dtis(thread);
 
-  SampleBuffer* sample_buffer = Profiler::sample_buffer();
   if (sample_buffer == NULL) {
     stream->PrintError(kFeatureDisabled, NULL);
     return;
   }
 
   {
     StackZone zone(thread);
     HANDLESCOPE(thread);
     Profile profile(isolate);
-    profile.Build(thread, filter, tag_order, extra_tags);
+    profile.Build(thread, filter, sample_buffer, tag_order, extra_tags);
     if (as_timeline) {
       profile.PrintTimelineJSON(stream);
     } else {
       profile.PrintProfileJSON(stream);
     }
   }
 }
 
 
 class NoAllocationSampleFilter : public SampleFilter {
  public:
   NoAllocationSampleFilter(Dart_Port port,
                            intptr_t thread_task_mask,
                            int64_t time_origin_micros,
                            int64_t time_extent_micros)
       : SampleFilter(port,
                      thread_task_mask,
                      time_origin_micros,
                      time_extent_micros) {}
 
-  bool FilterSample(Sample* sample) {
-    return !sample->is_allocation_sample() &&
-           !sample->is_native_allocation_sample();
-  }
+  bool FilterSample(Sample* sample) { return !sample->is_allocation_sample(); }
 };
 
 
 void ProfilerService::PrintJSON(JSONStream* stream,
                                 Profile::TagOrder tag_order,
                                 intptr_t extra_tags,
                                 int64_t time_origin_micros,
                                 int64_t time_extent_micros) {
   Thread* thread = Thread::Current();
   Isolate* isolate = thread->isolate();
   NoAllocationSampleFilter filter(isolate->main_port(), Thread::kMutatorTask,
                                   time_origin_micros, time_extent_micros);
   const bool as_timeline = false;
-  PrintJSONImpl(thread, stream, tag_order, extra_tags, &filter, as_timeline);
+  PrintJSONImpl(thread, stream, tag_order, extra_tags, &filter,
+                Profiler::sample_buffer(), as_timeline);
 }
 
 
 class ClassAllocationSampleFilter : public SampleFilter {
  public:
   ClassAllocationSampleFilter(Dart_Port port,
                               const Class& cls,
                               intptr_t thread_task_mask,
                               int64_t time_origin_micros,
                               int64_t time_extent_micros)
@@ skipping 19 matching lines @@
                                           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);
+  PrintJSONImpl(thread, stream, tag_order, kNoExtraTags, &filter,
+                Profiler::sample_buffer(), 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();
   NativeAllocationSampleFilter filter(time_origin_micros, time_extent_micros);
   const bool as_timeline = false;
-  PrintJSONImpl(thread, stream, tag_order, kNoExtraTags, &filter, as_timeline);
+  PrintJSONImpl(thread, stream, tag_order, kNoExtraTags, &filter,
+                Profiler::allocation_sample_buffer(), 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();
   Isolate* isolate = thread->isolate();
   const intptr_t thread_task_mask = Thread::kMutatorTask |
                                     Thread::kCompilerTask |
                                     Thread::kSweeperTask | Thread::kMarkerTask;
   NoAllocationSampleFilter filter(isolate->main_port(), thread_task_mask,
                                   time_origin_micros, time_extent_micros);
   const bool as_timeline = true;
-  PrintJSONImpl(thread, stream, tag_order, kNoExtraTags, &filter, as_timeline);
+  PrintJSONImpl(thread, stream, tag_order, kNoExtraTags, &filter,
+                Profiler::sample_buffer(), as_timeline);
 }
 
 
 void ProfilerService::ClearSamples() {
   SampleBuffer* sample_buffer = Profiler::sample_buffer();
   if (sample_buffer == NULL) {
     return;
   }
 
   Thread* thread = Thread::Current();
   Isolate* isolate = thread->isolate();
 
   // Disable thread interrupts while processing the buffer.
   DisableThreadInterruptsScope dtis(thread);
 
   ClearProfileVisitor clear_profile(isolate);
   sample_buffer->VisitSamples(&clear_profile);
 }
 
 #endif  // !PRODUCT
 
 }  // namespace dart