Linux: Stop using /proc/pid/smaps to calculate memory usage. It's too slow.

base/process_util_linux.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 "base/process_util.h"
 
 #include <ctype.h>
 #include <dirent.h>
 #include <dlfcn.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <sys/time.h>
 #include <sys/types.h>
 #include <sys/wait.h>
 #include <time.h>
 #include <unistd.h>
 
 #include "base/file_util.h"
 #include "base/logging.h"
-#include "base/stringprintf.h"
 #include "base/string_number_conversions.h"
 #include "base/string_split.h"
 #include "base/string_tokenizer.h"
 #include "base/string_util.h"
 #include "base/sys_info.h"
 #include "base/threading/thread_restrictions.h"
 
 namespace {
 
-// Max score for the old oom_adj range.  Used for conversion of new
-// values to old values.
-const int kMaxOldOomScore = 15;
-
 enum ParsingState {
   KEY_NAME,
   KEY_VALUE
 };
 
+const char kProcDir[] = "/proc";
+
+// Returns a FilePath to "/proc/pid".
+FilePath GetProcPidDir(pid_t pid) {
+  return FilePath(kProcDir).Append(base::Int64ToString(pid));
+}
+
 // Reads /proc/<pid>/stat and populates |proc_stats| with the values split by
 // spaces. Returns true if successful.
 bool GetProcStats(pid_t pid, std::vector<std::string>* proc_stats) {
   // Synchronously reading files in /proc is safe.
   base::ThreadRestrictions::ScopedAllowIO allow_io;
 
-  FilePath stat_file("/proc");
-  stat_file = stat_file.Append(base::IntToString(pid));
-  stat_file = stat_file.Append("stat");
+  FilePath stat_file = GetProcPidDir(pid).Append("stat");
   std::string mem_stats;
   if (!file_util::ReadFileToString(stat_file, &mem_stats))
     return false;
   base::SplitString(mem_stats, ' ', proc_stats);
   return true;
 }
 
 // Reads /proc/<pid>/cmdline and populates |proc_cmd_line_args| with the command
 // line arguments. Returns true if successful.
 // Note: /proc/<pid>/cmdline contains command line arguments separated by single
 // null characters. We tokenize it into a vector of strings using '\0' as a
 // delimiter.
 bool GetProcCmdline(pid_t pid, std::vector<std::string>* proc_cmd_line_args) {
   // Synchronously reading files in /proc is safe.
   base::ThreadRestrictions::ScopedAllowIO allow_io;
 
-  FilePath cmd_line_file("/proc");
-  cmd_line_file = cmd_line_file.Append(base::IntToString(pid));
-  cmd_line_file = cmd_line_file.Append("cmdline");
+  FilePath cmd_line_file = GetProcPidDir(pid).Append("cmdline");
   std::string cmd_line;
   if (!file_util::ReadFileToString(cmd_line_file, &cmd_line))
     return false;
   std::string delimiters;
   delimiters.push_back('\0');
   Tokenize(cmd_line, delimiters, proc_cmd_line_args);
   return true;
 }
 
 // Get the total CPU of a single process.  Return value is number of jiffies
 // on success or -1 on error.
 int GetProcessCPU(pid_t pid) {
   // Synchronously reading files in /proc is safe.
   base::ThreadRestrictions::ScopedAllowIO allow_io;
 
   // Use /proc/<pid>/task to find all threads and parse their /stat file.
-  FilePath path = FilePath(base::StringPrintf("/proc/%d/task/", pid));
+  FilePath path = GetProcPidDir(pid).Append("task");
 
   DIR* dir = opendir(path.value().c_str());
   if (!dir) {
     DPLOG(ERROR) << "opendir(" << path.value() << ")";
     return -1;
   }
 
   int total_cpu = 0;
   while (struct dirent* ent = readdir(dir)) {
     if (ent->d_name[0] == '.')
@@ skipping 13 matching lines @@
 }
 
 }  // namespace
 
 namespace base {
 
 ProcessId GetParentProcessId(ProcessHandle process) {
   // Synchronously reading files in /proc is safe.
   base::ThreadRestrictions::ScopedAllowIO allow_io;
 
-  FilePath stat_file("/proc");
-  stat_file = stat_file.Append(base::IntToString(process));
-  stat_file = stat_file.Append("status");
+  FilePath stat_file = GetProcPidDir(process).Append("status");
   std::string status;
   if (!file_util::ReadFileToString(stat_file, &status))
     return -1;
 
   StringTokenizer tokenizer(status, ":\n");
   ParsingState state = KEY_NAME;
   StringPiece last_key_name;
   while (tokenizer.GetNext()) {
     switch (state) {
       case KEY_NAME:
         last_key_name = tokenizer.token_piece();
         state = KEY_VALUE;
         break;
       case KEY_VALUE:
         DCHECK(!last_key_name.empty());
         if (last_key_name == "PPid") {
           int ppid;
           base::StringToInt(tokenizer.token_piece(), &ppid);
           return ppid;
         }
         state = KEY_NAME;
         break;
     }
   }
   NOTREACHED();
   return -1;
 }
 
 FilePath GetProcessExecutablePath(ProcessHandle process) {
-  FilePath stat_file("/proc");
-  stat_file = stat_file.Append(base::IntToString(process));
-  stat_file = stat_file.Append("exe");
+  FilePath stat_file = GetProcPidDir(process).Append("exe");
   FilePath exe_name;
   if (!file_util::ReadSymbolicLink(stat_file, &exe_name)) {
     // No such process.  Happens frequently in e.g. TerminateAllChromeProcesses
     return FilePath();
   }
   return exe_name;
 }
 
 ProcessIterator::ProcessIterator(const ProcessFilter* filter)
     : filter_(filter) {
-  procfs_dir_ = opendir("/proc");
+  procfs_dir_ = opendir(kProcDir);
 }
 
 ProcessIterator::~ProcessIterator() {
   if (procfs_dir_) {
     closedir(procfs_dir_);
     procfs_dir_ = NULL;
   }
 }
 
 bool ProcessIterator::CheckForNextProcess() {
@@ skipping 30 matching lines @@
 
     // Read the process's command line.
     std::string pid_string(slot->d_name);
     int pid;
     if (StringToInt(pid_string, &pid) && !GetProcCmdline(pid, &cmd_line_args))
       continue;
 
     // Read the process's status.
     char buf[NAME_MAX + 12];
     sprintf(buf, "/proc/%s/stat", slot->d_name);
-    FILE *fp = fopen(buf, "r");
+    FILE* fp = fopen(buf, "r");
     if (!fp)
       continue;
     const char* result = fgets(buf, sizeof(buf), fp);
     fclose(fp);
     if (!result)
       continue;
 
     // Parse the status.  It is formatted like this:
     // %d (%s) %c %d %d ...
     // pid (name) runstate ppid gid
@@ skipping 109 matching lines @@
 
   if (private_bytes)
     *private_bytes = ws_usage.priv << 10;
 
   if (shared_bytes)
     *shared_bytes = ws_usage.shared * 1024;
 
   return true;
 }
 
-// Private and Shared working set sizes are obtained from /proc/<pid>/smaps.
-// When that's not available, use the values from /proc<pid>/statm as a
-// close approximation.
-// See http://www.pixelbeat.org/scripts/ps_mem.py
+// Private and Shared working set sizes are obtained from /proc/<pid>/statm.
 bool ProcessMetrics::GetWorkingSetKBytes(WorkingSetKBytes* ws_usage) const {
-  // Synchronously reading files in /proc is safe.
-  base::ThreadRestrictions::ScopedAllowIO allow_io;
+  // Use statm instead of smaps because smaps is:
+  // a) Large and slow to parse.
+  // b) Unavailable in the SUID sandbox.
 
-  FilePath proc_dir = FilePath("/proc").Append(base::IntToString(process_));
-  std::string smaps;
-  int private_kb = 0;
-  int pss_kb = 0;
-  bool have_pss = false;
-  bool ret;
+  // First we need to get the page size, since everything is measured in pages.
+  // For details, see: man 5 proc.
+  const int page_size_kb = sysconf(_SC_PAGE_SIZE) / 1024;
+  if (page_size_kb <= 0)
+    return false;
 
+  std::string statm;
   {
-    FilePath smaps_file = proc_dir.Append("smaps");
+    FilePath statm_file = GetProcPidDir(process_).Append("statm");
     // Synchronously reading files in /proc is safe.
     base::ThreadRestrictions::ScopedAllowIO allow_io;
-    ret = file_util::ReadFileToString(smaps_file, &smaps);
-  }
-  if (ret && smaps.length() > 0) {
-    const std::string private_prefix = "Private_";
-    const std::string pss_prefix = "Pss";
-    StringTokenizer tokenizer(smaps, ":\n");
-    StringPiece last_key_name;
-    ParsingState state = KEY_NAME;
-    while (tokenizer.GetNext()) {
-      switch (state) {
-        case KEY_NAME:
-          last_key_name = tokenizer.token_piece();
-          state = KEY_VALUE;
-          break;
-        case KEY_VALUE:
-          if (last_key_name.empty()) {
-            NOTREACHED();
-            return false;
-          }
-          if (last_key_name.starts_with(private_prefix)) {
-            int cur;
-            base::StringToInt(tokenizer.token_piece(), &cur);
-            private_kb += cur;
-          } else if (last_key_name.starts_with(pss_prefix)) {
-            have_pss = true;
-            int cur;
-            base::StringToInt(tokenizer.token_piece(), &cur);
-            pss_kb += cur;
-          }
-          state = KEY_NAME;
-          break;
-      }
-    }
-  } else {
-    // Try statm if smaps is empty because of the SUID sandbox.
-    // First we need to get the page size though.
-    int page_size_kb = sysconf(_SC_PAGE_SIZE) / 1024;
-    if (page_size_kb <= 0)
-      return false;
-
-    std::string statm;
-    {
-      FilePath statm_file = proc_dir.Append("statm");
-      // Synchronously reading files in /proc is safe.
-      base::ThreadRestrictions::ScopedAllowIO allow_io;
-      ret = file_util::ReadFileToString(statm_file, &statm);
-    }
+    bool ret = file_util::ReadFileToString(statm_file, &statm);
     if (!ret || statm.length() == 0)
       return false;
+  }
 
-    std::vector<std::string> statm_vec;
-    base::SplitString(statm, ' ', &statm_vec);
-    if (statm_vec.size() != 7)
-      return false;  // Not the format we expect.
+  std::vector<std::string> statm_vec;
+  base::SplitString(statm, ' ', &statm_vec);
+  if (statm_vec.size() != 7)
+    return false;  // Not the format we expect.
 
-    int statm1, statm2;
-    base::StringToInt(statm_vec[1], &statm1);
-    base::StringToInt(statm_vec[2], &statm2);
-    private_kb = (statm1 - statm2) * page_size_kb;
-  }
-  ws_usage->priv = private_kb;
+  int statm_rss, statm_shared;
+  base::StringToInt(statm_vec[1], &statm_rss);
+  base::StringToInt(statm_vec[2], &statm_shared);
+
+  ws_usage->priv = (statm_rss - statm_shared) * page_size_kb;
+  ws_usage->shared = statm_shared * page_size_kb;
+
   // Sharable is not calculated, as it does not provide interesting data.
   ws_usage->shareable = 0;
 
-  ws_usage->shared = 0;
-  if (have_pss)
-    ws_usage->shared = pss_kb;
   return true;
 }
 
 double ProcessMetrics::GetCPUUsage() {
   // This queries the /proc-specific scaling factor which is
   // conceptually the system hertz.  To dump this value on another
   // system, try
   //   od -t dL /proc/self/auxv
   // and look for the number after 17 in the output; mine is
   //   0000040          17         100           3   134512692
@@ skipping 33 matching lines @@
   return percentage;
 }
 
 // To have /proc/self/io file you must enable CONFIG_TASK_IO_ACCOUNTING
 // in your kernel configuration.
 bool ProcessMetrics::GetIOCounters(IoCounters* io_counters) const {
   // Synchronously reading files in /proc is safe.
   base::ThreadRestrictions::ScopedAllowIO allow_io;
 
   std::string proc_io_contents;
-  FilePath io_file("/proc");
-  io_file = io_file.Append(base::IntToString(process_));
-  io_file = io_file.Append("io");
+  FilePath io_file = GetProcPidDir(process_).Append("io");
   if (!file_util::ReadFileToString(io_file, &proc_io_contents))
     return false;
 
   (*io_counters).OtherOperationCount = 0;
   (*io_counters).OtherTransferCount = 0;
 
   StringTokenizer tokenizer(proc_io_contents, ": \n");
   ParsingState state = KEY_NAME;
   StringPiece last_key_name;
   while (tokenizer.GetNext()) {
@@ skipping 243 matching lines @@
 #endif
 }
 
 // NOTE: This is not the only version of this function in the source:
 // the setuid sandbox (in process_util_linux.c, in the sandbox source)
 // also has it's own C version.
 bool AdjustOOMScore(ProcessId process, int score) {
   if (score < 0 || score > kMaxOomScore)
     return false;
 
-  FilePath oom_path("/proc");
-  oom_path = oom_path.Append(base::Int64ToString(process));
+  FilePath oom_path(GetProcPidDir(process));
 
   // Attempt to write the newer oom_score_adj file first.
   FilePath oom_file = oom_path.AppendASCII("oom_score_adj");
   if (file_util::PathExists(oom_file)) {
     std::string score_str = base::IntToString(score);
     DVLOG(1) << "Adjusting oom_score_adj of " << process << " to "
              << score_str;
     int score_len = static_cast<int>(score_str.length());
     return (score_len == file_util::WriteFile(oom_file,
                                               score_str.c_str(),
                                               score_len));
   }
 
   // If the oom_score_adj file doesn't exist, then we write the old
   // style file and translate the oom_adj score to the range 0-15.
   oom_file = oom_path.AppendASCII("oom_adj");
   if (file_util::PathExists(oom_file)) {
-    std::string score_str = base::IntToString(
-        score * kMaxOldOomScore / kMaxOomScore);
+    // Max score for the old oom_adj range.  Used for conversion of new
+    // values to old values.
+    const int kMaxOldOomScore = 15;
+
+    int converted_score = score * kMaxOldOomScore / kMaxOomScore;
+    std::string score_str = base::IntToString(converted_score);
     DVLOG(1) << "Adjusting oom_adj of " << process << " to " << score_str;
     int score_len = static_cast<int>(score_str.length());
     return (score_len == file_util::WriteFile(oom_file,
                                               score_str.c_str(),
                                               score_len));
   }
 
   return false;
 }
 
 }  // namespace base