[NOT TO COMMIT!] r109: Diff of the current tcmalloc from the original google-perftools r109.

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 58 matching lines @@
 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 40 matching lines @@
   // 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);
 
   bool Check();
   // Like Check() but does some more comprehensive checking.
   bool CheckExpensive();
@@ skipping 28 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.
-  static const int kMaxReleaseDelay = 1 << 20;
+  // Chrome:  Changed to 64MB
+  static const int kMaxReleaseDelay = 1 << 14;
 
   // If there is nothing to release, wait for so many pages before
   // scavenging again.  With 4K pages, this comes to 1GB of memory.
-  static const int kDefaultReleaseDelay = 1 << 18;
+  // Chrome:  Changed to 16MB
+  static const int kDefaultReleaseDelay = 1 << 12;
 
   // 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_