Add peak memory usage metric

chrome/browser/metrics/metrics_memory_details.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 "chrome/browser/metrics/metrics_memory_details.h"
 
 #include <stddef.h>
 
 #include <vector>
 
 #include "base/location.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/utf_string_conversions.h"
+#include "base/sys_info.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "build/build_config.h"
 #include "components/nacl/common/nacl_process_type.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/common/content_constants.h"
 #include "content/public/common/process_type.h"
 #include "ppapi/features/features.h"
 
 MemoryGrowthTracker::MemoryGrowthTracker() {
 }
@@ skipping 24 matching lines @@
     }
     // Skip if a last record is found less than 30 minutes ago.
   } else {
     // Not reporting if it's the first record for |pid|.
     times_[pid] = current_time;
     memory_sizes_[pid] = sample;
   }
   return false;
 }
 
+PeakMemoryUsageTracker::PeakMemoryUsageTracker() : peak_(0) {}
+
+bool PeakMemoryUsageTracker::Update(int memory_usage) {
+  if (memory_usage > peak_) {
+    peak_ = memory_usage;
+    return true;
+  }
+  return false;
+}
+
 MetricsMemoryDetails::MetricsMemoryDetails(
     const base::Closure& callback,
-    MemoryGrowthTracker* memory_growth_tracker)
+    MemoryGrowthTracker* memory_growth_tracker,
+    PeakMemoryUsageTracker* peak_memory_usage_tracker)
     : callback_(callback),
       memory_growth_tracker_(memory_growth_tracker),
+      peak_memory_usage_tracker_(peak_memory_usage_tracker),
       generate_histograms_(true) {}
 
 MetricsMemoryDetails::~MetricsMemoryDetails() {
 }
 
 void MetricsMemoryDetails::OnDetailsAvailable() {
   if (generate_histograms_)
     UpdateHistograms();
   AnalyzeMemoryGrowth();
   base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, callback_);
@@ skipping 118 matching lines @@
   UMA_HISTOGRAM_COUNTS_100("Memory.PepperPluginBrokerProcessCount",
                            pepper_plugin_broker_count);
   UMA_HISTOGRAM_COUNTS_100("Memory.RendererProcessCount", renderer_count);
   UMA_HISTOGRAM_COUNTS_100("Memory.WorkerProcessCount", worker_count);
   // TODO(viettrungluu): Do we want separate counts for the other
   // (platform-specific) process types?
 
   int total_sample = static_cast<int>(aggregate_memory / 1024);
   UMA_HISTOGRAM_MEMORY_LARGE_MB("Memory.Total2", total_sample);
 
+  if (peak_memory_usage_tracker_) {
+    int previous_peak = peak_memory_usage_tracker_->peak();
+    if (peak_memory_usage_tracker_->Update(
+            static_cast<int>(aggregate_memory))) {
+      int physical_memory =
+          static_cast<int>(base::SysInfo::AmountOfPhysicalMemory());
+      int previous_peak_percentage = std::min(
+          static_cast<int>(100.0 * previous_peak / physical_memory), 100);
+      int new_peak_percentage =
+          std::min(static_cast<int>(100.0 * peak_memory_usage_tracker_->peak() /
+                                    physical_memory),
+                   100);
+      for (int i = previous_peak_percentage + 1; i <= new_peak_percentage;
+           ++i) {
+        UMA_HISTOGRAM_COUNTS_100("Memory.Total2.RelativePeak", i);
+      }
+    }
+  }
+
   // Predict the number of processes needed when isolating all sites and when
   // isolating only HTTPS sites.
   int all_renderer_count = renderer_count + chrome_count + extension_count;
   int non_renderer_count = browser.processes.size() - all_renderer_count;
   DCHECK_GE(non_renderer_count, 1);
   SiteDetails::UpdateHistograms(browser.site_data, all_renderer_count,
                                 non_renderer_count);
 
 #if defined(OS_CHROMEOS)
   UpdateSwapHistograms();
@@ skipping 105 matching lines @@
         memory_growth_tracker_->UpdateSample(process_entry.pid, sample,
                                              &diff) &&
         generate_histograms_) {
       if (diff < 0)
         UMA_HISTOGRAM_MEMORY_KB("Memory.RendererShrinkIn30Min", -diff);
       else
         UMA_HISTOGRAM_MEMORY_KB("Memory.RendererGrowthIn30Min", diff);
     }
   }
 }