crossbeam-epoch

Author: youknowone

Cargo.lock

@@ -196,6 +196,8 @@ serde = { version = "1.0.225", default-features = false }
 schannel = "0.1.28"
 scoped-tls = "1"
 scopeguard = "1"
+memoffset = "0.9"
+atomic = "0.5"
 static_assertions = "1.1"
 strum = "0.27"
 strum_macros = "0.27"

Cargo.toml

@@ -31,6 +31,9 @@ parking_lot = { workspace = true, optional = true }
 unicode_names2 = { workspace = true }
 radium = { workspace = true }
 
+# EBR - Epoch-Based Reclamation
+crossbeam-epoch = "0.9"
+
 lock_api = "0.4"
 siphasher = "1"
 num-complex.workspace = true

crates/common/Cargo.toml

@@ -14,6 +14,7 @@ pub mod boxvec;
 pub mod cformat;
 #[cfg(any(unix, windows, target_os = "wasi"))]
 pub mod crt_fd;
+pub use crossbeam_epoch as epoch;
 pub mod encodings;
 #[cfg(any(not(target_arch = "wasm32"), target_os = "wasi"))]
 pub mod fileutils;

crates/common/src/lib.rs

@@ -7,15 +7,26 @@ use std::cell::{Cell, RefCell};
 use std::sync::atomic::{AtomicU64, Ordering};
 
 // Re-export EBR types
-pub use crate::ebr::{Guard, HIGH_TAG_WIDTH, cs, global_epoch};
+pub use crate::epoch::Guard;
+
+/// Epoch tag bit width - crossbeam-epoch doesn't use pointer tagging
+pub const HIGH_TAG_WIDTH: u32 = 0;
+
+/// Re-export pin() as cs() for API compatibility
+pub use crate::epoch::pin as cs;
 
 // ============================================================================
-// Constants from circ::utils - now defined locally
+// Constants for state layout
 // ============================================================================
 
 pub const EPOCH_WIDTH: u32 = HIGH_TAG_WIDTH;
 pub const EPOCH_MASK_HEIGHT: u32 = u64::BITS - EPOCH_WIDTH;
-pub const EPOCH: u64 = ((1 << EPOCH_WIDTH) - 1) << EPOCH_MASK_HEIGHT;
+/// Epoch mask - 0 when EPOCH_WIDTH is 0 (no epoch bits used)
+pub const EPOCH: u64 = if EPOCH_WIDTH == 0 {
+    0
+} else {
+    ((1u64 << EPOCH_WIDTH) - 1) << EPOCH_MASK_HEIGHT
+};
 pub const DESTRUCTED: u64 = 1 << (EPOCH_MASK_HEIGHT - 1);
 pub const WEAKED: u64 = 1 << (EPOCH_MASK_HEIGHT - 2);
 pub const TOTAL_COUNT_WIDTH: u32 = u64::BITS - EPOCH_WIDTH - 2;
