Tracks the amount of committed vs uncommitted memory in tcmalloc's page heap's freelists

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 103 matching lines @@
   inline Span* GetDescriptor(PageID p) const {
     return reinterpret_cast<Span*>(pagemap_.get(p));
   }
 
   // Dump state to stderr
   void Dump(TCMalloc_Printer* out);
 
   // Return number of bytes allocated from system
   inline uint64_t SystemBytes() const { return system_bytes_; }
 
+  inline uint64_t CommittedBytes() const { return committed_bytes_; }
+
   // Return number of free bytes in heap
   uint64_t FreeBytes() const {
     return (static_cast<uint64_t>(free_pages_) << kPageShift);
   }
 
   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
@@ skipping 47 matching lines @@
 
   // Array mapping from span length to a doubly linked list of free spans
   SpanList free_[kMaxPages];
 
   // Number of pages kept in free lists
   uintptr_t free_pages_;
 
   // Bytes allocated from system
   uint64_t system_bytes_;
 
+  // Bytes committed, always <= system_bytes_.
+  uint64_t committed_bytes_;
+
   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);
@@ skipping 12 matching lines @@
   // Commit the span.
   void CommitSpan(Span* span);
 
   // Decommit the span.
   void DecommitSpan(Span* span);
 
   // Incrementally release some memory to the system.
   // IncrementalScavenge(n) is called whenever n pages are freed.
   void IncrementalScavenge(Length n);
 
+  // Releases all memory held in the given list's 'normal' freelist and adds
+  // it to the 'released' freelist.
+  void ReleaseFreeList(Span* list, Span* returned);
+
   // Number of pages to deallocate before doing more scavenging
   int64_t scavenge_counter_;
 
   // Index of last free list we scavenged
   int scavenge_index_;
 };
 
 }  // namespace tcmalloc
 
 #endif  // TCMALLOC_PAGE_HEAP_H_