Enum LamellarWriteArray 

pub enum LamellarWriteArray<T: Dist> {
    UnsafeArray(UnsafeArray<T>),
    AtomicArray(AtomicArray<T>),
    LocalLockArray(LocalLockArray<T>),
    GlobalLockArray(GlobalLockArray<T>),
}

Represents the array types that allow write operations

Variants

UnsafeArray(UnsafeArray<T>)

AtomicArray(AtomicArray<T>)

LocalLockArray(LocalLockArray<T>)

GlobalLockArray(GlobalLockArray<T>)

Trait Implementations

impl<T: Dist> ActiveMessaging for LamellarWriteArray<T>

type SinglePeAmHandle<R: AmDist> = AmHandle<R>

The handle type for single PE active messages

type MultiAmHandle<R: AmDist> = MultiAmHandle<R>

The handle type for multi PE active messages

type LocalAmHandle<L> = LocalAmHandle<L>

The handle type for local active messages

fn exec_am_all<F>(&self, am: F) -> Self::MultiAmHandle<F::Output>

where F: RemoteActiveMessage + LamellarAM + Serde + AmDist,

launch and execute an active message on every PE (including originating PE).

fn exec_am_pe<F>(&self, pe: usize, am: F) -> Self::SinglePeAmHandle<F::Output>

where F: RemoteActiveMessage + LamellarAM + Serde + AmDist,

launch and execute an active message on a specifc PE.

fn exec_am_local<F>(&self, am: F) -> Self::LocalAmHandle<F::Output>

where F: LamellarActiveMessage + LocalAM + 'static,

launch and execute an active message on the calling PE.

fn wait_all(&self)

blocks calling thread until all remote tasks (e.g. active mesages, array operations) initiated by the calling PE have completed.

fn await_all(&self) -> impl Future<Output = ()> + Send

blocks calling task until all remote tasks (e.g. active mesages, array operations) initiated by the calling PE have completed. Intended to be used within an async context.

fn barrier(&self)

Global synchronization method which blocks the calling thread until all PEs in the barrier group (e.g. World, Team, Array) have entered Generally this is intended to be called from the main thread, if a barrier is needed within an active message or async context please see async_barrier

fn async_barrier(&self) -> BarrierHandle

EXPERIMENTAL: Global synchronization method which blocks the calling task until all PEs in the barrier group (e.g. World, Team, Array) have entered. This function allows for calling barrier in an async context without blocking the worker thread. Care should be taken when using this function to avoid deadlocks,as it is easy to mismatch barrier calls accross threads and PEs.

fn spawn<F>(&self, f: F) -> LamellarTask<F::Output>

where F: Future + Send + 'static, F::Output: Send,

Spawns a future on the worker threadpool

fn block_on<F: Future>(&self, f: F) -> F::Output

Run a future to completion on the current thread

fn block_on_all<I>( &self, iter: I, ) -> Vec<<<I as IntoIterator>::Item as Future>::Output>

where I: IntoIterator, <I as IntoIterator>::Item: Future + Send + 'static, <<I as IntoIterator>::Item as Future>::Output: Send,

Run a collection of futures to completion

impl<T: ElementArithmeticOps> ArithmeticOps<T> for LamellarWriteArray<T>

fn add(&self, index: usize, val: T) -> ArrayOpHandle

This call adds the supplied val into the element specified by index

fn batch_add<'a>( &self, index: impl OpInput<'a, usize>, val: impl OpInput<'a, T>, ) -> ArrayBatchOpHandle

This call performs a batched vesion of the add function,

fn fetch_add(&self, index: usize, val: T) -> ArrayFetchOpHandle<T>

This call adds the supplied val into the element specified by index, returning the old value

fn batch_fetch_add<'a>( &self, index: impl OpInput<'a, usize>, val: impl OpInput<'a, T>, ) -> ArrayFetchBatchOpHandle<T>

This call performs a batched vesion of the fetch_add function,

fn sub<'a>(&self, index: usize, val: T) -> ArrayOpHandle

