blob: 491081ded368e01df195b87ecbd6e98ebd4c7c6c (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
|
// Copyright 2014 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.
#ifndef TOOLS_ANDROID_HEAP_PROFILER_HEAP_PROFILER_H_
#define TOOLS_ANDROID_HEAP_PROFILER_HEAP_PROFILER_H_
#include <stdint.h>
#include "third_party/bsdtrees/tree.h"
#define HEAP_PROFILER_MAGIC_MARKER 0x42beef42L
#define HEAP_PROFILER_MAX_DEPTH 12
// The allocation is a result of a system malloc() invocation.
#define HEAP_PROFILER_FLAGS_MALLOC 1
// The allocation is a result of a mmap() invocation.
#define HEAP_PROFILER_FLAGS_MMAP 2 // Allocation performed through mmap.
// Only in the case of FLAGS_MMAP: The mmap is not anonymous (i.e. file backed).
#define HEAP_PROFILER_FLAGS_MMAP_FILE 4
// Android only: allocation made by the Zygote (before forking).
#define HEAP_PROFILER_FLAGS_IN_ZYGOTE 8
#ifdef __cplusplus
extern "C" {
#endif
typedef struct StacktraceEntry {
uintptr_t frames[HEAP_PROFILER_MAX_DEPTH]; // Absolute addrs of stack frames.
uint32_t hash; // H(frames), used to keep these entries in a hashtable.
// Total number of bytes allocated through this code path. It is equal to the
// sum of Alloc instances' length which .bt == this.
size_t alloc_bytes;
// |next| has a dual purpose. When the entry is used (hence in the hashtable),
// this is a ptr to the next item in the same bucket. When the entry is free,
// this is a ptr to the next entry in the freelist.
struct StacktraceEntry* next;
} StacktraceEntry;
// Represents a contiguous range of virtual memory which has been allocated by
// a give code path (identified by the corresponding StacktraceEntry).
typedef struct Alloc {
RB_ENTRY(Alloc) rb_node; // Anchor for the RB-tree;
uintptr_t start;
uintptr_t end;
uint32_t flags; // See HEAP_PROFILER_FLAGS_*.
StacktraceEntry* st; // NULL == free entry.
struct Alloc* next_free;
} Alloc;
typedef struct {
uint32_t magic_start; // The magic marker used to locate the stats mmap.
uint32_t num_allocs; // The total number of allocation entries present.
uint32_t max_allocs; // The max number of items in |allocs|.
uint32_t num_stack_traces; // The total number of stack traces present.
uint32_t max_stack_traces; // The max number of items in |stack_traces|.
size_t total_alloc_bytes; // Total allocation bytes tracked.
Alloc* allocs; // Start of the the Alloc pool.
StacktraceEntry* stack_traces; // Start of the StacktraceEntry pool.
} HeapStats;
// Initialize the heap_profiler. The caller has to allocate the HeapStats
// "superblock", since the way it is mapped is platform-specific.
void heap_profiler_init(HeapStats* heap_stats);
// Records and allocation. The caller must unwind the stack and pass the
// frames array. Flags are optionals and don't affect the behavior of the
// library (they're just kept along and dumped).
void heap_profiler_alloc(void* addr,
size_t size,
uintptr_t* frames,
uint32_t depth,
uint32_t flags);
// Frees any allocation (even partial) overlapping with the given range.
// If old_flags != NULL, it will be filled with the flags of the deleted allocs.
void heap_profiler_free(void* addr, size_t size, uint32_t* old_flags);
// Cleans up the HeapStats and all the internal data structures.
void heap_profiler_cleanup(void);
#ifdef __cplusplus
}
#endif
#endif // TOOLS_ANDROID_HEAP_PROFILER_HEAP_PROFILER_H_
|
