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

third_party/tcmalloc/tcmalloc.cc

 // Copyright (c) 2005, 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 349 matching lines @@
 
 size_t InvalidGetAllocatedSize(void* ptr) {
   CRASH("Attempt to get the size of an invalid pointer: %p\n", ptr);
   return 0;
 }
 }  // unnamed namespace
 
 // Extract interesting stats
 struct TCMallocStats {
   uint64_t system_bytes;        // Bytes alloced from system
+  uint64_t committed_bytes;     // Bytes alloced and committed from system
   uint64_t thread_bytes;        // Bytes in thread caches
   uint64_t central_bytes;       // Bytes in central cache
   uint64_t transfer_bytes;      // Bytes in central transfer cache
   uint64_t pageheap_bytes;      // Bytes in page heap
   uint64_t metadata_bytes;      // Bytes alloced for metadata
 };
 
 // Get stats into "r".  Also get per-size-class counts if class_count != NULL
 static void ExtractStats(TCMallocStats* r, uint64_t* class_count) {
   r->central_bytes = 0;
@@ skipping 11 matching lines @@
   // Add stats from per-thread heaps
   r->thread_bytes = 0;
   { // scope
     SpinLockHolder h(Static::pageheap_lock());
     ThreadCache::GetThreadStats(&r->thread_bytes, class_count);
   }
 
   { //scope
     SpinLockHolder h(Static::pageheap_lock());
     r->system_bytes = Static::pageheap()->SystemBytes();
+    r->committed_bytes = Static::pageheap()->CommittedBytes();
     r->metadata_bytes = tcmalloc::metadata_system_bytes();
     r->pageheap_bytes = Static::pageheap()->FreeBytes();
   }
 }
 
 // WRITE stats to "out"
 static void DumpStats(TCMalloc_Printer* out, int level) {
   TCMallocStats stats;
   uint64_t class_count[kNumClasses];
   ExtractStats(&stats, (level >= 2 ? class_count : NULL));
 
   static const double MB = 1048576.0;
 
+  const uint64_t bytes_in_use = stats.system_bytes
+                                - stats.pageheap_bytes
+                                - stats.central_bytes
+                                - stats.transfer_bytes
+                                - stats.thread_bytes;
+
+  out->printf("WASTE: %7.1f MB committed but not used\n"
+              "WASTE: %7.1f MB bytes committed, %7.1f MB bytes in use\n"
+              "WASTE: committed/used ratio of %f\n",
+              (stats.committed_bytes - bytes_in_use) / MB,
+              stats.committed_bytes / MB,
+              bytes_in_use / MB,
+              stats.committed_bytes / static_cast<double>(bytes_in_use));
+
   if (level >= 2) {
     out->printf("------------------------------------------------\n");
     uint64_t cumulative = 0;
     for (int cl = 0; cl < kNumClasses; ++cl) {
       if (class_count[cl] > 0) {
         uint64_t class_bytes =
             class_count[cl] * Static::sizemap()->ByteSizeForClass(cl);
         cumulative += class_bytes;
         out->printf("class %3d [ %8" PRIuS " bytes ] : "
                 "%8" PRIu64 " objs; %5.1f MB; %5.1f cum MB\n",
                 cl, Static::sizemap()->ByteSizeForClass(cl),
                 class_count[cl],
                 class_bytes / MB,
                 cumulative / MB);
       }
     }
 
     SpinLockHolder h(Static::pageheap_lock());
     Static::pageheap()->Dump(out);
 
     out->printf("------------------------------------------------\n");
     DumpSystemAllocatorStats(out);
   }
 
-  const uint64_t bytes_in_use = stats.system_bytes
-                                - stats.pageheap_bytes
-                                - stats.central_bytes
-                                - stats.transfer_bytes
-                                - stats.thread_bytes;
-
   out->printf("------------------------------------------------\n"
               "MALLOC: %12" PRIu64 " (%7.1f MB) Heap size\n"
+              "MALLOC: %12" PRIu64 " (%7.1f MB) Bytes committed\n"
               "MALLOC: %12" PRIu64 " (%7.1f MB) Bytes in use by application\n"
               "MALLOC: %12" PRIu64 " (%7.1f MB) Bytes free in page heap\n"
               "MALLOC: %12" PRIu64 " (%7.1f MB) Bytes free in central cache\n"
               "MALLOC: %12" PRIu64 " (%7.1f MB) Bytes free in transfer cache\n"
               "MALLOC: %12" PRIu64 " (%7.1f MB) Bytes free in thread caches\n"
               "MALLOC: %12" PRIu64 "              Spans in use\n"
               "MALLOC: %12" PRIu64 "              Thread heaps in use\n"
               "MALLOC: %12" PRIu64 " (%7.1f MB) Metadata allocated\n"
               "------------------------------------------------\n",
               stats.system_bytes, stats.system_bytes / MB,
+              stats.committed_bytes, stats.committed_bytes / MB,
               bytes_in_use, bytes_in_use / MB,
               stats.pageheap_bytes, stats.pageheap_bytes / MB,
               stats.central_bytes, stats.central_bytes / MB,
               stats.transfer_bytes, stats.transfer_bytes / MB,
               stats.thread_bytes, stats.thread_bytes / MB,
               uint64_t(Static::span_allocator()->inuse()),
               uint64_t(ThreadCache::HeapsInUse()),
               stats.metadata_bytes, stats.metadata_bytes / MB);
 }
 
@@ skipping 98 matching lines @@
       return true;
     }
 
     if (strcmp(name, "generic.heap_size") == 0) {
       TCMallocStats stats;
       ExtractStats(&stats, NULL);
       *value = stats.system_bytes;
       return true;
     }
 
+    if (strcmp(name, "generic.committed_bytes") == 0) {
+      TCMallocStats stats;
+      ExtractStats(&stats, NULL);
+      *value = Static::pageheap()->CommittedBytes();
+      return true;
+    }
+
     if (strcmp(name, "tcmalloc.slack_bytes") == 0) {
       // We assume that bytes in the page heap are not fragmented too
       // badly, and are therefore available for allocation.
       SpinLockHolder l(Static::pageheap_lock());
       *value = Static::pageheap()->FreeBytes();
       return true;
     }
 
     if (strcmp(name, "tcmalloc.max_total_thread_cache_bytes") == 0) {
       SpinLockHolder l(Static::pageheap_lock());
@@ skipping 700 matching lines @@
 static void *MemalignOverride(size_t align, size_t size, const void *caller)
     __THROW ATTRIBUTE_SECTION(google_malloc);
 
 static void *MemalignOverride(size_t align, size_t size, const void *caller)
     __THROW {
   void* result = do_memalign(align, size);
   MallocHook::InvokeNewHook(result, size);
   return result;
 }
 void *(*__memalign_hook)(size_t, size_t, const void *) = MemalignOverride;