[Tentaive patch for discussion] Add Purge+Suspend metrics as UMA.

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>
 #include <vector>
 
 #include "base/allocator/allocator_extension.h"
 #include "base/command_line.h"
 #include "base/debug/crash_logging.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/discardable_memory_allocator.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/shared_memory.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/path_service.h"
+#include "base/process/process_metrics.h"
 #include "base/run_loop.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/simple_thread.h"
 #include "base/threading/thread_local.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/threading/thread_task_runner_handle.h"
@@ skipping 169 matching lines @@
 #include "content/public/common/mojo_shell_connection.h"
 #include "content/renderer/mus/render_widget_mus_connection.h"
 #include "content/renderer/mus/render_widget_window_tree_client_factory.h"
 #include "services/ui/public/cpp/gpu_service.h"
 #endif
 
 #if defined(ENABLE_IPC_FUZZER)
 #include "content/common/external_ipc_dumper.h"
 #endif
 
+#if defined(OS_MACOSX)
+#include <malloc/malloc.h>
+#else
+#include <malloc.h>
+#endif
+
 using base::ThreadRestrictions;
 using blink::WebDocument;
 using blink::WebFrame;
 using blink::WebNetworkStateNotifier;
 using blink::WebRuntimeFeatures;
 using blink::WebScriptController;
 using blink::WebSecurityPolicy;
 using blink::WebString;
 using blink::WebView;
 using blink::scheduler::WebThreadImplForWorkerScheduler;
