Deep-Memory-Profiler (DMP) implementation

third_party/tcmalloc/chromium/src/heap-profiler.cc

 // Copyright (c) 2005, Google Inc.
 // All rights reserved.
 // 
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 // 
 //     * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
@@ skipping 53 matching lines @@
 #include "malloc_hook-inl.h"
 #include "tcmalloc_guard.h"
 #include <google/malloc_hook.h>
 #include <google/malloc_extension.h>
 #include "base/spinlock.h"
 #include "base/low_level_alloc.h"
 #include "base/sysinfo.h"      // for GetUniquePathFromEnv()
 #include "heap-profile-table.h"
 #include "memory_region_map.h"
 
-
 #ifndef PATH_MAX
 #ifdef MAXPATHLEN
 #define PATH_MAX        MAXPATHLEN
 #else
 #define PATH_MAX        4096         // seems conservative for max filename len!
 #endif
 #endif
 
 using STL_NAMESPACE::string;
 using STL_NAMESPACE::sort;
@@ skipping 25 matching lines @@
 DEFINE_bool(mmap_log,
             EnvToBool("HEAP_PROFILE_MMAP_LOG", false),
             "Should mmap/munmap calls be logged?");
 DEFINE_bool(mmap_profile,
             EnvToBool("HEAP_PROFILE_MMAP", false),
             "If heap-profiling is on, also profile mmap, mremap, and sbrk)");
 DEFINE_bool(only_mmap_profile,
             EnvToBool("HEAP_PROFILE_ONLY_MMAP", false),
             "If heap-profiling is on, only profile mmap, mremap, and sbrk; "
             "do not profile malloc/new/etc");
-
+#ifdef DEEP_PROFILER_ON
+DEFINE_int64(heap_profile_time_interval,
+             EnvToInt64("HEAP_PROFILE_TIME_INTERVAL", 0),
+             "If non-zero, dump heap profiling information once every "
+             "specified number of seconds since the last dump.");
+#endif
 
 //----------------------------------------------------------------------
 // Locking
 //----------------------------------------------------------------------
 
 // A pthread_mutex has way too much lock contention to be used here.
 //
 // I would like to use Mutex, but it can call malloc(),
 // which can cause us to fall into an infinite recursion.
 //
 // So we use a simple spinlock.
 static SpinLock heap_lock(SpinLock::LINKER_INITIALIZED);
 
 //----------------------------------------------------------------------
 // Simple allocator for heap profiler's internal memory
 //----------------------------------------------------------------------
 
 static LowLevelAlloc::Arena *heap_profiler_memory;
 
 static void* ProfilerMalloc(size_t bytes) {
   return LowLevelAlloc::AllocWithArena(bytes, heap_profiler_memory);
 }
 static void ProfilerFree(void* p) {
   LowLevelAlloc::Free(p);
 }
 
 // We use buffers of this size in DoGetHeapProfile.
-static const int kProfileBufferSize = 1 << 20;
-
+static const int kProfileBufferSize = 5 << 20;
 // This is a last-ditch buffer we use in DumpProfileLocked in case we
 // can't allocate more memory from ProfilerMalloc.  We expect this
 // will be used by HeapProfileEndWriter when the application has to
 // exit due to out-of-memory.  This buffer is allocated in
 // HeapProfilerStart.  Access to this must be protected by heap_lock.
 static char* global_profiler_buffer = NULL;
 
 
 //----------------------------------------------------------------------
 // Profiling control/state data
 //----------------------------------------------------------------------
 
 // Access to all of these is protected by heap_lock.
 static bool  is_on = false;           // If are on as a subsytem.
 static bool  dumping = false;         // Dumping status to prevent recursion
 static char* filename_prefix = NULL;  // Prefix used for profile file names
                                       // (NULL if no need for dumping yet)
 static int   dump_count = 0;          // How many dumps so far
 static int64 last_dump_alloc = 0;     // alloc_size when did we last dump
 static int64 last_dump_free = 0;      // free_size when did we last dump
 static int64 high_water_mark = 0;     // In-use-bytes at last high-water dump
+static int64 last_dump_time = 0;      // The time of the last dump
 
 static HeapProfileTable* heap_profile = NULL;  // the heap profile table
 
