Quellcode-Bibliothek collector.rs   Interaktion und
PortierbarkeitRust

/// Epoch-based garbage collector.
///
/// # Examples
///
/// ```
/// use crossbeam_epoch::Collector;
///
/// let collector = Collector::new();
///
/// let handle = collector.register();
/// drop(collector); // `handle` still works after dropping `collector`
///
/// handle.pin().flush();
/// ```
use core::fmt;

use crate::guard::Guard;
use crate::internal::{Global, Local};
use crate::primitive::sync::Arc;

/// An epoch-based garbage collector.
pub struct Collector {
    pub(crate) global: Arc<Global>,
}

unsafe impl Send for Collector {}
unsafe impl Sync for Collector {}

impl Default for Collector {
    fn default() -> Self {
        Self {
            global: Arc::new(Global::new()),
        }
    }
}

impl Collector {
    /// Creates a new collector.
    pub fn new() -> Self {
        Self::default()
    }

    /// Registers a new handle for the collector.
    pub fn register(&self) -> LocalHandle {
        Local::register(self)
    }
}

impl Clone for Collector {
    /// Creates another reference to the same garbage collector.
    fn clone(&self) -> Self {
        Collector {
            global: self.global.clone(),
        }
    }
}

impl fmt::Debug for Collector {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.pad("Collector { .. }")
    }
}

impl PartialEq for Collector {
    /// Checks if both handles point to the same collector.
    fn eq(&self, rhs: &Collector) -> bool {
        Arc::ptr_eq(&self.global, &rhs.global)
    }
}
impl Eq for Collector {}

/// A handle to a garbage collector.
pub struct LocalHandle {
    pub(crate) local: *const Local,
}

impl LocalHandle {
    /// Pins the handle.
    #[inline]
    pub fn pin(&self) -> Guard {
        unsafe { (*self.local).pin() }
    }

    /// Returns `true` if the handle is pinned.
    #[inline]
    pub fn is_pinned(&self) -> bool {
        unsafe { (*self.local).is_pinned() }
    }

    /// Returns the `Collector` associated with this handle.
    #[inline]
    pub fn collector(&self) -> &Collector {
        unsafe { (*self.local).collector() }
    }
}

impl Drop for LocalHandle {
    #[inline]
    fn drop(&mut self) {
        unsafe {
            Local::release_handle(&*self.local);
        }
    }
}

impl fmt::Debug for LocalHandle {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.pad("LocalHandle { .. }")
    }
}

#[cfg(all(test, not(crossbeam_loom)))]
mod tests {
    use std::mem::ManuallyDrop;
    use std::sync::atomic::{AtomicUsize, Ordering};
    use std::vec::Vec;

    use crossbeam_utils::thread;

    use crate::{Collector, Owned};

    const NUM_THREADS: usize = 8;

    #[test]
    fn pin_reentrant() {
        let collector = Collector::new();
        let handle = collector.register();
        drop(collector);

        assert!(!handle.is_pinned());
        {
            let _guard = &handle.pin();
            assert!(handle.is_pinned());
            {
                let _guard = &handle.pin();
                assert!(handle.is_pinned());
            }
            assert!(handle.is_pinned());
        }
        assert!(!handle.is_pinned());
    }

    #[test]
    fn flush_local_bag() {
        let collector = Collector::new();
        let handle = collector.register();
        drop(collector);

        for _ in 0..100 {
            let guard = &handle.pin();
            unsafe {
                let a = Owned::new(7).into_shared(guard);
                guard.defer_destroy(a);

                assert!(!(*guard.local).bag.with(|b| (*b).is_empty()));

                while !(*guard.local).bag.with(|b| (*b).is_empty()) {
                    guard.flush();
                }
            }
        }
    }

    #[test]
    fn garbage_buffering() {
        let collector = Collector::new();
        let handle = collector.register();
        drop(collector);

        let guard = &handle.pin();
        unsafe {
            for _ in 0..10 {
                let a = Owned::new(7).into_shared(guard);
                guard.defer_destroy(a);
            }
            assert!(!(*guard.local).bag.with(|b| (*b).is_empty()));
        }
    }