@@ skipping 1528 matching lines @@
   } else {
     renderer_scheduler_->OnRendererForegrounded();
     is_renderer_suspended_ = false;
   }
 }
 
 void RenderThreadImpl::OnProcessPurgeAndSuspend() {
   ChildThreadImpl::OnProcessPurgeAndSuspend();
   if (is_renderer_suspended_)
     return;
-  // TODO(hajimehoshi): Implement purging e.g. cache (crbug/607077)
+
+  // If PurgeAndSuspendFeature is disabled, do nothing except updating UMA.
+  // The data is used as "Force Disabled" metric.
+  if (base::FeatureList::IsEnabled(features::kPurgeAndSuspend)) {
+    // TODO(tasak): use MemoryCoordinator instead of NotifyMemoryPressure.
+    base::MemoryPressureListener::NotifyMemoryPressure(
+        base::MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL);
+    base::allocator::ReleaseFreeMemory();
+
+    renderer_scheduler_->SuspendRenderer();
+  }
   is_renderer_suspended_ = true;
-  renderer_scheduler_->SuspendRenderer();
+
+  // Since purging is not a synchronouse task (e.g. v8 GC, oilpan GC, ...),
+  // we need to wait until the task is finished. So wait 15 seconds and
+  // update purge+suspend UMA histogram.
+  // TODO(tasak): use MemoryCoordinator's callback to report purge+suspend
+  // UMA when MemoryCoordinator is available.
+  GetRendererScheduler()->DefaultTaskRunner()->PostDelayedTask(
+      FROM_HERE,
+      base::Bind(&RenderThreadImpl::OnDumpMemoryUsage, base::Unretained(this)),
+      base::TimeDelta::FromSeconds(15));
+}
+
+// TODO(tasak): Replace the following GetMallocUsage() with memory-infra
+// when it is possible to run memory-infra without tracing.
+#if defined(OS_WIN)
+namespace {
+
+class ScopedHeapLock {
+ public:
+  explicit ScopedHeapLock(HANDLE handle) : handle_(handle) {
+    ::HeapLock(handle_);
+  }
+  ~ScopedHeapLock() { ::HeapUnlock(handle_); }
+
+ private:
+  ScopedHeapLock() = delete;
+  ScopedHeapLock(const ScopedHeapLock&) = delete;
+
+  HANDLE handle_;
+};
+
+static size_t GetMallocUsage() {
+  DWORD number_of_heaps = ::GetProcessHeaps(0, NULL);
+  if (number_of_heaps <= 0)
+    return 0;
+
+  size_t malloc_usage = 0;
+  std::unique_ptr<HANDLE[]> heaps(new HANDLE[number_of_heaps]);
+  ::GetProcessHeaps(number_of_heaps, heaps.get());
+  for (unsigned i = 0; i < number_of_heaps; i++) {
+    PROCESS_HEAP_ENTRY heap_entry;
+    heap_entry.lpData = NULL;
+    {
+      ScopedHeapLock lock(heaps[i]);
+      while (::HeapWalk(heaps[i], &heap_entry) != 0) {
+        if (heap_entry.lpData == heaps.get())
+          continue;
+        if ((heap_entry.wFlags & PROCESS_HEAP_ENTRY_BUSY) != 0)
+          malloc_usage += heap_entry.cbData;
+      }
+    }
+  }
+  return malloc_usage;
+}
+
+}  // namespace
+#endif
+
+#if defined(OS_MACOSX) || defined(OS_IOS)
+namespace {
+
+static size_t GetMallocUsage() {
+  malloc_statistics_t stats = {0};
+  malloc_zone_statistics(nullptr, &stats);
+  return stats.size_in_use;
+}
+
+}  // namespace
+#endif
+
+// For purge+suspend, report memory usage diff by using UMA_HISTOGRAM.
+void RenderThreadImpl::OnDumpMemoryUsage() const {
+  // If this renderer is resumed, we should not update UMA.
+  if (!is_renderer_suspended_)
+    return;
+
+  // TODO(tasak): firstly we are trying to compare metrics from enabled and
+  // disabled renderers (A/B testing). However we also need to gather
+  // metrics which measures how many memory usages are reduced.
+  blink::WebMemoryStatistics blink_stats = blink::WebMemoryStatistics::Get();
+  UMA_HISTOGRAM_MEMORY_KB("Memory.PurgeAndSuspend.PartitionAllocKB",
+                          blink_stats.partitionAllocTotalAllocatedBytes);
+  UMA_HISTOGRAM_MEMORY_KB("Memory.PurgeAndSuspend.BlinkGCKB",
+                          blink_stats.blinkGCTotalAllocatedBytes);
+#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_KB("Memory.PurgeAndSuspend.MallocKB", malloc_usage);
+
+  ChildDiscardableSharedMemoryManager::Statistics discardable_stats =
+      ChildThreadImpl::discardable_shared_memory_manager()->GetStatistics();
+  size_t discardable_usage =
+      discardable_stats.total_size - discardable_stats.freelist_size;
+  UMA_HISTOGRAM_MEMORY_KB("Memory.PurgeAndSuspend.DiscardableKB",
+                          discardable_usage);
+
+  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();
+  }
+  UMA_HISTOGRAM_MEMORY_KB("Memory.PurgeAndSuspend.V8MainThreadIsolateKB",
+                          v8_usage);
+  UMA_HISTOGRAM_MEMORY_KB("Memory.PurgeAndSuspend.TotalAllocatedKB",
+                          blink_stats.partitionAllocTotalAllocatedBytes +
+                              blink_stats.blinkGCTotalAllocatedBytes +
+                              malloc_usage + v8_usage + discardable_usage);
 }
 
 void RenderThreadImpl::OnCreateNewFrame(FrameMsg_NewFrame_Params params) {
   // Debug cases of https://crbug.com/626802.
   base::debug::SetCrashKeyValue("newframe_routing_id",
                                 base::IntToString(params.routing_id));
   base::debug::SetCrashKeyValue("newframe_proxy_id",
                                 base::IntToString(params.proxy_routing_id));
   base::debug::SetCrashKeyValue("newframe_opener_id",
                                 base::IntToString(params.opener_routing_id));
@@ skipping 534 matching lines @@
   if (blink::mainThreadIsolate()) {
     blink::mainThreadIsolate()->MemoryPressureNotification(
         v8::MemoryPressureLevel::kCritical);
     blink::MemoryPressureNotificationToWorkerThreadIsolates(
         v8::MemoryPressureLevel::kCritical);
   }
 }
 
 
 }  // namespace content