This call subtracts the supplied val from the element specified by index

fn batch_sub<'a>( &self, index: impl OpInput<'a, usize>, val: impl OpInput<'a, T>, ) -> ArrayBatchOpHandle

This call performs a batched vesion of the sub function,

fn fetch_sub<'a>(&self, index: usize, val: T) -> ArrayFetchOpHandle<T>

This call subtracts the supplied val from the element specified by index, returning the old value

fn batch_fetch_sub<'a>( &self, index: impl OpInput<'a, usize>, val: impl OpInput<'a, T>, ) -> ArrayFetchBatchOpHandle<T>

This call performs a batched vesion of the fetch_sub function,

fn mul<'a>(&self, index: usize, val: T) -> ArrayOpHandle

This call multiplies the supplied val by the element specified by index and stores the result.

fn batch_mul<'a>( &self, index: impl OpInput<'a, usize>, val: impl OpInput<'a, T>, ) -> ArrayBatchOpHandle

This call performs a batched vesion of the mul function,

fn fetch_mul<'a>(&self, index: usize, val: T) -> ArrayFetchOpHandle<T>

This call multiplies the supplied val with the element specified by index, returning the old value

fn batch_fetch_mul<'a>( &self, index: impl OpInput<'a, usize>, val: impl OpInput<'a, T>, ) -> ArrayFetchBatchOpHandle<T>

This call performs a batched vesion of the fetch_mul function,

fn div<'a>(&self, index: usize, val: T) -> ArrayOpHandle

This call divides the element specified by index with the supplied val and stores the result

fn batch_div<'a>( &self, index: impl OpInput<'a, usize>, val: impl OpInput<'a, T>, ) -> ArrayBatchOpHandle

This call performs a batched vesion of the div function,

fn fetch_div<'a>(&self, index: usize, val: T) -> ArrayFetchOpHandle<T>

This call divides the element specified by index with the supplied val, returning the old value

fn batch_fetch_div<'a>( &self, index: impl OpInput<'a, usize>, val: impl OpInput<'a, T>, ) -> ArrayFetchBatchOpHandle<T>

This call performs a batched vesion of the fetch_div function,

fn rem<'a>(&self, index: usize, val: T) -> ArrayOpHandle

This call divides the element specified by index with the supplied val and stores the result

fn batch_rem<'a>( &self, index: impl OpInput<'a, usize>, val: impl OpInput<'a, T>, ) -> ArrayBatchOpHandle

This call performs a batched vesion of the rem function,

fn fetch_rem<'a>(&self, index: usize, val: T) -> ArrayFetchOpHandle<T>

This call divides the element specified by index with the supplied val, returning the old value

fn batch_fetch_rem<'a>( &self, index: impl OpInput<'a, usize>, val: impl OpInput<'a, T>, ) -> ArrayFetchBatchOpHandle<T>

This call performs a batched vesion of the fetch_rem function,

impl<T: Clone + Dist> Clone for LamellarWriteArray<T>

fn clone(&self) -> LamellarWriteArray<T>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'de, T> Deserialize<'de> for LamellarWriteArray<T>

where T: Dist + Serialize + DeserializeOwned,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T: Dist> From<AtomicArray<T>> for LamellarWriteArray<T>

fn from(v: AtomicArray<T>) -> LamellarWriteArray<T>

Converts to this type from the input type.

impl<T: Dist> From<GlobalLockArray<T>> for LamellarWriteArray<T>

fn from(v: GlobalLockArray<T>) -> LamellarWriteArray<T>

Converts to this type from the input type.

impl<T: Dist> From<LocalLockArray<T>> for LamellarWriteArray<T>

fn from(v: LocalLockArray<T>) -> LamellarWriteArray<T>

Converts to this type from the input type.

impl<T: Dist> From<UnsafeArray<T>> for LamellarWriteArray<T>

fn from(v: UnsafeArray<T>) -> LamellarWriteArray<T>

Converts to this type from the input type.

impl<T: Dist> LamellarArray<T> for LamellarWriteArray<T>

