Introduce SpaceInspector and RegionInspector

macros/src/has_spaces_impl.rs

@@ -70,12 +70,12 @@ pub(crate) fn generate_impl_items<'a>(
     };
 
     quote! {
-        fn for_each_space(&self, __func: &mut dyn FnMut(&dyn Space<VM>)) {
+        fn for_each_space<'a>(&'a self, __func: &mut dyn FnMut(&'a dyn Space<VM>)) {
             #(#space_visitors)*
             #parent_visitor
         }
 
-        fn for_each_space_mut(&mut self, __func: &mut dyn FnMut(&mut dyn Space<VM>)) {
+        fn for_each_space_mut<'a>(&'a mut self, __func: &mut dyn FnMut(&'a mut dyn Space<VM>)) {
             #(#space_visitors_mut)*
             #parent_visitor_mut
         }

src/mmtk.rs

@@ -12,6 +12,7 @@ use crate::util::address::ObjectReference;
 use crate::util::analysis::AnalysisManager;
 use crate::util::finalizable_processor::FinalizableProcessor;
 use crate::util::heap::gc_trigger::GCTrigger;
+use crate::util::heap::inspection::SpaceInspector;
 use crate::util::heap::layout::heap_parameters::MAX_SPACES;
 use crate::util::heap::layout::vm_layout::VMLayout;
 use crate::util::heap::layout::{self, Mmapper, VMMap};
@@ -596,4 +597,14 @@ impl<VM: VMBinding> MMTK<VM> {
             .vm_space
             .initialize_object_metadata(object, false)
     }
+
+    pub fn inspect_spaces<'a>(&'a self) -> Vec<&'a dyn SpaceInspector> {
+        let mut ret = vec![];
+        self.get_plan().for_each_space(&mut |space| {
+            if let Some(inspector) = space.as_inspector() {
+                ret.push(inspector);
+            }
+        });
+        ret
+    }
 }

src/plan/global.rs

