Add data collection for memory.numa_stat

Summary: As titled, this file has valuable data for numa memory consumption

Reviewed By: lnyng

Differential Revision: D40514647

fbshipit-source-id: 8a210f1e62b6aeea6242c432b90a304661498958

Author: Dan Schatzberg

below/cgroupfs/src/lib.rs

@@ -94,6 +94,15 @@ macro_rules! impl_read_pressure {
     }};
 }
 
+macro_rules! parse_and_set_fields {
+    ($struct:expr; $key:expr; $value:expr; [ $($field:ident,)+  ]) => (
+        match $key {
+            $(stringify!($field) => $struct.$field = Some($value),)*
+            _ => (),
+        }
+    )
+}
+
 impl CgroupReader {
     pub fn new(root: PathBuf) -> Result<CgroupReader> {
         CgroupReader::new_with_relative_path(root, PathBuf::from(OsStr::new("")))
@@ -248,6 +257,84 @@ impl CgroupReader {
         })
     }
 
+    // Reads memory.numa_stat - the return value is a map from numa_node_id ->
+    // memory breakdown
+    pub fn read_memory_numa_stat(&self) -> Result<BTreeMap<u32, MemoryNumaStat>> {
+        let mut s: BTreeMap<u32, MemoryNumaStat> = BTreeMap::new();
+        let file_name = "memory.numa_stat";
+        let file = self
+            .dir
+            .open_file(file_name)
+            .map_err(|e| self.io_error(file_name, e))?;
+        let buf_reader = BufReader::new(file);
+        for line in buf_reader.lines() {
+            let line = line.map_err(|e| self.io_error(file_name, e))?;
+            let items = line.split_whitespace().collect::<Vec<_>>();
+            // Need to have at least the field name + at least one N0=val item
+            if items.len() < 2 {
+                return Err(self.unexpected_line(file_name, line));
+            }
+            let field = items[0];
+            for item in items.iter().skip(1) {
+                let kv = item.split('=').collect::<Vec<_>>();
+                if kv.len() != 2 || kv[0].len() < 2 || !kv[0].starts_with('N') {
+                    return Err(self.unexpected_line(file_name, line));
+                }
+                let mut kchars = kv[0].chars();
+                kchars.next();
+                let numa_node = kchars
+                    .as_str()
+                    .parse::<u32>()
+                    .map_err(|_| self.unexpected_line(file_name, line.clone()))?;
+                parse_and_set_fields!(
+                    s.entry(numa_node).or_default();
+                    field;
+                    kv[1].parse().map_err(|_| self.unexpected_line(file_name, line.clone()))?;
+                    [
+                        anon,
+                        file,
+                        kernel_stack,
+                        pagetables,
+                        shmem,
+                        file_mapped,
+                        file_dirty,
+                        file_writeback,
+                        swapcached,
+                        anon_thp,
+                        file_thp,
+                        shmem_thp,
+                        inactive_anon,
+                        active_anon,
+                        inactive_file,
+                        active_file,
+                        unevictable,
+                        slab_reclaimable,
+                        slab_unreclaimable,
+                        workingset_refault_anon,
+                        workingset_refault_file,
+                        workingset_activate_anon,
+                        workingset_activate_file,
+                        workingset_restore_anon,
+                        workingset_restore_file,
+                        workingset_nodereclaim,
+                    ]
+                );
+            }
+        }
+
+        if s.is_empty() {
+            return Err(self.invalid_file_format(file_name));
+        }
+
+        for (_node, memory_numa_stat) in s.iter() {
+            if *memory_numa_stat == MemoryNumaStat::default() {
+                return Err(self.invalid_file_format(file_name));
+            }
+        }
+
+        Ok(s)
+    }
+
     /// Return an iterator over child cgroups
     pub fn child_cgroup_iter(&self) -> Result<impl Iterator<Item = CgroupReader> + '_> {
         Ok(self
@@ -428,13 +515,13 @@ macro_rules! name_key_equal_value_format {
                         }
                         // Certain keys such as cost.usage can not be struct fields so must use cost_usage
                         let key = kv[0].replace(".", "_");
-                        match key.as_ref() {
-                            $(stringify!($field) => s.$field = Some(
-                                kv[1].parse().map_err(|_| r.unexpected_line(file_name.clone(), line.clone()))?
-                            ),)*
-                            _ => (),
-                        };
-                    }
+                        parse_and_set_fields!(
+                            s;
+                            key.as_ref();
+                            kv[1].parse().map_err(|_| r.unexpected_line(file_name.clone(), line.clone()))?;
+                            [ $($field,)* ]
+                        )
+                    };
                     if s == $struct::default() {
                         return Err(r.invalid_file_format(file_name))
                     }

below/cgroupfs/src/test.rs

@@ -23,6 +23,7 @@ use tempfile::TempDir;
 
 use crate::CgroupReader;
 use crate::Error;
+use crate::MemoryNumaStat;
 
 struct TestCgroup {
     tempdir: TempDir,
@@ -620,3 +621,190 @@ fn test_cgroup_stat_invalid_format() {
         _ => panic!("Got unexpected error type: {}", err),
     }
 }
