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

base/profiler/native_stack_sampler_mac.cc

 // Copyright 2017 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/native_stack_sampler.h"
 
 #include <dlfcn.h>
 #include <libkern/OSByteOrder.h>
 #include <libunwind.h>
 #include <mach-o/swap.h>
@@ skipping 305 matching lines @@
 class NativeStackSamplerMac : public NativeStackSampler {
  public:
   NativeStackSamplerMac(mach_port_t thread_port,
                         AnnotateCallback annotator,
                         NativeStackSamplerTestDelegate* test_delegate);
   ~NativeStackSamplerMac() override;
 
   // StackSamplingProfiler::NativeStackSampler:
   void ProfileRecordingStarting(
       std::vector<StackSamplingProfiler::Module>* modules) override;
-  void RecordStackSample(StackSamplingProfiler::Sample* sample) override;
-  void ProfileRecordingStopped() override;
+  void RecordStackSample(StackBuffer* stackbuffer,
+                         StackSamplingProfiler::Sample* sample) override;
+  void ProfileRecordingStopped(StackBuffer* stackbuffer) override;
 
  private:
   // Suspends the thread with |thread_port_|, copies its stack and resumes the
   // thread, then records the stack frames and associated modules into |sample|.
-  void SuspendThreadAndRecordStack(StackSamplingProfiler::Sample* sample);
+  void SuspendThreadAndRecordStack(StackBuffer* stackbuffer,
+                                   StackSamplingProfiler::Sample* sample);
 
   // Weak reference: Mach port for thread being profiled.
   mach_port_t thread_port_;
 
   const AnnotateCallback annotator_;
 
   NativeStackSamplerTestDelegate* const test_delegate_;
 
   // The stack base address corresponding to |thread_handle_|.
   const void* const thread_stack_base_address_;
 
-  // The size of the |stack_copy_buffer_|.
-  const size_t stack_copy_buffer_size_;
-
-  // Buffer to use for copies of the stack. We use the same buffer for all the
-  // samples to avoid the overhead of multiple allocations and frees.
-  const std::unique_ptr<unsigned char[]> stack_copy_buffer_;
-
   // Weak. Points to the modules associated with the profile being recorded
   // between ProfileRecordingStarting() and ProfileRecordingStopped().
   std::vector<StackSamplingProfiler::Module>* current_modules_ = nullptr;
 
   // Maps a module's base address to the corresponding Module's index within
   // current_modules_.
   std::map<const void*, size_t> profile_module_index_;
 
   DISALLOW_COPY_AND_ASSIGN(NativeStackSamplerMac);
 };
 
 NativeStackSamplerMac::NativeStackSamplerMac(
     mach_port_t thread_port,
     AnnotateCallback annotator,
     NativeStackSamplerTestDelegate* test_delegate)
     : thread_port_(thread_port),
       annotator_(annotator),
       test_delegate_(test_delegate),
       thread_stack_base_address_(
-          pthread_get_stackaddr_np(pthread_from_mach_thread_np(thread_port))),
-      stack_copy_buffer_size_(StackCopyBufferSize()),
-      stack_copy_buffer_(new unsigned char[stack_copy_buffer_size_]) {
+          pthread_get_stackaddr_np(pthread_from_mach_thread_np(thread_port))) {
   DCHECK(annotator_);
 
   // This class suspends threads, and those threads might be suspended in dyld.
   // Therefore, for all the system functions that might be linked in dynamically
   // that are used while threads are suspended, make calls to them to make sure
   // that they are linked up.
   x86_thread_state64_t thread_state;
   GetThreadState(thread_port_, &thread_state);
 }
 
 NativeStackSamplerMac::~NativeStackSamplerMac() {}
 
 void NativeStackSamplerMac::ProfileRecordingStarting(
     std::vector<StackSamplingProfiler::Module>* modules) {
   current_modules_ = modules;
   profile_module_index_.clear();
 }
 
 void NativeStackSamplerMac::RecordStackSample(
+    StackBuffer* stackbuffer,
     StackSamplingProfiler::Sample* sample) {
   DCHECK(current_modules_);
 
-  SuspendThreadAndRecordStack(sample);
+  SuspendThreadAndRecordStack(stackbuffer, sample);
 }
 
-void NativeStackSamplerMac::ProfileRecordingStopped() {
+void NativeStackSamplerMac::ProfileRecordingStopped(StackBuffer* stackbuffer) {
   current_modules_ = nullptr;
 }
 
 void NativeStackSamplerMac::SuspendThreadAndRecordStack(
+    StackBuffer* stackbuffer,
     StackSamplingProfiler::Sample* sample) {
   x86_thread_state64_t thread_state;
 
   // Copy the stack.
 
   uintptr_t new_stack_top = 0;
   {
     // IMPORTANT NOTE: Do not do ANYTHING in this in this scope that might
     // allocate memory, including indirectly via use of DCHECK/CHECK or other
     // logging statements. Otherwise this code can deadlock on heap locks in the
     // default heap acquired by the target thread before it was suspended.
     ScopedSuspendThread suspend_thread(thread_port_);
     if (!suspend_thread.was_successful())
       return;
 
     if (!GetThreadState(thread_port_, &thread_state))
       return;
     uintptr_t stack_top =
         reinterpret_cast<uintptr_t>(thread_stack_base_address_);
     uintptr_t stack_bottom = thread_state.__rsp;
     if (stack_bottom >= stack_top)
       return;
     uintptr_t stack_size = stack_top - stack_bottom;
 
-    if (stack_size > stack_copy_buffer_size_)
+    if (stack_size > stackbuffer->size())
       return;
 
     (*annotator_)(sample);
 
     CopyStackAndRewritePointers(
-        reinterpret_cast<uintptr_t*>(stack_copy_buffer_.get()),
+        reinterpret_cast<uintptr_t*>(stackbuffer->buffer()),
         reinterpret_cast<uintptr_t*>(stack_bottom),
         reinterpret_cast<uintptr_t*>(stack_top), &thread_state);
 
     new_stack_top =
-        reinterpret_cast<uintptr_t>(stack_copy_buffer_.get()) + stack_size;
+        reinterpret_cast<uintptr_t>(stackbuffer->buffer()) + stack_size;
   }  // ScopedSuspendThread
 
   if (test_delegate_)
     test_delegate_->OnPreStackWalk();
 
   // Walk the stack and record it.
 
   // Reserve enough memory for most stacks, to avoid repeated allocations.
   // Approximately 99.9% of recorded stacks are 128 frames or fewer.
   sample->frames.reserve(128);
@@ skipping 12 matching lines @@
 }  // namespace
 
 std::unique_ptr<NativeStackSampler> NativeStackSampler::Create(
     PlatformThreadId thread_id,
     AnnotateCallback annotator,
     NativeStackSamplerTestDelegate* test_delegate) {
   return base::MakeUnique<NativeStackSamplerMac>(thread_id, annotator,
                                                  test_delegate);
 }
 
+std::unique_ptr<NativeStackSampler::StackBuffer>
+NativeStackSampler::CreateStackBuffer() {
+  return MakeUnique<StackBuffer>(StackCopyBufferSize());
+}
+
 }  // namespace base