@@ -74,12 +85,20 @@ impl State {
 
     #[inline]
     pub fn epoch(self) -> u32 {
-        ((self.inner & EPOCH) >> EPOCH_MASK_HEIGHT) as u32
+        if EPOCH_WIDTH == 0 {
+            0
+        } else {
+            ((self.inner & EPOCH) >> EPOCH_MASK_HEIGHT) as u32
+        }
     }
 
     #[inline]
     pub fn with_epoch(self, epoch: usize) -> Self {
-        Self::from_raw((self.inner & !EPOCH) | (((epoch as u64) << EPOCH_MASK_HEIGHT) & EPOCH))
+        if EPOCH_WIDTH == 0 {
+            self
+        } else {
+            Self::from_raw((self.inner & !EPOCH) | (((epoch as u64) << EPOCH_MASK_HEIGHT) & EPOCH))
+        }
     }
 
     #[inline]
@@ -192,12 +211,20 @@ impl PyState {
 
     #[inline]
     pub fn epoch(self) -> u32 {
-        ((self.inner & EPOCH) >> EPOCH_MASK_HEIGHT) as u32
+        if EPOCH_WIDTH == 0 {
+            0
+        } else {
+            ((self.inner & EPOCH) >> EPOCH_MASK_HEIGHT) as u32
+        }
     }
 
     #[inline]
     pub fn with_epoch(self, epoch: usize) -> Self {
-        Self::from_raw((self.inner & !EPOCH) | (((epoch as u64) << EPOCH_MASK_HEIGHT) & EPOCH))
+        if EPOCH_WIDTH == 0 {
+            self
+        } else {
+            Self::from_raw((self.inner & !EPOCH) | (((epoch as u64) << EPOCH_MASK_HEIGHT) & EPOCH))
+        }
     }
 
     #[inline]

crates/common/src/refcount.rs

@@ -389,7 +389,7 @@ impl GcState {
         // This ensures that any objects being freed by other threads won't have
         // their memory actually deallocated until we exit this critical section.
         // Other threads' deferred deallocations will wait for us to unpin.
-        let ebr_guard = rustpython_common::ebr::cs();
+        let ebr_guard = rustpython_common::epoch::pin();
 
         // Memory barrier to ensure visibility of all reference count updates
         // from other threads before we start analyzing the object graph.

crates/vm/src/gc_state.rs

@@ -924,18 +924,6 @@ impl PyObject {
             self.set_gc_finalized();
             call_slot_del(self, slot_del)?;
         }
-        if let Some(wrl) = self.weak_ref_list() && Some(slot_del) = del {
-            wrl.clear();
-            // Check if already finalized by GC (prevents double __del__ calls)
-            let ptr = core::ptr::NonNull::from(self);
-            let gc = crate::gc_state::gc_state();
-            if !gc.is_finalized(ptr) {
-                // Mark as finalized BEFORE calling __del__
-                // This ensures is_finalized() returns True even if object is resurrected
-                gc.mark_finalized(ptr);
-                call_slot_del(self, slot_del)?;
-            }
-        }
 
         Ok(())
     }

crates/vm/src/object/core.rs

@@ -828,7 +828,7 @@ mod sys {
 
         for (thread_id, frame) in frames {
             let key = vm.ctx.new_int(thread_id);
-            dict.set_item(key.as_object(), frame.into(), vm)?;
+            dict.set_item(key.as_object(), frame.as_object().to_owned(), vm)?;
         }
 
         Ok(dict)

crates/vm/src/stdlib/sys.rs

@@ -1,6 +1,6 @@
 //! Implementation of the _thread module
 #[cfg_attr(target_arch = "wasm32", allow(unused_imports))]
-pub(crate) use _thread::{
+pub(crate) use self::_thread::{
     CurrentFrameSlot, HandleEntry, RawRMutex, ShutdownEntry, after_fork_child,
     get_all_current_frames, get_ident, init_main_thread_ident, make_module,
 };
@@ -759,136 +759,7 @@ pub(crate) mod _thread {
         Ok(())
     }
 
->>>>>>> 884966677 (gc)
-    #[pyattr]
-    #[pyclass(module = "_thread", name = "_ExceptHookArgs")]
-    #[derive(Debug, PyPayload)]
-    struct ExceptHookArgs {
-        exc_type: crate::PyObjectRef,
-        exc_value: crate::PyObjectRef,
-        exc_traceback: crate::PyObjectRef,
-        thread: crate::PyObjectRef,
-    }
-
-    #[pyclass(with(Constructor))]
-    impl ExceptHookArgs {
-        #[pygetset]
-        fn exc_type(&self) -> crate::PyObjectRef {
-            self.exc_type.clone()
-        }
-
-        #[pygetset]
-        fn exc_value(&self) -> crate::PyObjectRef {
-            self.exc_value.clone()
-        }
-
-        #[pygetset]
-        fn exc_traceback(&self) -> crate::PyObjectRef {
-            self.exc_traceback.clone()
-        }
-
-        #[pygetset]
-        fn thread(&self) -> crate::PyObjectRef {
-            self.thread.clone()
-        }
-    }
-
-    impl Constructor for ExceptHookArgs {
-        // Takes a single iterable argument like namedtuple
-        type Args = (crate::PyObjectRef,);
-
-        fn py_new(_cls: &Py<PyType>, args: Self::Args, vm: &VirtualMachine) -> PyResult<Self> {
-            // Convert the argument to a list/tuple and extract elements
-            let seq: Vec<crate::PyObjectRef> = args.0.try_to_value(vm)?;
-            if seq.len() != 4 {
-                return Err(vm.new_type_error(format!(
-                    "_ExceptHookArgs expected 4 arguments, got {}",
-                    seq.len()
-                )));
-            }
-            Ok(Self {
-                exc_type: seq[0].clone(),
-                exc_value: seq[1].clone(),
-                exc_traceback: seq[2].clone(),
-                thread: seq[3].clone(),
-            })
-        }
-    }
-
-    /// Handle uncaught exception in Thread.run()
-    #[pyfunction]
-    fn _excepthook(args: crate::PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
-        // Type check: args must be _ExceptHookArgs
-        let args = args.downcast::<ExceptHookArgs>().map_err(|_| {
-            vm.new_type_error(
-                "_thread._excepthook argument type must be _ExceptHookArgs".to_owned(),
-            )
-        })?;
-
-        let exc_type = args.exc_type.clone();
-        let exc_value = args.exc_value.clone();
-        let exc_traceback = args.exc_traceback.clone();
-        let thread = args.thread.clone();
 
-        // Silently ignore SystemExit (identity check)
-        if exc_type.is(vm.ctx.exceptions.system_exit.as_ref()) {
-            return Ok(());
-        }
-
-        // Get stderr - fall back to thread._stderr if sys.stderr is None
-        let file = match vm.sys_module.get_attr("stderr", vm) {
-            Ok(stderr) if !vm.is_none(&stderr) => stderr,
-            _ => {
-                if vm.is_none(&thread) {
-                    // do nothing if sys.stderr is None and thread is None
-                    return Ok(());
-                }
-                let thread_stderr = thread.get_attr("_stderr", vm)?;
-                if vm.is_none(&thread_stderr) {
-                    // do nothing if sys.stderr is None and sys.stderr was None
-                    // when the thread was created
-                    return Ok(());
-                }
-                thread_stderr
-            }
-        };
-
-        // Print "Exception in thread {thread.name}:"
-        let thread_name = if !vm.is_none(&thread) {
-            thread
-                .get_attr("name", vm)
-                .ok()
-                .and_then(|n| n.str(vm).ok())
-                .map(|s| s.as_str().to_owned())
-        } else {
-            None
-        };
-        let name = thread_name.unwrap_or_else(|| format!("{}", get_ident()));
-
-        let _ = vm.call_method(
-            &file,
-            "write",
-            (format!("Exception in thread {}:\n", name),),
-        );
-
-        // Display the traceback
-        if let Ok(traceback_mod) = vm.import("traceback", 0)
-            && let Ok(print_exc) = traceback_mod.get_attr("print_exception", vm)
-        {
-            use crate::function::KwArgs;
-            let kwargs: KwArgs = vec![("file".to_owned(), file.clone())]
-                .into_iter()
-                .collect();
-            let _ = print_exc.call_with_args(
-                crate::function::FuncArgs::new(vec![exc_type, exc_value, exc_traceback], kwargs),
-                vm,
-            );
-        }
-
-        // Flush file
-        let _ = vm.call_method(&file, "flush", ());
-        Ok(())
-    }
 
     // Thread-local storage for cleanup guards
     // When a thread terminates, the guard is dropped, which triggers cleanup

crates/vm/src/stdlib/thread.rs

@@ -1,6 +1,6 @@
 #[cfg(feature = "threading")]
 use crate::frame::FrameRef;
-use crate::{AsObject, PyObject, VirtualMachine};
+use crate::{AsObject, PyObject, PyObjectRef, VirtualMachine};
 use core::{
     cell::{Cell, RefCell},
     ptr::NonNull,
@@ -27,7 +27,7 @@ thread_local! {
 
     /// Thread-local EBR guard for Coarse-grained pinning strategy.
     /// Holds the EBR critical section guard for this thread.
-    pub(crate) static EBR_GUARD: RefCell<Option<rustpython_common::ebr::Guard>> =
+    pub(crate) static EBR_GUARD: RefCell<Option<rustpython_common::epoch::Guard>> =
         const { RefCell::new(None) };
 }
 
@@ -42,7 +42,7 @@ scoped_tls::scoped_thread_local!(static VM_CURRENT: VirtualMachine);
 pub fn ensure_pinned() {
     EBR_GUARD.with(|guard| {
         if guard.borrow().is_none() {
-            *guard.borrow_mut() = Some(rustpython_common::ebr::cs());
+            *guard.borrow_mut() = Some(rustpython_common::epoch::pin());
         }
     });
 }
@@ -56,7 +56,7 @@ pub fn ensure_pinned() {
 pub fn reactivate_guard() {
     EBR_GUARD.with(|guard| {
         if let Some(ref mut g) = *guard.borrow_mut() {
-            g.reactivate();
+            g.repin();
         }
     });
 }