+#ifdef DEEP_PROFILER_ON
+#include "deep-memory-profiler.h"
+static DeepMemoryProfiler* deep_profiler = NULL; // deep memory profiler
+#endif
+
 //----------------------------------------------------------------------
 // Profile generation
 //----------------------------------------------------------------------
 
 enum AddOrRemove { ADD, REMOVE };
 
 // Add or remove all MMap-allocated regions to/from *heap_profile.
 // Assumes heap_lock is held.
 static void AddRemoveMMapDataLocked(AddOrRemove mode) {
   RAW_DCHECK(heap_lock.IsHeld(), "");
   if (!FLAGS_mmap_profile || !is_on) return;
   // MemoryRegionMap maintained all the data we need for all
   // mmap-like allocations, so we just use it here:
   MemoryRegionMap::LockHolder l;
+  heap_profile->MMapRecordBegin();
   for (MemoryRegionMap::RegionIterator r = MemoryRegionMap::BeginRegionLocked();
        r != MemoryRegionMap::EndRegionLocked(); ++r) {
     if (mode == ADD) {
       heap_profile->RecordAllocWithStack(
         reinterpret_cast<const void*>(r->start_addr),
         r->end_addr - r->start_addr,
         r->call_stack_depth, r->call_stack);
     } else {
       heap_profile->RecordFree(reinterpret_cast<void*>(r->start_addr));
     }
   }
+  heap_profile->MMapRecordEnd();
 }
 
 // Input must be a buffer of size at least 1MB.
 static char* DoGetHeapProfileLocked(char* buf, int buflen) {
   // We used to be smarter about estimating the required memory and
   // then capping it to 1MB and generating the profile into that.
   if (buf == NULL || buflen < 1)
     return NULL;
 
   RAW_DCHECK(heap_lock.IsHeld(), "");
   int bytes_written = 0;
   if (is_on) {
     HeapProfileTable::Stats const stats = heap_profile->total();
     (void)stats;   // avoid an unused-variable warning in non-debug mode.
     AddRemoveMMapDataLocked(ADD);
+#ifdef DEEP_PROFILER_ON
+    bytes_written = deep_profiler->FillOrderedProfile(buf, buflen - 1);
+#else
     bytes_written = heap_profile->FillOrderedProfile(buf, buflen - 1);
+#endif
     // FillOrderedProfile should not reduce the set of active mmap-ed regions,
     // hence MemoryRegionMap will let us remove everything we've added above:
     AddRemoveMMapDataLocked(REMOVE);
     RAW_DCHECK(stats.Equivalent(heap_profile->total()), "");
     // if this fails, we somehow removed by AddRemoveMMapDataLocked
     // more than we have added.
   }
   buf[bytes_written] = '\0';
   RAW_DCHECK(bytes_written == strlen(buf), "");
 
@@ skipping 78 matching lines @@
       snprintf(buf, sizeof(buf), ("%"PRId64" MB freed cumulatively, "
                                   "%"PRId64" MB currently in use"),
                total.free_size >> 20, inuse_bytes >> 20);
       need_to_dump = true;
     } else if (FLAGS_heap_profile_inuse_interval > 0 &&
                inuse_bytes >
                high_water_mark + FLAGS_heap_profile_inuse_interval) {
       snprintf(buf, sizeof(buf), "%"PRId64" MB currently in use",
                inuse_bytes >> 20);
       need_to_dump = true;
+    } else if (FLAGS_heap_profile_time_interval > 0 &&
+               time(NULL) - last_dump_time >= FLAGS_heap_profile_time_interval) {
+      snprintf(buf, sizeof(buf), "%d sec since the last dump",
+               time(NULL) - last_dump_time);
+      need_to_dump = true;
+      last_dump_time = time(NULL);
     }
     if (need_to_dump) {
       DumpProfileLocked(buf);
 
       last_dump_alloc = total.alloc_size;
       last_dump_free = total.free_size;
       if (inuse_bytes > high_water_mark)
         high_water_mark = inuse_bytes;
     }
   }
@@ skipping 140 matching lines @@
   // heap profile even if the application runs out of memory.
   global_profiler_buffer =
       reinterpret_cast<char*>(ProfilerMalloc(kProfileBufferSize));
 
   heap_profile = new(ProfilerMalloc(sizeof(HeapProfileTable)))
                    HeapProfileTable(ProfilerMalloc, ProfilerFree);
 
   last_dump_alloc = 0;
   last_dump_free = 0;
   high_water_mark = 0;
+  last_dump_time = 0;
+
+#ifdef DEEP_PROFILER_ON
+  // Initialize deep memory profiler
+  RAW_VLOG(0, "[%d] Starting a deep memory profiler", getpid());
+  deep_profiler = new(ProfilerMalloc(sizeof(DeepMemoryProfiler)))
+      DeepMemoryProfiler(heap_profile, prefix);
+#endif
 
   // We do not reset dump_count so if the user does a sequence of
   // HeapProfilerStart/HeapProfileStop, we will get a continuous
   // sequence of profiles.
 
   if (FLAGS_only_mmap_profile == false) {
     // Now set the hooks that capture new/delete and malloc/free.
     RAW_CHECK(MallocHook::AddNewHook(&NewHook), "");
     RAW_CHECK(MallocHook::AddDeleteHook(&DeleteHook), "");
   }
@@ skipping 22 matching lines @@
     RAW_CHECK(MallocHook::RemoveDeleteHook(&DeleteHook), "");
   }
   if (FLAGS_mmap_log) {
     // Restore mmap/sbrk hooks, checking that our hooks were set:
     RAW_CHECK(MallocHook::RemoveMmapHook(&MmapHook), "");
     RAW_CHECK(MallocHook::RemoveMremapHook(&MremapHook), "");
     RAW_CHECK(MallocHook::RemoveSbrkHook(&SbrkHook), "");
     RAW_CHECK(MallocHook::RemoveMunmapHook(&MunmapHook), "");
   }
 
+#ifdef DEEP_PROFILER_ON
+  // free deep memory profiler
+  deep_profiler->~DeepMemoryProfiler();
+  ProfilerFree(deep_profiler);
+  deep_profiler = NULL;
+#endif
+
   // free profile
   heap_profile->~HeapProfileTable();
   ProfilerFree(heap_profile);
   heap_profile = NULL;
 
   // free output-buffer memory
   ProfilerFree(global_profiler_buffer);
 
   // free prefix
   ProfilerFree(filename_prefix);
@@ skipping 44 matching lines @@
 
 // class used for finalization -- dumps the heap-profile at program exit
 struct HeapProfileEndWriter {
   ~HeapProfileEndWriter() { HeapProfilerDump("Exiting"); }
 };
 
 // We want to make sure tcmalloc is up and running before starting the profiler
 static const TCMallocGuard tcmalloc_initializer;
 REGISTER_MODULE_INITIALIZER(heapprofiler, HeapProfilerInit());
 static HeapProfileEndWriter heap_profile_end_writer;