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

third_party/tcmalloc/chromium/src/heap-profile-table.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 20 matching lines @@
 // Author: Sanjay Ghemawat
 //         Maxim Lifantsev (refactoring)
 //
 
 #ifndef BASE_HEAP_PROFILE_TABLE_H_
 #define BASE_HEAP_PROFILE_TABLE_H_
 
 #include "addressmap-inl.h"
 #include "base/basictypes.h"
 #include "base/logging.h"   // for RawFD
+#include "heap-profile-stats.h"
 
 #if defined(TYPE_PROFILING)
 #include <gperftools/type_profiler_map.h>
 #endif  // defined(TYPE_PROFILING)
 
 // Table to maintain a heap profile data inside,
 // i.e. the set of currently active heap memory allocations.
 // thread-unsafe and non-reentrant code:
 // each instance object must be used by one thread
 // at a time w/o self-recursion.
 //
 // TODO(maxim): add a unittest for this class.
 class HeapProfileTable {
  public:
 
   // Extension to be used for heap pforile files.
   static const char kFileExt[];
 
   // Longest stack trace we record.
   static const int kMaxStackDepth = 32;
 
   // data types ----------------------------
 
   // Profile stats.
-  struct Stats {
-    int32 allocs;      // Number of allocation calls
-    int32 frees;       // Number of free calls
-    int64 alloc_size;  // Total size of all allocated objects so far
-    int64 free_size;   // Total size of all freed objects so far
-
-    // semantic equality
-    bool Equivalent(const Stats& x) const {
-      return allocs - frees == x.allocs - x.frees  &&
-             alloc_size - free_size == x.alloc_size - x.free_size;
-    }
-  };
+  typedef HeapProfileStats Stats;
 
   // Possible marks for MarkCurrentAllocations and MarkUnmarkedAllocations. New
   // allocations are marked with UNMARKED by default.
   enum AllocationMark {
     UNMARKED = 0,
     MARK_ONE,
     MARK_TWO,
     MARK_THREE
   };
 
@@ skipping 13 matching lines @@
     int stack_depth;                // Depth of stack trace
     const void* const* call_stack;  // Stack trace
   };
 
   // Memory (de)allocator interface we'll use.
   typedef void* (*Allocator)(size_t size);
   typedef void  (*DeAllocator)(void* ptr);
 
   // interface ---------------------------
 
-  HeapProfileTable(Allocator alloc, DeAllocator dealloc);
+  HeapProfileTable(Allocator alloc, DeAllocator dealloc, bool profile_mmap);
   ~HeapProfileTable();
 
   // Collect the stack trace for the function that asked to do the
   // allocation for passing to RecordAlloc() below.
   //
   // The stack trace is stored in 'stack'. The stack depth is returned.
   //
   // 'skip_count' gives the number of stack frames between this call
   // and the memory allocation function.
   static int GetCallerStackTrace(int skip_count, void* stack[kMaxStackDepth]);
@@ skipping 41 matching lines @@
   // mmap'ed regions.
   const Stats& total() const { return total_; }
 
   // Allocation data iteration callback: gets passed object pointer and
   // fully-filled AllocInfo.
   typedef void (*AllocIterator)(const void* ptr, const AllocInfo& info);
 
   // Iterate over the allocation profile data calling "callback"
   // for every allocation.
   void IterateAllocs(AllocIterator callback) const {
-    alloc_address_map_->Iterate(MapArgsAllocIterator, callback);
+    address_map_->Iterate(MapArgsAllocIterator, callback);
   }
 
   // Callback for iterating through addresses of all allocated objects. Accepts
   // pointer to user data and object pointer.
   typedef void (*AddressIterator)(void* data, const void* ptr);
 
   // Iterate over the addresses of all allocated objects.
   void IterateAllocationAddresses(AddressIterator, void* data);
 
   // Allocation context profile data iteration callback
