Struct GlobalGroupChunk 

pub struct GlobalGroupChunk<'a, T, CS: ChunkScope, Map: ScopeUniqueMap<CS>> {
    pub map_params: Map,
    /* private fields */
}

Represent a chunk of global memory that is uniquely mapped to each thread group. It supports both continuous and non-continuous mapping strategies.

• T: element type
• Map: mapping strategy type
• ’a: lifetime of the underlying slice
• map_params: parameters for the mapping strategy

Fields

map_params: Map

Implementations

impl<'a, T, CS, Map: ScopeUniqueMap<CS>> GlobalGroupChunk<'a, T, CS, Map>

where CS: ChunkScope<FromScope = Grid> + ChunkScope,

Creating global chunk from GpuGlobal.

pub fn new(global: GpuGlobal<'a, [T]>, map_params: Map) -> Self

TODO: We will prevent rechunking of global mem in the mir_analysis. For now, we just leave it to the user.

pub fn new_from_host<'b: 'a>( slice: &'a mut TensorViewMut<'b, [T]>, map_params: Map, ) -> Self

In some cases, passing GlobalThreadChunk from host to device is more convenient. Due to unknown optimization-related factors, passing GlobalThreadChunk to kernel function may make the kernel faster (see examples/matmul). In addition, directly passing GlobalThreadChunk from host to device naturally avoids the problem of rechunking the global mem.

impl<'a, T, CS: ChunkScope, Map: ScopeUniqueMap<CS>> GlobalGroupChunk<'a, T, CS, Map>

Creating global chunk from GpuGlobal.

pub fn chunk_to_scope<CS2: ChunkScope, Map2: ScopeUniqueMap<CS2>>( self, _cs: CS2, map: Map2, ) -> GlobalGroupChunk<'a, T, ChainedScope<CS, CS2>, ChainedMap<CS, CS2, Map, Map2>>

where Map: ScopeUniqueMap<CS>, CS: ChunkScope<ToScope = CS2::FromScope>, Map2::GlobalIndexType: AsPrimitive<Map::IndexType>,

Convert GlobalGroupChunk to another GlobalGroupChunk with different ChunkScope and Map. See ChunkScope for more details about chunk scope.

pub fn local2global( &self, idx: <Map as ScopeUniqueMap<CS>>::IndexType, ) -> Map::GlobalIndexType

Trait Implementations

impl<'a, T, CS: ChunkScope, Map: ScopeUniqueMap<CS>> Index<<Map as ScopeUniqueMap<CS>>::IndexType> for GlobalGroupChunk<'a, T, CS, Map>

type Output = T

The returned type after indexing.

fn index(&self, idx: Map::IndexType) -> &T

Performs the indexing (container[index]) operation.

impl<'a, T, CS, Map: ScopeUniqueMap<CS>> IndexMut<<Map as ScopeUniqueMap<CS>>::IndexType> for GlobalGroupChunk<'a, T, CS, Map>

where CS: ChunkScope<ToScope = Thread> + ChunkScope,

fn index_mut(&mut self, idx: Map::IndexType) -> &mut T

Performs the mutable indexing (container[index]) operation.