Applying cargo fmt and refactoring scanning code further (#254)

Running `cargo fmt`, fixing some warnings and rewriting a few other
pieces of code in the object scanning function following from
#253.

Co-authored-by: Luis Eduardo de Souza Amorim <eduardo@boar.moma>

Author: udesou

mmtk/src/collection.rs

@@ -1,10 +1,10 @@
+use crate::jl_gc_log;
 use crate::SINGLETON;
 use crate::{
     jl_gc_get_max_memory, jl_gc_prepare_to_collect, jl_gc_update_stats, jl_get_gc_disable_counter,
     jl_hrtime, jl_throw_out_of_memory_error,
 };
 use crate::{JuliaVM, USER_TRIGGERED_GC};
-use crate::jl_gc_log;
 use log::{debug, trace};
 use mmtk::util::alloc::AllocationError;
 use mmtk::util::heap::GCTriggerPolicy;
@@ -26,6 +26,7 @@ use std::collections::HashSet;
 use std::sync::RwLock;
 use std::thread::ThreadId;
 
+#[cfg(feature = "print_fragmentation")]
 use crate::api::print_fragmentation;
 
 lazy_static! {
@@ -212,7 +213,6 @@ pub extern "C" fn mmtk_block_thread_for_gc() {
     AtomicIsize::store(&USER_TRIGGERED_GC, 0, Ordering::SeqCst);
 }
 
-
 #[cfg(feature = "dump_block_stats")]
 pub fn dump_immix_block_stats() {
     use mmtk::util::Address;
@@ -238,7 +238,12 @@ pub fn dump_immix_block_stats() {
                     unsafe {
                         crate::julia_scanning::get_julia_object_type(object.to_raw_address())
                     },
-                    unsafe { crate::object_model::get_so_object_size(object, crate::object_model::get_hash_size(object)) },
+                    unsafe {
+                        crate::object_model::get_so_object_size(
+                            object,
+                            crate::object_model::get_hash_size(object),
+                        )
+                    },
                     mmtk::memory_manager::is_pinned(object),
                 )
                 .expect("Unable to write to log file");
@@ -261,12 +266,13 @@ pub fn dump_immix_block_stats() {
 }
 
 #[cfg(feature = "heap_dump")]
-pub fn dump_heap(gc_count: u64, phase: u64) { // phase: 0 for pre-gc, 1 for post-gc
+pub fn dump_heap(gc_count: u64, phase: u64) {
+    // phase: 0 for pre-gc, 1 for post-gc
     println!("Dumping heap for GC {} phase {}", gc_count, phase);
+    use json::JsonValue;
+    use mmtk::util::constants::LOG_BYTES_IN_PAGE;
     use mmtk::util::heap::inspection::*;
     use mmtk::vm::ObjectModel;
-    use mmtk::util::constants::LOG_BYTES_IN_PAGE;
-    use json::JsonValue;
     use std::fs::File;
     use std::io::Write;
 
@@ -278,7 +284,7 @@ pub fn dump_heap(gc_count: u64, phase: u64) { // phase: 0 for pre-gc, 1 for post
         json
     }
 
-    fn region_into_json(space: &dyn SpaceInspector, region: &dyn RegionInspector) -> JsonValue{
+    fn region_into_json(space: &dyn SpaceInspector, region: &dyn RegionInspector) -> JsonValue {
         // println!("Dumping region: {} {}", region.region_type(), region.start());
         let mut json = JsonValue::new_object();
         json["type"] = JsonValue::String(region.region_type().to_string());
@@ -288,65 +294,74 @@ pub fn dump_heap(gc_count: u64, phase: u64) { // phase: 0 for pre-gc, 1 for post
         let sub_regions = space.list_sub_regions(region);
         if sub_regions.is_empty() {
             let objects = region.list_objects();
-            json["objects"] = objects.into_iter().map(|object| {
-                let mut obj_json = JsonValue::new_object();
-                obj_json["address"] = JsonValue::String(format!("{}", object));
-                obj_json["type"] = JsonValue::String(unsafe {
-                    crate::julia_scanning::get_julia_object_type(object.to_raw_address())
-                });
-                obj_json["size"] = JsonValue::Number(
-                    unsafe { crate::object_model::VMObjectModel::get_current_size(object) }.into(),
-                );
-                obj_json["pinned"] = JsonValue::Boolean(
-                    mmtk::memory_manager::is_pinned(object),
-                );
-                obj_json
-            }).collect::<Vec<_>>().into();
+            json["objects"] = objects
+                .into_iter()
+                .map(|object| {
+                    let mut obj_json = JsonValue::new_object();
+                    obj_json["address"] = JsonValue::String(format!("{}", object));
+                    obj_json["type"] = JsonValue::String(unsafe {
+                        crate::julia_scanning::get_julia_object_type(object.to_raw_address())
+                    });
+                    obj_json["size"] = JsonValue::Number(
+                        unsafe { crate::object_model::VMObjectModel::get_current_size(object) }
+                            .into(),
+                    );
+                    obj_json["pinned"] =
+                        JsonValue::Boolean(mmtk::memory_manager::is_pinned(object));
+                    obj_json
+                })
+                .collect::<Vec<_>>()
+                .into();
         } else {
-            json["regions"] = sub_regions.into_iter().map(|sub_region| {
-                region_into_json(space, &*sub_region)
-            }).collect::<Vec<_>>().into();
+            json["regions"] = sub_regions
+                .into_iter()
+                .map(|sub_region| region_into_json(space, &*sub_region))
+                .collect::<Vec<_>>()
+                .into();
         }
 
         json
     }
 
     // Dump high-levvel space information
     {
-        let mut file = File::create(format!(
-            "spaces_gc_{}_phase_{}.json",
-            gc_count,
-            phase
-        )).unwrap();
+        let mut file =
+            File::create(format!("spaces_gc_{}_phase_{}.json", gc_count, phase)).unwrap();
         let mut json = JsonValue::new_array();
-        SINGLETON.inspect_spaces().iter().for_each(|space| json.push(space_into_json(*space)).unwrap());
-        file.write_all(json::stringify_pretty(json, 2).as_bytes()).unwrap();
+        SINGLETON
+            .inspect_spaces()
+            .iter()
+            .for_each(|space| json.push(space_into_json(*space)).unwrap());
+        file.write_all(json::stringify_pretty(json, 2).as_bytes())
+            .unwrap();
     }
 
     // Dump Immix heap -- be careful we only dump one chunk at a time to avoid using too much Rust memory and get OOM
     {
-        let mut file = File::create(format!(
-            "immix_heap_gc_{}_phase_{}.json",
-            gc_count,
-            phase
-        )).unwrap();
+        let mut file =
+            File::create(format!("immix_heap_gc_{}_phase_{}.json", gc_count, phase)).unwrap();
 
         file.write_all(b"[\n").unwrap();
 
-        let immix_space = SINGLETON.inspect_spaces().into_iter()
+        let immix_space = SINGLETON
+            .inspect_spaces()
+            .into_iter()
             .find(|s| s.space_name() == "immix")
             .expect("Immix space not found");
         let chunks = immix_space.list_top_regions();
         let n_chunks = chunks.len();
         let mut i = 0;
-        chunks.into_iter().for_each(|chunk: Box<dyn RegionInspector>| {
-            let json = region_into_json(immix_space, &*chunk);
-            file.write_all(json::stringify_pretty(json, 2).as_bytes()).unwrap();
-            if i != n_chunks - 1 {
-                file.write_all(b",\n").unwrap();
-            }
-            i += 1;
-        });
+        chunks
+            .into_iter()
+            .for_each(|chunk: Box<dyn RegionInspector>| {
+                let json = region_into_json(immix_space, &*chunk);
+                file.write_all(json::stringify_pretty(json, 2).as_bytes())
+                    .unwrap();
+                if i != n_chunks - 1 {
+                    file.write_all(b",\n").unwrap();
+                }
+                i += 1;
+            });
         assert!(i == n_chunks);
 
         file.write_all(b"]\n").unwrap();

mmtk/src/conservative.rs

@@ -1,5 +1,5 @@
-use crate::julia_types::*;
 use crate::jl_log_pinning_event;
+use crate::julia_types::*;
 use mmtk::memory_manager;
 use mmtk::util::constants::BYTES_IN_ADDRESS;
 use mmtk::util::{Address, ObjectReference};

mmtk/src/julia_scanning.rs

@@ -358,32 +358,20 @@ pub unsafe fn scan_julia_object<SV: SlotVisitor<JuliaVMSlot>>(obj: Address, clos
                     objary_begin = objary_begin.shift::<Address>(elsize as isize);
                 }
             } else if (*layout).fielddesc_type_custom() == 0 {
-                let obj8_begin = mmtk_jl_dt_layout_ptrs(layout);
+                let mut obj8_begin = mmtk_jl_dt_layout_ptrs(layout);
                 let obj8_end = obj8_begin.shift::<u8>(npointers as isize);
-                let mut elem_begin = obj8_begin;
-                let elem_end = obj8_end;
 
                 while objary_begin < objary_end {
-                    while elem_begin < elem_end {
-                        let elem_begin_loaded = elem_begin.load::<u8>();
-                        let slot = objary_begin.shift::<Address>(elem_begin_loaded as isize);
-                        process_slot(closure, slot);
-                        elem_begin = elem_begin.shift::<u8>(1);
-                    }
-                    elem_begin = obj8_begin;
+                    scan_julia_obj_n::<u8>(objary_begin, obj8_begin, obj8_end, closure);
+                    obj8_begin = mmtk_jl_dt_layout_ptrs(layout);
                     objary_begin = objary_begin.shift::<Address>(elsize as isize);
                 }
             } else if (*layout).fielddesc_type_custom() == 1 {
                 let mut obj16_begin = mmtk_jl_dt_layout_ptrs(layout);
                 let obj16_end = obj16_begin.shift::<u16>(npointers as isize);
 
                 while objary_begin < objary_end {
-                    while obj16_begin < obj16_end {
-                        let elem_begin_loaded = obj16_begin.load::<u16>();
-                        let slot = objary_begin.shift::<Address>(elem_begin_loaded as isize);
-                        process_slot(closure, slot);
-                        obj16_begin = obj16_begin.shift::<u16>(1);
-                    }
+                    scan_julia_obj_n::<u16>(objary_begin, obj16_begin, obj16_end, closure);
                     obj16_begin = mmtk_jl_dt_layout_ptrs(layout);
                     objary_begin = objary_begin.shift::<Address>(elsize as isize);
                 }