Introduce LiveBytesStats. Cleanup

Author: qinsoon

docs/userguide/src/migration/prefix.md

@@ -30,6 +30,26 @@ Notes for the mmtk-core developers:
 
 <!-- Insert new versions here -->
 
+## 0.30.0
+
+### `live_bytes_in_last_gc` returns a map for live bytes in each space
+
+```admonish tldr
+The feature `count_live_bytes_in_gc` now collects live bytes statistics per space.
+Correspondingly, `memory_manager::live_bytes_in_last_gc` now returns a map for
+live bytes in each space.
+```
+
+API changes:
+
+-   module `memory_manager`
+    +   `live_bytes_in_last_gc` now returns a `HashMap<&'static str, LiveBytesStats>`. The keys are
+        strings for space names, and the values are statistics for live bytes in the space.
+
+See also:
+
+-   PR: <https://github.com/mmtk/mmtk-core/pull/1238>
+
 ## 0.28.0
 
 ### `handle_user_collection_request` returns `bool`

src/global_state.rs

@@ -46,9 +46,9 @@ pub struct GlobalState {
     /// A counteer that keeps tracks of the number of bytes allocated by malloc
     #[cfg(feature = "malloc_counted_size")]
     pub(crate) malloc_bytes: AtomicUsize,
-    /// This stores the size in bytes for all the live objects in last GC. This counter is only updated in the GC release phase.
+    /// This stores the live bytes and the used bytes (by pages) for each space in last GC. This counter is only updated in the GC release phase.
     #[cfg(feature = "count_live_bytes_in_gc")]
-    pub(crate) live_bytes_in_last_gc: AtomicRefCell<HashMap<&'static str, usize>>,
+    pub(crate) live_bytes_in_last_gc: AtomicRefCell<HashMap<&'static str, LiveBytesStats>>,
 }
 
 impl GlobalState {
@@ -216,3 +216,16 @@ pub enum GcStatus {
     GcPrepare,
     GcProper,
 }
+
+/// Statistics for the live bytes in the last GC. The statistics is per space.
+#[derive(Copy, Clone, Debug)]
+#[cfg(feature = "count_live_bytes_in_gc")]
+pub struct LiveBytesStats {
+    /// Total accumulated bytes of live objects in the space.
+    pub live_bytes: usize,
+    /// Total pages used by the space.
+    pub used_pages: usize,
+    /// Total bytes used by the space, computed from `used_pages`.
+    /// The ratio of live_bytes and used_bytes reflects the utilization of the memory in the space.
+    pub used_bytes: usize,
+}

src/lib.rs

@@ -46,6 +46,8 @@ pub(crate) use mmtk::MMAPPER;
 pub use mmtk::MMTK;
 
 mod global_state;
+#[cfg(feature = "count_live_bytes_in_gc")]
+pub use crate::global_state::LiveBytesStats;
 
 mod policy;
 

src/memory_manager.rs

@@ -534,14 +534,18 @@ pub fn free_bytes<VM: VMBinding>(mmtk: &MMTK<VM>) -> usize {
     mmtk.get_plan().get_free_pages() << LOG_BYTES_IN_PAGE
 }
 
-/// Return the size of all the live objects in bytes in the last GC. MMTk usually accounts for memory in pages.
+/// Return a hash map for live bytes statistics in the last GC for each space.
+///
+/// MMTk usually accounts for memory in pages by each space.
 /// This is a special method that we count the size of every live object in a GC, and sum up the total bytes.
-/// We provide this method so users can compare with `used_bytes` (which does page accounting), and know if
-/// the heap is fragmented.
+/// We provide this method so users can use [`crate::LiveBytesStats`] to know if
+/// the space is fragmented.
 /// 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_in_gc")]
-pub fn live_bytes_in_last_gc<VM: VMBinding>(mmtk: &MMTK<VM>) -> HashMap<&'static str, usize> {
+pub fn live_bytes_in_last_gc<VM: VMBinding>(
+    mmtk: &MMTK<VM>,
+) -> HashMap<&'static str, crate::LiveBytesStats> {
     mmtk.state.live_bytes_in_last_gc.borrow().clone()
 }
 

