Use a common buffer across all instances for stack-copy.

base/profiler/stack_sampling_profiler.cc

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/profiler/stack_sampling_profiler.h"
 
 #include <algorithm>
 #include <map>
 #include <utility>
 
@@ skipping 232 matching lines @@
   void PerformCollectionTask(int id);
   void ShutdownTask(int add_events);
 
   // Updates the |next_sample_time| time based on configured parameters.
   // Returns true if there is a next sample or false if sampling is complete.
   bool UpdateNextSampleTime(CollectionContext* collection);
 
   // Thread:
   void CleanUp() override;
 
+  // A stack-buffer used by the native sampler for its work. This buffer can
+  // be re-used for multiple native sampler objects so long as the API calls
+  // that take it are not called concurrently.
+  std::unique_ptr<NativeStackSampler::StackBuffer> stack_buffer_;
+
   // A map of IDs to collection contexts. Because this class is a singleton
   // that is never destroyed, context objects will never be destructed except
   // by explicit action. Thus, it's acceptable to pass unretained pointers
   // to these objects when posting tasks.
   std::map<int, std::unique_ptr<CollectionContext>> active_collections_;
 
   // State maintained about the current execution (or non-execution) of
   // the thread. This state must always be accessed while holding the
   // lock. A copy of the task-runner is maintained here for use by any
   // calling thread; this is necessary because Thread's accessor for it is
@@ skipping 151 matching lines @@
     DCHECK_NE(GetThreadId(), PlatformThread::CurrentId());
     return thread_execution_state_task_runner_;
   }
 
   if (thread_execution_state_ == EXITING) {
     // The previous instance has only been partially cleaned up. It is necessary
     // to call Stop() before Start().
     Stop();
   }
 
+  DCHECK(!stack_buffer_);
+  stack_buffer_ = NativeStackSampler::CreateStackBuffer();
+
   // The thread is not running. Start it and get associated runner. The task-
   // runner has to be saved for future use because though it can be used from
   // any thread, it can be acquired via task_runner() only on the created
   // thread and the thread that creates it (i.e. this thread) for thread-safety
   // reasons which are alleviated in SamplingThread by gating access to it with
   // the |thread_execution_state_lock_|.
   Start();
   thread_execution_state_ = RUNNING;
   thread_execution_state_task_runner_ = Thread::task_runner();
 
@@ skipping 76 matching lines @@
     profile.sampling_period = collection->params.sampling_interval;
     collection->profile_start_time = Time::Now();
     collection->native_sampler->ProfileRecordingStarting(&profile.modules);
   }
 
   // The currently active profile being captured.
   CallStackProfile& profile = collection->profiles.back();
 
   // Record a single sample.
   profile.samples.push_back(Sample());
-  collection->native_sampler->RecordStackSample(&profile.samples.back());
+  collection->native_sampler->RecordStackSample(stack_buffer_.get(),
+                                                &profile.samples.back());
 
   // If this is the last sample of a burst, record the total time.
   if (collection->sample == collection->params.samples_per_burst - 1) {
     profile.profile_duration = Time::Now() - collection->profile_start_time;
-    collection->native_sampler->ProfileRecordingStopped();
+    collection->native_sampler->ProfileRecordingStopped(stack_buffer_.get());
   }
 }
 
 void StackSamplingProfiler::SamplingThread::ScheduleShutdownIfIdle() {
   DCHECK_EQ(GetThreadId(), PlatformThread::CurrentId());
 
   if (!active_collections_.empty())
     return;
 
   int add_events;
@@ skipping 104 matching lines @@
   // (again) in order for Stop/Start to be called (again) should more work
   // come in. Holding the |thread_execution_state_lock_| ensures the necessary
   // happens-after with regard to this detach and future Thread API calls.
   DetachFromSequence();
 
   // Set the thread_state variable so the thread will be restarted when new
   // work comes in. Remove the |thread_execution_state_task_runner_| to avoid
   // confusion.
   thread_execution_state_ = EXITING;
   thread_execution_state_task_runner_ = nullptr;
+  stack_buffer_.reset();
 }
 
 bool StackSamplingProfiler::SamplingThread::UpdateNextSampleTime(
     CollectionContext* collection) {
   // This will keep a consistent average interval between samples but will
   // result in constant series of acquisitions, thus nearly locking out the
   // target thread, if the interval is smaller than the time it takes to
   // actually acquire the sample. Anything sampling that quickly is going
   // to be a problem anyway so don't worry about it.
   if (++collection->sample < collection->params.samples_per_burst) {
@@ skipping 173 matching lines @@
 }
 
 bool operator<(const StackSamplingProfiler::Frame &a,
                const StackSamplingProfiler::Frame &b) {
   return (a.module_index < b.module_index) ||
       (a.module_index == b.module_index &&
        a.instruction_pointer < b.instruction_pointer);
 }
 
 }  // namespace base