+
+#[test]
+fn test_memory_numa_stat_success() {
+    let cgroup = TestCgroup::new();
+    cgroup.create_file_with_content(
+        "memory.numa_stat",
+        b"anon N0=133948178432 N1=85731622912 N2=56469581824 N3=67508137984
+file N0=29022474240 N1=28619689984 N2=27863502848 N3=20205821952
+kernel_stack N0=139689984 N1=93978624 N2=104693760 N3=145391616
+pagetables N0=464572416 N1=392798208 N2=332378112 N3=352788480
+shmem N0=27244945408 N1=27178311680 N2=27170930688 N3=13595549696
+file_mapped N0=27685949440 N1=27733299200 N2=27522891776 N3=15582023680
+file_dirty N0=6488064 N1=17436672 N2=85155840 N3=165040128
+file_writeback N0=0 N1=0 N2=38522880 N3=123408384
+swapcached N0=0 N1=0 N2=0 N3=0
+anon_thp N0=1419771904 N1=673185792 N2=536870912 N3=681574400
+file_thp N0=48234496 N1=14680064 N2=0 N3=48234496
+shmem_thp N0=48234496 N1=8388608 N2=0 N3=8388608
+inactive_anon N0=160479961088 N1=112294313984 N2=83386806272 N3=80141840384
+active_anon N0=466096128 N1=398712832 N2=8605696 N3=599347200
+inactive_file N0=1189363712 N1=913510400 N2=448503808 N3=2159505408
+active_file N0=522350592 N1=460431360 N2=206303232 N3=4300206080
+unevictable N0=405504 N1=135168 N2=0 N3=0
+slab_reclaimable N0=663340528 N1=563089336 N2=514239048 N3=647222000
+slab_unreclaimable N0=686272088 N1=472630728 N2=556250640 N3=693263576
+workingset_refault_anon N0=3497864 N1=2225803 N2=2410565 N3=1468001
+workingset_refault_file N0=214724399 N1=172943243 N2=2094241456 N3=155295239
+workingset_activate_anon N0=477507 N1=238415 N2=318245 N3=235467
+workingset_activate_file N0=96231899 N1=75825820 N2=674636976 N3=61718859
+workingset_restore_anon N0=182593 N1=55793 N2=96984 N3=53780
+workingset_restore_file N0=74008297 N1=63719159 N2=528595708 N3=48463497
+workingset_nodereclaim N0=266941 N1=176289 N2=1260264 N3=638641",
+    );
+
+    let cgroup_reader = cgroup.get_reader();
+    let val = cgroup_reader
+        .read_memory_numa_stat()
+        .expect("Failed to read numa memory stat");
+
+    assert_eq!(val.len(), 4);
+    let node0 = MemoryNumaStat {
+        anon: Some(133948178432),
+        file: Some(29022474240),
+        kernel_stack: Some(139689984),
+        pagetables: Some(464572416),
+        shmem: Some(27244945408),
+        file_mapped: Some(27685949440),
+        file_dirty: Some(6488064),
+        file_writeback: Some(0),
+        swapcached: Some(0),
+        anon_thp: Some(1419771904),
+        file_thp: Some(48234496),
+        shmem_thp: Some(48234496),
+        inactive_anon: Some(160479961088),
+        active_anon: Some(466096128),
+        inactive_file: Some(1189363712),
+        active_file: Some(522350592),
+        unevictable: Some(405504),
+        slab_reclaimable: Some(663340528),
+        slab_unreclaimable: Some(686272088),
+        workingset_refault_anon: Some(3497864),
+        workingset_refault_file: Some(214724399),
+        workingset_activate_anon: Some(477507),
+        workingset_activate_file: Some(96231899),
+        workingset_restore_anon: Some(182593),
+        workingset_restore_file: Some(74008297),
+        workingset_nodereclaim: Some(266941),
+    };
+    let node1 = MemoryNumaStat {
+        anon: Some(85731622912),
+        file: Some(28619689984),
+        kernel_stack: Some(93978624),
+        pagetables: Some(392798208),
+        shmem: Some(27178311680),
+        file_mapped: Some(27733299200),
+        file_dirty: Some(17436672),
+        file_writeback: Some(0),
+        swapcached: Some(0),
+        anon_thp: Some(673185792),
+        file_thp: Some(14680064),
+        shmem_thp: Some(8388608),
+        inactive_anon: Some(112294313984),
+        active_anon: Some(398712832),
+        inactive_file: Some(913510400),
+        active_file: Some(460431360),
+        unevictable: Some(135168),
+        slab_reclaimable: Some(563089336),
+        slab_unreclaimable: Some(472630728),
+        workingset_refault_anon: Some(2225803),
+        workingset_refault_file: Some(172943243),
+        workingset_activate_anon: Some(238415),
+        workingset_activate_file: Some(75825820),
+        workingset_restore_anon: Some(55793),
+        workingset_restore_file: Some(63719159),
+        workingset_nodereclaim: Some(176289),
+    };
+    let node2 = MemoryNumaStat {
+        anon: Some(56469581824),
+        file: Some(27863502848),
+        kernel_stack: Some(104693760),
+        pagetables: Some(332378112),
+        shmem: Some(27170930688),
+        file_mapped: Some(27522891776),
+        file_dirty: Some(85155840),
+        file_writeback: Some(38522880),
+        swapcached: Some(0),
+        anon_thp: Some(536870912),
+        file_thp: Some(0),
+        shmem_thp: Some(0),
+        inactive_anon: Some(83386806272),
+        active_anon: Some(8605696),
+        inactive_file: Some(448503808),
+        active_file: Some(206303232),
+        unevictable: Some(0),
+        slab_reclaimable: Some(514239048),
+        slab_unreclaimable: Some(556250640),
+        workingset_refault_anon: Some(2410565),
+        workingset_refault_file: Some(2094241456),
+        workingset_activate_anon: Some(318245),
+        workingset_activate_file: Some(674636976),
+        workingset_restore_anon: Some(96984),
+        workingset_restore_file: Some(528595708),
+        workingset_nodereclaim: Some(1260264),
+    };
+    let node3 = MemoryNumaStat {
+        anon: Some(67508137984),
+        file: Some(20205821952),
+        kernel_stack: Some(145391616),
+        pagetables: Some(352788480),
+        shmem: Some(13595549696),
+        file_mapped: Some(15582023680),
+        file_dirty: Some(165040128),
+        file_writeback: Some(123408384),
+        swapcached: Some(0),
+        anon_thp: Some(681574400),
+        file_thp: Some(48234496),
+        shmem_thp: Some(8388608),
+        inactive_anon: Some(80141840384),
+        active_anon: Some(599347200),
+        inactive_file: Some(2159505408),
+        active_file: Some(4300206080),
+        unevictable: Some(0),
+        slab_reclaimable: Some(647222000),
+        slab_unreclaimable: Some(693263576),
+        workingset_refault_anon: Some(1468001),
+        workingset_refault_file: Some(155295239),
+        workingset_activate_anon: Some(235467),
+        workingset_activate_file: Some(61718859),
+        workingset_restore_anon: Some(53780),
+        workingset_restore_file: Some(48463497),
+        workingset_nodereclaim: Some(638641),
+    };
+    assert_eq!(val[&0], node0);
+    assert_eq!(val[&1], node1);
+    assert_eq!(val[&2], node2);
+    assert_eq!(val[&3], node3);
+}
+
+#[test]
+fn test_memory_numa_stat_parse_failure() {
+    let cgroup = TestCgroup::new();
+    cgroup.create_file_with_content("memory.numa_stat", b"anon garbage\nfile garbage");
+
+    let cgroup_reader = cgroup.get_reader();
+    let err = cgroup_reader
+        .read_memory_numa_stat()
+        .expect_err("Did not fail to read memory.numa.stat");
+    match err {
+        Error::UnexpectedLine(_, _) => {}
+        _ => panic!("Got unexpected error type {}", err),
+    }
+}
+
+#[test]
+fn test_memory_numa_stat_invalid_format() {
+    let cgroup = TestCgroup::new();
+    cgroup.create_file_with_content("memory.numa_stat", b"");
+
+    let cgroup_reader = cgroup.get_reader();
+    let err = cgroup_reader
+        .read_memory_numa_stat()
+        .expect_err("Did not fail to read memory.numa_stat");
+    match err {
+        Error::InvalidFileFormat(_) => {}
+        _ => panic!("Got unexpected error type: {}", err),
+    }
+}

