From 2801d95aa47300d132633a60f269d89e5d3c04f8 Mon Sep 17 00:00:00 2001 From: Peter Zhu Date: Wed, 23 Sep 2026 09:37:12 +0900 Subject: [PATCH] Bump to Rust 2024 edition --- gc/mmtk/Cargo.toml | 2 +- gc/mmtk/src/abi.rs | 2 +- gc/mmtk/src/active_plan.rs | 4 +- gc/mmtk/src/api.rs | 140 +++++++++++--------------- gc/mmtk/src/binding.rs | 6 +- gc/mmtk/src/collection.rs | 8 +- gc/mmtk/src/heap/cpu_heap_trigger.rs | 14 +-- gc/mmtk/src/heap/mod.rs | 4 +- gc/mmtk/src/heap/ruby_heap_trigger.rs | 15 ++- gc/mmtk/src/lib.rs | 4 +- gc/mmtk/src/object_model.rs | 8 +- gc/mmtk/src/pinning_registry.rs | 4 +- gc/mmtk/src/scanning.rs | 8 +- gc/mmtk/src/weak_proc.rs | 2 +- 14 files changed, 99 insertions(+), 122 deletions(-) diff --git a/gc/mmtk/Cargo.toml b/gc/mmtk/Cargo.toml index 6f24036..5e0d48c 100644 --- a/gc/mmtk/Cargo.toml +++ b/gc/mmtk/Cargo.toml @@ -2,7 +2,7 @@ name = "mmtk_ruby" version = "0.1.0" authors = [] -edition = "2021" +edition = "2024" [lib] name = "mmtk_ruby" diff --git a/gc/mmtk/src/abi.rs b/gc/mmtk/src/abi.rs index 30890e0..470a181 100644 --- a/gc/mmtk/src/abi.rs +++ b/gc/mmtk/src/abi.rs @@ -1,6 +1,6 @@ +use crate::Ruby; use crate::api::RubyMutator; use crate::extra_assert; -use crate::Ruby; use libc::c_int; use mmtk::scheduler::GCWorker; use mmtk::util::Address; diff --git a/gc/mmtk/src/active_plan.rs b/gc/mmtk/src/active_plan.rs index 80372a7..c859733 100644 --- a/gc/mmtk/src/active_plan.rs +++ b/gc/mmtk/src/active_plan.rs @@ -1,12 +1,12 @@ use std::collections::VecDeque; use std::marker::PhantomData; +use crate::Ruby; use crate::mmtk; use crate::upcalls; -use crate::Ruby; +use mmtk::Mutator; use mmtk::util::opaque_pointer::*; use mmtk::vm::ActivePlan; -use mmtk::Mutator; pub struct VMActivePlan {} diff --git a/gc/mmtk/src/api.rs b/gc/mmtk/src/api.rs index 8aecd32..4c978b9 100644 --- a/gc/mmtk/src/api.rs +++ b/gc/mmtk/src/api.rs @@ -8,40 +8,40 @@ use mmtk::util::conversions; use mmtk::util::options::PlanSelector; use std::str::FromStr; +use crate::Ruby; +use crate::RubySlot; use crate::abi::RawVecOfObjRef; use crate::abi::RubyBindingOptions; use crate::abi::RubyUpcalls; use crate::binding; use crate::binding::RubyBinding; -use crate::heap::CpuHeapTriggerConfig; -use crate::heap::RubyHeapTriggerConfig; use crate::heap::CPU_HEAP_TRIGGER_CONFIG; +use crate::heap::CpuHeapTriggerConfig; use crate::heap::RUBY_HEAP_TRIGGER_CONFIG; +use crate::heap::RubyHeapTriggerConfig; use crate::mmtk; use crate::utils::default_heap_max; use crate::utils::parse_capacity; -use crate::Ruby; -use crate::RubySlot; +use mmtk::AllocationSemantics; +use mmtk::MMTKBuilder; +use mmtk::Mutator; use mmtk::memory_manager; use mmtk::memory_manager::mmtk_init; -use mmtk::util::constants::MIN_OBJECT_SIZE; -use mmtk::util::options::GCTriggerSelector; use mmtk::util::Address; use mmtk::util::ObjectReference; use mmtk::util::VMMutatorThread; use mmtk::util::VMThread; -use mmtk::AllocationSemantics; -use mmtk::MMTKBuilder; -use mmtk::Mutator; +use mmtk::util::constants::MIN_OBJECT_SIZE; +use mmtk::util::options::GCTriggerSelector; pub type RubyMutator = Mutator; -#[no_mangle] +#[unsafe(no_mangle)] pub extern "C" fn mmtk_is_live_object(object: ObjectReference) -> bool { memory_manager::is_live_object(object) } -#[no_mangle] +#[unsafe(no_mangle)] pub extern "C" fn mmtk_is_reachable(object: ObjectReference) -> bool { binding::object_survives_current_gc(object) } @@ -106,11 +106,7 @@ fn parse_float_env_var(key: &str, default: f64, min: f64, max: f64) -> f64 { .unwrap_or(default) } -fn mmtk_builder_default_parse_heap_mode( - heap_min: usize, - heap_max: usize, - plan: PlanSelector, -) -> GCTriggerSelector { +fn mmtk_builder_default_parse_heap_mode(heap_min: usize, heap_max: usize) -> GCTriggerSelector { let make_fixed = || GCTriggerSelector::FixedHeapSize(heap_max); let make_dynamic = || GCTriggerSelector::DynamicHeapSize(heap_min, heap_max); @@ -118,13 +114,6 @@ fn mmtk_builder_default_parse_heap_mode( "fixed" => Some(make_fixed()), "dynamic" => Some(make_dynamic()), "ruby" => { - if plan == PlanSelector::NoGC { - eprintln!( - "[WARN] Cannot use ruby heap mode with NoGC. Using fixed heap mode instead." - ); - return Some(make_fixed()); - } - let min_ratio = parse_float_env_var("RUBY_GC_HEAP_FREE_SLOTS_MIN_RATIO", 0.2, 0.0, 1.0); let goal_ratio = parse_float_env_var("RUBY_GC_HEAP_FREE_SLOTS_GOAL_RATIO", 0.4, min_ratio, 1.0); @@ -144,13 +133,6 @@ fn mmtk_builder_default_parse_heap_mode( Some(GCTriggerSelector::Delegated) } "cpu" => { - if plan == PlanSelector::NoGC { - eprintln!( - "[WARN] Cannot use cpu heap mode with NoGC. Using fixed heap mode instead." - ); - return Some(make_fixed()); - } - // CPU-overhead-driven heap sizing based on Tavakolisomeh et al., // "Heap Size Adjustment with CPU Control", MPLR '23. // @@ -202,17 +184,17 @@ fn mmtk_builder_default_parse_plan() -> PlanSelector { .unwrap_or(PlanSelector::Immix) } -#[no_mangle] +#[unsafe(no_mangle)] pub extern "C" fn mmtk_builder_default() -> *mut MMTKBuilder { let mut builder = MMTKBuilder::new_no_env_vars(); builder.options.no_finalizer.set(true); - if let Some(threads) = mmtk_builder_default_parse_threads() { - if !builder.options.threads.set(threads) { - // MMTk will validate it and reject 0. - eprintln!("[FATAL] Failed to set the number of MMTk threads to {threads}"); - std::process::exit(1); - } + if let Some(threads) = mmtk_builder_default_parse_threads() + && !builder.options.threads.set(threads) + { + // MMTk will validate it and reject 0. + eprintln!("[FATAL] Failed to set the number of MMTk threads to {threads}"); + std::process::exit(1); } let heap_min = mmtk_builder_default_parse_heap_min(); @@ -224,21 +206,17 @@ pub extern "C" fn mmtk_builder_default() -> *mut MMTKBuilder { std::process::exit(1); } - let plan = mmtk_builder_default_parse_plan(); - - builder.options.plan.set(plan); - builder .options .gc_trigger - .set(mmtk_builder_default_parse_heap_mode( - heap_min, heap_max, plan, - )); + .set(mmtk_builder_default_parse_heap_mode(heap_min, heap_max)); + + builder.options.plan.set(mmtk_builder_default_parse_plan()); Box::into_raw(Box::new(builder)) } -#[no_mangle] +#[unsafe(no_mangle)] pub unsafe extern "C" fn mmtk_init_binding( builder: *mut MMTKBuilder, binding_options: *const RubyBindingOptions, @@ -265,27 +243,27 @@ pub unsafe extern "C" fn mmtk_init_binding( .unwrap_or_else(|_| panic!("Binding is already initialized")); } -#[no_mangle] +#[unsafe(no_mangle)] pub extern "C" fn mmtk_get_vo_bit_log_region_size() -> usize { mmtk::util::is_mmtk_object::VO_BIT_REGION_SIZE.trailing_zeros() as usize } -#[no_mangle] +#[unsafe(no_mangle)] pub extern "C" fn mmtk_get_vo_bit_base_addr() -> usize { mmtk::util::metadata::side_metadata::vo_bit_side_metadata_addr().as_usize() } -#[no_mangle] +#[unsafe(no_mangle)] pub extern "C" fn mmtk_initialize_collection(tls: VMThread) { memory_manager::initialize_collection(mmtk(), tls) } -#[no_mangle] +#[unsafe(no_mangle)] pub extern "C" fn mmtk_bind_mutator(tls: VMMutatorThread) -> *mut RubyMutator { Box::into_raw(memory_manager::bind_mutator(mmtk(), tls)) } -#[no_mangle] +#[unsafe(no_mangle)] pub unsafe extern "C" fn mmtk_get_bump_pointer_allocator(m: *mut RubyMutator) -> *mut BumpPointer { match *crate::BINDING.get().unwrap().mmtk.get_options().plan { PlanSelector::Immix | PlanSelector::StickyImmix => { @@ -303,7 +281,7 @@ pub unsafe extern "C" fn mmtk_get_bump_pointer_allocator(m: *mut RubyMutator) -> } } -#[no_mangle] +#[unsafe(no_mangle)] pub unsafe extern "C" fn mmtk_destroy_mutator(mutator: *mut RubyMutator) { // notify mmtk-core about destroyed mutator memory_manager::destroy_mutator(unsafe { &mut *mutator }); @@ -313,7 +291,7 @@ pub unsafe extern "C" fn mmtk_destroy_mutator(mutator: *mut RubyMutator) { // =============== GC =============== -#[no_mangle] +#[unsafe(no_mangle)] pub extern "C" fn mmtk_handle_user_collection_request( tls: VMMutatorThread, force: bool, @@ -339,7 +317,7 @@ pub extern "C" fn mmtk_handle_user_collection_request( } } -#[no_mangle] +#[unsafe(no_mangle)] pub extern "C" fn mmtk_set_gc_enabled(enable: bool) { if enable { crate::mmtk().enable_collection(); @@ -357,14 +335,14 @@ pub extern "C" fn mmtk_set_gc_enabled(enable: bool) { } } -#[no_mangle] +#[unsafe(no_mangle)] pub extern "C" fn mmtk_gc_enabled_p() -> bool { crate::mmtk().is_collection_enabled() } // =============== Object allocation =============== -#[no_mangle] +#[unsafe(no_mangle)] pub extern "C" fn mmtk_max_non_los_default_alloc_bytes() -> usize { mmtk() .get_plan() @@ -372,7 +350,7 @@ pub extern "C" fn mmtk_max_non_los_default_alloc_bytes() -> usize { .max_non_los_default_alloc_bytes } -#[no_mangle] +#[unsafe(no_mangle)] pub unsafe extern "C" fn mmtk_alloc( mutator: *mut RubyMutator, size: usize, @@ -390,7 +368,7 @@ pub unsafe extern "C" fn mmtk_alloc( ) } -#[no_mangle] +#[unsafe(no_mangle)] pub unsafe extern "C" fn mmtk_post_alloc( mutator: *mut RubyMutator, refer: ObjectReference, @@ -400,7 +378,7 @@ pub unsafe extern "C" fn mmtk_post_alloc( memory_manager::post_alloc::(unsafe { &mut *mutator }, refer, bytes, semantics) } -#[no_mangle] +#[unsafe(no_mangle)] pub unsafe extern "C" fn mmtk_add_obj_free_candidates( objects: *const ObjectReference, count: usize, @@ -414,31 +392,31 @@ pub unsafe extern "C" fn mmtk_add_obj_free_candidates( // =============== Weak references =============== -#[no_mangle] +#[unsafe(no_mangle)] pub extern "C" fn mmtk_declare_weak_references(object: ObjectReference) { binding().weak_proc.add_weak_reference(object); } -#[no_mangle] +#[unsafe(no_mangle)] pub extern "C" fn mmtk_weak_references_alive_p(object: ObjectReference) -> bool { binding::object_survives_current_gc(object) } -#[no_mangle] +#[unsafe(no_mangle)] pub extern "C" fn mmtk_weak_references_count() -> usize { binding().weak_proc.weak_references_count() } // =============== Compaction =============== -#[no_mangle] +#[unsafe(no_mangle)] pub extern "C" fn mmtk_register_pinning_obj(obj: ObjectReference) { crate::binding().pinning_registry.register(obj); } // =============== Write barriers =============== -#[no_mangle] +#[unsafe(no_mangle)] pub unsafe extern "C" fn mmtk_object_reference_write_post( mutator: *mut RubyMutator, object: ObjectReference, @@ -453,19 +431,19 @@ pub unsafe extern "C" fn mmtk_object_reference_write_post( ) } -#[no_mangle] +#[unsafe(no_mangle)] pub extern "C" fn mmtk_register_wb_unprotected_object(object: ObjectReference) { crate::binding().register_wb_unprotected_object(object) } -#[no_mangle] +#[unsafe(no_mangle)] pub extern "C" fn mmtk_object_wb_unprotected_p(object: ObjectReference) -> bool { crate::binding().object_wb_unprotected_p(object) } // =============== Heap walking =============== -#[no_mangle] +#[unsafe(no_mangle)] pub extern "C" fn mmtk_enumerate_objects( callback: extern "C" fn(ObjectReference, *mut libc::c_void), data: *mut libc::c_void, @@ -477,63 +455,63 @@ pub extern "C" fn mmtk_enumerate_objects( // =============== Finalizers =============== -#[no_mangle] +#[unsafe(no_mangle)] pub extern "C" fn mmtk_get_all_obj_free_candidates() -> RawVecOfObjRef { let vec = binding().weak_proc.get_all_obj_free_candidates(); RawVecOfObjRef::from_vec(vec) } -#[no_mangle] +#[unsafe(no_mangle)] pub extern "C" fn mmtk_free_raw_vec_of_obj_ref(raw_vec: RawVecOfObjRef) { unsafe { raw_vec.into_vec() }; } // =============== Forking =============== -#[no_mangle] +#[unsafe(no_mangle)] pub extern "C" fn mmtk_before_fork() { mmtk().prepare_to_fork(); binding().join_all_gc_threads(); } -#[no_mangle] +#[unsafe(no_mangle)] pub extern "C" fn mmtk_after_fork(tls: VMThread) { mmtk().after_fork(tls); } // =============== Statistics =============== -#[no_mangle] +#[unsafe(no_mangle)] pub extern "C" fn mmtk_total_bytes() -> usize { memory_manager::total_bytes(mmtk()) } -#[no_mangle] +#[unsafe(no_mangle)] pub extern "C" fn mmtk_used_bytes() -> usize { memory_manager::used_bytes(mmtk()) } -#[no_mangle] +#[unsafe(no_mangle)] pub extern "C" fn mmtk_free_bytes() -> usize { memory_manager::free_bytes(mmtk()) } -#[no_mangle] +#[unsafe(no_mangle)] pub extern "C" fn mmtk_starting_heap_address() -> Address { memory_manager::starting_heap_address() } -#[no_mangle] +#[unsafe(no_mangle)] pub extern "C" fn mmtk_last_heap_address() -> Address { memory_manager::last_heap_address() } -#[no_mangle] +#[unsafe(no_mangle)] pub extern "C" fn mmtk_worker_count() -> usize { memory_manager::num_of_workers(mmtk()) } -#[no_mangle] +#[unsafe(no_mangle)] pub extern "C" fn mmtk_plan() -> *const u8 { static NO_GC: &[u8] = b"NoGC\0"; static MARK_SWEEP: &[u8] = b"MarkSweep\0"; @@ -549,7 +527,7 @@ pub extern "C" fn mmtk_plan() -> *const u8 { } } -#[no_mangle] +#[unsafe(no_mangle)] pub extern "C" fn mmtk_heap_mode() -> *const u8 { static FIXED_HEAP: &[u8] = b"fixed\0"; static DYNAMIC_HEAP: &[u8] = b"dynamic\0"; @@ -571,7 +549,7 @@ pub extern "C" fn mmtk_heap_mode() -> *const u8 { } } -#[no_mangle] +#[unsafe(no_mangle)] pub extern "C" fn mmtk_heap_min() -> usize { match *crate::BINDING.get().unwrap().mmtk.get_options().gc_trigger { GCTriggerSelector::FixedHeapSize(_) => 0, @@ -591,7 +569,7 @@ pub extern "C" fn mmtk_heap_min() -> usize { } } -#[no_mangle] +#[unsafe(no_mangle)] pub extern "C" fn mmtk_heap_max() -> usize { match *crate::BINDING.get().unwrap().mmtk.get_options().gc_trigger { GCTriggerSelector::FixedHeapSize(max_size) => max_size, @@ -613,7 +591,7 @@ pub extern "C" fn mmtk_heap_max() -> usize { // =============== Miscellaneous =============== -#[no_mangle] +#[unsafe(no_mangle)] pub extern "C" fn mmtk_is_mmtk_object(addr: Address) -> bool { debug_assert!(!addr.is_zero()); debug_assert!(addr.is_aligned_to(mmtk::util::is_mmtk_object::VO_BIT_REGION_SIZE)); diff --git a/gc/mmtk/src/binding.rs b/gc/mmtk/src/binding.rs index 793e8cb..9c24cd6 100644 --- a/gc/mmtk/src/binding.rs +++ b/gc/mmtk/src/binding.rs @@ -3,15 +3,15 @@ use std::ffi::CString; use std::sync::Mutex; use std::thread::JoinHandle; +use mmtk::MMTK; use mmtk::util::ObjectReference; use mmtk::vm::ObjectModel; -use mmtk::MMTK; +use crate::Ruby; use crate::abi; use crate::abi::RubyBindingOptions; use crate::pinning_registry::PinningRegistry; use crate::weak_proc::WeakProcessor; -use crate::Ruby; pub struct RubyBindingFast { pub suffix_size: usize, @@ -113,7 +113,7 @@ pub(crate) fn object_survives_current_gc(object: ObjectReference) -> bool { let is_nursery_gc = plan .generational() - .is_some_and(|gen| gen.is_current_gc_nursery()); + .is_some_and(|gen_plan| gen_plan.is_current_gc_nursery()); if !is_nursery_gc { return object.is_reachable(); diff --git a/gc/mmtk/src/collection.rs b/gc/mmtk/src/collection.rs index 7d444e0..d7e44a3 100644 --- a/gc/mmtk/src/collection.rs +++ b/gc/mmtk/src/collection.rs @@ -1,19 +1,19 @@ use crate::abi::GCThreadTLS; +use crate::Ruby; use crate::api::RubyMutator; +use crate::heap::CPU_HEAP_TRIGGER_CONFIG; use crate::heap::CpuHeapTrigger; use crate::heap::RubyHeapTrigger; -use crate::heap::CPU_HEAP_TRIGGER_CONFIG; use crate::mmtk; use crate::upcalls; -use crate::Ruby; use mmtk::memory_manager; use mmtk::scheduler::*; -use mmtk::util::alloc::AllocationError; -use mmtk::util::heap::GCTriggerPolicy; use mmtk::util::VMMutatorThread; use mmtk::util::VMThread; use mmtk::util::VMWorkerThread; +use mmtk::util::alloc::AllocationError; +use mmtk::util::heap::GCTriggerPolicy; use mmtk::vm::Collection; use mmtk::vm::GCThreadContext; use std::sync::atomic::AtomicBool; diff --git a/gc/mmtk/src/heap/cpu_heap_trigger.rs b/gc/mmtk/src/heap/cpu_heap_trigger.rs index dc0c081..b0a3d87 100644 --- a/gc/mmtk/src/heap/cpu_heap_trigger.rs +++ b/gc/mmtk/src/heap/cpu_heap_trigger.rs @@ -44,14 +44,14 @@ //! during the mutator phase is correctly attributed. For generational plans //! we skip nursery-only GCs, consistent with MemBalancer. +use std::sync::Mutex; use std::sync::atomic::AtomicUsize; use std::sync::atomic::Ordering; -use std::sync::Mutex; +use mmtk::MMTK; +use mmtk::Plan; use mmtk::util::heap::GCTriggerPolicy; use mmtk::util::heap::SpaceStats; -use mmtk::Plan; -use mmtk::MMTK; use once_cell::sync::OnceCell; use crate::Ruby; @@ -172,10 +172,10 @@ impl GCTriggerPolicy for CpuHeapTrigger { // Skip nursery-only GCs for generational plans. The heap resizing // decision is driven by the (much more expensive) full collections // where the signal-to-noise ratio is high enough to be useful. - if let Some(gen_plan) = mmtk.get_plan().generational() { - if gen_plan.is_current_gc_nursery() { - return; - } + if let Some(gen_plan) = mmtk.get_plan().generational() + && gen_plan.is_current_gc_nursery() + { + return; } let cfg = Self::get_config(); diff --git a/gc/mmtk/src/heap/mod.rs b/gc/mmtk/src/heap/mod.rs index 05a35ef..9722aba 100644 --- a/gc/mmtk/src/heap/mod.rs +++ b/gc/mmtk/src/heap/mod.rs @@ -1,9 +1,9 @@ mod cpu_heap_trigger; mod ruby_heap_trigger; +pub use cpu_heap_trigger::CPU_HEAP_TRIGGER_CONFIG; pub use cpu_heap_trigger::CpuHeapTrigger; pub use cpu_heap_trigger::CpuHeapTriggerConfig; -pub use cpu_heap_trigger::CPU_HEAP_TRIGGER_CONFIG; +pub use ruby_heap_trigger::RUBY_HEAP_TRIGGER_CONFIG; pub use ruby_heap_trigger::RubyHeapTrigger; pub use ruby_heap_trigger::RubyHeapTriggerConfig; -pub use ruby_heap_trigger::RUBY_HEAP_TRIGGER_CONFIG; diff --git a/gc/mmtk/src/heap/ruby_heap_trigger.rs b/gc/mmtk/src/heap/ruby_heap_trigger.rs index b152a31..6cb644c 100644 --- a/gc/mmtk/src/heap/ruby_heap_trigger.rs +++ b/gc/mmtk/src/heap/ruby_heap_trigger.rs @@ -1,10 +1,10 @@ use std::sync::atomic::AtomicUsize; use std::sync::atomic::Ordering; +use mmtk::MMTK; +use mmtk::Plan; use mmtk::util::heap::GCTriggerPolicy; use mmtk::util::heap::SpaceStats; -use mmtk::Plan; -use mmtk::MMTK; use once_cell::sync::OnceCell; use crate::Ruby; @@ -50,12 +50,11 @@ impl GCTriggerPolicy for RubyHeapTrigger { // Nursery GCs don't resize the heap, unless a failed allocation is // waiting on us to make room for it. - if pending_pages == 0 { - if let Some(plan) = mmtk.get_plan().generational() { - if plan.is_current_gc_nursery() { - return; - } - } + if pending_pages == 0 + && let Some(plan) = mmtk.get_plan().generational() + && plan.is_current_gc_nursery() + { + return; } let used_pages = mmtk.get_plan().get_used_pages(); diff --git a/gc/mmtk/src/lib.rs b/gc/mmtk/src/lib.rs index 2cd6ec0..b9deace 100644 --- a/gc/mmtk/src/lib.rs +++ b/gc/mmtk/src/lib.rs @@ -16,10 +16,10 @@ use std::thread::ThreadId; use abi::RubyUpcalls; use binding::RubyBinding; use binding::RubyBindingFast; +use mmtk::MMTK; +use mmtk::vm::VMBinding; use mmtk::vm::slot::SimpleSlot; use mmtk::vm::slot::UnimplementedMemorySlice; -use mmtk::vm::VMBinding; -use mmtk::MMTK; use once_cell::sync::OnceCell; pub mod abi; diff --git a/gc/mmtk/src/object_model.rs b/gc/mmtk/src/object_model.rs index 6dcc520..940f98a 100644 --- a/gc/mmtk/src/object_model.rs +++ b/gc/mmtk/src/object_model.rs @@ -1,15 +1,15 @@ use std::ptr::copy_nonoverlapping; +use crate::Ruby; use crate::abi; -use crate::abi::RubyObjectAccess; use crate::abi::MIN_OBJ_ALIGN; use crate::abi::OBJREF_OFFSET; -use crate::Ruby; +use crate::abi::RubyObjectAccess; +use mmtk::util::Address; +use mmtk::util::ObjectReference; use mmtk::util::constants::BITS_IN_BYTE; use mmtk::util::copy::CopySemantics; use mmtk::util::copy::GCWorkerCopyContext; -use mmtk::util::Address; -use mmtk::util::ObjectReference; use mmtk::vm::*; pub struct VMObjectModel {} diff --git a/gc/mmtk/src/pinning_registry.rs b/gc/mmtk/src/pinning_registry.rs index 335d91b..8ba7dc2 100644 --- a/gc/mmtk/src/pinning_registry.rs +++ b/gc/mmtk/src/pinning_registry.rs @@ -1,16 +1,16 @@ use std::sync::Mutex; +use mmtk::MMTK; use mmtk::memory_manager; use mmtk::scheduler::GCWork; use mmtk::scheduler::GCWorker; use mmtk::scheduler::WorkBucketStage; use mmtk::util::ObjectReference; use mmtk::util::VMWorkerThread; -use mmtk::MMTK; +use crate::Ruby; use crate::abi::GCThreadTLS; use crate::upcalls; -use crate::Ruby; pub struct PinningRegistry { pinning_objs: Mutex>, diff --git a/gc/mmtk/src/scanning.rs b/gc/mmtk/src/scanning.rs index 34314ab..ee7c993 100644 --- a/gc/mmtk/src/scanning.rs +++ b/gc/mmtk/src/scanning.rs @@ -1,9 +1,10 @@ use crate::abi::GCThreadTLS; -use crate::upcalls; -use crate::utils::ChunkedVecCollector; use crate::Ruby; use crate::RubySlot; +use crate::upcalls; +use crate::utils::ChunkedVecCollector; +use mmtk::Mutator; use mmtk::memory_manager; use mmtk::scheduler::GCWork; use mmtk::scheduler::GCWorker; @@ -14,7 +15,6 @@ use mmtk::vm::ObjectTracer; use mmtk::vm::RootsWorkFactory; use mmtk::vm::Scanning; use mmtk::vm::SlotVisitor; -use mmtk::Mutator; pub struct VMScanning {} @@ -111,7 +111,7 @@ impl Scanning for VMScanning { 'gen_wb_unprotected_work: { let is_nursery_gc = (crate::mmtk().get_plan().generational()) - .is_some_and(|gen| gen.is_current_gc_nursery()); + .is_some_and(|gen_plan| gen_plan.is_current_gc_nursery()); if !is_nursery_gc { break 'gen_wb_unprotected_work; } diff --git a/gc/mmtk/src/weak_proc.rs b/gc/mmtk/src/weak_proc.rs index b48ce71..cf00bdb 100644 --- a/gc/mmtk/src/weak_proc.rs +++ b/gc/mmtk/src/weak_proc.rs @@ -6,10 +6,10 @@ use mmtk::scheduler::WorkBucketStage; use mmtk::util::ObjectReference; use mmtk::vm::ObjectTracerContext; +use crate::Ruby; use crate::abi::GCThreadTLS; use crate::binding::object_survives_current_gc; use crate::upcalls; -use crate::Ruby; pub struct WeakProcessor { non_parallel_obj_free_candidates: Mutex>,