Add some examples that show how to get currernt memory usage

Author: eminence

README.md

@@ -18,8 +18,6 @@ Here's a small example that prints out all processes that are running on the sam
 process.  This is very similar to what "ps" does in its default mode:
 
 ```rust
-extern crate procfs;
-
 fn main() {
     let me = procfs::Process::myself().unwrap();
     let tps = procfs::ticks_per_second().unwrap();
@@ -41,6 +39,28 @@ fn main() {
 }
 ```
 
+Here's another example that shows how to get the current memory usage of the current process:
+
+```rust
+use procfs::process::Process;
+
+fn main() {
+    let me = Process::myself().unwrap();
+    println!("PID: {}", me.pid);
+
+    let page_size = procfs::page_size().unwrap() as u64;
+    println!("Memory page size: {}", page_size);
+
+    println!("== Data from /proc/self/stat:");
+    println!("Total virtual memory used: {} bytes", me.stat.vsize);
+    println!("Total resident set: {} pages ({} bytes)", me.stat.rss, me.stat.rss as u64 * page_size);
+}
+```
+
+There are a few ways to get this data, so also checkout the longer
+[self_memory](https://github.com/eminence/procfs/blob/master/examples/self_memory.rs) example for more
+details.
+
 ## Cargo features
 
 The following cargo features are available:

examples/README.md

@@ -60,3 +60,24 @@ Prints out all processes that share the same tty as the current terminal.  This
 24206 pty/13       0.11 ps
 ```
 
+## self_memory.rs
+
+Shows several ways to get the current memory usage of the current process
+
+```
+PID: 21867
+Memory page size: 4096
+== Data from /proc/self/stat:
+Total virtual memory used: 3436544 bytes
+Total resident set: 220 pages (901120 bytes)
+
+== Data from /proc/self/statm:
+Total virtual memory used: 839 pages (3436544 bytes)
+Total resident set: 220 pages (901120 byte)s
+Total shared memory: 191 pages (782336 bytes)
+
+== Data from /proc/self/status:
+Total virtual memory used: 3436544 bytes
+Total resident set: 901120 bytes
+Total shared memory: 782336 bytes
+```

examples/self_memory.rs

@@ -0,0 +1,57 @@
+use procfs::process::Process;
+
+fn main() {
+    let me = Process::myself().expect("Unable to load myself!");
+    println!("PID: {}", me.pid);
+
+    let page_size = procfs::page_size().expect("Unable to determinte page size!") as u64;
+    println!("Memory page size: {}", page_size);
+
+    // Note: when comparing the below values to what "top" will display, note that "top" will use
+    // base-2 units (kibibytes), not base-10 units (kilobytes).
+
+    println!("== Data from /proc/self/stat:");
+    println!("Total virtual memory used: {} bytes", me.stat.vsize);
+    println!(
+        "Total resident set: {} pages ({} bytes)",
+        me.stat.rss,
+        me.stat.rss as u64 * page_size
+    );
+    println!();
+
+    if let Ok(statm) = me.statm() {
+        println!("== Data from /proc/self/statm:");
+        println!(
+            "Total virtual memory used: {} pages ({} bytes)",
+            statm.size,
+            statm.size * page_size
+        );
+        println!(
+            "Total resident set: {} pages ({} byte)s",
+            statm.resident,
+            statm.resident * page_size
+        );
+        println!(
+            "Total shared memory: {} pages ({} bytes)",
+            statm.shared,
+            statm.shared * page_size
+        );
+        println!();
+    }
+
+    if let Ok(status) = me.status() {
+        println!("== Data from /proc/self/status:");
+        println!(
+            "Total virtual memory used: {} bytes",
+            status.vmsize.expect("vmsize") * 1024
+        );
+        println!(
+            "Total resident set: {} bytes",
+            status.vmrss.expect("vmrss") * 1024
+        );
+        println!(
+            "Total shared memory: {} bytes",
+            status.rssfile.expect("rssfile") * 1024 + status.rssshmem.expect("rssshmem") * 1024
+        );
+    }
+}

src/process.rs

@@ -32,6 +32,22 @@
 //!     }
 //! }
 //! ```
+//!
+//! Here's a simple example of how you could get the total memory used by the current process.
+//! There are several ways to do this.  For a longer example, see the `examples/self_memory.rs`
+//! file in the git repository.  You can run this example with:
+//!
+//! > cargo run --example=self_memory
+//!
+//! ```rust
+//! # use procfs::process::Process;
+//! let me = Process::myself().unwrap();
+//! let page_size = procfs::page_size().unwrap() as u64;
+//!
+//! println!("== Data from /proc/self/stat:");
+//! println!("Total virtual memory used: {} bytes", me.stat.vsize);
+//! println!("Total resident set: {} pages ({} bytes)", me.stat.rss, me.stat.rss as u64 * page_size);
+//! ```
 
 use super::*;
 use crate::from_iter;