@@ skipping 24 matching lines @@
   // Release a previously taken snapshot.  snapshot must not
   // be used after this call.
   void ReleaseSnapshot(Snapshot* snapshot);
 
   // Return a snapshot of every non-live, non-ignored object in *this.
   // If "base" is non-NULL, skip any objects present in "base".
   // As a side-effect, clears the "live" bit on every live object in *this.
   // Caller must call ReleaseSnapshot() on result when no longer needed.
   Snapshot* NonLiveSnapshot(Snapshot* base);
 
-  // Refresh the internal mmap information from MemoryRegionMap.  Results of
-  // FillOrderedProfile and IterateOrderedAllocContexts will contain mmap'ed
-  // memory regions as at calling RefreshMMapData.
-  // 'mmap_alloc' is an allocator for an address map.  A function which calls
-  // LowLevelAlloc::AllocWithArena is expected like the constractor.
-  // 'mmap_dealloc' is a corresponding deallocator to 'mmap_alloc'.
-  // They are introduced to avoid expected memory fragmentation and bloat in
-  // an arena.  A dedicated arena for this function allows disposing whole the
-  // arena after ClearMMapData.
-  void RefreshMMapData(Allocator mmap_alloc, DeAllocator mmap_dealloc);
-
-  // Clear the internal mmap information.  Results of FillOrderedProfile and
-  // IterateOrderedAllocContexts won't contain mmap'ed memory regions after
-  // calling ClearMMapData.
-  void ClearMMapData();
-
   // Dump a list of allocations marked as "live" along with their creation
   // stack traces and sizes to a file named |file_name|. Together with
   // MarkCurrentAllocatiosn and MarkUnmarkedAllocations this can be used
   // to find objects that are created in a certain time span:
   //   1. Invoke MarkCurrentAllocations(MARK_ONE) to mark the start of the
   //      timespan.
   //   2. Perform whatever action you suspect allocates memory that is not
   //      correctly freed.
   //   3. Invoke MarkUnmarkedAllocations(MARK_TWO).
   //   4. Perform whatever action is supposed to free the memory again. New
@@ skipping 10 matching lines @@
   void DumpTypeStatistics(const char* file_name) const;
 #endif  // defined(TYPE_PROFILING)
 
  private:
   friend class DeepHeapProfile;
 
   // data types ----------------------------
 
   // Hash table bucket to hold (de)allocation stats
   // for a given allocation call stack trace.
-  struct Bucket : public Stats {
-    uintptr_t    hash;   // Hash value of the stack trace
-    int          depth;  // Depth of stack trace
-    const void** stack;  // Stack trace
-    Bucket*      next;   // Next entry in hash-table
-  };
+  typedef HeapProfileBucket Bucket;
 
   // Info stored in the address map
   struct AllocValue {
     // Access to the stack-trace bucket
     Bucket* bucket() const {
       return reinterpret_cast<Bucket*>(bucket_rep & ~uintptr_t(kMask));
     }
     // This also does set_live(false).
     void set_bucket(Bucket* b) { bucket_rep = reinterpret_cast<uintptr_t>(b); }
     size_t  bytes;   // Number of bytes in this allocation
@@ skipping 24 matching lines @@
     static const int kMask = kLive | kIgnore;
 
     uintptr_t bucket_rep;
   };
 
   // helper for FindInsideAlloc
   static size_t AllocValueSize(const AllocValue& v) { return v.bytes; }
 
   typedef AddressMap<AllocValue> AllocationMap;
 
