Rollback Scavenge implemetation and rely on existing functionality to free...

third_party/tcmalloc/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 30 matching lines @@
 
 // This #ifdef should almost never be set.  Set NO_TCMALLOC_SAMPLES if
 // you're porting to a system where you really can't get a stacktrace.
 #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
 
-
 namespace tcmalloc {
 
 // -------------------------------------------------------------------------
 // Map from page-id to per-page data
 // -------------------------------------------------------------------------
 
 // We use PageMap2<> for 32-bit and PageMap3<> for 64-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.
 
@@ skipping 77 matching lines @@
   // Return 0 if we have no information, or else the correct sizeclass for p.
   // Reads and writes to pagemap_cache_ do not require locking.
   // The entries are 64 bits on 64-bit hardware and 16 bits on
   // 32-bit hardware, and we don't mind raciness as long as each read of
   // an entry yields a valid entry, not a partially updated entry.
   size_t GetSizeClassIfCached(PageID p) const {
     return pagemap_cache_.GetOrDefault(p, 0);
   }
   void CacheSizeClass(PageID p, size_t cl) const { pagemap_cache_.Put(p, cl); }
 
-  // Attempt to free some free pages currently not used.
-  void Scavenge();
-
  private:
   // Allocates a big block of memory for the pagemap once we reach more than
   // 128MB
   static const size_t kPageMapBigAllocationThreshold = 128 << 20;
 
   // Minimum number of pages to fetch from system at a time.  Must be
   // significantly bigger than kBlockSize to amortize system-call
   // 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
@@ skipping 45 matching lines @@
     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);
 
-  // Commits the span.
+  // Commit the span.
   void CommitSpan(Span* span);
 
-#if DEFER_DECOMMIT
-  // Number of free committed pages that we want to keep around.
-  static const size_t kMinimumFreeCommittedPageCount = 512;  // 2M (2 ** 21) for 4K pages
-
-  // During a scavenge, we'll release up to a fraction of the free committed pages.
-#ifdef _WIN32
-  // We are slightly less aggressive in releasing memory on Windows due to performance reasons.
-  static const int kMaxScavengeAmountFactor = 3;
-#else
-  static const int kMaxScavengeAmountFactor = 2;
-#endif
-
-  // Decommits some parts from SpanList.
-  uint64_t DecommitFromSpanList(SpanList* span_list, uint64_t to_decommit);
-
-  // Decommits some parts from SpanList.
-  Length DecommitLastSpan(SpanList* span_list, Span* span);
-
-  // Number of pages kept in free lists that are still committed a.k.a. total
-  // number of pages in "normal" lists.
-  uint64_t free_committed_pages_;
-
-  // Number of pages that we commited in the last scavenge wait interval.
-  uint64_t pages_committed_since_last_scavenge_;
-#else
   // Incrementally release some memory to the system.
   // IncrementalScavenge(n) is called whenever n pages are freed.
   void IncrementalScavenge(Length n);
 
   // Number of pages to deallocate before doing more scavenging
   int64_t scavenge_counter_;
-#endif
 
   // Index of last free list we scavenged
   int scavenge_index_;
 };
 
 }  // namespace tcmalloc
 
 #endif  // TCMALLOC_PAGE_HEAP_H_