@@ -714,13 +714,13 @@ pub trait HasSpaces {
     ///
     /// If `Self` contains nested fields that contain more spaces, this method shall visit spaces
     /// in the outer struct first.
-    fn for_each_space(&self, func: &mut dyn FnMut(&dyn Space<Self::VM>));
+    fn for_each_space<'a>(&'a self, func: &mut dyn FnMut(&'a dyn Space<Self::VM>));
 
     /// Visit each space field mutably.
     ///
     /// If `Self` contains nested fields that contain more spaces, this method shall visit spaces
     /// in the outer struct first.
-    fn for_each_space_mut(&mut self, func: &mut dyn FnMut(&mut dyn Space<Self::VM>));
+    fn for_each_space_mut<'a>(&'a mut self, func: &mut dyn FnMut(&'a mut dyn Space<Self::VM>));
 }
 
 /// A plan that uses `PlanProcessEdges` needs to provide an implementation for this trait.

src/policy/immix/immixspace.rs

@@ -167,6 +167,9 @@ impl<VM: VMBinding> Space<VM> for ImmixSpace<VM> {
     fn as_sft(&self) -> &(dyn SFT + Sync + 'static) {
         self
     }
+    fn as_inspector(&self) -> Option<&dyn crate::util::heap::inspection::SpaceInspector> {
+        Some(self)
+    }
     fn get_page_resource(&self) -> &dyn PageResource<VM> {
         &self.pr
     }
@@ -409,7 +412,7 @@ impl<VM: VMBinding> ImmixSpace<VM> {
             if self.common.needs_log_bit {
                 if let MetadataSpec::OnSide(side) = *VM::VMObjectModel::GLOBAL_LOG_BIT_SPEC {
                     for chunk in self.chunk_map.all_chunks() {
-                        side.bzero_metadata(chunk.start(), Chunk::BYTES);
+                        side.bzero_metadata(chunk .start(), Chunk::BYTES);
                     }
                 }
             }
@@ -1178,3 +1181,27 @@ impl ClearVOBitsAfterPrepare {
         }
     }
 }
+
+mod inspector {
+    use super::*;
+    use crate::util::heap::inspection::{RegionInspector, SpaceInspector, list_child_regions};
+    impl<VM: VMBinding> SpaceInspector for ImmixSpace<VM> {
+        fn name(&self) -> &str {
+            SFT::name(self)
+        }
+
+        fn list_regions(&self, parent_region: Option<&dyn RegionInspector>) -> Vec<Box<dyn RegionInspector>> {
+            if let Some(parent_region) = parent_region {
+                list_child_regions::<Chunk, Block>(parent_region).or_else(|| {
+                    if !crate::policy::immix::BLOCK_ONLY {
+                        list_child_regions::<Block, Line>(parent_region)
+                    } else {
+                        None
+                    }
+                }).unwrap_or_else(|| vec![])
+            } else {
+                self.chunk_map.all_chunks().map(|r: Chunk| Box::new(r) as Box<dyn RegionInspector>).collect()
+            }
+        }
+    }
+}

src/policy/space.rs

@@ -2,6 +2,7 @@ use crate::global_state::GlobalState;
 use crate::plan::PlanConstraints;
 use crate::scheduler::GCWorkScheduler;
 use crate::util::conversions::*;
+use crate::util::heap::inspection::SpaceInspector;
 use crate::util::metadata::side_metadata::{
     SideMetadataContext, SideMetadataSanity, SideMetadataSpec,
 };
@@ -42,6 +43,9 @@ use downcast_rs::Downcast;
 pub trait Space<VM: VMBinding>: 'static + SFT + Sync + Downcast {
     fn as_space(&self) -> &dyn Space<VM>;
     fn as_sft(&self) -> &(dyn SFT + Sync + 'static);
+    fn as_inspector(&self) -> Option<&dyn SpaceInspector> {
+        None
+    }
     fn get_page_resource(&self) -> &dyn PageResource<VM>;
 
     /// Get a mutable reference to the underlying page resource, or `None` if the space does not

src/util/heap/inspection/mod.rs

@@ -0,0 +1,52 @@
+use crate::policy::sft::SFT;
+use crate::util::linear_scan::RegionIterator;
+use crate::util::{linear_scan::Region, Address, ObjectReference};
+use crate::util::metadata::side_metadata::spec_defs::VO_BIT;
+use crate::util::heap::chunk_map::Chunk;
+
+pub trait SpaceInspector {
+    fn name(&self) -> &str;
+    fn list_regions(&self, parent_region: Option<&dyn RegionInspector>) -> Vec<Box<dyn RegionInspector>>;
+}
+
+pub(crate) fn list_child_regions<PARENT: Region, CHILD: Region + 'static>(region: &dyn RegionInspector) -> Option<Vec<Box<dyn RegionInspector>>> {
+    if region.region_type() == std::any::type_name::<PARENT>() {
+        let start_child_region = CHILD::from_aligned_address(region.start());
+        let end_child_region = CHILD::from_aligned_address(region.start() + region.size());
+        Some(RegionIterator::<CHILD>::new(start_child_region, end_child_region)
+            .map(|r| Box::new(r) as Box<dyn RegionInspector>)
+            .collect())
+    } else {
+        None
+    }
+}
+
+pub trait RegionInspector {
+    fn region_type(&self) -> &str;
+    fn start(&self) -> Address;
+    fn size(&self) -> usize;
+    #[cfg(feature = "vo_bit")]
+    fn list_objects(&self) -> Vec<ObjectReference> {
+        let mut objects = vec![];
+        VO_BIT.scan_non_zero_values::<u8>(self.start(), self.start() + self.size(), &mut |address| {
+            use crate::util::metadata::vo_bit;
+            let object = vo_bit::get_object_ref_for_vo_addr(address);
+            objects.push(object);
+        });
+        objects
+    }
+}
+
+impl<R: Region> RegionInspector for R {
+    fn region_type(&self) -> &str {
+        std::any::type_name::<R>()
+    }
+
+    fn start(&self) -> Address {
+        Region::start(self)
+    }
+
+    fn size(&self) -> usize {
+        Self::BYTES
+    }
+}

src/util/heap/mod.rs

@@ -22,3 +22,5 @@ pub use self::layout::vm_layout;
 pub(crate) use self::monotonepageresource::MonotonePageResource;
 pub(crate) use self::pageresource::PageResource;
 pub(crate) use self::vmrequest::VMRequest;
+
+pub mod inspection;

src/vm/tests/mock_tests/mock_test_heap_inspector.rs

@@ -0,0 +1,99 @@
+// GITHUB-CI: MMTK_PLAN=Immix
+// GITHUB-CI: FEATURES=vo_bit
+
+use std::collections::HashSet;
+
+use constants::BYTES_IN_WORD;
+
+use super::mock_test_prelude::*;
+
+use crate::{util::*, AllocationSemantics, MMTK};
+
+lazy_static! {
+    static ref FIXTURE: Fixture<MutatorFixture> = Fixture::new();
+}
+
+pub fn get_all_objects(mmtk: &'static MMTK<MockVM>) -> HashSet<ObjectReference> {
+    let mut result = HashSet::new();
+    mmtk.enumerate_objects(|object| {
+        result.insert(object);
+    });
+    result
+}
+
+#[test]
+pub fn test_heap_inspector() {
+    with_mockvm(
+        default_setup,
+        || {
+            FIXTURE.with_fixture_mut(|fixture| {
+                let mmtk = fixture.mmtk();
+                let mutator = &mut fixture.mutator;
+                let space_inspector = mmtk.inspect_spaces();
+                assert!(space_inspector.len() > 0);
+
+                let get_immix_inspector = || {
+                    space_inspector.iter().find(|s| s.name() == "immix").unwrap()
+                };
+
+                {
+                    let immix_space_inspector = get_immix_inspector();
+                    let chunk_inspector = immix_space_inspector.list_regions(None);
+                    assert_eq!(chunk_inspector.len(), 0);
+                }
+
+                let mut new_obj = |size: usize, semantics: AllocationSemantics| {
+                    let align = BYTES_IN_WORD;
+                    let start = memory_manager::alloc(mutator, size, align, 0, semantics);
+                    let object = MockVM::object_start_to_ref(start);
+                    memory_manager::post_alloc(mutator, object, size, semantics);
+                    object
+                };
+
+                // Allocate one object
+                let object = new_obj(40, AllocationSemantics::Default);
+
+                {
+                    let immix_space_inspector = get_immix_inspector();
+                    // Check chunks
+                    let chunk_inspector = immix_space_inspector.list_regions(None);
+                    assert_eq!(chunk_inspector.len(), 1);
+                    assert_eq!(chunk_inspector[0].region_type(), "mmtk::util::heap::chunk_map::Chunk");
+                    let objects = chunk_inspector[0].list_objects();
+                    assert_eq!(objects.len(), 1);
+                    assert_eq!(objects[0], object);
+                    // Check blocks
+                    let block_inspector = immix_space_inspector.list_regions(Some(&*chunk_inspector[0]));
+                    assert_eq!(block_inspector.len(), 128); // 128 blocks in a chunk
+                    assert_eq!(block_inspector[0].region_type(), "mmtk::policy::immix::block::Block");
+                    let objects = block_inspector[0].list_objects();
+                    assert_eq!(objects.len(), 1);
+                    assert_eq!(objects[0], object);
+                    // Check lines
+                    let line_inspector = immix_space_inspector.list_regions(Some(&*block_inspector[0]));
+                    assert_eq!(line_inspector.len(), 128); // 128 lines in a block
+                    assert_eq!(line_inspector[0].region_type(), "mmtk::policy::immix::line::Line");
+                    let objects = line_inspector[0].list_objects();
+                    assert_eq!(objects.len(), 1);
+                    assert_eq!(objects[0], object);
+                }
+
+                // Allocate another object
+                let object2 = new_obj(40, AllocationSemantics::Default);
+
+                {
+                    let immix_space_inspector = get_immix_inspector();
+                    // Check checks
+                    let chunk_inspector = immix_space_inspector.list_regions(None);
+                    assert_eq!(chunk_inspector.len(), 1);
+                    assert_eq!(chunk_inspector[0].region_type(), "mmtk::util::heap::chunk_map::Chunk");
+                    let objects = chunk_inspector[0].list_objects();
+                    assert_eq!(objects.len(), 2);
+                    assert_eq!(objects[0], object);
+                    assert_eq!(objects[1], object2);
+                }
+            });
+        },
+        no_cleanup,
+    )
+}

src/vm/tests/mock_tests/mod.rs

@@ -40,6 +40,7 @@ mod mock_test_handle_mmap_conflict;
 mod mock_test_handle_mmap_oom;
 #[cfg(feature = "vo_bit")]
 mod mock_test_heap_traversal;
+mod mock_test_heap_inspector;
 mod mock_test_init_fork;
 #[cfg(feature = "is_mmtk_object")]
 mod mock_test_internal_ptr_before_object_ref;