src/mmtk.rs

@@ -26,6 +26,8 @@ use crate::util::statistics::stats::Stats;
 use crate::vm::ReferenceGlue;
 use crate::vm::VMBinding;
 use std::cell::UnsafeCell;
+#[cfg(feature = "count_live_bytes_in_gc")]
+use std::collections::HashMap;
 use std::default::Default;
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::Arc;
@@ -526,4 +528,34 @@ impl<VM: VMBinding> MMTK<VM> {
             space.enumerate_objects(&mut enumerator);
         })
     }
+
+    /// Aggregate a hash map of live bytes per space with the space stats to produce
+    /// a map of [`crate::liveByteStats`] for the spaces.
+    #[cfg(feature = "count_live_bytes_in_gc")]
+    pub(crate) fn aggregate_live_bytes_in_last_gc(
+        &self,
+        live_bytes_per_space: HashMap<&'static str, usize>,
+    ) -> HashMap<&'static str, crate::LiveBytesStats> {
+        use crate::policy::space::Space;
+        let mut ret = HashMap::new();
+        self.get_plan().for_each_space(&mut |space: &dyn Space<VM>| {
+            let space_name = space.get_name();
+            let used_pages = space.reserved_pages();
+            if used_pages != 0 {
+                let used_bytes = space.reserved_pages() << crate::util::constants::LOG_BYTES_IN_PAGE;
+                let live_bytes = *live_bytes_per_space.get(space_name).unwrap_or(&0);
+                debug_assert!(
+                    live_bytes <= used_bytes,
+                    "Live bytes of objects in {} ({} bytes) is larger than used pages ({} bytes), something is wrong.",
+                    space_name, live_bytes, used_bytes
+                );
+                ret.insert(space_name, crate::LiveBytesStats {
+                    live_bytes,
+                    used_pages,
+                    used_bytes,
+                });
+            }
+        });
+        return ret;
+    }
 }

src/scheduler/gc_work.rs

@@ -160,7 +160,8 @@ impl<C: GCWorkContext + 'static> GCWork<C::VM> for Release<C> {
                 .scheduler
                 .worker_group
                 .get_and_clear_worker_live_bytes();
-            *mmtk.state.live_bytes_in_last_gc.borrow_mut() = live_bytes;
+            *mmtk.state.live_bytes_in_last_gc.borrow_mut() =
+                mmtk.aggregate_live_bytes_in_last_gc(live_bytes);
         }
     }
 }

src/scheduler/scheduler.rs

@@ -555,28 +555,15 @@ impl<VM: VMBinding> GCWorkScheduler<VM> {
 
         #[cfg(feature = "count_live_bytes_in_gc")]
         {
-            use crate::policy::space::Space;
-            let live_bytes_per_space = mmtk.state.live_bytes_in_last_gc.borrow();
-            mmtk.get_plan().for_each_space(&mut |space: &dyn Space<VM>| {
-                let space_name = space.get_name();
-                let used_pages = space.reserved_pages();
-                if used_pages != 0 {
-                    let used_bytes = space.reserved_pages() << crate::util::constants::LOG_BYTES_IN_PAGE;
-                    let live_bytes = *live_bytes_per_space.get(space_name).unwrap_or(&0);
-                    debug_assert!(
-                        live_bytes <= used_bytes,
-                        "Live bytes of objects in {} ({} bytes) is larger than used pages ({} bytes), something is wrong.",
-                        space_name, live_bytes, used_bytes
-                    );
-                    info!(
-                        "{} = {} bytes ({:.1}% of {} used pages)",
-                        space_name,
-                        live_bytes,
-                        live_bytes as f64 * 100.0 / used_bytes as f64,
-                        used_pages
-                    );
-                }
-            })
+            for (space_name, &stats) in mmtk.state.live_bytes_in_last_gc.borrow().iter() {
+                info!(
+                    "{} = {} bytes ({:.1}% of {} used pages)",
+                    space_name,
+                    stats.live_bytes,
+                    stats.live_bytes as f64 * 100.0 / stats.used_bytes as f64,
+                    stats.used_bytes,
+                );
+            }
         }
 
         #[cfg(feature = "extreme_assertions")]