[Android] Introduce libheap_profiler for memory profiling.

tools/android/heap_profiler/heap_profiler_integrationtest.cc

+// 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.
+
+#include <dlfcn.h>
+#include <fcntl.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/mman.h>
+#include <unistd.h>
+#include <map>
+
+#include "base/compiler_specific.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "tools/android/heap_profiler/heap_profiler.h"
+
+namespace {
+
+// The purpose of the four functions below is to create watermarked allocations,
+// so the test fixture can ascertain that the hooks work end-to-end.
+__attribute__((noinline)) void* MallocInner(size_t size) {
+  void* ptr = malloc(size);
+  // The memset below is to avoid tail-call elimination optimizations and ensure
+  // that this function will be part of the stack trace.
+  memset(ptr, 0, size);
+  return ptr;
+}
+
+__attribute__((noinline)) void* MallocOuter(size_t size) {
+  void* ptr = MallocInner(size);
+  memset(ptr, 0, size);
+  return ptr;
+}
+
+__attribute__((noinline)) void* DoMmap(size_t size) {
+  return mmap(
+      0, size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, 0, 0);
+}
+
+__attribute__((noinline)) void* MmapInner(size_t size) {
+  void* ptr = DoMmap(size);
+  memset(ptr, 0, size);
+  return ptr;
+}
+
+__attribute__((noinline)) void* MmapOuter(size_t size) {
+  void* ptr = MmapInner(size);
+  memset(ptr, 0, size);
+  return ptr;
+}
+
+class HeapProfilerIntegrationTest : public testing::Test {
+ public:
+  virtual void SetUp() OVERRIDE {
+    HeapStats* const* stats_ptr = reinterpret_cast<HeapStats* const*>(
+        dlsym(RTLD_DEFAULT, "heap_profiler_stats_for_tests"));
+    EXPECT_TRUE(stats_ptr != NULL);
+    stats_ = *stats_ptr;
+    EXPECT_TRUE(stats_ != NULL);
+    EXPECT_EQ(HEAP_PROFILER_MAGIC_MARKER, stats_->magic_start);
+  }
+
+ protected:
+  void Initialize(void* (*outer_fn)(size_t), void* (*inner_fn)(size_t)) {

[bulach, 2014/06/26 12:49:38]

nit: could do with a typedef void* (*AllocatorFn)(size_t), then here it'd be
AllocatorFn outer_fn, AllocatorFn inner_fn..

[Primiano Tucci (use gerrit), 2014/06/26 13:38:17]

Done.

+    outer_fn_ = reinterpret_cast<uintptr_t>(outer_fn);
+    inner_fn_ = reinterpret_cast<uintptr_t>(inner_fn);
+  }
+
+  void TestAfterAllAllocatedAnd3Freed() {
+    const StacktraceEntry* st1 = LookupStackTrace(kSize1, inner_fn_);
+    const StacktraceEntry* st2 = LookupStackTrace(kSize2, inner_fn_);
+    const StacktraceEntry* st3 = LookupStackTrace(kSize3, inner_fn_);
+
+    EXPECT_TRUE(st1 != NULL);
+    EXPECT_TRUE(StackTraceContains(st1, outer_fn_));
+    EXPECT_TRUE(StackTraceContains(st1, inner_fn_));
+
+    EXPECT_TRUE(st2 != NULL);
+    EXPECT_FALSE(StackTraceContains(st2, outer_fn_));
+    EXPECT_TRUE(StackTraceContains(st2, inner_fn_));
+
+    EXPECT_EQ(NULL, st3);
+
+    total_alloc_start_ = stats_->total_alloc_bytes;
+    num_stack_traces_start_ = stats_->num_stack_traces;
+  }
+
+  void TestAfterAllFreed() {
+    const size_t total_alloc_end = stats_->total_alloc_bytes;
+    const size_t num_stack_traces_end = stats_->num_stack_traces;
+
+    EXPECT_EQ(kSize1 + kSize2, total_alloc_start_ - total_alloc_end);
+    EXPECT_EQ(2, num_stack_traces_start_ - num_stack_traces_end);
+    EXPECT_EQ(NULL, LookupStackTrace(kSize1, inner_fn_));
+    EXPECT_EQ(NULL, LookupStackTrace(kSize2, inner_fn_));
+    EXPECT_EQ(NULL, LookupStackTrace(kSize3, inner_fn_));
+  }
+
+  static const size_t kSize1 = 499 * PAGE_SIZE;
+  static const size_t kSize2 = 503 * PAGE_SIZE;
+  static const size_t kSize3 = 509 * PAGE_SIZE;
+
+ private:
+  static bool StackTraceContains(const StacktraceEntry* s, uintptr_t fn_addr) {
+    // kExpectedFnLen is a gross estimation of the watermark functions' size.
+    // It tries to address the following problem: the addrs in the unwound stack
+    // stack frames will NOT point to the beginning of the functions, but to the
+    // PC after the call to malloc/mmap.
+    const size_t kExpectedFnLen = 16;
+
+    for (size_t i = 0; i < HEAP_PROFILER_MAX_DEPTH; ++i) {
+      if (s->frames[i] >= fn_addr && s->frames[i] <= fn_addr + kExpectedFnLen)
+        return true;
+    }
+    return false;
+  }
+
+  const StacktraceEntry* LookupStackTrace(size_t size, uintptr_t fn_addr) {
+    for (size_t i = 0; i < stats_->max_stack_traces; ++i) {
+      const StacktraceEntry* st = &stats_->stack_traces[i];
+      if (st->alloc_bytes == size && StackTraceContains(st, fn_addr))
+        return st;
+    }
+    return NULL;
+  }
+
+  const HeapStats* stats_;
+  size_t total_alloc_start_;
+  size_t num_stack_traces_start_;
+  uintptr_t outer_fn_;
+  uintptr_t inner_fn_;
+};
+
+TEST_F(HeapProfilerIntegrationTest, TestMallocStackTraces) {
+  Initialize(&MallocOuter, &MallocInner);
+
+  void* m1 = MallocOuter(kSize1);
+  void* m2 = MallocInner(kSize2);
+  void* m3 = MallocInner(kSize3);

[bulach, 2014/06/26 12:49:38]

nit: could move these three and 151-153 to Initialize?

[Primiano Tucci (use gerrit), 2014/06/26 13:38:17]

Hmm I tried but it looks odd. I can move the allocation inside Init using the
outer/inner fn pointer. However, I cannot move the free (because munmap takes a
2nd param). 
The overall result feels "unbalanced" and hard to follow.
You have to realize that the actual allocation is made inside Init following the
function pointer assignment. I'd keep it more readable. Also, the overall lines
count wouldn't decrease, as I have to add three extra fields in the class to
allocate them in a single place, and we're back to 6. :)

This is how it would look like.

void Initialize(AllocatorFn outer_fn, AllocatorFn inner_fn) {
  outer_fn_ = reinterpret_cast<uintptr_t>(outer_fn);
  inner_fn_ = reinterpret_cast<uintptr_t>(inner_fn);
  m1_ = outer_fn(kSize1)
  m2_ = outer_fn(kSize2)
  m3_ = outer_fn(kSize3)
}

...
TEST_F(HeapProfilerIntegrationTest, TestMmapStackTraces) {
  Initialize(&MmapOuter, &MmapInner);

  munmap(m3_, kSize3);
  TestAfterAllAllocatedAnd3Freed();
...

protected:
  void* m1_;
  void* m2_;
  void* m3_;

+  free(m3);
+  TestAfterAllAllocatedAnd3Freed();
+
+  free(m1);
+  free(m2);
+  TestAfterAllFreed();
+}
+
+TEST_F(HeapProfilerIntegrationTest, TestMmapStackTraces) {
+  Initialize(&MmapOuter, &MmapInner);
+
+  void* m1 = MmapOuter(kSize1);
+  void* m2 = MmapInner(kSize2);
+  void* m3 = MmapInner(kSize3);
+  munmap(m3, kSize3);
+  TestAfterAllAllocatedAnd3Freed();
+
+  munmap(m1, kSize1);
+  munmap(m2, kSize2);
+  TestAfterAllFreed();
+}
+
+// Returns the path of the directory containing the current executable.
+std::string GetExePath() {
+  char buf[1024];
+  ssize_t len = readlink("/proc/self/exe", buf, sizeof(buf) - 1);
+  if (len == -1)
+    return std::string();
+  std::string path(buf, len);
+  size_t sep = path.find_last_of('/');
+  if (sep == std::string::npos)
+    return std::string();
+  path.erase(sep);
+  return path;
+}
+
+}  // namespace
+
+int main(int argc, char** argv) {
+  // Re-launch the process itself forcing the preload of the libheap_profiler.
+  if (getenv("LD_PRELOAD") == NULL) {
+    char env_ld_lib_path[256];
+    strlcpy(env_ld_lib_path, "LD_LIBRARY_PATH=", sizeof(env_ld_lib_path));
+    strlcat(env_ld_lib_path, GetExePath().c_str(), sizeof(env_ld_lib_path));
+    char env_ld_preload[] = "LD_PRELOAD=libheap_profiler.so";
+    char* const env[] = {env_ld_preload, env_ld_lib_path, 0};
+    execve("/proc/self/exe", argv, env);
+    // execve() never returns, unless something goes wrong.
+    perror("execve");
+    assert(false);
+  }
+
+  testing::InitGoogleTest(&argc, argv);
+  return RUN_ALL_TESTS();
+}