Add memory stats for linux page cycler. On linux, we collect

base/process_util_linux.cc

 // Copyright (c) 2008 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 <fcntl.h>
 #include <unistd.h>
 #include <string>
 #include <sys/types.h>
 #include <sys/wait.h>
 
 #include "base/eintr_wrapper.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/string_tokenizer.h"
 #include "base/string_util.h"
 
 namespace {
 
 enum ParsingState {
   KEY_NAME,
   KEY_VALUE
 };
 
+// Reads /proc/<pid>/stat and populates |proc_stats| with the values split by
+// spaces.
+void GetProcStats(pid_t pid, std::vector<std::string>* proc_stats) {
+  FilePath stat_file("/proc");
+  stat_file = stat_file.Append(IntToString(pid));
+  stat_file = stat_file.Append("stat");
+  std::string mem_stats;
+  if (!file_util::ReadFileToString(stat_file, &mem_stats))
+    return;
+  SplitString(mem_stats, ' ', proc_stats);
+}
+
 }  // namespace
 
 namespace base {
 
 bool LaunchApp(const std::vector<std::string>& argv,
                const file_handle_mapping_vector& fds_to_remap,
                bool wait, ProcessHandle* process_handle) {
   pid_t pid = fork();
   if (pid < 0)
     return false;
@@ skipping 142 matching lines @@
 
 bool NamedProcessIterator::IncludeEntry() {
   // TODO(port): make this also work for non-ASCII filenames
   if (WideToASCII(executable_name_) != entry_.szExeFile)
     return false;
   if (!filter_)
     return true;
   return filter_->Includes(entry_.pid, entry_.ppid);
 }
 
+// On linux, we return vsize.
+size_t ProcessMetrics::GetPagefileUsage() const {
+  std::vector<std::string> proc_stats;
+  GetProcStats(process_, &proc_stats);
+  const size_t kVmSize = 22;
+  if (proc_stats.size() > kVmSize)
+    return static_cast<size_t>(StringToInt(proc_stats[kVmSize]));
+  return 0;
+}
+
+size_t ProcessMetrics::GetPeakPagefileUsage() const {
+  NOTIMPLEMENTED();
+  return 0;
+}
+
+// On linux, we return RSS.
+size_t ProcessMetrics::GetWorkingSetSize() const {
+  std::vector<std::string> proc_stats;
+  GetProcStats(process_, &proc_stats);
+  const size_t kVmRss = 23;
+  if (proc_stats.size() > kVmRss) {
+    size_t num_pages = static_cast<size_t>(StringToInt(proc_stats[kVmRss]));
+    return num_pages * getpagesize();
+  }
+  return 0;
+}
+
+size_t ProcessMetrics::GetPeakWorkingSetSize() const {
+  NOTIMPLEMENTED();
+  return 0;
+}
+
 // To have /proc/self/io file you must enable CONFIG_TASK_IO_ACCOUNTING
 // in your kernel configuration.
 bool ProcessMetrics::GetIOCounters(IoCounters* io_counters) const {
   std::string proc_io_contents;
-  if (!file_util::ReadFileToString(L"/proc/self/io", &proc_io_contents))
+  FilePath io_file("/proc");
+  io_file = io_file.Append(IntToString(process_));
+  io_file = io_file.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;
   std::string last_key_name;
   while (tokenizer.GetNext()) {
     switch (state) {
@@ skipping 13 matching lines @@
           (*io_counters).WriteTransferCount = StringToInt64(tokenizer.token());
         }
         state = KEY_NAME;
         break;
     }
   }
   return true;
 }
 
 }  // namespace base