fn len(&self) -> usize

Returns the team used to construct this array, the PEs in the team represent the same PEs which have a slice of data of the array

One-sided Operation

the result is returned only on the calling PE

Examples

 use lamellar::array::prelude::*;
 let world = LamellarWorldBuilder::new().build();
 let array: LocalLockArray<usize> = LocalLockArray::new(&world,100,Distribution::Cyclic).block();

 let a_team = array.team();

Return the total number of elements in this array

One-sided Operation

the result is returned only on the calling PE

Examples

 use lamellar::array::prelude::*;
 let world = LamellarWorldBuilder::new().build();
 let array: UnsafeArray<usize> = UnsafeArray::new(&world,100,Distribution::Cyclic).block();

 assert_eq!(100,array.len());

fn num_elems_local(&self) -> usize

Return the number of elements of the array local to this PE

One-sided Operation

the result is returned only on the calling PE

Examples

Assume a 4 PE system

 use lamellar::array::prelude::*;
 let world = LamellarWorldBuilder::new().build();
 let array = ReadOnlyArray::<usize>::new(&world,100,Distribution::Cyclic).block();

 assert_eq!(25,array.num_elems_local());

fn pe_and_offset_for_global_index( &self, __enum_dispatch_arg_0: usize, ) -> Option<(usize, usize)>

Given a global index, calculate the PE and offset on that PE where the element actually resides. Returns None if the index is Out of bounds

One-sided Operation

the result is returned only on the calling PE

Examples

assume we have 4 PEs

Block

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

 let block_array: UnsafeArray<usize> = UnsafeArray::new(&world,16,Distribution::Block).block();
 // block array index location  = PE0 [0,1,2,3],  PE1 [4,5,6,7],  PE2 [8,9,10,11], PE3 [12,13,14,15]
 let  Some((pe,offset)) = block_array.pe_and_offset_for_global_index(6) else { panic!("out of bounds");};
 assert_eq!((pe,offset) ,(1,2));

Cyclic

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

 let cyclic_array: UnsafeArray<usize> = UnsafeArray::new(world,16,Distribution::Cyclic).block();
 // cyclic array index location = PE0 [0,4,8,12], PE1 [1,5,9,13], PE2 [2,6,10,14], PE3 [3,7,11,15]
 let Some((pe,offset)) = cyclic_array.pe_and_offset_for_global_index(6) else { panic!("out of bounds");};
 assert_eq!((pe,offset) ,(2,1));

fn first_global_index_for_pe( &self, __enum_dispatch_arg_0: usize, ) -> Option<usize>

Given a PE, return the global index of the first element on that PE Returns None if no data exists on that PE

One-sided Operation

the result is returned only on the calling PE

Examples

assume we have 4 PEs

Block

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

 let block_array: UnsafeArray<usize> = UnsafeArray::new(&world,16,Distribution::Block).block();
 // block array index location  = PE0 [0,1,2,3],  PE1 [4,5,6,7],  PE2 [8,9,10,11], PE3 [12,13,14,15]
 let index = block_array.first_global_index_for_pe(0).unwrap();
 assert_eq!(index , 0);
 let index = block_array.first_global_index_for_pe(1).unwrap();
 assert_eq!(index , 4);
 let index = block_array.first_global_index_for_pe(2).unwrap();
 assert_eq!(index , 8);
 let index = block_array.first_global_index_for_pe(3).unwrap();
 assert_eq!(index , 12);

Cyclic

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

 let cyclic_array: UnsafeArray<usize> = UnsafeArray::new(world,16,Distribution::Cyclic).block();
 // cyclic array index location = PE0 [0,4,8,12], PE1 [1,5,9,13], PE2 [2,6,10,14], PE3 [3,7,11,15]
 let Some((pe,offset)) = cyclic_array.pe_and_offset_for_global_index(6) else { panic!("out of bounds");};
 let index = cyclic_array.first_global_index_for_pe(0).unwrap();
 assert_eq!(index , 0);
 let index = cyclic_array.first_global_index_for_pe(1).unwrap();
 assert_eq!(index , 1);
 let index = cyclic_array.first_global_index_for_pe(2).unwrap();
 assert_eq!(index , 2);
 let index = cyclic_array.first_global_index_for_pe(3).unwrap();
 assert_eq!(index , 3);

