Remove tools/android/heap_profiler

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 <stddef.h>
-#include <stdlib.h>
-#include <string.h>
-#include <sys/mman.h>
-#include <unistd.h>
-#include <map>
-
-#include "testing/gtest/include/gtest/gtest.h"
-#include "tools/android/heap_profiler/heap_profiler.h"
-
-namespace {
-
-typedef void* (*AllocatorFn)(size_t);
-typedef int (*FreeFn)(void*, size_t);
-
-const size_t kSize1 = 499 * PAGE_SIZE;
-const size_t kSize2 = 503 * PAGE_SIZE;
-const size_t kSize3 = 509 * PAGE_SIZE;
-
-// 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;
-}
-
-const HeapStats* GetHeapStats() {
-  HeapStats* const* stats_ptr = reinterpret_cast<HeapStats* const*>(
-      dlsym(RTLD_DEFAULT, "heap_profiler_stats_for_tests"));
-  EXPECT_TRUE(stats_ptr != NULL);
-  const HeapStats* stats = *stats_ptr;
-  EXPECT_TRUE(stats != NULL);
-  EXPECT_EQ(HEAP_PROFILER_MAGIC_MARKER, stats->magic_start);
-  return stats;
-}
-
-bool StackTraceContains(const StacktraceEntry* s, AllocatorFn fn) {
-  // 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;
-  const uintptr_t fn_addr = reinterpret_cast<uintptr_t>(fn);
-  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, AllocatorFn fn) {
-  const HeapStats* stats = GetHeapStats();
-  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))
-      return st;
-  }
-  return NULL;
-}
-
-int DoFree(void* addr, size_t /*size, ignored.*/) {
-  free(addr);
-  return 0;
-}
-
-void TestStackTracesWithParams(AllocatorFn outer_fn,
-                               AllocatorFn inner_fn,
-                               FreeFn free_fn) {
-  const HeapStats* stats = GetHeapStats();
-
-  void* m1 = outer_fn(kSize1);
-  void* m2 = inner_fn(kSize2);
-  void* m3 = inner_fn(kSize3);
-  free_fn(m3, kSize3);
-
-  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);
-
-  const size_t total_alloc_start = stats->total_alloc_bytes;
-  const size_t num_stack_traces_start = stats->num_stack_traces;
-
-  free_fn(m1, kSize1);
-  free_fn(m2, kSize2);
-
-  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));
-}
-
-TEST(HeapProfilerIntegrationTest, TestMallocStackTraces) {
-  TestStackTracesWithParams(&MallocOuter, &MallocInner, &DoFree);
-}
-
-TEST(HeapProfilerIntegrationTest, TestMmapStackTraces) {
-  TestStackTracesWithParams(&MmapOuter, &MmapInner, &munmap);
-}
-
-// 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.
-  char* ld_preload = getenv("LD_PRELOAD");
-  if (ld_preload == NULL || strstr(ld_preload, "libheap_profiler.so") == 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();
-}