memory metrics: record growth after purging BG renderer's cache

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 905 matching lines @@
 
 #if defined(OS_LINUX)
   ChildProcess::current()->SetIOThreadPriority(base::ThreadPriority::DISPLAY);
   ChildThreadImpl::current()->SetThreadPriority(
       categorized_worker_pool_->background_worker_thread_id(),
       base::ThreadPriority::BACKGROUND);
 #endif
 
   record_purge_suspend_metric_closure_.Reset(base::Bind(
       &RenderThreadImpl::RecordPurgeAndSuspendMetrics, base::Unretained(this)));
+  record_purge_suspend_growth_metric_closure_.Reset(
+      base::Bind(&RenderThreadImpl::RecordPurgeAndSuspendMemoryGrowthMetrics,
+                 base::Unretained(this)));
 
   base::MemoryCoordinatorClientRegistry::GetInstance()->Register(this);
 
   // If this renderer doesn't run inside the browser process, enable
   // 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();
 }
@@ skipping 727 matching lines @@
     // TODO(tasak): after enabling MemoryCoordinator, remove this Notify
     // and follow MemoryCoordinator's request.
     if (base::FeatureList::IsEnabled(features::kPurgeAndSuspend))
       base::MemoryCoordinatorClientRegistry::GetInstance()->Notify(
           base::MemoryState::NORMAL);
 
     record_purge_suspend_metric_closure_.Cancel();
     record_purge_suspend_metric_closure_.Reset(
         base::Bind(&RenderThreadImpl::RecordPurgeAndSuspendMetrics,
                    base::Unretained(this)));
+    record_purge_suspend_growth_metric_closure_.Cancel();
+    record_purge_suspend_growth_metric_closure_.Reset(
+        base::Bind(&RenderThreadImpl::RecordPurgeAndSuspendMemoryGrowthMetrics,
+                   base::Unretained(this)));
   }
 }
 
 void RenderThreadImpl::OnProcessPurgeAndSuspend() {
   ChildThreadImpl::OnProcessPurgeAndSuspend();
   if (!RendererIsHidden())
     return;
 
   // TODO(bashi): Enable the tab suspension when MemoryCoordinator is enabled.
   if (base::FeatureList::IsEnabled(features::kMemoryCoordinator))
@@ skipping 94 matching lines @@
   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 {
+void RenderThreadImpl::RecordPurgeAndSuspendMetrics() {
   // 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",
                           memory_metrics.v8_main_thread_isolate_mb);
   UMA_HISTOGRAM_MEMORY_MB("PurgeAndSuspend.Memory.TotalAllocatedMB",
                           memory_metrics.total_allocated_mb);
+  purge_and_suspend_memory_metrics_ = memory_metrics;
+
+  // record how many memory usage increases after purged.
+  GetRendererScheduler()->DefaultTaskRunner()->PostDelayedTask(
+      FROM_HERE, record_purge_suspend_growth_metric_closure_.callback(),
+      base::TimeDelta::FromMinutes(5));
+  GetRendererScheduler()->DefaultTaskRunner()->PostDelayedTask(
+      FROM_HERE, record_purge_suspend_growth_metric_closure_.callback(),
+      base::TimeDelta::FromMinutes(10));
+  GetRendererScheduler()->DefaultTaskRunner()->PostDelayedTask(
+      FROM_HERE, record_purge_suspend_growth_metric_closure_.callback(),
+      base::TimeDelta::FromMinutes(15));
+}
+
+#define GET_MEMORY_GROWTH(current, previous, allocator) \
+  (current.allocator > previous.allocator               \
+       ? current.allocator - previous.allocator         \
+       : 0)
+
+void RenderThreadImpl::RecordPurgeAndSuspendMemoryGrowthMetrics() const {
+  // If this renderer is resumed, we should not update UMA.
+  if (!RendererIsHidden())
+    return;
+
+  RendererMemoryMetrics memory_metrics;
+  GetRendererMemoryMetrics(&memory_metrics);
+  UMA_HISTOGRAM_MEMORY_KB(
+      "PurgeAndSuspend.Experimental.MemoryGrowth.PartitionAllocKB",
+      GET_MEMORY_GROWTH(memory_metrics, purge_and_suspend_memory_metrics_,
+                        partition_alloc_kb));
+  UMA_HISTOGRAM_MEMORY_KB(
+      "PurgeAndSuspend.Experimental.MemoryGrowth.BlinkGCKB",
+      GET_MEMORY_GROWTH(memory_metrics, purge_and_suspend_memory_metrics_,
+                        blink_gc_kb));
+  UMA_HISTOGRAM_MEMORY_MB(
+      "PurgeAndSuspend.Experimental.MemoryGrowth.MallocMB",
+      GET_MEMORY_GROWTH(memory_metrics, purge_and_suspend_memory_metrics_,
+                        malloc_mb));
+  UMA_HISTOGRAM_MEMORY_KB(
+      "PurgeAndSuspend.Experimental.MemoryGrowth.DiscardableKB",
+      GET_MEMORY_GROWTH(memory_metrics, purge_and_suspend_memory_metrics_,
+                        discardable_kb));
+  UMA_HISTOGRAM_MEMORY_MB(
+      "PurgeAndSuspend.Experimental.MemoryGrowth.V8MainThreadIsolateMB",
+      GET_MEMORY_GROWTH(memory_metrics, purge_and_suspend_memory_metrics_,
+                        v8_main_thread_isolate_mb));
+  UMA_HISTOGRAM_MEMORY_MB(
+      "PurgeAndSuspend.Experimental.MemoryGrowth.TotalAllocatedMB",
+      GET_MEMORY_GROWTH(memory_metrics, purge_and_suspend_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 584 matching lines @@
   }
 }
 
 void RenderThreadImpl::OnRendererInterfaceRequest(
     mojom::RendererAssociatedRequest request) {
   DCHECK(!renderer_binding_.is_bound());
   renderer_binding_.Bind(std::move(request));
 }
 
 }  // namespace content