Count m(un)map for each stacktrace in MemoryRegionMap instead of HeapProfileTable.

third_party/tcmalloc/chromium/src/memory_region_map.h

 /* Copyright (c) 2006, 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 27 matching lines @@
 
 #ifdef HAVE_PTHREAD
 #include <pthread.h>
 #endif
 #include <stddef.h>
 #include <set>
 #include "base/stl_allocator.h"
 #include "base/spinlock.h"
 #include "base/thread_annotations.h"
 #include "base/low_level_alloc.h"
+#include "heap-profile-stats.h"
 
 // TODO(maxim): add a unittest:
 //  execute a bunch of mmaps and compare memory map what strace logs
 //  execute a bunch of mmap/munmup and compare memory map with
 //  own accounting of what those mmaps generated
 
 // Thread-safe class to collect and query the map of all memory regions
 // in a process that have been created with mmap, munmap, mremap, sbrk.
 // For each memory region, we keep track of (and provide to users)
 // the stack trace that allocated that memory region.
 // The recorded stack trace depth is bounded by
 // a user-supplied max_stack_depth parameter of Init().
 // After initialization with Init()
 // (which can happened even before global object constructor execution)
 // we collect the map by installing and monitoring MallocHook-s
 // to mmap, munmap, mremap, sbrk.
 // At any time one can query this map via provided interface.
 // For more details on the design of MemoryRegionMap
 // see the comment at the top of our .cc file.
 class MemoryRegionMap {
  private:
   // Max call stack recording depth supported by Init().  Set it to be
   // high enough for all our clients.  Note: we do not define storage
   // for this (doing that requires special handling in windows), so
   // don't take the address of it!
   static const int kMaxStackDepth = 32;
 
+  static const int kHashTableSize = 179999;
+
  public:
   // interface ================================================================
 
   // Every client of MemoryRegionMap must call Init() before first use,
   // and Shutdown() after last use.  This allows us to reference count
   // this (singleton) class properly.  MemoryRegionMap assumes it's the
   // only client of MallocHooks, so a client can only register other
   // MallocHooks after calling Init() and must unregister them before
   // calling Shutdown().
 
   // Initialize this module to record memory allocation stack traces.
   // Stack traces that have more than "max_stack_depth" frames
   // are automatically shrunk to "max_stack_depth" when they are recorded.
   // Init() can be called more than once w/o harm, largest max_stack_depth
   // will be the effective one.
   // It will install mmap, munmap, mremap, sbrk hooks
   // and initialize arena_ and our hook and locks, hence one can use
   // MemoryRegionMap::Lock()/Unlock() to manage the locks.
   // Uses Lock/Unlock inside.
-  static void Init(int max_stack_depth);
+  static void Init(int max_stack_depth, bool use_buckets);
 
   // Try to shutdown this module undoing what Init() did.
   // Returns true iff could do full shutdown (or it was not attempted).
   // Full shutdown is attempted when the number of Shutdown() calls equals
   // the number of Init() calls.
   static bool Shutdown();
 
+  static bool IsWorking();
+
   // Locks to protect our internal data structures.
   // These also protect use of arena_ if our Init() has been done.
   // The lock is recursive.
   static void Lock() EXCLUSIVE_LOCK_FUNCTION(lock_);
   static void Unlock() UNLOCK_FUNCTION(lock_);
 
   // Returns true when the lock is held by this thread (for use in RAW_CHECK-s).
   static bool LockIsHeld();
 
   // Locker object that acquires the MemoryRegionMap::Lock
   // for the duration of its lifetime (a C++ scope).
   class LockHolder {
    public:
     LockHolder() { Lock(); }
     ~LockHolder() { Unlock(); }
    private:
     DISALLOW_COPY_AND_ASSIGN(LockHolder);
   };
 
+  // Profile stats.
+  typedef HeapProfileStats::Stats Stats;
+  typedef HeapProfileStats::Bucket Bucket;
+
   // A memory region that we know about through malloc_hook-s.
   // This is essentially an interface through which MemoryRegionMap
   // exports the collected data to its clients.  Thread-compatible.
   struct Region {
     uintptr_t start_addr;  // region start address
     uintptr_t end_addr;  // region end address
     int call_stack_depth;  // number of caller stack frames that we saved
     const void* call_stack[kMaxStackDepth];  // caller address stack array
                                              // filled to call_stack_depth size
     bool is_stack;  // does this region contain a thread's stack:
@@ skipping 76 matching lines @@
   // Returns success. Uses Lock/Unlock inside.
   static bool FindRegion(uintptr_t addr, Region* result);
 
   // Find the region that contains stack_top, mark that region as
   // a stack region, and write its data into *result if found,
   // in which case *result gets filled so that it stays fully functional
   // even when the underlying region gets removed from MemoryRegionMap.
   // Returns success. Uses Lock/Unlock inside.
   static bool FindAndMarkStackRegion(uintptr_t stack_top, Region* result);
 
+  template<class Type>
+  static void IterateBuckets(void (*callback)(const Bucket*, Type), Type arg);
+
+  static Bucket* GetBucket(int depth, const void* const key[]);
+
  private:  // our internal types ==============================================
 
   // Region comparator for sorting with STL
   struct RegionCmp {
     bool operator()(const Region& x, const Region& y) const {
       return x.end_addr < y.end_addr;
     }
   };
 
   // We allocate STL objects in our own arena.
@@ skipping 61 matching lines @@
   // Recursion count for the recursive lock.
   static int recursion_count_;
   // The thread id of the thread that's inside the recursive lock.
   static pthread_t lock_owner_tid_;
 
   // Total size of all mapped pages so far
   static int64 map_size_;
   // Total size of all unmapped pages so far
   static int64 unmap_size_;
 
+  // Bucket hash table.
+  static Bucket** bucket_table_;
+  static int num_buckets_;
+
+  // Number of unprocessed bucket inserts.
+  static int saved_buckets_count_;
+
+  // Unprocessed inserts (must be big enough to hold all mmaps that can be
+  // caused by a GetBucket call).
+  // Bucket has no constructor, so that c-tor execution does not interfere
+  // with the any-time use of the static memory behind saved_buckets.
+  static Bucket saved_buckets_[20];
+
+  static const void* saved_buckets_keys_[20][kMaxStackDepth];
+
   // helpers ==================================================================
 
   // Helper for FindRegion and FindAndMarkStackRegion:
   // returns the region covering 'addr' or NULL; assumes our lock_ is held.
   static const Region* DoFindRegionLocked(uintptr_t addr);
 
   // Verifying wrapper around regions_->insert(region)
   // To be called to do InsertRegionLocked's work only!
   inline static void DoInsertRegionLocked(const Region& region);
   // Handle regions saved by InsertRegionLocked into a tmp static array
   // by calling insert_func on them.
   inline static void HandleSavedRegionsLocked(
                        void (*insert_func)(const Region& region));
+
+  inline static void HandleSavedBucketsLocked();
+
   // Wrapper around DoInsertRegionLocked
   // that handles the case of recursive allocator calls.
   inline static void InsertRegionLocked(const Region& region);
 
   // Record addition of a memory region at address "start" of size "size"
   // (called from our mmap/mremap/sbrk hooks).
   static void RecordRegionAddition(const void* start, size_t size);
   // Record deletion of a memory region at address "start" of size "size"
   // (called from our munmap/mremap/sbrk hooks).
   static void RecordRegionRemoval(const void* start, size_t size);
 
   // Hooks for MallocHook
   static void MmapHook(const void* result,
                        const void* start, size_t size,
                        int prot, int flags,
                        int fd, off_t offset);
   static void MunmapHook(const void* ptr, size_t size);
   static void MremapHook(const void* result, const void* old_addr,
                          size_t old_size, size_t new_size, int flags,
                          const void* new_addr);
   static void SbrkHook(const void* result, ptrdiff_t increment);
 
   // Log all memory regions; Useful for debugging only.
   // Assumes Lock() is held
   static void LogAllLocked();
 
   DISALLOW_COPY_AND_ASSIGN(MemoryRegionMap);
 };
 
+template <class Type>
+void MemoryRegionMap::IterateBuckets(
+    void (*callback)(const Bucket*, Type), Type arg) {
+  for (int b = 0; b < kHashTableSize; b++) {
+    for (Bucket* x = bucket_table_[b]; x != 0; x = x->next) {

[Alexander Potapenko, 2013/03/07 06:08:25]

x != NULL this is.

[Dai Mikurube (NOT FULLTIME), 2013/03/07 12:32:16]

Done.

+      callback(x, arg);
+    }
+  }
+}
+
 #endif  // BASE_MEMORY_REGION_MAP_H_