PartitionAlloc: use less stack when dumping stats.

base/allocator/partition_allocator/partition_alloc.cc

 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/allocator/partition_allocator/partition_alloc.h"
 
 #include <string.h>
 
 #include "base/allocator/partition_allocator/oom.h"
 #include "base/allocator/partition_allocator/spin_lock.h"
@@ skipping 1292 matching lines @@
       DCHECK(page != &PartitionRootGeneric::gSeedPage);
       PartitionDumpPageStats(stats_out, page);
     }
   }
 }
 
 void PartitionDumpStatsGeneric(PartitionRootGeneric* partition,
                                const char* partition_name,
                                bool is_light_dump,
                                PartitionStatsDumper* dumper) {
+  PartitionMemoryStats stats = {0};
+  stats.total_mmapped_bytes = partition->total_size_of_super_pages +
+                              partition->total_size_of_direct_mapped_pages;
+  stats.total_committed_bytes = partition->total_size_of_committed_pages;
+
+  size_t direct_mapped_allocations_total_size = 0;
+
+  static const size_t kMaxReportableDirectMaps = 4096;
+
+  // A heap allocation rather than on the stack to avoid stack overflows
+  // skirmishes (on Windows, in particular.)
+  uint32_t* direct_map_lengths = nullptr;
+  if (!is_light_dump)
+    direct_map_lengths = new uint32_t[kMaxReportableDirectMaps];
+
   PartitionBucketMemoryStats bucket_stats[kGenericNumBuckets];
-  static const size_t kMaxReportableDirectMaps = 4096;
-  uint32_t direct_map_lengths[kMaxReportableDirectMaps];
   size_t num_direct_mapped_allocations = 0;
-
   {
     subtle::SpinLock::Guard guard(partition->lock);
 
     for (size_t i = 0; i < kGenericNumBuckets; ++i) {
       const PartitionBucket* bucket = &partition->buckets[i];
       // Don't report the pseudo buckets that the generic allocator sets up in
       // order to preserve a fast size->bucket map (see
       // PartitionAllocGenericInit for details).
       if (!bucket->active_pages_head)
         bucket_stats[i].is_valid = false;
       else
         PartitionDumpBucketStats(&bucket_stats[i], bucket);
+      if (bucket_stats[i].is_valid) {
+        stats.total_resident_bytes += bucket_stats[i].resident_bytes;
+        stats.total_active_bytes += bucket_stats[i].active_bytes;
+        stats.total_decommittable_bytes += bucket_stats[i].decommittable_bytes;
+        stats.total_discardable_bytes += bucket_stats[i].discardable_bytes;
+      }
     }
 
-    for (PartitionDirectMapExtent* extent = partition->direct_map_list; extent;
-         extent = extent->next_extent) {
+    for (PartitionDirectMapExtent *extent = partition->direct_map_list;
+         extent && num_direct_mapped_allocations < kMaxReportableDirectMaps;
+         extent = extent->next_extent, ++num_direct_mapped_allocations) {
       DCHECK(!extent->next_extent ||
              extent->next_extent->prev_extent == extent);
-      direct_map_lengths[num_direct_mapped_allocations] =
-          extent->bucket->slot_size;
-      ++num_direct_mapped_allocations;
-      if (num_direct_mapped_allocations == kMaxReportableDirectMaps)
-        break;
+      size_t slot_size = extent->bucket->slot_size;
+      direct_mapped_allocations_total_size += slot_size;
+      if (is_light_dump)
+        continue;
+      direct_map_lengths[num_direct_mapped_allocations] = slot_size;
     }
   }
 
-  // Call |PartitionsDumpBucketStats| after collecting stats because it can try
-  // to allocate using |PartitionAllocGeneric| and it can't obtain the lock.
-  PartitionMemoryStats stats = {0};
-  stats.total_mmapped_bytes = partition->total_size_of_super_pages +
-                              partition->total_size_of_direct_mapped_pages;
-  stats.total_committed_bytes = partition->total_size_of_committed_pages;
-  for (size_t i = 0; i < kGenericNumBuckets; ++i) {
-    if (bucket_stats[i].is_valid) {
-      stats.total_resident_bytes += bucket_stats[i].resident_bytes;
-      stats.total_active_bytes += bucket_stats[i].active_bytes;
-      stats.total_decommittable_bytes += bucket_stats[i].decommittable_bytes;
-      stats.total_discardable_bytes += bucket_stats[i].discardable_bytes;
-      if (!is_light_dump)
+  if (!is_light_dump) {
+    // Call |PartitionsDumpBucketStats| after collecting stats because it can
+    // try to allocate using |PartitionAllocGeneric| and it can't obtain the
+    // lock.
+    for (size_t i = 0; i < kGenericNumBuckets; ++i) {
+      if (bucket_stats[i].is_valid)
         dumper->PartitionsDumpBucketStats(partition_name, &bucket_stats[i]);
     }
+
+    for (size_t i = 0; i < num_direct_mapped_allocations; ++i) {
+      uint32_t size = direct_map_lengths[i];
+
+      PartitionBucketMemoryStats stats;
+      memset(&stats, '\0', sizeof(stats));
+      stats.is_valid = true;
+      stats.is_direct_map = true;
+      stats.num_full_pages = 1;
+      stats.allocated_page_size = size;
+      stats.bucket_slot_size = size;
+      stats.active_bytes = size;
+      stats.resident_bytes = size;
+      dumper->PartitionsDumpBucketStats(partition_name, &stats);
+    }
+    delete[] direct_map_lengths;
   }
 
-  size_t direct_mapped_allocations_total_size = 0;
-  for (size_t i = 0; i < num_direct_mapped_allocations; ++i) {
-    uint32_t size = direct_map_lengths[i];
-    direct_mapped_allocations_total_size += size;
-    if (is_light_dump)
-      continue;
-
-    PartitionBucketMemoryStats stats;
-    memset(&stats, '\0', sizeof(stats));
-    stats.is_valid = true;
-    stats.is_direct_map = true;
-    stats.num_full_pages = 1;
-    stats.allocated_page_size = size;
-    stats.bucket_slot_size = size;
-    stats.active_bytes = size;
-    stats.resident_bytes = size;
-    dumper->PartitionsDumpBucketStats(partition_name, &stats);
-  }
   stats.total_resident_bytes += direct_mapped_allocations_total_size;
   stats.total_active_bytes += direct_mapped_allocations_total_size;
   dumper->PartitionDumpTotals(partition_name, &stats);
 }
 
 void PartitionDumpStats(PartitionRoot* partition,
                         const char* partition_name,
                         bool is_light_dump,
                         PartitionStatsDumper* dumper) {
   static const size_t kMaxReportableBuckets = 4096 / sizeof(void*);
@@ skipping 17 matching lines @@
       stats.total_decommittable_bytes += memory_stats[i].decommittable_bytes;
       stats.total_discardable_bytes += memory_stats[i].discardable_bytes;
       if (!is_light_dump)
         dumper->PartitionsDumpBucketStats(partition_name, &memory_stats[i]);
     }
   }
   dumper->PartitionDumpTotals(partition_name, &stats);
 }
 
 }  // namespace base