blob: f32e96029d6e57a88fca678946eb1cde5d66a0e5 [file] [log] [blame] [edit]
// Copyright 2015 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef BASE_PROFILER_STACK_SAMPLER_H_
#define BASE_PROFILER_STACK_SAMPLER_H_
#include <memory>
#include <vector>
#include "base/base_export.h"
#include "base/containers/circular_deque.h"
#include "base/functional/callback.h"
#include "base/gtest_prod_util.h"
#include "base/memory/raw_ptr.h"
#include "base/profiler/frame.h"
#include "base/profiler/register_context.h"
#include "base/profiler/sampling_profiler_thread_token.h"
#include "base/profiler/stack_copier.h"
#include "base/profiler/stack_unwind_data.h"
#include "base/threading/platform_thread.h"
#include "build/build_config.h"
namespace base {
class ModuleCache;
class StackBuffer;
class StackSamplerTestDelegate;
class Unwinder;
// StackSampler is an implementation detail of StackSamplingProfiler. It
// abstracts the native implementation required to record a set of stack frames
// for a given thread. It delegates to StackCopier for the
// platform-specific stack copying implementation.
// This class is used on both the SamplingThread and a worker thread of the
// thread pool. Recording stack frames always occurs on the
// SamplingThread but unwinding the stack can occur on either the SamplingThread
// or a worker thread. Sampling can start before the thread pool is running so
// unwinding will occur on the SamplingThread until the thread pool is ready.
class BASE_EXPORT StackSampler {
public:
// Factory for generating a set of Unwinders for use by the profiler.
using UnwindersFactory =
OnceCallback<std::vector<std::unique_ptr<Unwinder>>()>;
// Creates a stack sampler that records samples for thread with
// |thread_token|. Unwinders in |unwinders| must be stored in increasing
// priority to guide unwind attempts. Only the unwinder with the lowest
// priority is allowed to return with UnwindResult::kCompleted. Returns null
// if this platform does not support stack sampling.
static std::unique_ptr<StackSampler> Create(
SamplingProfilerThreadToken thread_token,
std::unique_ptr<StackUnwindData> stack_unwind_data,
UnwindersFactory core_unwinders_factory,
RepeatingClosure record_sample_callback,
StackSamplerTestDelegate* test_delegate);
~StackSampler();
StackSampler(const StackSampler&) = delete;
StackSampler& operator=(const StackSampler&) = delete;
// Gets the required size of the stack buffer.
static size_t GetStackBufferSize();
// Creates an instance of the a stack buffer that can be used for calls to
// any StackSampler object.
static std::unique_ptr<StackBuffer> CreateStackBuffer();
// The following functions are all called on the SamplingThread (not the
// thread being sampled).
// Performs post-construction initialization on the SamplingThread.
void Initialize();
// Stops the sampler.
void Stop(OnceClosure done_callback);
// Adds an auxiliary unwinder to handle additional, non-native-code unwind
// scenarios. Unwinders must be inserted in increasing priority, following
// |unwinders| provided in Create(), to guide unwind attempts.
void AddAuxUnwinder(std::unique_ptr<Unwinder> unwinder);
// Records a set of frames and returns them.
void RecordStackFrames(StackBuffer* stack_buffer,
PlatformThreadId thread_id,
OnceClosure done_callback);
StackUnwindData* GetStackUnwindData();
// Exposes the internal function for unit testing.
static std::vector<Frame> WalkStackForTesting(
ModuleCache* module_cache,
RegisterContext* thread_context,
uintptr_t stack_top,
std::vector<UnwinderCapture> unwinders);
// Create a StackSampler, overriding the platform-specific components.
static std::unique_ptr<StackSampler> CreateForTesting(
std::unique_ptr<StackCopier> stack_copier,
std::unique_ptr<StackUnwindData> stack_unwind_data,
UnwindersFactory core_unwinders_factory,
RepeatingClosure record_sample_callback = RepeatingClosure(),
StackSamplerTestDelegate* test_delegate = nullptr);
#if BUILDFLAG(IS_CHROMEOS)
// How often to record the "Memory.StackSamplingProfiler.StackSampleSize2" UMA
// histogram. Specifically, only 1 in kUMAHistogramDownsampleAmount calls to
// RecordStackFrames will add a sample to the histogram. RecordStackFrames is
// called many times a second. We don't need multiple samples per second to
// get a good understanding of average stack sizes, and it's a lot of data to
// record. kUMAHistogramDownsampleAmount should give us about 1 sample per 10
// seconds per process, which is plenty. 199 is prime which should avoid any
// aliasing issues (e.g. if stacks are larger on second boundaries or some
// such weirdness).
static constexpr uint32_t kUMAHistogramDownsampleAmount = 199;
#endif
private:
FRIEND_TEST_ALL_PREFIXES(StackSamplerTest,
AuxUnwinderInvokedWhileRecordingStackFrames);
StackSampler(std::unique_ptr<StackCopier> stack_copier,
std::unique_ptr<StackUnwindData> stack_unwind_data,
UnwindersFactory core_unwinders_factory,
RepeatingClosure record_sample_callback,
StackSamplerTestDelegate* test_delegate);
static std::vector<Frame> WalkStack(ModuleCache* module_cache,
RegisterContext* thread_context,
uintptr_t stack_top,
std::vector<UnwinderCapture> unwinders);
void UnwindComplete(TimeTicks timestamp,
OnceClosure done_callback,
std::vector<Frame> frames);
void AddAuxUnwinderWithoutInit(std::unique_ptr<Unwinder> unwinder);
void ThreadPoolRunning();
const std::unique_ptr<StackCopier> stack_copier_;
UnwindersFactory unwinders_factory_;
const RepeatingClosure record_sample_callback_;
const raw_ptr<StackSamplerTestDelegate> test_delegate_;
#if BUILDFLAG(IS_CHROMEOS)
// Counter for "Memory.StackSamplingProfiler.StackSampleSize2" UMA histogram.
// See comments above kUMAHistogramDownsampleAmount. Unsigned so that overflow
// isn't undefined behavior.
uint32_t stack_size_histogram_sampling_counter_ = 0;
#endif
scoped_refptr<SequencedTaskRunner> thread_pool_runner_;
// The StackUnwindData will be in released on the `thread_pool_runner_` if it
// is non-null.
std::unique_ptr<StackUnwindData> unwind_data_;
bool was_initialized_ = false;
bool thread_pool_ready_ = false;
base::WeakPtrFactory<StackSampler> weak_ptr_factory_{this};
};
// StackSamplerTestDelegate provides seams for test code to execute during stack
// collection.
class BASE_EXPORT StackSamplerTestDelegate {
public:
StackSamplerTestDelegate(const StackSamplerTestDelegate&) = delete;
StackSamplerTestDelegate& operator=(const StackSamplerTestDelegate&) = delete;
virtual ~StackSamplerTestDelegate();
// Called after copying the stack and resuming the target thread, but prior to
// walking the stack. Invoked on the SamplingThread.
virtual void OnPreStackWalk() = 0;
protected:
StackSamplerTestDelegate();
};
} // namespace base
#endif // BASE_PROFILER_STACK_SAMPLER_H_