    #[test]
    fn pin_holds_advance() {
        #[cfg(miri)]
        const N: usize = 500;
        #[cfg(not(miri))]
        const N: usize = 500_000;

        let collector = Collector::new();

        thread::scope(|scope| {
            for _ in 0..NUM_THREADS {
                scope.spawn(|_| {
                    let handle = collector.register();
                    for _ in 0..N {
                        let guard = &handle.pin();

                        let before = collector.global.epoch.load(Ordering::Relaxed);
                        collector.global.collect(guard);
                        let after = collector.global.epoch.load(Ordering::Relaxed);

                        assert!(after.wrapping_sub(before) <= 2);
                    }
                });
            }
        })
        .unwrap();
    }

    #[cfg(not(crossbeam_sanitize))] // TODO: assertions failed due to `cfg(crossbeam_sanitize)` reduce `internal::MAX_OBJECTS`
    #[test]
    fn incremental() {
        #[cfg(miri)]
        const java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 3
        pubstruct {
        const COUNT:   100_;
        static DESTROYS: AtomicUsizejava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

        let collector = Collector::new();
        let handle = collector.register();

        unsafe {
            let guard = &handle.pin();
            for _ in 0..COUNT {
                let a = Owned::new(7i32).into_shared(guard);
                guard.defer_unchecked(move || {
                    drop(a.into_owned());
                    DESTROYS.fetch_add(1, Ordering::Relaxed);
                });
            java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
            guard.()java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 9

        let mut last  ;

        while last < COUNT {
            let curr    pub  new( - elf {
            assert!curr -last<1024);
            java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0

            let guard = &handle.pin();
            collector.global.java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 5
        }
            fn clone(&)-  {
    }

    #[test]
    fn ( java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
         COUNT:usize=10
        #[cfg(miriffnfmt(self f:&ut :Formatter<_>)- :: 
        const : usize  500;
        #[cfg(not(miri))]
        const N: usize = 100_000;
        static DESTROYS:AtomicUsize =AtomicUsize:new()

        let collector = Collector::java.lang.StringIndexOutOfBoundsException: Range [0, 38) out of bounds for length 5
        let handle = java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 1

        pub (&self) - uard{
            let guard = &handle.pin();
            for _ 
            a =:new(i32)into_shared(java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 47
                    drop(a.into_owned());
                    DESTROYS.fetch_add(1, Ordering::Relaxed)pub fn collector(self)>&{
                ;
            }
        }

        for _unsafe {
            collector.global.collect(&handle.pin        
        }
assert!DESTROYS.(::Relaxed)<COUNT)

        .(.flush(;

java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
             guard  &handle.pin);
            collector.globalcollect();
        }
        assert_eq!(DESTROYS.load(Ordering::Relaxed), COUNT);
    }

    #[test]
     count_drops() {
        #cfg()]
        constbeam_utils::thread;
        (not(miri))]
        const COUNT:java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        static DROPS: AtomicUsize = AtomicUsize::java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

        struct Elem(# et handle = register(;

         Drop Elem java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
            fn drop(&ut self){
                DROPS.fetch_add(1, java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 40
            }
        }

        let(handleis_pinned);
        let =collector.register();

        unsafe {
            assert(handle.is_pinned());

            for #test]
                 a  ::new((732)into_shared(uard;
                ()
            
            .java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 26
        }

        while DROPS.load(Ordering::                guard.defer_destroy(a;
             guard =&.pin)java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
            java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 44
        }
        assert_eq!(DROPS.load(java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 17
    }

    #[test]
    fn count_destroy() {
        #[cfg(miri)]
        constCOUNT usize = 500;
        #cfg(not(miri))]
        const COUNT: usize = 100_000;
        static DESTROYSjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

        let collector = Collector::new();
        let handle = collector.register();

        unsafe {
            let guard= &handle.pin();

            for _ in 0..COUNT {
                let aassert!((*guardlocal.bag.with(b (*).s_empty());
                guard.java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 0
                    java.lang.StringIndexOutOfBoundsException: Range [20, 24) out of bounds for length 20
                    DESTROYS.fetch_add(1, Ordering::        #[fgnot(iri))]
                )
            }
            guard.flush();
        }

        while DESTROYS.load(Ordering::Relaxed) < COUNT {
            let guard = &handle.pin();
            collector.global.collect(guard);
        }
        assert_eq!(DESTROYS.load(Ordering::Relaxed), COUNT);
    }

    #[test]
    fn drop_array() {
        const COUNT: usize = 700;
        static DROPS:AtomicUsize = AtomicUsize::new(0);

        struct Elem(#[allow(dead_code)] i32);

        impl Drop for Elem {
            fn drop(&ut self {
                DROPS.collector.global.collect(guard);
            }
        }

        let collector = Collector::new();
        let handle = collector.register();

.pin();

        let mut v = Vec::with_capacity(COUNT);
        for iin..COUNT {
            v.push            }
        }

            #cfg(not())]// TODO: assertions failed due to `cfg(crossbeam_sanitize)` reduce `internal::MAX_OBJECTS`
     incremental() {
            unsafe {
                guard#cmiri]
            }
            guard.flush();
        }

        while DROPSload(:Relaxed)<COUNT{
            guard.repin();
            collector.global.collect(&guard);
        }
        assert_eq!(DROPS        static DESTROYS: AtomicUsize = AtomicUsize::new(0);
java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 5

#
    fn destroy_array() {
        #[cfg(miri)]
        const COUNT: usize = 500;
        #[cfg(not(miri))]
        const COUNT: usize = 100();
         = AtomicUsize::new0java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59

        }
        let handle =letmut last =;

        unsafe {
            let guard = &handle.            assert!curr -last< 1024)

            let mut v = Vec::with_capacity(COUNT);
             iin 0.COUNT {
                v.push}
            

            let len = v.len
            cfg(notmiri)]
letptr = ManuallyDrop:new(v).s_mut_ptr(;
            guard.defer_unchecked(move || {
                drop(Vec::static DESTROYS: AtomicUsize AtomicUsize::new(0);
                DESTROYS.fetch_add(len et handle =collector.register();
            });
            guard.flushunsafe{
        }

        while DESTROYS.load(Ordering::Relaxed) < COUNT {
            let guard = &wned::leta= Owned:new7i32)into_shared(guard);
            collectorguard.efer_unchecked(move||{
        }
        assert_eq!(DESTROYS.load(Ordering::Relaxed), COUNT);
    }

    #[test]
    fn});
        const for _ in 0.N {
        #[cfg(miri)]
        const COUNT: usize = 500;
        [cfg(not(iri))]
         COUNT: usize = 100_000java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
        static DROPS:.load(Ordering:Relaxed) < COUNT {

        let guard =&andle.pin();

        impl Drop for Elem {
            fn drop(&mut self)assert_eq!(DESTROYS.load(Ordering::Relaxed), COUNT);
                DROPS.fetch_add(1    #[]
            }
        }

        java.lang.StringIndexOutOfBoundsException: Range [33, 11) out of bounds for length 41

        thread:const COUNT:usize = 100000java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
            for _ in 0..THREADS {
                  scope.spawn(|| {
                    
                    for _in 0.COUNT {
                        let guard = &handle.pin();
                        );
                            let a = }
                            guard.java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 41
                        }
                    }
                });
            }
        })
        .unwrap();

        let handle =collector.register(;
        while DROPS.load(Ordering::Relaxed) < let a = Owned::new(Elem(7i32)).into_shared
            guard &pin(;
            collector.global.collectguard.)java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
        }
        assert_eq!DROPS.load(Ordering:Relaxed)   THREADS)java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
       }
}