Bump to Rust 2024 edition

Author: peterzhu2118

gc/mmtk/Cargo.toml

@@ -2,7 +2,7 @@
 name = "mmtk_ruby"
 version = "0.1.0"
 authors = []
-edition = "2021"
+edition = "2024"
 
 [lib]
 name = "mmtk_ruby"

gc/mmtk/src/api.rs

@@ -36,12 +36,12 @@ use mmtk::Mutator;
 
 pub type RubyMutator = Mutator<Ruby>;
 
-#[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,25 +106,14 @@ 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);
 
     parse_env_var_with("MMTK_HEAP_MODE", |s| match s {
         "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,15 @@ 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 +204,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 +241,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 +279,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 +289,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 +315,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,22 +333,22 @@ 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()
         .constraints()
         .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 +366,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 +376,7 @@ pub unsafe extern "C" fn mmtk_post_alloc(
     memory_manager::post_alloc::<Ruby>(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 +390,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 +429,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 +453,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 +525,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 +547,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 +567,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 +589,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));

gc/mmtk/src/binding.rs

@@ -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();