Struct AtomicI16 

pub struct AtomicI16(/* private fields */);

Creusot wrapper around [std::sync::atomic::$atomic_type] Creusot wrapper around std::sync::atomic::AtomicI16.

Implementations

impl AtomicI16

pub fn new(val: i16) -> (Self, Ghost<Perm<AtomicI16>>)

ensures

result.1.val() == val

ensures

*result.1.ward() == result.0

terminates

pub fn into_inner(self, own: Ghost<Perm<AtomicI16>>) -> i16

Wrapper for std::sync::atomic::AtomicI16::into_inner.

requires

self == *own.ward()

ensures

result == own.val()

pub fn compare_exchange<F>( &self, current: i16, new: i16, f: Ghost<F>, ) -> Result<i16, i16>

where F: FnGhost + FnOnce(Result<&mut Committer<Self, i16, SeqCst, SeqCst>, &Committer<Self, i16, SeqCst, ()>>),

Wrapper for std::sync::atomic::AtomicI16::compare_exchange.

The load and the store are always sequentially consistent.

requires

forall<c: &mut Committer<Self, $type, SeqCst, SeqCst>>
    !c.shot_store() ==> c.ward() == *self ==>
    c.val_load().deep_model() == current.deep_model() ==>
    c.val_store() == new ==>
    f.precondition((Ok(c),)) && (f.postcondition_once((Ok(c),), ()) ==> (^c).shot_store())

requires

forall<c: &Committer<Self, $type, SeqCst, ()>>
    !c.shot_store() ==> c.ward() == *self ==>
    // NOTE: This following line is not present for `weak`
    c.val_load().deep_model() != current.deep_model() ==>
    f.precondition((Err(c),))

ensures

match result {
    Ok(result) => {
        exists<c: &mut Committer<Self, $type, SeqCst, SeqCst>>
            !c.shot_store() && c.ward() == *self &&
            c.val_load().deep_model() == current.deep_model() &&
            c.val_store() == new &&
            result == c.val_load() &&
            f.postcondition_once((Ok(c),), ())
    },
    Err(result) => {
       exists<c: &Committer<Self, $type, SeqCst, ()>>
            !c.shot_store() && c.ward() == *self &&
            // NOTE: This following line is not present for `weak`
            c.val_load().deep_model() != current.deep_model() &&
            result == c.val_load() &&
            f.postcondition_once((Err(c),), ())
    }
}

pub fn compare_exchange_weak<F>( &self, current: i16, new: i16, f: Ghost<F>, ) -> Result<i16, i16>

where F: FnGhost + FnOnce(Result<&mut Committer<Self, i16, SeqCst, SeqCst>, &Committer<Self, i16, SeqCst, ()>>),

Wrapper for std::sync::atomic::AtomicI16::compare_exchange_weak.

The load and the store are always sequentially consistent.

requires

forall<c: &mut Committer<Self, $type, SeqCst, SeqCst>>
    !c.shot_store() ==> c.ward() == *self ==>
    c.val_load().deep_model() == current.deep_model() ==>
    c.val_store() == new ==>
    f.precondition((Ok(c),)) && (f.postcondition_once((Ok(c),), ()) ==> (^c).shot_store())

requires

forall<c: &Committer<Self, $type, SeqCst, ()>>
    !c.shot_store() ==> c.ward() == *self ==>
    f.precondition((Err(c),))

ensures

match result {
    Ok(result) => {
        exists<c: &mut Committer<Self, $type, SeqCst, SeqCst>>
            !c.shot_store() && c.ward() == *self &&
            c.val_load().deep_model() == current.deep_model() &&
            c.val_store() == new &&
            result == c.val_load() &&
            f.postcondition_once((Ok(c),), ())
    },
    Err(result) => {
       exists<c: &Committer<Self, $type, SeqCst, ()>>
            !c.shot_store() && c.ward() == *self &&
            result == c.val_load() &&
            f.postcondition_once((Err(c),), ())
    }
}

pub fn load<F>(&self, f: Ghost<F>) -> i16

where F: FnGhost + FnOnce(&Committer<Self, i16, SeqCst, ()>),

Wrapper for std::sync::atomic::AtomicI16::load.

The load is always sequentially consistent.

requires

forall<c: &Committer<Self, $type, SeqCst, ()>>
    !c.shot_store() ==> c.ward() == *self ==> f.precondition((c,))

ensures

exists<c: &Committer<Self, $type, SeqCst, ()>>
    !c.shot_store() && c.ward() == *self && c.val_load() == result && f.postcondition_once((c,), ())

pub fn store<F>(&self, val: i16, f: Ghost<F>)

where F: FnGhost + FnOnce(&mut Committer<Self, i16, (), SeqCst>),

Wrapper for std::sync::atomic::AtomicI16::store.

The store is always sequentially consistent.

requires

forall<c: &mut Committer<Self, $type, (), SeqCst>>
    !c.shot_store() ==> c.ward() == *self ==> c.val_store() == val ==>
    f.precondition((c,)) && (f.postcondition_once((c,), ()) ==> (^c).shot_store())

ensures

exists<c: &mut Committer<Self, $type, (), SeqCst>>
    !c.shot_store() && c.ward() == *self && c.val_store() == val &&
    f.postcondition_once((c,), ())

impl AtomicI16

pub fn fetch_add<F>(&self, val: i16, f: Ghost<F>) -> i16

where F: FnGhost + FnOnce(&mut Committer<Self, i16, SeqCst, SeqCst>),

Wrapper for std::sync::atomic::AtomicI16::fetch_add.

The load and the store are always sequentially consistent.

requires

forall<c: &mut Committer<Self, $int_type, SeqCst, SeqCst>>
    !c.shot_store() ==> c.ward() == *self ==> c.val_store() == val + c.val_load() ==>
    f.precondition((c,)) && (f.postcondition_once((c,), ()) ==> (^c).shot_store())

ensures

exists<c: &mut Committer<Self, $int_type, SeqCst, SeqCst>>
    !c.shot_store() && c.ward() == *self && c.val_store() == val + c.val_load() &&
    c.val_load() == result && f.postcondition_once((c,), ())

Trait Implementations

impl PermTarget for AtomicI16

type Value = i16

Value managed by the type.

type Objectiveness = ()

Objectiveness parametrization for the Perm.

fn is_disjoint( &self, _self_val: &Self::Value, other: &Self, _other_val: &Self::Value, ) -> bool

Logical function that describes the behavior of Perm::disjoint_lemma.