Struct AtomSetOnce

pub struct AtomSetOnce<P>
where
    P: IntoRawPtr + FromRawPtr,
{ /* private fields */ }

This is a restricted version of the Atom. It allows for only set_if_none to be called.

swap and take can be used only with a mutable reference. Meaning that AtomSetOnce is not usable as a

Implementations

impl<P> AtomSetOnce<P>

where P: IntoRawPtr + FromRawPtr,

pub fn empty() -> AtomSetOnce<P>

Create an empty AtomSetOnce

Examples found in repository

examples/fifo.rs (line 33)

    fn drop(&mut self) {
        // This is done to avoid a recusive drop of the List
        while let Some(mut h) = self.next.atom().take(Ordering::Acquire) {
            self.next = mem::replace(&mut h.next, AtomSetOnce::empty());
        }
    }
}

fn main() {
    let b = Arc::new(Barrier::new(THREADS + 1));

    let head = Arc::new(Link {
        next: AtomSetOnce::empty(),
    });

    for _ in 0..THREADS {
        let b = b.clone();
        let head = head.clone();
        thread::spawn(move || {
            let mut hptr = &*head;

            for _ in 0..10_000 {
                let mut my_awesome_node = Box::new(Link {
                    next: AtomSetOnce::empty(),
                });

                loop {
                    while let Some(h) = hptr.next.get(Ordering::Acquire) {
                        hptr = h;
                    }

                    my_awesome_node =
                        match hptr.next.set_if_none(my_awesome_node, Ordering::Release) {
                            Some(v) => v,
                            None => break,
                        };
                }
            }
            b.wait();
        });
    }

    b.wait();

    let mut hptr = &*head;
    let mut count = 0;
    while let Some(h) = hptr.next.get(Ordering::Acquire) {
        hptr = h;
        count += 1;
    }
    println!(
        "Using {} threads we wrote {} links at the same time!",
        THREADS, count
    );
}

pub fn new(value: P) -> AtomSetOnce<P>

Create a new AtomSetOnce from Pointer P

pub fn set_if_none(&self, v: P, order: Ordering) -> Option<P>

This will do a CAS setting the value only if it is NULL this will return OK(()) if the value was written, otherwise a Err(P) will be returned, where the value was the same value that you passed into this function

Examples found in repository

examples/fifo.rs (line 62)

fn main() {
    let b = Arc::new(Barrier::new(THREADS + 1));

    let head = Arc::new(Link {
        next: AtomSetOnce::empty(),
    });

    for _ in 0..THREADS {
        let b = b.clone();
        let head = head.clone();
        thread::spawn(move || {
            let mut hptr = &*head;

            for _ in 0..10_000 {
                let mut my_awesome_node = Box::new(Link {
                    next: AtomSetOnce::empty(),
                });

                loop {
                    while let Some(h) = hptr.next.get(Ordering::Acquire) {
                        hptr = h;
                    }

                    my_awesome_node =
                        match hptr.next.set_if_none(my_awesome_node, Ordering::Release) {
                            Some(v) => v,
                            None => break,
                        };
                }
            }
            b.wait();
        });
    }

    b.wait();

    let mut hptr = &*head;
    let mut count = 0;
    while let Some(h) = hptr.next.get(Ordering::Acquire) {
        hptr = h;
        count += 1;
    }
    println!(
        "Using {} threads we wrote {} links at the same time!",
        THREADS, count
    );
}

pub fn into_atom(self) -> Atom<P>

Convert an AtomSetOnce into an Atom

pub fn atom(&mut self) -> &mut Atom<P>

Allow access to the atom if exclusive access is granted

Examples found in repository

examples/fifo.rs (line 32)

    fn drop(&mut self) {
        // This is done to avoid a recusive drop of the List
        while let Some(mut h) = self.next.atom().take(Ordering::Acquire) {
            self.next = mem::replace(&mut h.next, AtomSetOnce::empty());
        }
    }

pub fn is_none(&self, order: Ordering) -> bool

Check to see if an atom is None

This only means that the contents was None when it was measured

impl<T, P> AtomSetOnce<P>

where P: IntoRawPtr + FromRawPtr + Deref<Target = T>,

pub fn get(&self, order: Ordering) -> Option<&T>

If the Atom is set, get the value

Examples found in repository

examples/fifo.rs (line 57)

fn main() {
    let b = Arc::new(Barrier::new(THREADS + 1));

    let head = Arc::new(Link {
        next: AtomSetOnce::empty(),
    });

    for _ in 0..THREADS {
        let b = b.clone();
        let head = head.clone();
        thread::spawn(move || {
            let mut hptr = &*head;

            for _ in 0..10_000 {
                let mut my_awesome_node = Box::new(Link {
                    next: AtomSetOnce::empty(),
                });

                loop {
                    while let Some(h) = hptr.next.get(Ordering::Acquire) {
                        hptr = h;
                    }

                    my_awesome_node =
                        match hptr.next.set_if_none(my_awesome_node, Ordering::Release) {
                            Some(v) => v,
                            None => break,
                        };
                }
            }
            b.wait();
        });
    }

    b.wait();

    let mut hptr = &*head;
    let mut count = 0;
    while let Some(h) = hptr.next.get(Ordering::Acquire) {
        hptr = h;
        count += 1;
    }
    println!(
        "Using {} threads we wrote {} links at the same time!",
        THREADS, count
    );
}

impl<T> AtomSetOnce<Box<T>>

pub fn get_mut(&mut self, order: Ordering) -> Option<&mut T>

If the Atom is set, get the value

impl<T> AtomSetOnce<T>

where T: Clone + IntoRawPtr + FromRawPtr,

pub fn dup(&self, order: Ordering) -> Option<T>

Duplicate the inner pointer if it is set

Trait Implementations

impl<P> Debug for AtomSetOnce<P>

where P: IntoRawPtr + FromRawPtr + Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.