1. A small fix of Windows VM size.

third_party/tcmalloc/chromium/src/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 298 matching lines @@
   return 0;
 }
 }  // unnamed namespace
 
 // Extract interesting stats
 struct TCMallocStats {
   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 metadata_bytes;    // Bytes alloced for metadata
+  uint64_t metadata_unmapped_bytes;    // Address space reserved for metadata
+                                       // but is not committed.
   PageHeap::Stats pageheap;   // Stats from page heap
 };
 
 // Get stats into "r".  Also get per-size-class counts if class_count != NULL
 static void ExtractStats(TCMallocStats* r, uint64_t* class_count,
                          PageHeap::SmallSpanStats* small_spans,
                          PageHeap::LargeSpanStats* large_spans) {
   r->central_bytes = 0;
   r->transfer_bytes = 0;
   for (int cl = 0; cl < kNumClasses; ++cl) {
     const int length = Static::central_cache()[cl].length();
     const int tc_length = Static::central_cache()[cl].tc_length();
     const size_t cache_overhead = Static::central_cache()[cl].OverheadBytes();
     const size_t size = static_cast<uint64_t>(
         Static::sizemap()->ByteSizeForClass(cl));
     r->central_bytes += (size * length) + cache_overhead;
     r->transfer_bytes += (size * tc_length);
     if (class_count) class_count[cl] = length + tc_length;
   }
 
   // Add stats from per-thread heaps
   r->thread_bytes = 0;
   { // scope
     SpinLockHolder h(Static::pageheap_lock());
     ThreadCache::GetThreadStats(&r->thread_bytes, class_count);
     r->metadata_bytes = tcmalloc::metadata_system_bytes();
+    r->metadata_unmapped_bytes = tcmalloc::metadata_unmapped_bytes();
     r->pageheap = Static::pageheap()->stats();
     if (small_spans != NULL) {
       Static::pageheap()->GetSmallSpanStats(small_spans);
     }
     if (large_spans != NULL) {
       Static::pageheap()->GetLargeSpanStats(large_spans);
     }
   }
 }
 
 static double PagesToMiB(uint64_t pages) {
   return (pages << kPageShift) / 1048576.0;
 }
 
 // WRITE stats to "out"
 static void DumpStats(TCMalloc_Printer* out, int level) {
   TCMallocStats stats;
   uint64_t class_count[kNumClasses];
   PageHeap::SmallSpanStats small;
   PageHeap::LargeSpanStats large;
   if (level >= 2) {
     ExtractStats(&stats, class_count, &small, &large);
   } else {
     ExtractStats(&stats, NULL, NULL, NULL);
   }
 
   static const double MiB = 1048576.0;
 
+  const uint64_t physical_memory_used_by_metadata =
+      stats.metadata_bytes - stats.metadata_unmapped_bytes;
+  const uint64_t unmapped_bytes =
+      stats.pageheap.unmapped_bytes + stats.metadata_unmapped_bytes;
+
   const uint64_t virtual_memory_used = (stats.pageheap.system_bytes
                                         + stats.metadata_bytes);
-  const uint64_t physical_memory_used = (virtual_memory_used
-                                         - stats.pageheap.unmapped_bytes);
+  const uint64_t physical_memory_used = virtual_memory_used - unmapped_bytes;
   const uint64_t bytes_in_use_by_app = (physical_memory_used
-                                        - stats.metadata_bytes
+                                        - physical_memory_used_by_metadata
                                         - stats.pageheap.free_bytes
                                         - stats.central_bytes
                                         - stats.transfer_bytes
                                         - stats.thread_bytes);
 
   out->printf(
-      "WASTE: %7.1f MiB committed but not used\n"
-      "WASTE: %7.1f MiB bytes committed, %7.1f MiB bytes in use\n"
+      "WASTE:   %7.1f MiB bytes in use\n"
+      "WASTE: + %7.1f MiB committed but not used\n"
+      "WASTE:   ------------\n"
+      "WASTE: = %7.1f MiB bytes committed\n"

[jar (doing other things), 2012/06/04 04:31:28]

I think I like your formatting better... but does it add enough value to branch
away from the standard distribution?

(I'm looking at the above 4 lines only, vs the 3 lines of the existing file).

[kaiwang, 2012/06/04 18:30:52]

This WASTE part(line 391-401) is chromium only, does not exist in gperftools. :)

       "WASTE: committed/used ratio of %f\n",
+      bytes_in_use_by_app / MiB,

[jar (doing other things), 2012/06/04 04:31:28]

This probably shouldn't be moved... as it just makes merging harder.

       (stats.pageheap.committed_bytes - bytes_in_use_by_app) / MiB,
       stats.pageheap.committed_bytes / MiB,
-      bytes_in_use_by_app / MiB,
       stats.pageheap.committed_bytes / static_cast<double>(bytes_in_use_by_app)
       );
 #ifdef TCMALLOC_SMALL_BUT_SLOW
   out->printf(
       "NOTE:  SMALL MEMORY MODEL IS IN USE, PERFORMANCE MAY SUFFER.\n");
 #endif
   out->printf(
       "------------------------------------------------\n"
       "MALLOC:   %12" PRIu64 " (%7.1f MiB) Bytes in use by application\n"
-      "MALLOC: %12" PRIu64 " (%7.1f MB) Bytes committed\n"
       "MALLOC: + %12" PRIu64 " (%7.1f MiB) Bytes in page heap freelist\n"
       "MALLOC: + %12" PRIu64 " (%7.1f MiB) Bytes in central cache freelist\n"
       "MALLOC: + %12" PRIu64 " (%7.1f MiB) Bytes in transfer cache freelist\n"
       "MALLOC: + %12" PRIu64 " (%7.1f MiB) Bytes in thread cache freelists\n"
+      "MALLOC:   ------------\n"
+      "MALLOC: = %12" PRIu64 " (%7.1f MiB) Bytes committed\n"

[jar (doing other things), 2012/06/04 04:31:28]

again... I like your format better... but I'd rather make merges easier and not
move this line.

[kaiwang, 2012/06/04 18:30:52]

This single line is actually chromium code (again :). Last merging had some
mistake and put it in wrong place, so the about:tcmalloc become nonsense:
https://code.google.com/p/chromium/issues/detail?id=130840

       "MALLOC: + %12" PRIu64 " (%7.1f MiB) Bytes in malloc metadata\n"
       "MALLOC:   ------------\n"
       "MALLOC: = %12" PRIu64 " (%7.1f MiB) Actual memory used (physical + swap)\n"
       "MALLOC: + %12" PRIu64 " (%7.1f MiB) Bytes released to OS (aka unmapped)\n"
       "MALLOC:   ------------\n"
       "MALLOC: = %12" PRIu64 " (%7.1f MiB) Virtual address space used\n"
       "MALLOC:\n"
       "MALLOC:   %12" PRIu64 "              Spans in use\n"
       "MALLOC:   %12" PRIu64 "              Thread heaps in use\n"
       "MALLOC:   %12" PRIu64 "              Tcmalloc page size\n"
       "------------------------------------------------\n"
       "Call ReleaseFreeMemory() to release freelist memory to the OS"
       " (via madvise()).\n"
       "Bytes released to the OS take up virtual address space"
       " but no physical memory.\n",
       bytes_in_use_by_app, bytes_in_use_by_app / MiB,
-      stats.pageheap.committed_bytes, stats.pageheap.committed_bytes / MiB,
       stats.pageheap.free_bytes, stats.pageheap.free_bytes / MiB,
       stats.central_bytes, stats.central_bytes / MiB,
       stats.transfer_bytes, stats.transfer_bytes / MiB,
       stats.thread_bytes, stats.thread_bytes / MiB,
-      stats.metadata_bytes, stats.metadata_bytes / MiB,
+      stats.pageheap.committed_bytes, stats.pageheap.committed_bytes / MiB,
+      physical_memory_used_by_metadata , physical_memory_used_by_metadata / MiB,
       physical_memory_used, physical_memory_used / MiB,
-      stats.pageheap.unmapped_bytes, stats.pageheap.unmapped_bytes / MiB,
+      unmapped_bytes, unmapped_bytes / MiB,
       virtual_memory_used, virtual_memory_used / MiB,
       uint64_t(Static::span_allocator()->inuse()),
       uint64_t(ThreadCache::HeapsInUse()),
       uint64_t(kPageSize));
 
   if (level >= 2) {
     out->printf("------------------------------------------------\n");
     out->printf("Size class breakdown\n");
     out->printf("------------------------------------------------\n");
     uint64_t cumulative = 0;
@@ skipping 1417 matching lines @@
   *mark = ~allocated_mark;  //  Distinctively not allocated.
 }
 
 static void MarkAllocatedRegion(void* ptr) {
   if (ptr == NULL) return;
   MarkType* mark = GetMarkLocation(ptr);
   *mark = GetMarkValue(ptr, mark);
 }
 
 #endif  // TCMALLOC_VALIDATION