below/cgroupfs/src/types.rs

@@ -121,3 +121,33 @@ pub struct CgroupStat {
     pub nr_descendants: Option<u32>,
     pub nr_dying_descendants: Option<u32>,
 }
+
+#[derive(Default, Clone, PartialEq, Eq, Debug, Serialize, Deserialize)]
+pub struct MemoryNumaStat {
+    pub anon: Option<u64>,
+    pub file: Option<u64>,
+    pub kernel_stack: Option<u64>,
+    pub pagetables: Option<u64>,
+    pub shmem: Option<u64>,
+    pub file_mapped: Option<u64>,
+    pub file_dirty: Option<u64>,
+    pub file_writeback: Option<u64>,
+    pub swapcached: Option<u64>,
+    pub anon_thp: Option<u64>,
+    pub file_thp: Option<u64>,
+    pub shmem_thp: Option<u64>,
+    pub inactive_anon: Option<u64>,
+    pub active_anon: Option<u64>,
+    pub inactive_file: Option<u64>,
+    pub active_file: Option<u64>,
+    pub unevictable: Option<u64>,
+    pub slab_reclaimable: Option<u64>,
+    pub slab_unreclaimable: Option<u64>,
+    pub workingset_refault_anon: Option<u64>,
+    pub workingset_refault_file: Option<u64>,
+    pub workingset_activate_anon: Option<u64>,
+    pub workingset_activate_file: Option<u64>,
+    pub workingset_restore_anon: Option<u64>,
+    pub workingset_restore_file: Option<u64>,
+    pub workingset_nodereclaim: Option<u64>,
+}