Add out of memory stats for graphics memory, discards per minute

chrome/browser/chromeos/memory/oom_priority_manager.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 "chrome/browser/chromeos/memory/oom_priority_manager.h"
 
 #include <algorithm>
 #include <set>
 #include <vector>
 
@@ skipping 54 matching lines @@
     }
 
 // Record a size in megabytes, over a potential interval up to 32 GB.
 #define EXPERIMENT_HISTOGRAM_MEGABYTES(name, sample)                     \
     EXPERIMENT_CUSTOM_COUNTS(name, sample, 1, 32768, 50)
 
 // The default interval in seconds after which to adjust the oom_score_adj
 // value.
 const int kAdjustmentIntervalSeconds = 10;
 
+// For each period of this length we record a statistic to indicate whether
+// or not the user experienced a low memory event. If you change this interval
+// you must replace Tabs.Discard.DiscardInLastMinute with a new statistic.
+const int kRecentTabDiscardIntervalSeconds = 60;
+
 // If there has been no priority adjustment in this interval, we assume the
 // machine was suspended and correct our timing statistics.
 const int kSuspendThresholdSeconds = kAdjustmentIntervalSeconds * 4;
 
 // When switching to a new tab the tab's renderer's OOM score needs to be
 // updated to reflect its front-most status and protect it from discard.
 // However, doing this immediately might slow down tab switch time, so wait
 // a little while before doing the adjustment.
 const int kFocusedTabScoreAdjustIntervalMs = 500;
 
 // Returns a unique ID for a WebContents.  Do not cast back to a pointer, as
 // the WebContents could be deleted if the user closed the tab.
 int64 IdFromWebContents(WebContents* web_contents) {
   return reinterpret_cast<int64>(web_contents);
 }
 
