Struct LocalLockMutLocalDataHandle 

pub struct LocalLockMutLocalDataHandle<T: Dist> { /* private fields */ }

Handle used to retrieve the aquired mutable local data LocalLockMutLocalData of a LocalLockArray

This handle must be awaited or blocked on to acquire the lock

Once awaited/blocked the handle will not return while any readers or writer currently has access to the lock

Returns an RAII guard which will drop the read access of the wrlock when dropped

Examples

 use lamellar::array::prelude::*;
 let world = LamellarWorldBuilder::new().build();
 let my_pe = world.my_pe();

 let array: LocalLockArray<usize> = LocalLockArray::new(&world,100,Distribution::Cyclic).block();
 let handle = array.write_local_data();
 world.spawn(async move {
     let mut local_data = handle.await;
     local_data.iter_mut().for_each(|elem| *elem += my_pe);
 });
 let mut local_data = array.write_local_data().block();
 local_data.iter_mut().for_each(|elem| *elem += my_pe);

Implementations

impl<T: Dist> LocalLockMutLocalDataHandle<T>

pub fn block(self) -> LocalLockMutLocalData<T>

Blocks the calling thread to retrieve the aquired mutable local data LocalLockMutLocalData of a LocalLockArray within a non async context

Returns an RAII guard which will drop the write access of the wrlock when dropped

Examples

 use lamellar::array::prelude::*;
 let world = LamellarWorldBuilder::new().build();
 let my_pe = world.my_pe();

 let array: LocalLockArray<usize> = LocalLockArray::new(&world,100,Distribution::Cyclic).block();
 let handle = array.write_local_data();
 let mut local_data = handle.block();
 local_data.iter_mut().for_each(|elem| *elem += my_pe);

pub fn spawn(self) -> LamellarTask<LocalLockMutLocalData<T>>

This method will spawn the associated active message to capture the lock and data on the work queue, initiating the operation.

This function returns a handle that can be used to wait for the operation to complete

Examples

 use lamellar::array::prelude::*;
 let world = LamellarWorldBuilder::new().build();
 let my_pe = world.my_pe();

 let array: LocalLockArray<usize> = LocalLockArray::new(&world,100,Distribution::Cyclic).block();
 let handle = array.write_local_data();
 let task = handle.spawn(); // initiate getting the write lock
 //do other work
 let mut local_data = task.block();
 local_data.iter_mut().for_each(|elem| *elem += my_pe);

Trait Implementations

impl<T: Dist> Drop for LocalLockMutLocalDataHandle<T>

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl<T: Dist> Future for LocalLockMutLocalDataHandle<T>

type Output = LocalLockMutLocalData<T>

The type of value produced on completion.

fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output>

Attempts to resolve the future to a final value, registering the current task for wakeup if the value is not yet available.

impl<'pin, T: Dist> Unpin for LocalLockMutLocalDataHandle<T>

where PinnedFieldsOf<__LocalLockMutLocalDataHandle<'pin, T>>: Unpin,