Trying to count live blocks and live lines

Author: udesou

Cargo.toml

@@ -50,6 +50,7 @@ static_assertions = "1.1.0"
 strum = "0.25"
 strum_macros = "0.25"
 sysinfo = "0.29"
+chrono = "*"
 
 [dev-dependencies]
 paste = "1.0.8"

src/memory_manager.rs

@@ -557,13 +557,13 @@ pub fn live_bytes_in_last_gc<VM: VMBinding>(mmtk: &MMTK<VM>) -> usize {
     mmtk.state.live_bytes_in_last_gc.load(Ordering::SeqCst)
 }
 
-/// Return the percentage of fragmentation of the immixspace (e.g. 42.98 percent). To do that we count the size of every live object
+/// Return the percentage of occupation of the immixspace (e.g. 42.98 percent). To do that we count the size of every live object
 /// in the immixspace. Since MMTk accounts for memory in pages, we return the ratio between this number and
 /// the number of used bytes (according to the used pages by the immixspace).
 /// The value returned by this method is only updated when we finish tracing in a GC. A recommended timing
 /// to call this method is at the end of a GC (e.g. when the runtime is about to resume threads).
 #[cfg(feature = "count_live_bytes_immixspace")]
-pub fn fragmentation_rate_in_immixspace<VM: VMBinding>(mmtk: &MMTK<VM>) -> f64 {
+pub fn occupation_rate_in_immixspace<VM: VMBinding>(mmtk: &MMTK<VM>) -> f64 {
     use crate::policy::immix::ImmixSpace;
     use crate::policy::space::Space;
     let mut rate = None;
@@ -575,7 +575,7 @@ pub fn fragmentation_rate_in_immixspace<VM: VMBinding>(mmtk: &MMTK<VM>) -> f64 {
                     "There are multiple Immix spaces in the plan."
                 );
                 // Get the stats here from ImmixSpace
-                rate = Some(immix.get_fragmentation_rate());
+                rate = Some(immix.get_occupation_rate());
             }
         });
     rate.expect("No Immix space in the plan.") as f64 / 100.0

src/policy/immix/immixspace.rs

@@ -58,7 +58,7 @@ pub struct ImmixSpace<VM: VMBinding> {
     #[cfg(feature = "count_live_bytes_immixspace")]
     live_bytes_in_immixspace: AtomicUsize,
     #[cfg(feature = "count_live_bytes_immixspace")]
-    fragmentation_rate: AtomicUsize,
+    occupation_rate: AtomicUsize,
 }
 
 /// Some arguments for Immix Space.
@@ -328,7 +328,7 @@ impl<VM: VMBinding> ImmixSpace<VM> {
             #[cfg(feature = "count_live_bytes_immixspace")]
             live_bytes_in_immixspace: AtomicUsize::new(0),
             #[cfg(feature = "count_live_bytes_immixspace")]
-            fragmentation_rate: AtomicUsize::new(0),
+            occupation_rate: AtomicUsize::new(0),
         }
     }
 
@@ -483,25 +483,66 @@ impl<VM: VMBinding> ImmixSpace<VM> {
 
         // calculate the fragmentation rate
         #[cfg(feature = "count_live_bytes_immixspace")]
-        {
-            trace!("Live bytes in immixspace = {}", self.get_live_bytes());
-            trace!("Reserved pages in immixspace = {}", self.reserved_pages());
-
-            trace!(
-                "Reserved bytes in immixspace = {}",
-                self.reserved_pages() << LOG_BYTES_IN_PAGE
-            );
-            let f_rate: f64 =
-                self.get_live_bytes() as f64 / (self.reserved_pages() << LOG_BYTES_IN_PAGE) as f64;
+        self.dump_memory_stats();
 
-            let f_rate_usize: usize = (f_rate * 10000.0) as usize;
+        did_defrag
+    }
 
-            debug_assert!((0.0..=1.0).contains(&f_rate));
+    fn dump_memory_stats(&mut self) {
+        #[derive(Default)]
+        struct Dist {
+            live_blocks: usize,
+            live_lines: usize,
+        }
+        let mut dist = Dist::default();
+        for chunk in self.chunk_map.all_chunks() {
+            if !self.address_in_space(chunk.start()) {
+                continue;
+            }
 
-            self.set_fragmentation_rate(f_rate_usize);
+            for block in chunk
+                .iter_region::<Block>()
+                .filter(|b| b.get_state() != BlockState::Unallocated)
+            {
+                dist.live_blocks += 1;
+                for _line in block
+                    .lines()
+                    .filter(|l| l.is_marked(self.line_mark_state.load(Ordering::Acquire)))
+                {
+                    dist.live_lines = 1;
+                }
+            }
         }
 
-        did_defrag
+        println!(
+            "{} immixspace",
+            chrono::offset::Local::now().format("%Y-%m-%d %H:%M:%S")
+        );
+        println!("Live bytes = {}", self.get_live_bytes());
+        println!("Reserved pages = {}", self.reserved_pages());
+        println!(
+            "Reserved pages (bytes) = {}",
+            self.reserved_pages() << LOG_BYTES_IN_PAGE
+        );
+        println!("Live blocks = {}", dist.live_blocks);
+        println!(
+            "Live blocks (bytes) = {}",
+            dist.live_blocks << Block::LOG_BYTES
+        );
+        println!("Live lines = {}", dist.live_lines);
+        println!(
+            "Live lines (bytes) = {}",
+            dist.live_lines << Line::LOG_BYTES
+        );
+
+        let o_rate: f64 =
+            self.get_live_bytes() as f64 / (self.reserved_pages() << LOG_BYTES_IN_PAGE) as f64;
+
+        let o_rate_usize: usize = (o_rate * 10000.0) as usize;
+
+        debug_assert!((0.0..=1.0).contains(&o_rate));
+
+        self.set_occupation_rate(o_rate_usize);
     }
 
     /// Generate chunk sweep tasks
@@ -862,13 +903,13 @@ impl<VM: VMBinding> ImmixSpace<VM> {
     }
 
     #[cfg(feature = "count_live_bytes_immixspace")]
-    pub fn get_fragmentation_rate(&self) -> usize {
-        self.fragmentation_rate.load(Ordering::SeqCst)
+    pub fn get_occupation_rate(&self) -> usize {
+        self.occupation_rate.load(Ordering::SeqCst)
     }
 
     #[cfg(feature = "count_live_bytes_immixspace")]
-    pub fn set_fragmentation_rate(&self, size: usize) {
-        self.fragmentation_rate.store(size, Ordering::SeqCst);
+    pub fn set_occupation_rate(&self, size: usize) {
+        self.occupation_rate.store(size, Ordering::SeqCst);
     }
 }