+  // Arguments that need to be passed DumpBucketIterator callback below.
+  struct BufferArgs {
+    BufferArgs(char* buf_arg, int buflen_arg, int bufsize_arg)
+        : buf(buf_arg),
+          buflen(buflen_arg),
+          bufsize(bufsize_arg) {
+    }
+
+    char* buf;
+    int buflen;
+    int bufsize;
+
+    DISALLOW_COPY_AND_ASSIGN(BufferArgs);
+  };
+
   // Arguments that need to be passed DumpNonLiveIterator callback below.
   struct DumpArgs {
+    DumpArgs(RawFD fd_arg, Stats* profile_stats_arg)
+        : fd(fd_arg),
+          profile_stats(profile_stats_arg) {
+    }
+
     RawFD fd;  // file to write to
     Stats* profile_stats;  // stats to update (may be NULL)
-
-    DumpArgs(RawFD a, Stats* d)
-      : fd(a), profile_stats(d) { }
   };
 
   // Arguments that need to be passed DumpMarkedIterator callback below.
   struct DumpMarkedArgs {
+    DumpMarkedArgs(RawFD fd_arg, AllocationMark mark_arg)
+        : fd(fd_arg),
+          mark(mark_arg) {
+    }
+
     RawFD fd;  // file to write to.
     AllocationMark mark;  // The mark of the allocations to process.
-
-    DumpMarkedArgs(RawFD a, AllocationMark m) : fd(a), mark(m) { }
   };
 
   // Arguments that need to be passed MarkIterator callback below.
   struct MarkArgs {
+    MarkArgs(AllocationMark mark_arg, bool mark_all_arg)
+        : mark(mark_arg),
+          mark_all(mark_all_arg) {
+    }
+
     AllocationMark mark;  // The mark to put on allocations.
     bool mark_all;  // True if all allocations should be marked. Otherwise just
                     // mark unmarked allocations.
-
-    MarkArgs(AllocationMark m, bool a) : mark(m), mark_all(a) { }
   };
 
 #if defined(TYPE_PROFILING)
   struct TypeCount {
-    size_t bytes;
-    unsigned int objects;
-
     TypeCount(size_t bytes_arg, unsigned int objects_arg)
         : bytes(bytes_arg),
           objects(objects_arg) {
     }
+
+    size_t bytes;
+    unsigned int objects;
   };
 #endif  // defined(TYPE_PROFILING)
 
   struct AllocationAddressIteratorArgs {
+    AllocationAddressIteratorArgs(AddressIterator callback_arg, void* data_arg)
+        : callback(callback_arg),
+          data(data_arg) {
+    }
+
     AddressIterator callback;
     void* data;
-
-    AllocationAddressIteratorArgs(AddressIterator iterator, void* d)
-        : callback(iterator),
-          data(d) {
-    }
   };
 
   // helpers ----------------------------
 
   // Unparse bucket b and print its portion of profile dump into buf.
   // We return the amount of space in buf that we use.  We start printing
   // at buf + buflen, and promise not to go beyond buf + bufsize.
   // We do not provision for 0-terminating 'buf'.
   //
   // If profile_stats is non-NULL, we update *profile_stats by
   // counting bucket b.
   //
   // "extra" is appended to the unparsed bucket.  Typically it is empty,
   // but may be set to something like " heapprofile" for the total
   // bucket to indicate the type of the profile.
   static int UnparseBucket(const Bucket& b,
                            char* buf, int buflen, int bufsize,
                            const char* extra,
                            Stats* profile_stats);
 
-  // Deallocate a given allocation map.
-  void DeallocateAllocationMap(AllocationMap* allocation);
-
-  // Deallocate a given bucket table.
-  void DeallocateBucketTable(Bucket** table);
-
-  // Get the bucket for the caller stack trace 'key' of depth 'depth' from a
-  // bucket hash map 'table' creating the bucket if needed.  '*bucket_count'
-  // is incremented both when 'bucket_count' is not NULL and when a new
-  // bucket object is created.
-  Bucket* GetBucket(int depth, const void* const key[], Bucket** table,
-                    int* bucket_count);
+  // Get the bucket for the caller stack trace 'key' of depth 'depth'
+  // creating the bucket if needed.
+  Bucket* GetBucket(int depth, const void* const key[]);
 
   // Helper for IterateAllocs to do callback signature conversion
   // from AllocationMap::Iterate to AllocIterator.
   static void MapArgsAllocIterator(const void* ptr, AllocValue* v,
                                    AllocIterator callback) {
     AllocInfo info;
     info.object_size = v->bytes;
     info.call_stack = v->bucket()->stack;
     info.stack_depth = v->bucket()->depth;
     info.live = v->live();
     info.ignored = v->ignore();
     callback(ptr, info);
   }
 
