[NOT TO COMMIT!] Merge Chromium-specific changes in tcmalloc thru. the original gperftools r136.

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 89 matching lines @@
              "If non-zero, dump heap profiling information once every "
              "specified number of bytes deallocated by the program "
              "since the last dump.");
 // We could also add flags that report whenever inuse_bytes changes by
 // X or -X, but there hasn't been a need for that yet, so we haven't.
 DEFINE_int64(heap_profile_inuse_interval,
              EnvToInt64("HEAP_PROFILE_INUSE_INTERVAL", 100 << 20 /*100MB*/),
              "If non-zero, dump heap profiling information whenever "
              "the high-water memory usage mark increases by the specified "
              "number of bytes.");
+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.");
 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");
@@ skipping 18 matching lines @@
 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;
+// The size is 1 << 20 in the original google-perftools.  Changed it to
+// 5 << 20 since a larger buffer is requried for deeper profiling in Chromium.
+// The buffer is allocated only when the environment variable HEAPPROFILE is
+// specified to dump heap information.
+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
 
 //----------------------------------------------------------------------
 // Profile generation
 //----------------------------------------------------------------------
 
 // 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
@@ skipping 35 matching lines @@
   RAW_DCHECK(is_on, "");
   RAW_DCHECK(!dumping, "");
 
   if (filename_prefix == NULL) return;  // we do not yet need dumping
 
   dumping = true;
 
   // Make file name
   char file_name[1000];
   dump_count++;
-  snprintf(file_name, sizeof(file_name), "%s.%04d%s",
-           filename_prefix, dump_count, HeapProfileTable::kFileExt);
+  snprintf(file_name, sizeof(file_name), "%s.%05d.%04d%s",
+           filename_prefix, getpid(), dump_count, HeapProfileTable::kFileExt);
 
   // Dump the profile
   RAW_VLOG(0, "Dumping heap profile to %s (%s)", file_name, reason);
   // We must use file routines that don't access memory, since we hold
   // a memory lock now.
   RawFD fd = RawOpenForWriting(file_name);
   if (fd == kIllegalRawFD) {
     RAW_LOG(ERROR, "Failed dumping heap profile to %s", file_name);
     dumping = false;
     return;
@@ skipping 19 matching lines @@
 //----------------------------------------------------------------------
 
 // Dump a profile after either an allocation or deallocation, if
 // the memory use has changed enough since the last dump.
 static void MaybeDumpProfileLocked() {
   if (!dumping) {
     const HeapProfileTable::Stats& total = heap_profile->total();
     const int64 inuse_bytes = total.alloc_size - total.free_size;
     bool need_to_dump = false;
     char buf[128];
+    int64 current_time = time(NULL);
     if (FLAGS_heap_profile_allocation_interval > 0 &&
         total.alloc_size >=
         last_dump_alloc + FLAGS_heap_profile_allocation_interval) {
       snprintf(buf, sizeof(buf), ("%"PRId64" MB allocated cumulatively, "
                                   "%"PRId64" MB currently in use"),
                total.alloc_size >> 20, inuse_bytes >> 20);
       need_to_dump = true;
     } else if (FLAGS_heap_profile_deallocation_interval > 0 &&
                total.free_size >=
                last_dump_free + FLAGS_heap_profile_deallocation_interval) {
       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 &&
+               current_time - last_dump_time >=
+               FLAGS_heap_profile_time_interval) {
+      snprintf(buf, sizeof(buf), "%d sec since the last dump",
+               current_time - last_dump_time);
+      need_to_dump = true;
+      last_dump_time = current_time;
     }
     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 84 matching lines @@
     // in pretty-printing of NULL as "nil".
     // TODO(maxim): instead should use a safe snprintf reimplementation
     RAW_LOG(INFO, "munmap(start=0x%"PRIxPTR", len=%"PRIuS")",
                   (uintptr_t) ptr, size);
 #ifdef TODO_REENABLE_STACK_TRACING
     DumpStackTrace(1, RawInfoStackDumper, NULL);
 #endif
   }
 }
 
-static void SbrkHook(const void* result, ptrdiff_t increment) {
+static void SbrkHook(const void* result, std::ptrdiff_t increment) {
   if (FLAGS_mmap_log) {  // log it
     RAW_LOG(INFO, "sbrk(inc=%"PRIdS") = 0x%"PRIxPTR"",
                   increment, (uintptr_t) result);
 #ifdef TODO_REENABLE_STACK_TRACING
     DumpStackTrace(1, RawInfoStackDumper, NULL);
 #endif
   }
 }
 
 //----------------------------------------------------------------------
@@ skipping 38 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;
 
   // 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 86 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;