Add per-process "hard fault" column to TaskManager

Hard faults (or "major" faults) are attempts to access memory pages
which are not resident in physical RAM, and therefore incur substantial
cost to make available (e.g. paging-in from disk, decompressing from
in-memory compressed swap, etc).

Task Manager will now offer an optional column showing the hard-fault
rate in each sampling cycle. 

Bug: 723767
Change-Id: If3e77759e7725f6c70b2e4f163adbca600d00ba7
Reviewed-on: https://chromium-review.googlesource.com/538464Reviewed-by: Nick Carter <nick@chromium.org>
Commit-Queue: Wez <wez@chromium.org>
Cr-Commit-Position: refs/heads/master@{#515799}

chrome/app/generated_resources.grd

@@ -2994,6 +2994,9 @@ From <ph name="DOWNLOAD_DOMAIN">$3<ex>example.com</ex></ph>
           <message name="IDS_TASK_MANAGER_IDLE_WAKEUPS_COLUMN" desc="Task manager idle processor wakeups column">
             Idle wake ups
           </message>
+          <message name="IDS_TASK_MANAGER_HARD_FAULTS_COLUMN" desc="Task manager hard fault count column">
+            Hard faults
+          </message>
           <message name="IDS_TASK_MANAGER_OPEN_FD_COUNT_COLUMN" desc="Task manager open fds (file descriptors) count column">
             File descriptors
           </message>
@@ -3077,6 +3080,9 @@ From <ph name="DOWNLOAD_DOMAIN">$3<ex>example.com</ex></ph>
           <message name="IDS_TASK_MANAGER_IDLE_WAKEUPS_COLUMN" desc="Task manager idle processor wakeups column">
             Idle Wake Ups
           </message>
+          <message name="IDS_TASK_MANAGER_HARD_FAULTS_COLUMN" desc="Task manager hard fault count column">
+            Hard Faults
+          </message>
           <message name="IDS_TASK_MANAGER_OPEN_FD_COUNT_COLUMN" desc="Task manager open fds (file descriptors) count column">
             File Descriptors
           </message>

chrome/browser/task_manager/sampling/shared_sampler.h

@@ -39,10 +39,11 @@ class SharedSampler : public base::RefCountedThreadSafe<SharedSampler> {
       const scoped_refptr<base::SequencedTaskRunner>& blocking_pool_runner);
 
   struct SamplingResult {
+    base::TimeDelta cpu_time;
+    int64_t hard_faults_per_second;
     int idle_wakeups_per_second;
     int64_t physical_bytes;
     base::Time start_time;
-    base::TimeDelta cpu_time;
   };
   using OnSamplingCompleteCallback =
       base::Callback<void(base::Optional<SamplingResult>)>;

chrome/browser/task_manager/sampling/shared_sampler_win.cc

@@ -141,6 +141,7 @@ struct ProcessData {
   ProcessData() = default;
   ProcessData(ProcessData&&) = default;
 
+  int64_t hard_fault_count;
   int64_t physical_bytes;
   base::Time start_time;
   base::TimeDelta cpu_time;
@@ -249,7 +250,8 @@ SharedSampler::~SharedSampler() {}
 
 int64_t SharedSampler::GetSupportedFlags() const {
   return REFRESH_TYPE_IDLE_WAKEUPS | REFRESH_TYPE_PHYSICAL_MEMORY |
-         REFRESH_TYPE_START_TIME | REFRESH_TYPE_CPU_TIME;
+         REFRESH_TYPE_START_TIME | REFRESH_TYPE_CPU_TIME |
+         REFRESH_TYPE_HARD_FAULTS;
 }
 
 void SharedSampler::RegisterCallback(
@@ -411,6 +413,7 @@ std::unique_ptr<ProcessDataSnapshot> SharedSampler::CaptureSnapshot() {
         // not count context switches for threads that are missing in the most
         // recent snapshot.
         ProcessData process_data;
+        process_data.hard_fault_count = pi->HardFaultCount;
         process_data.physical_bytes =
             static_cast<int64_t>(pi->WorkingSetPrivateSize);
         process_data.start_time = ConvertTicksToTime(pi->CreateTime);
@@ -478,9 +481,12 @@ SharedSampler::AllSamplingResults SharedSampler::MakeResultsFromTwoSnapshots(
         process_id, &prev_iter, prev_snapshot.processes.end());
 
     // Delta between the old snapshot and the new snapshot.
+    int64_t hard_faults_delta = 0;
     int idle_wakeups_delta;
 
     if (prev_snapshot_process) {
+      hard_faults_delta =
+          process.hard_fault_count - prev_snapshot_process->hard_fault_count;
       // Processes match between two snapshots. Diff context switches.
       idle_wakeups_delta =
           CountContextSwitchesDelta(*prev_snapshot_process, process);
@@ -492,6 +498,8 @@ SharedSampler::AllSamplingResults SharedSampler::MakeResultsFromTwoSnapshots(
 
     ProcessIdAndSamplingResult result;
     result.process_id = process_id;
+    result.data.hard_faults_per_second =
+        static_cast<int>(round(hard_faults_delta / time_delta));
     result.data.idle_wakeups_per_second =
         static_cast<int>(round(idle_wakeups_delta / time_delta));
     result.data.physical_bytes = process.physical_bytes;
@@ -512,6 +520,7 @@ SharedSampler::AllSamplingResults SharedSampler::MakeResultsFromSnapshot(
     result.process_id = pair.first;
     // Use 0 for Idle Wakeups / sec in this case. This is consistent with
     // ProcessMetrics::CalculateIdleWakeupsPerSecond implementation.
+    result.data.hard_faults_per_second = 0;
     result.data.idle_wakeups_per_second = 0;
     result.data.physical_bytes = pair.second.physical_bytes;
     result.data.start_time = pair.second.start_time;

chrome/browser/task_manager/sampling/task_group.cc

@@ -100,14 +100,15 @@ TaskGroup::TaskGroup(
       gdi_peak_handles_(-1),
       user_current_handles_(-1),
       user_peak_handles_(-1),
+      hard_faults_per_second_(-1),
 #endif  // defined(OS_WIN)
 #if BUILDFLAG(ENABLE_NACL)
       nacl_debug_stub_port_(nacl::kGdbDebugStubPortUnknown),
 #endif  // BUILDFLAG(ENABLE_NACL)
-      idle_wakeups_per_second_(-1),
 #if defined(OS_LINUX)
       open_fd_count_(-1),
 #endif  // defined(OS_LINUX)
+      idle_wakeups_per_second_(-1),
       gpu_memory_has_duplicates_(false),
       is_backgrounded_(false),
       weak_ptr_factory_(this) {
@@ -336,19 +337,21 @@ void TaskGroup::OnSamplerRefreshDone(
   // TODO(wez): Migrate the TaskGroup fields to Optional<> so we can remove
   // the need for all this sentinel-handling logic.
   if (results) {
-    start_time_ = results->start_time;
     cpu_time_ = results->cpu_time;
     idle_wakeups_per_second_ = results->idle_wakeups_per_second;
 #if defined(OS_WIN)
+    hard_faults_per_second_ = results->hard_faults_per_second;
     memory_usage_.physical_bytes = results->physical_bytes;
 #endif
+    start_time_ = results->start_time;
   } else {
-    start_time_ = base::Time();
     cpu_time_ = base::TimeDelta();
     idle_wakeups_per_second_ = -1;
 #if defined(OS_WIN)
+    hard_faults_per_second_ = 0;
     memory_usage_.physical_bytes = -1;
 #endif
+    start_time_ = base::Time();
   }
 
   OnBackgroundRefreshTypeFinished(expected_on_bg_done_flags_ &

chrome/browser/task_manager/sampling/task_group.h

@@ -99,6 +99,7 @@ class TaskGroup {
   int64_t gdi_peak_handles() const { return gdi_peak_handles_; }
   int64_t user_current_handles() const { return user_current_handles_; }
   int64_t user_peak_handles() const { return user_peak_handles_; }
+  int64_t hard_faults_per_second() const { return hard_faults_per_second_; }
 #endif  // defined(OS_WIN)
 
 #if BUILDFLAG(ENABLE_NACL)
@@ -178,15 +179,16 @@ class TaskGroup {
   int64_t gdi_peak_handles_;
   int64_t user_current_handles_;
   int64_t user_peak_handles_;
+  int64_t hard_faults_per_second_;
 #endif  // defined(OS_WIN)
 #if BUILDFLAG(ENABLE_NACL)
   int nacl_debug_stub_port_;
 #endif  // BUILDFLAG(ENABLE_NACL)
-  int idle_wakeups_per_second_;
 #if defined(OS_LINUX)
   // The number of file descriptors currently open by the process.
   int open_fd_count_;
 #endif  // defined(OS_LINUX)
+  int idle_wakeups_per_second_;
   bool gpu_memory_has_duplicates_;
   bool is_backgrounded_;
 

chrome/browser/task_manager/sampling/task_manager_impl.cc

@@ -160,6 +160,14 @@ int TaskManagerImpl::GetIdleWakeupsPerSecond(TaskId task_id) const {
   return GetTaskGroupByTaskId(task_id)->idle_wakeups_per_second();
 }
 
+int TaskManagerImpl::GetHardFaultsPerSecond(TaskId task_id) const {
+#if defined(OS_WIN)
+  return GetTaskGroupByTaskId(task_id)->hard_faults_per_second();
+#else
+  return -1;
+#endif
+}
+
 int TaskManagerImpl::GetNaClDebugStubPort(TaskId task_id) const {
 #if BUILDFLAG(ENABLE_NACL)
   return GetTaskGroupByTaskId(task_id)->nacl_debug_stub_port();

chrome/browser/task_manager/sampling/task_manager_impl.h

@@ -54,6 +54,7 @@ class TaskManagerImpl : public TaskManagerInterface,
                             bool* has_duplicates) const override;
   base::MemoryState GetMemoryState(TaskId task_id) const override;
   int GetIdleWakeupsPerSecond(TaskId task_id) const override;
+  int GetHardFaultsPerSecond(TaskId task_id) const override;
   int GetNaClDebugStubPort(TaskId task_id) const override;
   void GetGDIHandles(TaskId task_id,
                      int64_t* current,

chrome/browser/task_manager/task_manager_interface.h

@@ -110,6 +110,10 @@ class TaskManagerInterface {
   // refresh cycle. A value of -1 means no valid value is currently available.
   virtual int GetIdleWakeupsPerSecond(TaskId task_id) const = 0;
 
+  // Returns the number of hard page faults per second since the last refresh
+  // cycle. A value of -1 means no valid value is currently available.
+  virtual int GetHardFaultsPerSecond(TaskId task_id) const = 0;
+
   // Returns the NaCl GDB debug stub port. A value of
   // |nacl::kGdbDebugStubPortUnknown| means no valid value is currently
   // available. A value of -2 means NaCl is not enabled for this build.

chrome/browser/task_manager/task_manager_observer.h

@@ -51,6 +51,7 @@ enum RefreshType {
   REFRESH_TYPE_MEMORY_STATE = 1 << 15,
   REFRESH_TYPE_KEEPALIVE_COUNT = 1 << 16,
   REFRESH_TYPE_MEMORY_FOOTPRINT = 1 << 17,
+  REFRESH_TYPE_HARD_FAULTS = 1 << 18,
 
   REFRESH_TYPE_MEMORY = REFRESH_TYPE_PHYSICAL_MEMORY |
                         REFRESH_TYPE_MEMORY_FOOTPRINT |

chrome/browser/task_manager/test_task_manager.cc

@@ -71,6 +71,10 @@ int TestTaskManager::GetIdleWakeupsPerSecond(TaskId task_id) const {
   return -1;
 }
 
+int TestTaskManager::GetHardFaultsPerSecond(TaskId task_id) const {
+  return -1;
+}
+
 int TestTaskManager::GetNaClDebugStubPort(TaskId task_id) const {
   return -1;
 }

chrome/browser/task_manager/test_task_manager.h

@@ -38,6 +38,7 @@ class TestTaskManager : public TaskManagerInterface {
                             bool* has_duplicates) const override;
   base::MemoryState GetMemoryState(TaskId task_id) const override;
   int GetIdleWakeupsPerSecond(TaskId task_id) const override;
+  int GetHardFaultsPerSecond(TaskId task_id) const override;
   int GetNaClDebugStubPort(TaskId task_id) const override;
   void GetGDIHandles(TaskId task_id,
                      int64_t* current,

chrome/browser/ui/task_manager/task_manager_columns.cc

@@ -94,6 +94,11 @@ const TableColumnData kColumns[] = {
     {IDS_TASK_MANAGER_IDLE_WAKEUPS_COLUMN, ui::TableColumn::RIGHT, -1, 0,
      arraysize("idlewakeups") * kCharWidth, -1, true, false, false},
 
+#if defined(OS_WIN)
+    {IDS_TASK_MANAGER_HARD_FAULTS_COLUMN, ui::TableColumn::RIGHT, -1, 0,
+     arraysize("100000") * kCharWidth, -1, true, false, false},
+#endif
+
 #if defined(OS_LINUX)
     {IDS_TASK_MANAGER_OPEN_FD_COUNT_COLUMN, ui::TableColumn::RIGHT, -1, 0,
      arraysize("999") * kCharWidth, -1, true, false, false},
@@ -145,6 +150,7 @@ std::string GetColumnIdAsString(int column_id) {
     COLUMN_CASE(IDS_TASK_MANAGER_NACL_DEBUG_STUB_PORT_COLUMN);
     COLUMN_CASE(IDS_TASK_MANAGER_JAVASCRIPT_MEMORY_ALLOCATED_COLUMN);
     COLUMN_CASE(IDS_TASK_MANAGER_IDLE_WAKEUPS_COLUMN);
+    COLUMN_CASE(IDS_TASK_MANAGER_HARD_FAULTS_COLUMN);
     COLUMN_CASE(IDS_TASK_MANAGER_OPEN_FD_COUNT_COLUMN);
     COLUMN_CASE(IDS_TASK_MANAGER_PROCESS_PRIORITY_COLUMN);
     COLUMN_CASE(IDS_TASK_MANAGER_MEMORY_STATE_COLUMN);

chrome/browser/ui/task_manager/task_manager_table_model.cc

@@ -66,6 +66,7 @@ bool IsSharedByGroup(int column_id) {
     case IDS_TASK_MANAGER_WEBCORE_CSS_CACHE_COLUMN:
     case IDS_TASK_MANAGER_NACL_DEBUG_STUB_PORT_COLUMN:
     case IDS_TASK_MANAGER_IDLE_WAKEUPS_COLUMN:
+    case IDS_TASK_MANAGER_HARD_FAULTS_COLUMN:
     case IDS_TASK_MANAGER_OPEN_FD_COUNT_COLUMN:
     case IDS_TASK_MANAGER_PROCESS_PRIORITY_COLUMN:
     case IDS_TASK_MANAGER_MEMORY_STATE_COLUMN:
@@ -195,6 +196,13 @@ class TaskManagerValuesStringifier {
     return base::FormatNumber(idle_wakeups);
   }
 
+  base::string16 GetHardFaultsText(int hard_faults) {
+    if (hard_faults == -1)
+      return n_a_string_;
+
+    return base::FormatNumber(hard_faults);
+  }
+
   base::string16 GetNaClPortText(int nacl_port) {
     // Only called if NaCl debug stub ports are enabled.
 
@@ -404,6 +412,10 @@ base::string16 TaskManagerTableModel::GetText(int row, int column) {
       return stringifier_->GetIdleWakeupsText(
           observed_task_manager()->GetIdleWakeupsPerSecond(tasks_[row]));
 
+    case IDS_TASK_MANAGER_HARD_FAULTS_COLUMN:
+      return stringifier_->GetHardFaultsText(
+          observed_task_manager()->GetHardFaultsPerSecond(tasks_[row]));
+
     case IDS_TASK_MANAGER_WEBCORE_IMAGE_CACHE_COLUMN: {
       blink::WebCache::ResourceTypeStats stats;
       if (observed_task_manager()->GetWebCacheStats(tasks_[row], &stats))
@@ -574,6 +586,11 @@ int TaskManagerTableModel::CompareValues(int row1,
           observed_task_manager()->GetIdleWakeupsPerSecond(tasks_[row1]),
           observed_task_manager()->GetIdleWakeupsPerSecond(tasks_[row2]));
 
+    case IDS_TASK_MANAGER_HARD_FAULTS_COLUMN:
+      return ValueCompare(
+          observed_task_manager()->GetHardFaultsPerSecond(tasks_[row1]),
+          observed_task_manager()->GetHardFaultsPerSecond(tasks_[row2]));
+
     case IDS_TASK_MANAGER_WEBCORE_IMAGE_CACHE_COLUMN:
     case IDS_TASK_MANAGER_WEBCORE_SCRIPTS_CACHE_COLUMN:
     case IDS_TASK_MANAGER_WEBCORE_CSS_CACHE_COLUMN: {
@@ -774,6 +791,10 @@ void TaskManagerTableModel::UpdateRefreshTypes(int column_id, bool visibility) {
       type = REFRESH_TYPE_IDLE_WAKEUPS;
       break;
 
+    case IDS_TASK_MANAGER_HARD_FAULTS_COLUMN:
+      type = REFRESH_TYPE_HARD_FAULTS;
+      break;
+
     case IDS_TASK_MANAGER_WEBCORE_IMAGE_CACHE_COLUMN:
     case IDS_TASK_MANAGER_WEBCORE_SCRIPTS_CACHE_COLUMN:
     case IDS_TASK_MANAGER_WEBCORE_CSS_CACHE_COLUMN: