Add renderer memory metrics

content/renderer/render_thread_impl.cc

 // Copyright (c) 2012 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 "content/renderer/render_thread_impl.h"
 
 #include <algorithm>
 #include <limits>
 #include <map>
 #include <utility>
@@ skipping 919 matching lines @@
   // SequencedWorkerPool. Otherwise, it should already have been enabled.
   // TODO(fdoray): Remove this once the SequencedWorkerPool to TaskScheduler
   // redirection experiment concludes https://crbug.com/622400.
   if (!command_line.HasSwitch(switches::kSingleProcess))
     base::SequencedWorkerPool::EnableForProcess();
 }
 
 RenderThreadImpl::~RenderThreadImpl() {
 }
 
 void RenderThreadImpl::Shutdown() {

[Ilya Sherman, 2017/01/10 20:29:56]

Are you sure that this code is routinely reached?  My understanding is that
renderers typically go through a fast teardown path, which skips pretty much all
of the cleanup work.

[keishi, 2017/01/11 02:40:46]

You're right this wasn't called so I've removed this.

+  {
+    RendererMemoryMetrics memory_metrics;
+    GetRendererMemoryMetrics(&memory_metrics);
+    UMA_HISTOGRAM_MEMORY_MB(
+        "Memory.Experimental.Renderer.Shutdown.PartitionAllocMB",
+        memory_metrics.partition_alloc_kb / 1024);
+    UMA_HISTOGRAM_MEMORY_MB(
+        "Memory.Experimental.Renderer.Shutdown.BlinkGCMB",
+        memory_metrics.blink_gc_kb / 1024);
+    UMA_HISTOGRAM_MEMORY_MB("Memory.Experimental.Renderer.Shutdown.MallocMB",
+                            memory_metrics.malloc_mb);
+    UMA_HISTOGRAM_MEMORY_MB(
+        "Memory.Experimental.Renderer.Shutdown.DiscardableMB",
+        memory_metrics.discardable_kb / 1024);
+    UMA_HISTOGRAM_MEMORY_MB(
+        "Memory.Experimental.Renderer.Shutdown.V8MainThreadIsolateMB",
+        memory_metrics.v8_main_thread_isolate_mb);
+    UMA_HISTOGRAM_MEMORY_MB(
+        "Memory.Experimental.Renderer.Shutdown.TotalAllocatedMB",
+        memory_metrics.total_allocated_mb);
+    UMA_HISTOGRAM_MEMORY_MB(
+        "Memory.Experimental.Renderer.Shutdown.NonDiscardableTotalAllocatedMB",
+        memory_metrics.non_discardable_total_allocated_mb);
+    UMA_HISTOGRAM_MEMORY_MB(
+        "Memory.Experimental.Renderer.Shutdown.TotalAllocatedPerRenderViewMB",
+        memory_metrics.total_allocated_per_render_view_mb);
+  }
+
   for (auto& observer : observers_)
     observer.OnRenderProcessShutdown();
 
   if (memory_observer_) {
     message_loop()->RemoveTaskObserver(memory_observer_.get());
     memory_observer_.reset();
   }
 
   // Wait for all databases to be closed.
   if (blink_platform_impl_) {
@@ skipping 877 matching lines @@
 
 static size_t GetMallocUsage() {
   malloc_statistics_t stats = {0};
   malloc_zone_statistics(nullptr, &stats);
   return stats.size_in_use;
 }
 
 }  // namespace
 #endif
 
-// TODO(tasak): Once it is possible to use memory-infra without tracing,
-// we should collect the metrics using memory-infra.
-// TODO(tasak): We should also report a difference between the memory usages
-// before and after purging by using memory-infra.
-void RenderThreadImpl::RecordPurgeAndSuspendMetrics() const {
-  // If this renderer is resumed, we should not update UMA.
-  if (!RendererIsHidden())
-    return;
+void RenderThreadImpl::GetRendererMemoryMetrics(
+    RendererMemoryMetrics* memory_metrics) const {
+  DCHECK(memory_metrics);
 
-  // TODO(tasak): Compare memory metrics between purge-enabled renderers and
-  // purge-disabled renderers (A/B testing).
   blink::WebMemoryStatistics blink_stats = blink::WebMemoryStatistics::Get();
-  UMA_HISTOGRAM_MEMORY_KB("PurgeAndSuspend.Memory.PartitionAllocKB",
-                          blink_stats.partitionAllocTotalAllocatedBytes / 1024);
-  UMA_HISTOGRAM_MEMORY_KB("PurgeAndSuspend.Memory.BlinkGCKB",
-                          blink_stats.blinkGCTotalAllocatedBytes / 1024);
+  memory_metrics->partition_alloc_kb =
+      blink_stats.partitionAllocTotalAllocatedBytes / 1024;
+  memory_metrics->blink_gc_kb = blink_stats.blinkGCTotalAllocatedBytes / 1024;
 #if defined(OS_LINUX) || defined(OS_ANDROID)
   struct mallinfo minfo = mallinfo();
 #if defined(USE_TCMALLOC)
   size_t malloc_usage = minfo.uordblks;
 #else
   size_t malloc_usage = minfo.hblkhd + minfo.arena;
 #endif
 #else
   size_t malloc_usage = GetMallocUsage();
 #endif
-  UMA_HISTOGRAM_MEMORY_MB("PurgeAndSuspend.Memory.MallocMB",
-                          malloc_usage / 1024 / 1024);
+  memory_metrics->malloc_mb = malloc_usage / 1024 / 1024;
 
   discardable_memory::ClientDiscardableSharedMemoryManager::Statistics
       discardable_stats = discardable_shared_memory_manager_->GetStatistics();
   size_t discardable_usage =
       discardable_stats.total_size - discardable_stats.freelist_size;
-  UMA_HISTOGRAM_MEMORY_KB("PurgeAndSuspend.Memory.DiscardableKB",
-                          discardable_usage / 1024);
+  memory_metrics->discardable_kb = discardable_usage / 1024;
 
   size_t v8_usage = 0;
   if (v8::Isolate* isolate = blink::mainThreadIsolate()) {
     v8::HeapStatistics v8_heap_statistics;
     isolate->GetHeapStatistics(&v8_heap_statistics);
     v8_usage = v8_heap_statistics.total_heap_size();
   }
   // TODO(tasak): Currently only memory usage of mainThreadIsolate() is
   // reported. We should collect memory usages of all isolates using
   // memory-infra.
+  memory_metrics->v8_main_thread_isolate_mb = v8_usage / 1024 / 1024;
+  size_t total_allocated = blink_stats.partitionAllocTotalAllocatedBytes +
+                           blink_stats.blinkGCTotalAllocatedBytes +
+                           malloc_usage + v8_usage + discardable_usage;
+  memory_metrics->total_allocated_mb = total_allocated / 1024 / 1024;
+  memory_metrics->non_discardable_total_allocated_mb =
+      (total_allocated - discardable_usage) / 1024 / 1024;
+  memory_metrics->total_allocated_per_render_view_mb =
+      total_allocated / RenderView::GetRenderViewCount() / 1024 / 1024;
+}
+
+// TODO(tasak): Once it is possible to use memory-infra without tracing,
+// we should collect the metrics using memory-infra.
+// TODO(tasak): We should also report a difference between the memory usages
+// before and after purging by using memory-infra.
+void RenderThreadImpl::RecordPurgeAndSuspendMetrics() const {
+  // If this renderer is resumed, we should not update UMA.
+  if (!RendererIsHidden())
+    return;
+
+  // TODO(tasak): Compare memory metrics between purge-enabled renderers and
+  // purge-disabled renderers (A/B testing).
+  RendererMemoryMetrics memory_metrics;
+  GetRendererMemoryMetrics(&memory_metrics);
+  UMA_HISTOGRAM_MEMORY_KB("PurgeAndSuspend.Memory.PartitionAllocKB",
+                          memory_metrics.partition_alloc_kb);
+  UMA_HISTOGRAM_MEMORY_KB("PurgeAndSuspend.Memory.BlinkGCKB",
+                          memory_metrics.blink_gc_kb);
+  UMA_HISTOGRAM_MEMORY_MB("PurgeAndSuspend.Memory.MallocMB",
+                          memory_metrics.malloc_mb);
+  UMA_HISTOGRAM_MEMORY_KB("PurgeAndSuspend.Memory.DiscardableKB",
+                          memory_metrics.discardable_kb);
   UMA_HISTOGRAM_MEMORY_MB("PurgeAndSuspend.Memory.V8MainThreadIsolateMB",
-                          v8_usage / 1024 / 1024);
+                          memory_metrics.v8_main_thread_isolate_mb);
   UMA_HISTOGRAM_MEMORY_MB("PurgeAndSuspend.Memory.TotalAllocatedMB",
-                          (blink_stats.partitionAllocTotalAllocatedBytes +
-                           blink_stats.blinkGCTotalAllocatedBytes +
-                           malloc_usage + v8_usage + discardable_usage) /
-                              1024 / 1024);
+                          memory_metrics.total_allocated_mb);
 }
 
 void RenderThreadImpl::OnProcessResume() {
   ChildThreadImpl::OnProcessResume();
 
   if (!RendererIsHidden())
     return;
 
   // TODO(bashi): Enable the tab suspension when MemoryCoordinator is enabled.
   if (base::FeatureList::IsEnabled(features::kMemoryCoordinator))
@@ skipping 602 matching lines @@
   }
 }
 
 void RenderThreadImpl::OnRendererInterfaceRequest(
     mojom::RendererAssociatedRequest request) {
   DCHECK(!renderer_binding_.is_bound());
   renderer_binding_.Bind(std::move(request));
 }
 
 }  // namespace content