ProcessMetrics::GetCPUUsage() is Slow

base/process/process_metrics_linux.cc

 // Copyright (c) 2013 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 "base/process/process_metrics.h"
 
 #include <dirent.h>
 #include <fcntl.h>
 #include <sys/stat.h>
 #include <sys/time.h>
@@ skipping 381 matching lines @@
   return ret;
 }
 
 size_t GetSystemCommitCharge() {
   SystemMemoryInfoKB meminfo;
   if (!GetSystemMemoryInfo(&meminfo))
     return 0;
   return meminfo.total - meminfo.free - meminfo.buffers - meminfo.cached;
 }
 
-// Exposed for testing.
 int ParseProcStatCPU(const std::string& input) {
-  std::vector<std::string> proc_stats;
-  if (!internal::ParseProcStats(input, &proc_stats))
+  // |input| may be empty if the process disappeared somehow.
+  // e.g. http://crbug.com/145811.
+  if (input.empty())
     return -1;
 
-  if (proc_stats.size() <= internal::VM_STIME)
+  size_t start = input.find_last_of(')');
+  if (start == input.npos)
     return -1;
-  int utime = GetProcStatsFieldAsInt64(proc_stats, internal::VM_UTIME);
-  int stime = GetProcStatsFieldAsInt64(proc_stats, internal::VM_STIME);
+
+  // Number of spaces remaining until reaching utime's index starting after the
+  // last ')'.
+  int num_spaces_remaining = internal::VM_UTIME - 1;
+  int utime_start_index = 0;
+
+  size_t i = start;
+  while ((i = input.find(' ', i + 1)) != input.npos) {
+    // Validate the assumption that there aren't any contiguous spaces
+    // in |input| before utime.
+    DCHECK_NE(input[i - 1], ' ');
+    if (--num_spaces_remaining == 0) {
+      utime_start_index = i;

[danakj, 2015/02/04 19:52:44]

cool thanks. one more comment, i think we could save a bunch of lines some
branching, and a variable by just doing the sscanf here on |i|. wdyt?

[afakhry, 2015/02/04 20:07:05]

I like that! :) Done!

+      break;
+    }
+  }
+
+  if (utime_start_index == 0)
+    return -1;
+
+  int utime = 0;
+  int stime = 0;
+  if (sscanf(&input.data()[utime_start_index], "%d %d", &utime, &stime) != 2)
+    return -1;
+
   return utime + stime;
 }
 
 const char kProcSelfExe[] = "/proc/self/exe";
 
 int GetNumberOfThreads(ProcessHandle process) {
   return internal::ReadProcStatsAndGetFieldAsInt64(process,
                                                    internal::VM_NUMTHREADS);
 }
 
@@ skipping 466 matching lines @@
 #if defined(OS_LINUX)
 int ProcessMetrics::GetIdleWakeupsPerSecond() {
   uint64 wake_ups;
   const char kWakeupStat[] = "se.statistics.nr_wakeups";
   return ReadProcSchedAndGetFieldAsUint64(process_, kWakeupStat, &wake_ups) ?
       CalculateIdleWakeupsPerSecond(wake_ups) : 0;
 }
 #endif  // defined(OS_LINUX)
 
 }  // namespace base