fn last_global_index_for_pe( &self, __enum_dispatch_arg_0: usize, ) -> Option<usize>

Given a PE, return the global index of the first element on that PE Returns None if no data exists on that PE

One-sided Operation

the result is returned only on the calling PE

Examples

assume we have 4 PEs

Block

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

 let block_array: UnsafeArray<usize> = UnsafeArray::new(&world,16,Distribution::Block).block();
 // block array index location  = PE0 [0,1,2,3],  PE1 [4,5,6,7],  PE2 [8,9,10,11], PE3 [12,13,14,15]
 let index = block_array.last_global_index_for_pe(0).unwrap();
 assert_eq!(index , 3);
 let index = block_array.last_global_index_for_pe(1).unwrap();
 assert_eq!(index , 7);
 let index = block_array.last_global_index_for_pe(2).unwrap();
 assert_eq!(index , 11);
 let index = block_array.last_global_index_for_pe(3).unwrap();
 assert_eq!(index , 15);

Cyclic

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

 let cyclic_array: UnsafeArray<usize> = UnsafeArray::new(world,16,Distribution::Cyclic).block();
 // cyclic array index location = PE0 [0,4,8,12], PE1 [1,5,9,13], PE2 [2,6,10,14], PE3 [3,7,11,15]
 let Some((pe,offset)) = cyclic_array.pe_and_offset_for_global_index(6) else { panic!("out of bounds");};
 let index = cyclic_array.last_global_index_for_pe(0).unwrap();
 assert_eq!(index , 12);
 let index = cyclic_array.last_global_index_for_pe(1).unwrap();
 assert_eq!(index , 13);
 let index = cyclic_array.last_global_index_for_pe(2).unwrap();
 assert_eq!(index , 14);
 let index = cyclic_array.last_global_index_for_pe(3).unwrap();
 assert_eq!(index , 15);

impl<T: Dist> LamellarEnv for LamellarWriteArray<T>

fn my_pe(&self) -> usize

Return the PE id of the calling PE, if called on a team instance, the PE id will be with respect to the team (not to the world)

fn num_pes(&self) -> usize

Return the number of PEs in the execution

fn num_threads_per_pe(&self) -> usize

Return the number of threads per PE

fn world(&self) -> Arc<LamellarTeam>

Return a pointer the world team

fn team(&self) -> Arc<LamellarTeam>

Return a pointer to the LamellarTeam

impl<T> Serialize for LamellarWriteArray<T>

where T: Dist + Serialize + DeserializeOwned,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T: Dist> TryInto<AtomicArray<T>> for LamellarWriteArray<T>

type Error = &'static str

The type returned in the event of a conversion error.

fn try_into( self, ) -> Result<AtomicArray<T>, <Self as TryInto<AtomicArray<T>>>::Error>

Performs the conversion.

impl<T: Dist> TryInto<GlobalLockArray<T>> for LamellarWriteArray<T>

type Error = &'static str

The type returned in the event of a conversion error.

fn try_into( self, ) -> Result<GlobalLockArray<T>, <Self as TryInto<GlobalLockArray<T>>>::Error>

Performs the conversion.

impl<T: Dist> TryInto<LocalLockArray<T>> for LamellarWriteArray<T>

type Error = &'static str

The type returned in the event of a conversion error.

fn try_into( self, ) -> Result<LocalLockArray<T>, <Self as TryInto<LocalLockArray<T>>>::Error>

Performs the conversion.

impl<T: Dist> TryInto<UnsafeArray<T>> for LamellarWriteArray<T>

type Error = &'static str

The type returned in the event of a conversion error.

fn try_into( self, ) -> Result<UnsafeArray<T>, <Self as TryInto<UnsafeArray<T>>>::Error>

Performs the conversion.