memory-infra: Fill the memory dump callback result (1/2)

base/trace_event/memory_dump_manager.cc

 // Copyright 2015 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/trace_event/memory_dump_manager.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/allocator/features.h"
@@ skipping 701 matching lines @@
   // disabled (unregistered). This is to avoid taking lock while polling.
   for (const auto& mdpinfo : dump_providers_for_polling_) {
     uint64_t value = 0;
     mdpinfo->dump_provider->PollFastMemoryTotal(&value);
     *memory_total += value;
   }
   return true;
 }
 
 // static
+uint32_t MemoryDumpManager::SumSizesInKbForPrefix(
+    const std::string& prefix,
+    const ProcessMemoryDump* pmd) {
+  uint64_t sum = 0;
+  for (const auto& kv : pmd->allocator_dumps()) {
+    if (kv.first.compare(0, prefix.length(), prefix) == 0) {

[Primiano Tucci (use gerrit), 2017/03/22 17:19:52]

as we discussed offline let's use StartsWith in string_util.h because, oh boy,
C++ is hard

[hjd, 2017/03/22 19:24:20]

Done.

+      sum += kv.second->GetSize();
+    }
+  }
+  // Convert bytes to kilobytes.

[Primiano Tucci (use gerrit), 2017/03/22 17:19:52]

this comment should be unnecessary given the name :)

[hjd, 2017/03/22 19:24:20]

Done.

+  return sum / 1024;
+}
+
+// static
 void MemoryDumpManager::FinalizeDumpAndAddToTrace(
     std::unique_ptr<ProcessMemoryDumpAsyncState> pmd_async_state) {
   HEAP_PROFILER_SCOPED_IGNORE;
   DCHECK(pmd_async_state->pending_dump_providers.empty());
   const uint64_t dump_guid = pmd_async_state->req_args.dump_guid;
   if (!pmd_async_state->callback_task_runner->BelongsToCurrentThread()) {
     scoped_refptr<SingleThreadTaskRunner> callback_task_runner =
         pmd_async_state->callback_task_runner;
     callback_task_runner->PostTask(
         FROM_HERE, Bind(&MemoryDumpManager::FinalizeDumpAndAddToTrace,
                         Passed(&pmd_async_state)));
     return;
   }
 
   TRACE_EVENT_WITH_FLOW0(kTraceCategory,
                          "MemoryDumpManager::FinalizeDumpAndAddToTrace",
                          TRACE_ID_MANGLE(dump_guid), TRACE_EVENT_FLAG_FLOW_IN);
 
+  // Fill results struct.

[Primiano Tucci (use gerrit), 2017/03/22 17:19:52]

ditto about todo + bug

[hjd, 2017/03/22 19:24:20]

Done.

+  MemoryDumpCallbackResult result;
+  for (const auto& kv : pmd_async_state->process_dumps) {

[Primiano Tucci (use gerrit), 2017/03/22 17:19:52]

since you have the same loop below, could you make this part of that? (I guess
there is some other reason for keeping a separate loop I did overlook)

[hjd, 2017/03/22 19:24:20]

not really, just seemed easier while I was debugging, I have combined them.

+    ProcessMemoryDump* process_memory_dump = kv.second.get();
+    if (kv.first == kNullProcessId) {
+      result.chrome_dump.v8_total_kb =
+          SumSizesInKbForPrefix("v8/", process_memory_dump);
+      result.chrome_dump.malloc_total_kb =
+          SumSizesInKbForPrefix("malloc/", process_memory_dump);

[Primiano Tucci (use gerrit), 2017/03/22 17:19:52]

hmm I know that we discussed this offline but now I wonder if this is going to
count also the suballocations of malloc obtained via AddSuballocation (sorry
didn't think to malloc before).
On one side the suballocations should be only part of DETAILED dumps, so as long
as we limit this to BACKGROUND for the moment everything should work (but maybe
you could add a DCHECK for "/__" in the SumSizesInKbForPrefix that checks that
we don't accidentally use this with things that have suballocations).

[hjd, 2017/03/22 19:24:20]

Done.

+      // partition_alloc reports sizes for both allocated_objects and
+      // partitions. The memory allocated_objects uses is a subset of
+      // the partitions memory so to avoid double counting we only
+      // count partitions memory.
+      result.chrome_dump.partition_alloc_total_kb = SumSizesInKbForPrefix(
+          "partition_alloc/partitions", process_memory_dump);
+      result.chrome_dump.blink_gc_total_kb =
+          SumSizesInKbForPrefix("blink_gc/", process_memory_dump);
+    }
+  }
+
   for (const auto& kv : pmd_async_state->process_dumps) {
     ProcessId pid = kv.first;  // kNullProcessId for the current process.
     ProcessMemoryDump* process_memory_dump = kv.second.get();
     std::unique_ptr<TracedValue> traced_value(new TracedValue);
     process_memory_dump->AsValueInto(traced_value.get());
     traced_value->SetString("level_of_detail",
                             MemoryDumpLevelOfDetailToString(
                                 pmd_async_state->req_args.level_of_detail));
     const char* const event_name =
         MemoryDumpTypeToString(pmd_async_state->req_args.dump_type);
@@ skipping 211 matching lines @@
   if (iter == process_dumps.end()) {
     std::unique_ptr<ProcessMemoryDump> new_pmd(
         new ProcessMemoryDump(session_state, dump_args));
     iter = process_dumps.insert(std::make_pair(pid, std::move(new_pmd))).first;
   }
   return iter->second.get();
 }
 
 }  // namespace trace_event
 }  // namespace base