Revert 126020 - Experiment for updating the tcmalloc chromium branch to r144 (gperftools 2.0).

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 79 matching lines @@
 
   // 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();
 
-  // 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]);
+  // Record an allocation at 'ptr' of 'bytes' bytes.
+  // skip_count gives the number of stack frames between this call
+  // and the memory allocation function that was asked to do the allocation.
+  void RecordAlloc(const void* ptr, size_t bytes, int skip_count);
 
-  // Record an allocation at 'ptr' of 'bytes' bytes.  'stack_depth'
-  // and 'call_stack' identifying the function that requested the
-  // allocation. They can be generated using GetCallerStackTrace() above.
-  void RecordAlloc(const void* ptr, size_t bytes,
-                   int stack_depth, const void* const call_stack[]);
+  // Direct version of RecordAlloc when the caller stack to use
+  // is already known: call_stack of depth stack_depth.
+  void RecordAllocWithStack(const void* ptr, size_t bytes,
+                            int stack_depth, const void* const call_stack[]);
 
   // Record the deallocation of memory at 'ptr'.
   void RecordFree(const void* ptr);
 
   // Return true iff we have recorded an allocation at 'ptr'.
   // If yes, fill *object_size with the allocation byte size.
   bool FindAlloc(const void* ptr, size_t* object_size) const;
   // Same as FindAlloc, but fills all of *info.
   bool FindAllocDetails(const void* ptr, AllocInfo* info) const;
 
   // Return true iff "ptr" points into a recorded allocation
   // If yes, fill *object_ptr with the actual allocation address
   // and *object_size with the allocation byte size.
   // max_size specifies largest currently possible allocation size.
   bool FindInsideAlloc(const void* ptr, size_t max_size,
                        const void** object_ptr, size_t* object_size) const;
 
   // If "ptr" points to a recorded allocation and it's not marked as live
   // mark it as live and return true. Else return false.
   // All allocations start as non-live.
   bool MarkAsLive(const void* ptr);
 
   // If "ptr" points to a recorded allocation, mark it as "ignored".
   // Ignored objects are treated like other objects, except that they
   // are skipped in heap checking reports.
   void MarkAsIgnored(const void* ptr);
 
-  // Return current total (de)allocation statistics.  It doesn't contain
-  // mmap'ed regions.
+  // Return current total (de)allocation statistics.
   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);
+    allocation_->Iterate(MapArgsAllocIterator, callback);
   }
 
   // Allocation context profile data iteration callback
   typedef void (*AllocContextIterator)(const AllocContextInfo& info);
 
   // Iterate over the allocation context profile data calling "callback"
   // for every allocation context. Allocation contexts are ordered by the
   // size of allocated space.
   void IterateOrderedAllocContexts(AllocContextIterator callback) const;
 
@@ skipping 17 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.
-  void RefreshMMapData();
-
-  // Clear the internal mmap information.  Results of FillOrderedProfile and
-  // IterateOrderedAllocContexts won't contain mmap'ed memory regions after
-  // calling ClearMMapData.
-  void ClearMMapData();
-
  private:
 
   // 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
@@ skipping 57 matching lines @@
   // 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 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 filling size variables in buckets by zero.
-  inline static void ZeroBucketCountsIterator(
-      const void* ptr, AllocValue* v, HeapProfileTable* heap_profile);
-
   // Helper for IterateOrderedAllocContexts and FillOrderedProfile.
-  // Creates a sorted list of Buckets whose length is num_alloc_buckets_ +
-  // num_avaliable_mmap_buckets_.
-  // The caller is responsible for deallocating the returned list.
+  // Creates a sorted list of Buckets whose length is num_buckets_.
+  // The caller is responsible for dellocating 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 11 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_;
 
-  // Bucket hash table for malloc.
+  // Bucket hash table.
   // 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** table_;
+  int num_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_;
-
-  // Map of all currently allocated objects and mapped regions we know about.
-  AllocationMap* alloc_address_map_;
-  AllocationMap* mmap_address_map_;
+  // Map of all currently allocated objects we know about.
+  AllocationMap* allocation_;
 
   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_