[NOT TO COMMIT YET] Using proc/pid/status file contents to get process metrics in linux.

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 30 matching lines @@
   if (!ReadFileToString(file, &file_as_string))
     return 0;
   TrimWhitespaceASCII(file_as_string, TRIM_ALL, &file_as_string);
   uint64 file_as_uint64 = 0;
   if (!StringToUint64(file_as_string, &file_as_uint64))
     return 0;
   return file_as_uint64;
 }
 #endif
 
-// Read /proc/<pid>/status and return the value for |field|, or 0 on failure.
-// Only works for fields in the form of "Field: value kB".
-size_t ReadProcStatusAndGetFieldAsSizeT(pid_t pid, const std::string& field) {
-  std::string status;
-  {
-    // Synchronously reading files in /proc does not hit the disk.
-    ThreadRestrictions::ScopedAllowIO allow_io;
-    FilePath stat_file = internal::GetProcPidDir(pid).Append("status");
-    if (!ReadFileToString(stat_file, &status))
-      return 0;
-  }
-
+// Parse the contents of status file and return the value of the field
+// requested.
+size_t ParseProcStatsAndGetFieldAsSizeT(const char* status_contents,

[Lei Zhang, 2015/10/06 21:09:00]

Just use StringPiece instead of const char* ? Then you can pass in a std::string
or const char*, without needing to do .c_str().

[ssid, 2015/10/07 09:12:15]

changed to string

+                                        const std::string& field) {
   StringPairs pairs;
-  SplitStringIntoKeyValuePairs(status, ':', '\n', &pairs);
+  SplitStringIntoKeyValuePairs(status_contents, ':', '\n', &pairs);
   TrimKeyValuePairs(&pairs);
   for (size_t i = 0; i < pairs.size(); ++i) {
     const std::string& key = pairs[i].first;
     const std::string& value_str = pairs[i].second;
     if (key == field) {
       std::vector<StringPiece> split_value_str = SplitStringPiece(
           value_str, " ", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
       if (split_value_str.size() != 2 || split_value_str[1] != "kB") {
         NOTREACHED();
         return 0;
       }
       size_t value;
       if (!StringToSizeT(split_value_str[0], &value)) {
         NOTREACHED();
         return 0;
       }
       return value;
     }
   }
   NOTREACHED();
   return 0;
 }
 
+// Read /proc/<pid>/status and return the value for |field|, or 0 on failure.
+// Only works for fields in the form of "Field: value kB".
+size_t ReadProcStatusAndGetFieldAsSizeT(pid_t pid, const std::string& field) {
+  std::string status;
+  {
+    // Synchronously reading files in /proc does not hit the disk.
+    ThreadRestrictions::ScopedAllowIO allow_io;
+    FilePath stat_file = internal::GetProcPidDir(pid).Append("status");
+    if (!ReadFileToString(stat_file, &status))
+      return 0;
+  }
+  return ParseProcStatsAndGetFieldAsSizeT(status.c_str(), field);
+}
+
+// Read file descriptor passed file descritor of /proc/<pid>/status and return
+// the value for |field|, or 0 on failure.
+// Only works for fields in the form of "Field: value kB".
+size_t ReadProcStatusFdAndGetFieldAsSizeT(PlatformFile proc_status_fd,

[Lei Zhang, 2015/10/06 21:09:00]

/proc/<pid>/status isn't that big, right? Why bother passing the fd and not just
the contents? I can see using a fd for smaps, which IIRC, is quite large.

[ssid, 2015/10/07 09:12:14]

yes, I moved the reading part to other file and not the api takes string.

+                                          const std::string& field) {
+  const size_t kMaxStatFileSize = 1 << 12;

[Lei Zhang, 2015/10/06 21:09:00]

Easier to just write 4096?

[ssid, 2015/10/07 09:12:15]

Done.

+  char status_data[kMaxStatFileSize];
+  status_data[0] = '\0';
+  lseek(proc_status_fd, 0, SEEK_SET);

[Lei Zhang, 2015/10/06 21:09:00]

Check return value?

[ssid, 2015/10/07 09:12:15]

Done.

+  ReadFromFD(proc_status_fd, status_data, kMaxStatFileSize);

[Lei Zhang, 2015/10/06 21:09:00]

Ditto, check this return value in place of the next line.

[ssid, 2015/10/07 09:12:14]

Done.

+  if (strlen(status_data) == 0)
+    return 0;
+  return ParseProcStatsAndGetFieldAsSizeT(status_data, field);
+}
+
 #if defined(OS_LINUX)
 // Read /proc/<pid>/sched and look for |field|. On succes, return true and
 // write the value for |field| into |result|.
 // Only works for fields in the form of "field    :     uint_value"
 bool ReadProcSchedAndGetFieldAsUint64(pid_t pid,
                                       const std::string& field,
                                       uint64* result) {
   std::string sched_data;
   {
     // Synchronously reading files in /proc does not hit the disk.
@@ skipping 288 matching lines @@
   ws_usage->shareable = 0;
 
 #if defined(OS_CHROMEOS)
   // Can't get swapped memory from statm.
   ws_usage->swapped = 0;
 #endif
 
   return ret;
 }
 
+size_t ProcessMetrics::GetWorkingSetSize(int proc_status_fd) const {
+  return ReadProcStatusFdAndGetFieldAsSizeT(proc_status_fd, "VmRSS") * 1024;
+}
+
+size_t ProcessMetrics::GetPeakWorkingSetSize(int proc_status_fd) const {
+  return ReadProcStatusFdAndGetFieldAsSizeT(proc_status_fd, "VmHWM") * 1024;
+}
+
 size_t GetSystemCommitCharge() {
   SystemMemoryInfoKB meminfo;
   if (!GetSystemMemoryInfo(&meminfo))
     return 0;
   return meminfo.total - meminfo.free - meminfo.buffers - meminfo.cached;
 }
 
 int ParseProcStatCPU(const std::string& input) {
   // |input| may be empty if the process disappeared somehow.
   // e.g. http://crbug.com/145811.
@@ skipping 498 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