Make task manager memory data more efficient and meaningful.

chrome/browser/task_manager/task_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/task_manager/task_manager.h"
 
 #include "base/bind.h"
 #include "base/i18n/number_formatting.h"
 #include "base/i18n/rtl.h"
 #include "base/location.h"
 #include "base/prefs/pref_registry_simple.h"
 #include "base/prefs/pref_service.h"
-#include "base/process/process_metrics.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/thread_task_runner_handle.h"
 #include "chrome/browser/browser_process.h"
+#include "chrome/browser/private_working_set_snapshot.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/profiles/profile_window.h"
 #include "chrome/browser/task_manager/background_information.h"
 #include "chrome/browser/task_manager/browser_process_resource_provider.h"
 #include "chrome/browser/task_manager/child_process_resource_provider.h"
 #include "chrome/browser/task_manager/extension_information.h"
 #include "chrome/browser/task_manager/guest_information.h"
 #include "chrome/browser/task_manager/panel_information.h"
 #include "chrome/browser/task_manager/printing_information.h"
 #include "chrome/browser/task_manager/resource_provider.h"
@@ skipping 235 matching lines @@
   AddResourceProvider(
       new task_manager::ChildProcessResourceProvider(task_manager));
   AddResourceProvider(new task_manager::WebContentsResourceProvider(
       task_manager,
       scoped_ptr<WebContentsInformation>(
           new task_manager::ExtensionInformation())));
   AddResourceProvider(new task_manager::WebContentsResourceProvider(
       task_manager,
       scoped_ptr<WebContentsInformation>(
           new task_manager::GuestInformation())));
+#if defined(OS_WIN)
+  working_set_snapshot_.reset(new PrivateWorkingSetSnapshot);
+  working_set_snapshot_->AddToMonitorList("chrome");
+  working_set_snapshot_->AddToMonitorList("nacl64");
+#endif
 }
 
 void TaskManagerModel::AddObserver(TaskManagerModelObserver* observer) {
   observer_list_.AddObserver(observer);
 }
 
 void TaskManagerModel::RemoveObserver(TaskManagerModelObserver* observer) {
   observer_list_.RemoveObserver(observer);
 }
 
@@ skipping 284 matching lines @@
     MetricsMap::const_iterator iter = metrics_map_.find(handle);
     if (iter == metrics_map_.end() ||
         !iter->second->GetWorkingSetKBytes(&ws_usage))
       return false;
 
     values.is_physical_memory_valid = true;
 #if defined(OS_LINUX)
     // On Linux private memory is also resident. Just use it.
     values.physical_memory = ws_usage.priv * 1024;
 #else
-    // Memory = working_set.private + working_set.shareable.
-    // We exclude the shared memory.
+    // Memory = working_set.private which is working set minus shareable. This
+    // avoids the unpredictable counting that occurs when calculating memory as
+    // working set minus shared (renderer code counted when one tab is open and
+    // not counted when two or more are open) and it is much more efficient to
+    // calculate on Windows.
     values.physical_memory = iter->second->GetWorkingSetSize();
-    values.physical_memory -= ws_usage.shared * 1024;
+    values.physical_memory -= ws_usage.shareable * 1024;
 #endif
   }
   *result = values.physical_memory;
   return true;
 }
 
 void TaskManagerModel::GetGDIHandles(int index,
                                      size_t* current,
                                      size_t* peak) const {
   *current = 0;
@@ skipping 521 matching lines @@
     FOR_EACH_OBSERVER(TaskManagerModelObserver, observer_list_,
                       OnItemsRemoved(0, size));
   }
 }
 
 void TaskManagerModel::ModelChanged() {
   // Notify the table that the contents have changed for it to redraw.
   FOR_EACH_OBSERVER(TaskManagerModelObserver, observer_list_, OnModelChanged());
 }
 
+void TaskManagerModel::RefreshPhysicalMemoryFromWorkingSetSnapshot() {
+#if defined(OS_WIN)
+  // Collect working-set data for all monitored processes in one operation, to
+  // avoid the inefficiency of retrieving it one at a time.
+  working_set_snapshot_->Sample();
+
+  for (size_t i = 0; i < resources_.size(); ++i) {
+    size_t private_working_set =
+        working_set_snapshot_->GetPrivateWorkingSet(GetProcessId(i));
+
+    // If working-set data is available then use it. If not then
+    // GetWorkingSetKBytes will retrieve the data. This is rare except on
+    // Windows XP where GetWorkingSetKBytes will always be used.
+    if (private_working_set) {
+      // Fill in the cache with the retrieved private working set value.
+      base::ProcessHandle handle = GetResource(i)->GetProcess();
+      PerProcessValues& values(per_process_cache_[handle]);
+      values.is_physical_memory_valid = true;
+      // Note that the other memory fields are *not* filled in.
+      values.physical_memory = private_working_set;
+    }
+  }
+#else
+// This is a NOP on other platforms because they can efficiently retrieve
+// the private working-set data on a per-process basis.
+#endif
+}
+
 void TaskManagerModel::Refresh() {
   per_resource_cache_.clear();
   per_process_cache_.clear();
+  RefreshPhysicalMemoryFromWorkingSetSnapshot();
 
 #if !defined(DISABLE_NACL)
   nacl::NaClBrowser* nacl_browser = nacl::NaClBrowser::GetInstance();
 #endif  // !defined(DISABLE_NACL)
 
   // Compute the CPU usage values and check if NaCl GDB debug stub port is
   // known.
   // Note that we compute the CPU usage for all resources (instead of doing it
   // lazily) as process_util::GetCPUUsage() returns the CPU usage since the last
   // time it was called, and not calling it everytime would skew the value the
@@ skipping 386 matching lines @@
   params.host_desktop_type = desktop_type;
   chrome::Navigate(&params);
 }
 
 TaskManager::TaskManager()
     : model_(new TaskManagerModel(this)) {
 }
 
 TaskManager::~TaskManager() {
 }