[Sanitizers] Add more details to ASan allocator stats report.

[alekseyshl]

Summary

.

[cryptoad]

LGTM

lib/asan/asan_memory_profile.cc

 }
 
 static void MemoryProfileCB(const SuspendedThreadsList &suspended_threads_list,
                             void *argument) {
   HeapProfile hp;
   __lsan::ForEachChunk(ChunkCallback, &hp);
   uptr *Arg = reinterpret_cast<uptr*>(argument);
   hp.Print(Arg[0], Arg[1]);
+
+  if (Verbosity())
+    __asan_print_accumulated_stats();
 }
 
 }  // namespace __asan
 
 #endif  // CAN_SANITIZE_LEAKS
 
 extern "C" {
 SANITIZER_INTERFACE_ATTRIBUTE

lib/sanitizer_common/sanitizer_allocator_primary64.h

public:
 
   void PrintStats(uptr class_id, uptr rss) {
     RegionInfo *region = GetRegionInfo(class_id);
     if (region->mapped_user == 0) return;
     uptr in_use = region->stats.n_allocated - region->stats.n_freed;
     uptr avail_chunks = region->allocated_user / ClassIdToSize(class_id);
     Printf(
         "%s %02zd (%6zd): mapped: %6zdK allocs: %7zd frees: %7zd inuse: %6zd "
-        "num_freed_chunks %7zd avail: %6zd rss: %6zdK releases: %6zd\n",
+        "num_freed_chunks %7zd avail: %6zd rss: %6zdK releases: %6zd "
+        "last released: %6zdK region: 0x%zx\n",
         region->exhausted ? "F" : " ", class_id, ClassIdToSize(class_id),
         region->mapped_user >> 10, region->stats.n_allocated,
         region->stats.n_freed, in_use, region->num_freed_chunks, avail_chunks,
-        rss >> 10, region->rtoi.num_releases);
+        rss >> 10, region->rtoi.num_releases,
+        region->rtoi.last_released_bytes >> 10,
+        SpaceBeg() + kRegionSize * class_id);
   }
 
   void PrintStats() {
     uptr total_mapped = 0;
     uptr n_allocated = 0;
     uptr n_freed = 0;
     for (uptr class_id = 1; class_id < kNumClasses; class_id++) {
       RegionInfo *region = GetRegionInfo(class_id);
struct Stats {
     uptr n_allocated;
     uptr n_freed;
   };
 
   struct ReleaseToOsInfo {
     uptr n_freed_at_last_release;
     uptr num_releases;
     u64 last_release_at_ns;
+    u64 last_released_bytes;
   };
 
   struct RegionInfo {
     BlockingMutex mutex;
     uptr num_freed_chunks;  // Number of elements in the freearray.
     uptr mapped_free_array;  // Bytes mapped for freearray.
     uptr allocated_user;  // Bytes allocated for user memory.
     uptr allocated_meta;  // Bytes allocated for metadata.
NOINLINE bool PopulateFreeArray(AllocatorStats *stat, uptr class_id,
     return true;
   }
 
   class MemoryMapper {
    public:
     MemoryMapper(const ThisT& base_allocator, uptr class_id)
         : allocator(base_allocator),
           region_base(base_allocator.GetRegionBeginBySizeClass(class_id)),
-          released_ranges_count(0) {
+          released_ranges_count(0),
+          released_bytes(0) {
     }
 
     uptr GetReleasedRangesCount() const {
       return released_ranges_count;
     }
 
+    uptr GetReleasedBytes() const {
+      return released_bytes;
+    }
+
     uptr MapPackedCounterArrayBuffer(uptr buffer_size) {
       // TODO(alekseyshl): The idea to explore is to check if we have enough
       // space between num_freed_chunks*sizeof(CompactPtrT) and
       // mapped_free_array to fit buffer_size bytes and use that space instead
       // of mapping a temporary one.
       return reinterpret_cast<uptr>(
           MmapOrDieOnFatalError(buffer_size, "ReleaseToOSPageCounters"));
     }
 
     void UnmapPackedCounterArrayBuffer(uptr buffer, uptr buffer_size) {
       UnmapOrDie(reinterpret_cast<void *>(buffer), buffer_size);
     }
 
     // Releases [from, to) range of pages back to OS.
     void ReleasePageRangeToOS(CompactPtrT from, CompactPtrT to) {
-      ReleaseMemoryPagesToOS(
-          allocator.CompactPtrToPointer(region_base, from),
-          allocator.CompactPtrToPointer(region_base, to));
+      const uptr from_page = allocator.CompactPtrToPointer(region_base, from);
+      const uptr to_page = allocator.CompactPtrToPointer(region_base, to);
+      ReleaseMemoryPagesToOS(from_page, to_page);
       released_ranges_count++;
+      released_bytes += to_page - from_page;
     }
 
    private:
     const ThisT& allocator;
     const uptr region_base;
     uptr released_ranges_count;
+    uptr released_bytes;
   };
 
   // Attempts to release RAM occupied by freed chunks back to OS. The region is
   // expected to be locked.
   void MaybeReleaseToOS(uptr class_id) {
     RegionInfo *region = GetRegionInfo(class_id);
     const uptr chunk_size = ClassIdToSize(class_id);
     const uptr page_size = GetPageSizeCached();
void MaybeReleaseToOS(uptr class_id) {
     ReleaseFreeMemoryToOS<MemoryMapper>(
         GetFreeArray(GetRegionBeginBySizeClass(class_id)), n, chunk_size,
         RoundUpTo(region->allocated_user, page_size) / page_size,
         &memory_mapper);
 
     if (memory_mapper.GetReleasedRangesCount() > 0) {
       region->rtoi.n_freed_at_last_release = region->stats.n_freed;
       region->rtoi.num_releases += memory_mapper.GetReleasedRangesCount();
+      region->rtoi.last_released_bytes = memory_mapper.GetReleasedBytes();
     }
     region->rtoi.last_release_at_ns = NanoTime();
   }
 };