Struct LocalLockLocalDataHandle 

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

Handle used to retrieve the aquired local data LocalLockLocalData 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 writer currently has access to the lock, but there may be other readers

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.read_local_data();
 world.spawn(async move {
     let  local_data = handle.await;
     println!("PE{my_pe}, local_data: {:?}", local_data);
 });
 let mut local_data = array.read_local_data().block();
 println!("PE{my_pe}, local_data: {:?}", local_data);

Implementations

impl<T: Dist> LocalLockLocalDataHandle<T>

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

Blocks the calling thread to retrieve the aquired local data LocalLockLocalData 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.read_local_data();
 let  local_data = handle.block();
 println!("local data: {:?}",local_data);

pub fn spawn(self) -> LamellarTask<LocalLockLocalData<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.read_local_data();
 let task = handle.spawn(); // initiate getting the read lock
 // do other work
 let  local_data = task.block();
 println!("local data: {:?}",local_data);

Trait Implementations

impl<T: Dist> Drop for LocalLockLocalDataHandle<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 LocalLockLocalDataHandle<T>

type Output = LocalLockLocalData<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 LocalLockLocalDataHandle<T>

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