+// Records a statistics |sample| for UMA histogram |name| using a linear
+// distribution of buckets.
+void RecordLinearHistogram(const std::string& name,
+                           int sample,
+                           int maximum,
+                           size_t bucket_count) {
+  // Do not use the UMA_HISTOGRAM_... macros here.  They cache the Histogram
+  // instance and thus only work if |name| is constant.
+  base::HistogramBase* counter = base::LinearHistogram::FactoryGet(
+      name,
+      1,  // Minimum. The 0 bin for underflow is automatically added.
+      maximum + 1,  // Ensure bucket size of |maximum| / |bucket_count|.
+      bucket_count + 2,  // Account for the underflow and overflow bins.
+      base::Histogram::kUmaTargetedHistogramFlag);
+  counter->Add(sample);
+}
+
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // OomMemoryDetails logs details about all Chrome processes during an out-of-
 // memory event in an attempt to identify the culprit, then discards a tab and
 // deletes itself.
 class OomMemoryDetails : public MemoryDetails {
  public:
   OomMemoryDetails();
 
@@ skipping 46 matching lines @@
     is_discarded(false),
     renderer_handle(0),
     tab_contents_id(0) {
 }
 
 OomPriorityManager::TabStats::~TabStats() {
 }
 
 OomPriorityManager::OomPriorityManager()
     : focused_tab_pid_(0),
-      discard_count_(0) {
+      discard_count_(0),
+      recent_tab_discard_(false) {
   // We only need the low memory observer if we want to discard tabs.
   if (!CommandLine::ForCurrentProcess()->HasSwitch(switches::kNoDiscardTabs))
     low_memory_observer_.reset(new LowMemoryObserver);
 
   registrar_.Add(this,
       content::NOTIFICATION_RENDERER_PROCESS_CLOSED,
       content::NotificationService::AllBrowserContextsAndSources());
   registrar_.Add(this,
       content::NOTIFICATION_RENDERER_PROCESS_TERMINATED,
       content::NotificationService::AllBrowserContextsAndSources());
   registrar_.Add(this,
       content::NOTIFICATION_RENDER_WIDGET_VISIBILITY_CHANGED,
       content::NotificationService::AllBrowserContextsAndSources());
 }
 
 OomPriorityManager::~OomPriorityManager() {
   Stop();
 }
 
 void OomPriorityManager::Start() {
   if (!timer_.IsRunning()) {
     timer_.Start(FROM_HERE,
                  TimeDelta::FromSeconds(kAdjustmentIntervalSeconds),
                  this,
                  &OomPriorityManager::AdjustOomPriorities);
   }
+  if (!recent_tab_discard_timer_.IsRunning()) {
+    recent_tab_discard_timer_.Start(
+        FROM_HERE,
+        TimeDelta::FromSeconds(kRecentTabDiscardIntervalSeconds),
+        this,
+        &OomPriorityManager::RecordRecentTabDiscard);
+  }
   if (low_memory_observer_.get())
     low_memory_observer_->Start();
   start_time_ = TimeTicks::Now();
 }
 
 void OomPriorityManager::Stop() {
   timer_.Stop();
+  recent_tab_discard_timer_.Stop();
   if (low_memory_observer_.get())
     low_memory_observer_->Stop();
 }
 
 std::vector<string16> OomPriorityManager::GetTabTitles() {
   TabStatsList stats = GetTabStatsOnUIThread();
   base::AutoLock pid_to_oom_score_autolock(pid_to_oom_score_lock_);
   std::vector<string16> titles;
   titles.reserve(stats.size());
   TabStatsList::iterator it = stats.begin();
@@ skipping 74 matching lines @@
         continue;
       WebContents* web_contents = model->GetWebContentsAt(idx);
       int64 web_contents_id = IdFromWebContents(web_contents);
       if (web_contents_id == target_web_contents_id) {
         LOG(WARNING) << "Discarding tab " << idx
             << " id " << target_web_contents_id;
         // Record statistics before discarding because we want to capture the
         // memory state that lead to the discard.
         RecordDiscardStatistics();
         model->DiscardWebContentsAt(idx);
+        recent_tab_discard_ = true;
         return true;
       }
     }
   }
   return false;
 }
 
 void OomPriorityManager::RecordDiscardStatistics() {
   // Record a raw count so we can compare to discard reloads.
   discard_count_++;
@@ skipping 25 matching lines @@
   // Record Chrome's concept of system memory usage at the time of the discard.
   base::SystemMemoryInfoKB memory;
   if (base::GetSystemMemoryInfo(&memory)) {
     // TODO(jamescook): Remove this after R25 is deployed to stable. It does
     // not have sufficient resolution in the 2-4 GB range and does not properly
     // account for graphics memory on ARM. Replace with MemAllocatedMB below.
     int mem_anonymous_mb = (memory.active_anon + memory.inactive_anon) / 1024;
     EXPERIMENT_HISTOGRAM_MEGABYTES("Tabs.Discard.MemAnonymousMB",
                                    mem_anonymous_mb);
 
+    // Record graphics GEM object size in a histogram with 50 MB buckets.
+    int mem_graphics_gem_mb = 0;
+    if (memory.gem_size != -1)
+      mem_graphics_gem_mb = memory.gem_size / 1024 / 1024;
+    RecordLinearHistogram(
+        "Tabs.Discard.MemGraphicsMB", mem_graphics_gem_mb, 2500, 50);
+
+    // Record shared memory (used by renderer/GPU buffers).
+    int mem_shmem_mb = memory.shmem / 1024;
+    RecordLinearHistogram("Tabs.Discard.MemShmemMB", mem_shmem_mb, 2500, 50);
+
     // On Intel, graphics objects are in anonymous pages, but on ARM they are
     // not. For a total "allocated count" add in graphics pages on ARM.
     int mem_allocated_mb = mem_anonymous_mb;
 #if defined(ARCH_CPU_ARM_FAMILY)
-    if (memory.gem_size != -1)
-      mem_allocated_mb += memory.gem_size / 1024 / 1024;
+    mem_allocated_mb += mem_graphics_gem_mb;
 #endif
     EXPERIMENT_CUSTOM_COUNTS("Tabs.Discard.MemAllocatedMB", mem_allocated_mb,
                              256, 32768, 50)
 
     int mem_available_mb =
         (memory.active_file + memory.inactive_file + memory.free) / 1024;
     EXPERIMENT_HISTOGRAM_MEGABYTES("Tabs.Discard.MemAvailableMB",
                                    mem_available_mb);
   }
   // Set up to record the next interval.
   last_discard_time_ = TimeTicks::Now();
 }
 
+void OomPriorityManager::RecordRecentTabDiscard() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  // If we change the interval we need to change the histogram name.
+  UMA_HISTOGRAM_BOOLEAN("Tabs.Discard.DiscardInLastMinute",
+                        recent_tab_discard_);
+  // Reset for the next interval.
+  recent_tab_discard_ = false;
+}
+
 void OomPriorityManager::PurgeBrowserMemory() {
   // Based on experimental evidence, attempts to free memory from renderers
   // have been too slow to use in OOM situations (V8 garbage collection) or
   // do not lead to persistent decreased usage (image/bitmap caches). This
   // function therefore only targets large blocks of memory in the browser.
   for (TabContentsIterator it; !it.done(); it.Next()) {
     WebContents* web_contents = *it;
     // Screenshots can consume ~5 MB per web contents for platforms that do
     // touch back/forward.
     web_contents->GetController().ClearAllScreenshots();
@@ skipping 222 matching lines @@
         content::ZygoteHost::GetInstance()->AdjustRendererOOMScore(
             iterator->renderer_handle, score);
         pid_to_oom_score_[iterator->renderer_handle] = score;
       }
       priority += priority_increment;
     }
   }
 }
 
 }  // namespace chromeos