[NOT TO COMMIT!] Replace third_party/tcmalloc/chromium with tcmalloc r136 (the latest).

third_party/tcmalloc/chromium/src/page_heap.h

 // Copyright (c) 2008, 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 46 matching lines @@
 // you're porting to a system where you really can't get a stacktrace.
 // Because we control the definition of GetStackTrace, all clients of
 // GetStackTrace should #include us rather than stacktrace.h.
 #ifdef NO_TCMALLOC_SAMPLES
   // We use #define so code compiles even if you #include stacktrace.h somehow.
 # define GetStackTrace(stack, depth, skip)  (0)
 #else
 # include <google/stacktrace.h>
 #endif
 
-class TCMalloc_Printer;
 namespace base {
 struct MallocRange;
 }
 
 namespace tcmalloc {
 
 // -------------------------------------------------------------------------
 // Map from page-id to per-page data
 // -------------------------------------------------------------------------
 
 // We use PageMap2<> for 32-bit and PageMap3<> for 64-bit machines.
-// ...except...
-// On Windows, we use TCMalloc_PageMap1_LazyCommit<> for 32-bit machines.
 // We also use a simple one-level cache for hot PageID-to-sizeclass mappings,
 // because sometimes the sizeclass is all the information we need.
 
 // Selector class -- general selector uses 3-level map
 template <int BITS> class MapSelector {
  public:
   typedef TCMalloc_PageMap3<BITS-kPageShift> Type;
   typedef PackedCache<BITS-kPageShift, uint64_t> CacheType;
 };
 
 // A two-level map for 32-bit machines
 template <> class MapSelector<32> {
  public:
-#ifdef WIN32
-// A flat map for 32-bit machines (with lazy commit of memory).
-  typedef TCMalloc_PageMap1_LazyCommit<32-kPageShift> Type;
-#else
-  // A two-level map for 32-bit machines
   typedef TCMalloc_PageMap2<32-kPageShift> Type;
-#endif
   typedef PackedCache<32-kPageShift, uint16_t> CacheType;
 };
 
 // -------------------------------------------------------------------------
 // Page-level allocator
 //  * Eager coalescing
 //
 // Heap for page-level allocation.  We allow allocating and freeing a
 // contiguous runs of pages (called a "span").
 // -------------------------------------------------------------------------
@@ skipping 27 matching lines @@
   // REQUIRES: span->location == IN_USE
   // REQUIRES: span->sizeclass == 0
   Span* Split(Span* span, Length n);
 
   // Return the descriptor for the specified page.  Returns NULL if
   // this PageID was not allocated previously.
   inline Span* GetDescriptor(PageID p) const {
     return reinterpret_cast<Span*>(pagemap_.get(p));
   }
 
-  // Dump state to stderr
-  void Dump(TCMalloc_Printer* out);
-
   // If this page heap is managing a range with starting page # >= start,
   // store info about the range in *r and return true.  Else return false.
   bool GetNextRange(PageID start, base::MallocRange* r);
 
   // Page heap statistics
   struct Stats {
     Stats() : system_bytes(0), free_bytes(0), unmapped_bytes(0) {}
     uint64_t system_bytes;    // Total bytes allocated from system
     uint64_t free_bytes;      // Total bytes on normal freelists
     uint64_t unmapped_bytes;  // Total bytes on returned freelists
-    uint64_t committed_bytes;  // Bytes committed, always <= system_bytes_.
-
   };
   inline Stats stats() const { return stats_; }
-  void GetClassSizes(int64 class_sizes_normal[kMaxPages],
-                     int64 class_sizes_returned[kMaxPages],
-                     int64* normal_pages_in_spans,
-                     int64* returned_pages_in_spans);
+
+  struct SmallSpanStats {
+    // For each free list of small spans, the length (in spans) of the
+    // normal and returned free lists for that size.
+    int64 normal_length[kMaxPages];
+    int64 returned_length[kMaxPages];
+  };
+  void GetSmallSpanStats(SmallSpanStats* result);
+
+  // Stats for free large spans (i.e., spans with more than kMaxPages pages).
+  struct LargeSpanStats {
+    int64 spans;           // Number of such spans
+    int64 normal_pages;    // Combined page length of normal large spans
+    int64 returned_pages;  // Combined page length of unmapped spans
+  };
+  void GetLargeSpanStats(LargeSpanStats* result);
 
   bool Check();
   // Like Check() but does some more comprehensive checking.
   bool CheckExpensive();
   bool CheckList(Span* list, Length min_pages, Length max_pages,
                  int freelist);  // ON_NORMAL_FREELIST or ON_RETURNED_FREELIST
 
   // Try to release at least num_pages for reuse by the OS.  Returns
   // the actual number of pages released, which may be less than
   // num_pages if there weren't enough pages to release. The result
@@ skipping 22 matching lines @@
   // overhead, and also to reduce external fragementation.  Also, we
   // should keep this value big because various incarnations of Linux
   // have small limits on the number of mmap() regions per
   // address-space.
   // REQUIRED: kMinSystemAlloc <= kMaxPages;
   static const int kMinSystemAlloc = kMaxPages;
 
   // Never delay scavenging for more than the following number of
   // deallocated pages.  With 4K pages, this comes to 4GB of
   // deallocation.
-  // Chrome:  Changed to 64MB
-  static const int kMaxReleaseDelay = 1 << 14;
+  static const int kMaxReleaseDelay = 1 << 20;
 
   // If there is nothing to release, wait for so many pages before
   // scavenging again.  With 4K pages, this comes to 1GB of memory.
-  // Chrome:  Changed to 16MB
-  static const int kDefaultReleaseDelay = 1 << 12;
+  static const int kDefaultReleaseDelay = 1 << 18;
 
   // Pick the appropriate map and cache types based on pointer size
   typedef MapSelector<kAddressBits>::Type PageMap;
   typedef MapSelector<kAddressBits>::CacheType PageMapCache;
   PageMap pagemap_;
   mutable PageMapCache pagemap_cache_;
 
   // We segregate spans of a given size into two circular linked
   // lists: one for normal spans, and one for spans whose memory
   // has been returned to the system.
   struct SpanList {
     Span        normal;
     Span        returned;
   };
 
   // List of free spans of length >= kMaxPages
   SpanList large_;
 
   // Array mapping from span length to a doubly linked list of free spans
   SpanList free_[kMaxPages];
 
   // Statistics on system, free, and unmapped bytes
   Stats stats_;
+
   Span* SearchFreeAndLargeLists(Length n);
 
   bool GrowHeap(Length n);
 
   // REQUIRES: span->length >= n
   // REQUIRES: span->location != IN_USE
   // Remove span from its free list, and move any leftover part of
   // span into appropriate free lists.  Also update "span" to have
   // length exactly "n" and mark it as non-free so it can be returned
   // to the client.  After all that, decrease free_pages_ by n and
   // return span.
   Span* Carve(Span* span, Length n);
 
   void RecordSpan(Span* span) {
     pagemap_.set(span->start, span);
     if (span->length > 1) {
       pagemap_.set(span->start + span->length - 1, span);
     }
   }
 
   // Allocate a large span of length == n.  If successful, returns a
   // span of exactly the specified length.  Else, returns NULL.
   Span* AllocLarge(Length n);
 
   // Coalesce span with neighboring spans if possible, prepend to
   // appropriate free list, and adjust stats.
   void MergeIntoFreeList(Span* span);
 
-  // Commit the span.
-  void CommitSpan(Span* span);
-
-  // Decommit the span.
-  void DecommitSpan(Span* span);
-
   // Prepends span to appropriate free list, and adjusts stats.
   void PrependToFreeList(Span* span);
 
   // Removes span from its free list, and adjust stats.
   void RemoveFromFreeList(Span* span);
 
   // Incrementally release some memory to the system.
   // IncrementalScavenge(n) is called whenever n pages are freed.
   void IncrementalScavenge(Length n);
 
   // Release the last span on the normal portion of this list.
   // Return the length of that span.
   Length ReleaseLastNormalSpan(SpanList* slist);
 
 
   // Number of pages to deallocate before doing more scavenging
   int64_t scavenge_counter_;
 
   // Index of last free list where we released memory to the OS.
   int release_index_;
 };
 
 }  // namespace tcmalloc
 
 #ifdef _MSC_VER
 #pragma warning(pop)
 #endif
 
 #endif  // TCMALLOC_PAGE_HEAP_H_