blob: 454200c474ee32be54c15e234cfa1753a8e580ce [file] [log] [blame]
// 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 <vector>
#include "base/atomicops.h"
#include "base/base_export.h"
#include "base/debug/stack_trace.h"
#include "base/logging.h"
#include "base/macros.h"
#include "base/trace_event/heap_profiler_allocation_context.h"
namespace base {
namespace trace_event {
// The allocation context tracker keeps track of thread-local context for heap
// profiling. It includes a pseudo stack of trace events. On every allocation
// the tracker provides a snapshot of its context in the form of an
// |AllocationContext| that is to be stored together with the allocation
// details.
class BASE_EXPORT AllocationContextTracker {
enum class CaptureMode: int32_t {
DISABLED, // Don't capture anything
PSEUDO_STACK, // GetContextSnapshot() returns pseudo stack trace
NATIVE_STACK // GetContextSnapshot() returns native (real) stack trace
// Globally sets capturing mode.
// TODO(primiano): How to guard against *_STACK -> DISABLED -> *_STACK?
static void SetCaptureMode(CaptureMode mode);
// Returns global capturing mode.
inline static CaptureMode capture_mode() {
// A little lag after heap profiling is enabled or disabled is fine, it is
// more important that the check is as cheap as possible when capturing is
// not enabled, so do not issue a memory barrier in the fast path.
if (subtle::NoBarrier_Load(&capture_mode_) ==
return CaptureMode::DISABLED;
// In the slow path, an acquire load is required to pair with the release
// store in |SetCaptureMode|. This is to ensure that the TLS slot for
// the thread-local allocation context tracker has been initialized if
// |capture_mode| returns something other than DISABLED.
return static_cast<CaptureMode>(subtle::Acquire_Load(&capture_mode_));
// Returns the thread-local instance, creating one if necessary. Returns
// always a valid instance, unless it is called re-entrantly, in which case
// returns nullptr in the nested calls.
static AllocationContextTracker* GetInstanceForCurrentThread();
// Set the thread name in the AllocationContextTracker of the current thread
// if capture is enabled.
static void SetCurrentThreadName(const char* name);
// Starts and ends a new ignore scope between which the allocations are
// ignored in the heap profiler. A dummy context that short circuits to
// "tracing_overhead" is returned for these allocations.
void begin_ignore_scope() { ignore_scope_depth_++; }
void end_ignore_scope() {
if (ignore_scope_depth_)
// Pushes a frame onto the thread-local pseudo stack.
void PushPseudoStackFrame(const char* trace_event_name);
// Pops a frame from the thread-local pseudo stack.
void PopPseudoStackFrame(const char* trace_event_name);
// Push and pop current task's context. A stack is used to support nested
// tasks and the top of the stack will be used in allocation context.
void PushCurrentTaskContext(const char* context);
void PopCurrentTaskContext(const char* context);
// Returns a snapshot of the current thread-local context.
AllocationContext GetContextSnapshot();
static subtle::Atomic32 capture_mode_;
// The pseudo stack where frames are |TRACE_EVENT| names.
std::vector<const char*> pseudo_stack_;
// The thread name is used as the first entry in the pseudo stack.
const char* thread_name_;
// Stack of tasks' contexts. Context serves as a different dimension than
// pseudo stack to cluster allocations.
std::vector<const char*> task_contexts_;
uint32_t ignore_scope_depth_;
} // namespace trace_event
} // namespace base