+  // Helper to dump a bucket.
+  inline static void DumpBucketIterator(const Bucket* bucket,
+                                        BufferArgs* args);
+
   // Helper for IterateAllocationAddresses.
   inline static void AllocationAddressesIterator(
       const void* ptr,
       AllocValue* v,
       const AllocationAddressIteratorArgs& args);
 
   // Helper for MarkCurrentAllocations and MarkUnmarkedAllocations.
   inline static void MarkIterator(const void* ptr, AllocValue* v,
                                   const MarkArgs& args);
 
   // Helper for DumpNonLiveProfile to do object-granularity
   // heap profile dumping. It gets passed to AllocationMap::Iterate.
   inline static void DumpNonLiveIterator(const void* ptr, AllocValue* v,
                                          const DumpArgs& args);
 
   // Helper for DumpMarkedObjects to dump all allocations with a given mark. It
   // gets passed to AllocationMap::Iterate.
   inline static void DumpMarkedIterator(const void* ptr, AllocValue* v,
                                         const DumpMarkedArgs& args);
 
-  // Helper for filling size variables in buckets by zero.
-  inline static void ZeroBucketCountsIterator(
-      const void* ptr, AllocValue* v, HeapProfileTable* heap_profile);
-
 #if defined(TYPE_PROFILING)
   inline static void TallyTypesItererator(const void* ptr,
                                           AllocValue* value,
                                           AddressMap<TypeCount>* type_size_map);
 
   inline static void DumpTypesIterator(const void* ptr,
                                        TypeCount* size,
                                        const DumpArgs& args);
 #endif  // defined(TYPE_PROFILING)
 
   // Helper for IterateOrderedAllocContexts and FillOrderedProfile.
-  // Creates a sorted list of Buckets whose length is num_alloc_buckets_ +
-  // num_avaliable_mmap_buckets_.
+  // Creates a sorted list of Buckets whose length is num_buckets_.
   // The caller is responsible for deallocating the returned list.
   Bucket** MakeSortedBucketList() const;
 
   // Helper for TakeSnapshot.  Saves object to snapshot.
   static void AddToSnapshot(const void* ptr, AllocValue* v, Snapshot* s);
 
   // Arguments passed to AddIfNonLive
   struct AddNonLiveArgs {
     Snapshot* dest;
     Snapshot* base;
@@ skipping 12 matching lines @@
                            AllocationMap* allocations);
 
   // data ----------------------------
 
   // Memory (de)allocator that we use.
   Allocator alloc_;
   DeAllocator dealloc_;
 
   // Overall profile stats; we use only the Stats part,
   // but make it a Bucket to pass to UnparseBucket.
-  // It doesn't contain mmap'ed regions.
   Bucket total_;
 
+  bool profile_mmap_;
+
   // Bucket hash table for malloc.
   // We hand-craft one instead of using one of the pre-written
   // ones because we do not want to use malloc when operating on the table.
   // It is only few lines of code, so no big deal.
-  Bucket** alloc_table_;
-  int num_alloc_buckets_;
-
-  // Bucket hash table for mmap.
-  // This table is filled with the information from MemoryRegionMap by calling
-  // RefreshMMapData.
-  Bucket** mmap_table_;
-  int num_available_mmap_buckets_;
+  Bucket** bucket_table_;
+  int num_buckets_;
 
   // Map of all currently allocated objects and mapped regions we know about.
-  AllocationMap* alloc_address_map_;
-  AllocationMap* mmap_address_map_;
+  AllocationMap* address_map_;
 
   DISALLOW_COPY_AND_ASSIGN(HeapProfileTable);
 };
 
 class HeapProfileTable::Snapshot {
  public:
   const Stats& total() const { return total_; }
 
   // Report anything in this snapshot as a leak.
   // May use new/delete for temporary storage.
@@ skipping 37 matching lines @@
   // Helpers for sorting and generating leak reports
   struct Entry;
   struct ReportState;
   static void ReportCallback(const void* ptr, AllocValue* v, ReportState*);
   static void ReportObject(const void* ptr, AllocValue* v, char*);
 
   DISALLOW_COPY_AND_ASSIGN(Snapshot);
 };
 
 #endif  // BASE_HEAP_PROFILE_TABLE_H_