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 11 matching lines @@
 #include "base/logging.h"
 #include "base/mac/mach_logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/string_number_conversions.h"
 
 namespace base {
 
 namespace {
 
-// Miscellaneous --------------------------------------------------------------
-
-size_t StackCopyBufferSize() {
-  static size_t stack_size = 0;
-  if (stack_size)
-    return stack_size;
-
-  // In platform_thread_mac's GetDefaultThreadStackSize(), RLIMIT_STACK is used
-  // for all stacks, not just the main thread's, so it is good for use here.
-  struct rlimit stack_rlimit;
-  if (getrlimit(RLIMIT_STACK, &stack_rlimit) == 0 &&
-      stack_rlimit.rlim_cur != RLIM_INFINITY) {
-    stack_size = stack_rlimit.rlim_cur;
-    return stack_size;
-  }
-
-  // If getrlimit somehow fails, return the default macOS main thread stack size
-  // of 8 MB (DFLSSIZ in <i386/vmparam.h>) with extra wiggle room.
-  return 12 * 1024 * 1024;
-}
-
 // Stack walking --------------------------------------------------------------
 
 // Fills |state| with |target_thread|'s context.
 //
 // Note that this is called while a thread is suspended. Make very very sure
 // that no shared resources (e.g. memory allocators) are used for the duration
 // of this function.
 bool GetThreadState(thread_act_t target_thread, x86_thread_state64_t* state) {
   mach_msg_type_number_t count =
       static_cast<mach_msg_type_number_t>(x86_THREAD_STATE64_COUNT);
@@ skipping 253 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* stack_buffer,
+                         StackSamplingProfiler::Sample* sample) override;
+  void ProfileRecordingStopped(StackBuffer* stack_buffer) 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* stack_buffer,
+                                   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* stack_buffer,
     StackSamplingProfiler::Sample* sample) {
   DCHECK(current_modules_);
 
-  SuspendThreadAndRecordStack(sample);
+  SuspendThreadAndRecordStack(stack_buffer, sample);
 }
 
-void NativeStackSamplerMac::ProfileRecordingStopped() {
+void NativeStackSamplerMac::ProfileRecordingStopped(StackBuffer* stack_buffer) {
   current_modules_ = nullptr;
 }
 
 void NativeStackSamplerMac::SuspendThreadAndRecordStack(
+    StackBuffer* stack_buffer,
     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 > stack_buffer->size())
       return;
 
     (*annotator_)(sample);
 
     CopyStackAndRewritePointers(
-        reinterpret_cast<uintptr_t*>(stack_copy_buffer_.get()),
+        reinterpret_cast<uintptr_t*>(stack_buffer->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>(stack_buffer->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);
 }
 
+size_t NativeStackSampler::GetStackBufferSize() {
+  // In platform_thread_mac's GetDefaultThreadStackSize(), RLIMIT_STACK is used
+  // for all stacks, not just the main thread's, so it is good for use here.
+  struct rlimit stack_rlimit;
+  if (getrlimit(RLIMIT_STACK, &stack_rlimit) == 0 &&
+      stack_rlimit.rlim_cur != RLIM_INFINITY) {
+    return stack_rlimit.rlim_cur;
+  }
+
+  // If getrlimit somehow fails, return the default macOS main thread stack size
+  // of 8 MB (DFLSSIZ in <i386/vmparam.h>) with extra wiggle room.
+  return 12 * 1024 * 1024;
+}
+
 }  // namespace base