可扩展延迟销毁

一个可扩展的无锁延迟内存回收器，通过跟踪内存可达性来模拟垃圾回收。

它的延迟销毁算法基于基于时期回收的一种变体，其中已退役的内存块存储在线程局部存储中，直到满足某些标准。crossbeam_epoch crate 提供了类似的功能，但是用户会发现 sdd 更容易使用，因为内存块的生命周期被安全地管理。例如，sdd::AtomicOwned 和 sdd::Owned 在它们被丢弃时退役包含的实例，而 sdd::AtomicShared 和 sdd::Shared 在最后一个强引用被丢弃时退役实例。

功能

• 基于时期的无锁回收。
• Loom 支持： features = ["loom"]。

示例

此 crate 可以在 不使用 unsafe 块的情况下使用。

use sdd::{suspend, AtomicOwned, AtomicShared, Guard, Owned, Ptr, Shared, Tag};
use std::sync::atomic::Ordering::Relaxed;

// `atomic_shared` holds a strong reference to `17`.
let atomic_shared: AtomicShared<usize> = AtomicShared::new(17);

// `atomic_owned` owns `19`.
let atomic_owned: AtomicOwned<usize> = AtomicOwned::new(19);

// `guard` prevents the garbage collector from dropping reachable instances.
let guard = Guard::new();

// `ptr` cannot outlive `guard`.
let mut ptr: Ptr<usize> = atomic_shared.load(Relaxed, &guard);
assert_eq!(*ptr.as_ref().unwrap(), 17);

// `atomic_shared` can be tagged.
atomic_shared.update_tag_if(Tag::First, |p| p.tag() == Tag::None, Relaxed, Relaxed);

// `ptr` is not tagged, so CAS fails.
assert!(atomic_shared.compare_exchange(
    ptr,
    (Some(Shared::new(18)), Tag::First),
    Relaxed,
    Relaxed,
    &guard).is_err());

// `ptr` can be tagged.
ptr.set_tag(Tag::First);

// The ownership of the contained instance is transferred to the return value of CAS.
let prev: Shared<usize> = atomic_shared.compare_exchange(
    ptr,
    (Some(Shared::new(19)), Tag::Second),
    Relaxed,
    Relaxed,
    &guard).unwrap().0.unwrap();
assert_eq!(*prev, 17);

// `17` will be garbage-collected later.
drop(prev);

// `sdd::AtomicShared` can be converted into `sdd::Shared`.
let shared: Shared<usize> = atomic_shared.into_shared(Relaxed).unwrap();
assert_eq!(*shared, 19);

// `18` and `19` will be garbage-collected later.
drop(shared);
drop(atomic_owned);

// `17` is still valid as `guard` keeps the garbage collector from dropping it.
assert_eq!(*ptr.as_ref().unwrap(), 17);

// Execution of a closure can be deferred until all the current readers are gone.
guard.defer_execute(|| println!("deferred"));
drop(guard);

// `sdd::Owned` and `sdd::Shared` can be nested.
let shared_nested: Shared<Owned<Shared<usize>>> = Shared::new(Owned::new(Shared::new(20)));
assert_eq!(***shared_nested, 20);

// If the thread is expected to lie dormant for a while, call `suspend()` to allow
// others to reclaim the memory.
suspend();

内存开销

已退役的实例存储在线程局部存储中的侵入式队列中，因此为每个实例分配了额外的空间 Option<NonNull<dyn Collectible>>。

性能

进入和退出受保护区域的平均时间：在 Apple M2 Max 上为 2.4 纳秒。

变更日志