[Android] Introduce libheap_profiler for memory profiling.

tools/android/heap_profiler/heap_profiler.h

+// 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 "tools/android/heap_profiler/third_party/bsd-trees/tree.h"
+
+#define HEAP_PROFILER_MAGIC_MARKER 0x42beef42L
+#define HEAP_PROFILER_MAX_DEPTH 12
+#define HEAP_PROFILER_EXPORT __attribute__((visibility("default")))
+
+// The allocated vma is a result of a system malloc() invocation.
+#define HEAP_PROFILER_FLAGS_MALLOC 1
+
+// The allocation vma 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 VMA instances' length which .bt == this.

[pasko, 2014/06/10 16:59:52]

nit:
second sentence in this comment just repeats the first

+  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 VMA {
+  RB_ENTRY(VMA) 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 VMA* next_free;
+} VMA;
+
+typedef struct {
+  uint32_t magic_start;  // The magic marker used by hdump to discover the area.
+  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.
+  VMA* allocs;  // Start of the the VMA pool.
+  StacktraceEntry* stack_traces;  // Start of the StacktraceEntry pool.
+} HeapStats;
+
+// The API is exported in order to be accessed from custom allocators.
+
+// Initialize the heap_profiler. The caller has to allocate the HeapStats
+// "superblock", since the way it is mapped is platform-specific.
+HEAP_PROFILER_EXPORT 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).
+HEAP_PROFILER_EXPORT 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 VMAs.
+HEAP_PROFILER_EXPORT void heap_profiler_free(
+    void* addr, size_t size, uint32_t* old_flags);
+
+// Cleans up the HeapStats and all the internal data structures.
+HEAP_PROFILER_EXPORT void heap_profiler_cleanup(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // TOOLS_ANDROID_HEAP_PROFILER_HEAP_PROFILER_H_