Add configurable limit to allocations in heap profiler.

base/trace_event/heap_profiler_heap_dump_writer.cc

Index: base/trace_event/heap_profiler_heap_dump_writer.cc
diff --git a/base/trace_event/heap_profiler_heap_dump_writer.cc b/base/trace_event/heap_profiler_heap_dump_writer.cc
index 9a3112eacf3ea508c4b6da1adc54d279280c0ae5..ae9ec7be90e24f20f2ad04da5ca98145de27c584 100644
--- a/base/trace_event/heap_profiler_heap_dump_writer.cc
+++ b/base/trace_event/heap_profiler_heap_dump_writer.cc
@@ -18,7 +18,9 @@
 #include "base/strings/stringprintf.h"
 #include "base/trace_event/heap_profiler_stack_frame_deduplicator.h"
 #include "base/trace_event/heap_profiler_type_name_deduplicator.h"
+#include "base/trace_event/trace_config.h"
 #include "base/trace_event/trace_event_argument.h"
+#include "base/trace_event/trace_log.h"
 
 // Most of what the |HeapDumpWriter| does is aggregating detailed information
 // about the heap and deciding what to dump. The Input to this process is a list
@@ -128,8 +130,10 @@ std::vector<Bucket> GetSubbuckets(const Bucket& bucket, BreakDownMode breakBy) {
 }
 
 // Breaks down the bucket by |breakBy|. Returns only buckets that contribute
-// significantly to the total size. The long tail is omitted.
-std::vector<Bucket> BreakDownBy(const Bucket& bucket, BreakDownMode breakBy) {
+// more than |minSizeBytes| to the total size. The long tail is omitted.
+std::vector<Bucket> BreakDownBy(const Bucket& bucket,
+                                BreakDownMode breakBy,
+                                size_t min_size_bytes) {
   std::vector<Bucket> buckets = GetSubbuckets(bucket, breakBy);
 
   // Ensure that |buckets| is a max-heap (the data structure, not memory heap),
@@ -141,14 +145,12 @@ std::vector<Bucket> BreakDownBy(const Bucket& bucket, BreakDownMode breakBy) {
   std::make_heap(buckets.begin(), buckets.end());
 
   // Keep including buckets until adding one would increase the number of
-  // bytes accounted for by less than 0.8% (1/125). This simple heuristic works
-  // quite well. The large buckets end up in [it, end()), [begin(), it) is the
-  // part that contains the max-heap of small buckets.
-  size_t accounted_for = 0;
+  // bytes accounted for by |min_size_bytes|. The large buckets end up in
+  // [it, end()), [begin(), it) is the part that contains the max-heap
+  // of small buckets.
   std::vector<Bucket>::iterator it;
   for (it = buckets.end(); it != buckets.begin(); --it) {
-    accounted_for += buckets.front().size;
-    if (buckets.front().size < (accounted_for / 125))
+    if (buckets.front().size < min_size_bytes)
       break;
 
     // Put the largest bucket in [begin, it) at |it - 1| and max-heapify
@@ -183,7 +185,10 @@ bool operator<(Entry lhs, Entry rhs) {
 HeapDumpWriter::HeapDumpWriter(StackFrameDeduplicator* stack_frame_deduplicator,
                                TypeNameDeduplicator* type_name_deduplicator)
     : stack_frame_deduplicator_(stack_frame_deduplicator),
-      type_name_deduplicator_(type_name_deduplicator) {}
+      type_name_deduplicator_(type_name_deduplicator) {
+  min_allocation_size_bytes_ = TraceLog::GetInstance()->GetCurrentTraceConfig()

[Primiano Tucci (use gerrit), 2016/04/21 16:53:21]

Hmm this is now introducing the assumption that HeapDumpWriter is alive only
when tracing is enabled, which might cause bugs.
Can we instead pass a HeapProfilerConfig& (see comment below) here?

What I would do here is:
It is safe to get the TraceLog in the OnMemoryDump of the MemoryDumpProviders,
because at that point tracing is guaranteed to be active.
This will mean having to do GetCurrentTraceConfig() in 3 places (malloc,
partition alloc and blinkgc heap profiler), which is bad in terms of copy/paste
but better in terms of lifetime.

A better alternative could be the following:
in MemoryDumpManager::OnTraceLogEnabled(), we already read the MemoryDumpConfig
from the TraceLog. Let's copy that into the SessionState (which is accessible to
all MemoryDumpProviders via pmd->session_state()).
If you do that, at this point the only arg you need to pass to HeapDumpWriter is
a const MemoryDumpSessionState&, which would make everything cleaner.

In other words today in malloc_dump_provider you have:
  std::unique_ptr<TracedValue> heap_dump = ExportHeapDump(
          metrics_by_context, pmd->session_state()->stack_frame_deduplicator(),
          pmd->session_state()->type_name_deduplicator());

with this change you will just
   std::unique_ptr<TracedValue> heap_dump = ExportHeapDump(
          metrics_by_context, pmd->session_state())

This can be done in a separate CL, before or after this (i.e. you could first
refactor the existing code to move make this take the SessionState which is
going to be a non-funcitonal refactor easier to review, and later add the extra
threshold to the trace config)

+      .GetMinAllocationSizeBytes();
+}
 
 HeapDumpWriter::~HeapDumpWriter() {}
 
@@ -216,8 +221,12 @@ bool HeapDumpWriter::AddEntryForBucket(const Bucket& bucket) {
 }
 
 void HeapDumpWriter::BreakDown(const Bucket& bucket) {
-  auto by_backtrace = BreakDownBy(bucket, BreakDownMode::kByBacktrace);
-  auto by_type_name = BreakDownBy(bucket, BreakDownMode::kByTypeName);
+  auto by_backtrace = BreakDownBy(bucket,
+                                  BreakDownMode::kByBacktrace,
+                                  min_allocation_size_bytes_);
+  auto by_type_name = BreakDownBy(bucket,
+                                  BreakDownMode::kByTypeName,
+                                  min_allocation_size_bytes_);
 
   // Insert entries for the buckets. If a bucket was not present before, it has
   // not been broken down before, so recursively continue breaking down in that