Add about:memory support for Linux....

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 <sys/types.h>
@@ skipping 308 matching lines @@
     return num_pages * getpagesize();
   }
   return 0;
 }
 
 size_t ProcessMetrics::GetPrivateBytes() const {
   // http://crbug.com/16251
   return 0;
 }
 
+void ProcessMetrics::GetCommittedKBytes(CommittedKBytes* usage) const {
+  FilePath stat_file =
+    FilePath("/proc").Append(IntToString(process_)).Append("maps");

[Joel Stanley (old), 2009/08/03 16:02:37]

The other functions that scrape /proc/<pid> use smaps instead of maps, do you
have a reason to not be consistent?

smaps has the same data; the value 'Size' is the same as what you calculate for
size_t size = address_end - address_begin.

+  std::string maps;
+  size_t file_mapped_size = 0;
+  size_t anon_size = 0;
+  size_t private_size = 0;

[Evan Martin, 2009/08/03 05:16:11]

you can declare these variables closer to where they're used...

+  if (!file_util::ReadFileToString(stat_file, &maps))

[Evan Martin, 2009/08/03 05:16:11]

should this error case fill in |usage| since the caller can't otherwise tell the
call failed?

+    return;
+
+  std::vector<std::string> map_lines;
+  SplitString(maps, '\n', &map_lines);
+  for (std::vector<std::string>::iterator iter = map_lines.begin();
+       iter != map_lines.end(); ++iter) {
+    if (*iter == "") {
+      continue;
+    }
+
+    std::vector<std::string> fields;
+    SplitString(*iter, ' ', &fields);
+    if (fields.size() < 5) {
+      LOG(ERROR) << "Badly formatted /proc/*/maps line: " << *iter;
+      continue;
+    }
+
+    // First fields is memory range, which gives us size. Formatted as:
+    // XXXXXXXX-XXXXXXXX
+    unsigned int sep_pos = fields[0].find('-');

[Evan Martin, 2009/08/03 05:16:11]

string::size_type here, i guess

+    if (sep_pos == std::string::npos) {
+      LOG(ERROR) << "Badly formatted address range: " << fields[0];
+      continue;
+    }
+    int address_begin = HexStringToInt(fields[0].substr(0, sep_pos));
+    int address_end = HexStringToInt(fields[0].substr(sep_pos + 1));
+    if (address_end < address_begin)
+      continue;
+    size_t size = address_end - address_begin;
+
+    // Second field is permissions formatted as:
+    // [r-][w-][x-][ps]

[Evan Martin, 2009/08/03 05:16:11]

I think you have regex syntax here, right?  might make it more clear to sayu

"Second field is permissions formatted as four characters:"

+    // Where:
+    //   r = read
+    //   w = write
+    //   x = execute
+    //   p = private
+    //   s = shared
+    if (fields[1][3] == 'p')
+      private_size += size;
+
+    // Fifth field is inode. If non-zero, this memory region is mapped by a
+    // file.
+    int inode = 0;
+    StringToInt(fields[4], &inode);
+    if (inode) {
+      file_mapped_size += size;
+    } else {
+      anon_size += size;
+    }
+  }
+
+  usage->priv = private_size / 1024;
+  usage->image = file_mapped_size / 1024;
+  usage->mapped = anon_size / 1024;
+}
+
 // Private and Shared working set sizes are obtained from /proc/<pid>/smaps,
 // as in http://www.pixelbeat.org/scripts/ps_mem.py
 bool ProcessMetrics::GetWorkingSetKBytes(WorkingSetKBytes* ws_usage) const {
   FilePath stat_file =
     FilePath("/proc").Append(IntToString(process_)).Append("smaps");
   std::string smaps;
   int shared_kb = 0;
   int private_kb = 0;
   int pss_kb = 0;
   bool have_pss = false;
@@ skipping 21 matching lines @@
             private_kb += StringToInt(tokenizer.token());
         } else if (StartsWithASCII(last_key_name, "Pss", 1)) {
             have_pss = true;
             pss_kb += StringToInt(tokenizer.token()) + kPssAdjust;
         }
         state = KEY_NAME;
         break;
     }
   }
   ws_usage->priv = private_kb;
-  // Sharable is not calculated, as it does not provide interesting data.
-  ws_usage->shareable = 0;
   if (have_pss) {
-   ws_usage->shared = pss_kb - private_kb;
+    ws_usage->shared = pss_kb - private_kb;
   } else {
     ws_usage->shared = shared_kb;
   }
+  // Shared pages are sharable, so even if this isn't that useful, fill it in
+  // with the most sensible value since the about:memory handler page needs it.
+  ws_usage->shareable = ws_usage->shared;

[Joel Stanley (old), 2009/08/03 16:02:37]

from chrome/browser/resources/about_memory.html, which will be the only consumer
of this data on linux:
Ok, so on linux total private will be private. Makes sense
this looks like windows trying to calculate 'PSS' to me.
Can't work out what this is displayed as, so not sure if it makes sense.

If it were up to me, we would stop trying to fit the square linux memory stats
peg into the round windows memory stats hole.  Linux should parse
/proc/<pid>/smaps once, parse /proc/<pid>/status once, and the 5 columns on
about:memory will read:

Memory:
Private = Private_Dirty + Private_Clean
Shared = Pss - Private
Total = sum of the two above

Virtual Memory:
Private = VmSize
Mapped = VmRSS

A function in process_util can calculate these numbers directly, instead of
having the javascript do this.  The data structure for holding the info can
represent what is to be shown on the screen, instead of what the Windows API
returns.

   return true;
 }
 
 // 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;
   FilePath io_file("/proc");
   io_file = io_file.Append(IntToString(process_));
   io_file = io_file.Append("io");
@@ skipping 24 matching lines @@
           (*io_counters).WriteTransferCount = StringToInt64(tokenizer.token());
         }
         state = KEY_NAME;
         break;
     }
   }
   return true;
 }
 
 }  // namespace base