Struct Barrier 

pub struct Barrier;

A mechanism for awaiting on asynchronous data transfers Behavior is defined by its BarrierLevel.

Implementations

impl Barrier

pub fn tma_load_1d<C1: RudaPrimitive, C2: RudaPrimitive<Scalar = C1::Scalar>>( &self, source: &TensorMap<C1, Tiled>, destination: &mut SliceMut<C2>, x: i32, )

Copy a tile from a global memory source to a shared memory destination, with the provided offsets.

pub fn __expand_tma_load_1d<C1: RudaPrimitive, C2: RudaPrimitive<Scalar = C1::Scalar>>( scope: &mut Scope, expand: BarrierExpand, source: NativeExpand<TensorMap<C1, Tiled>>, destination: SliceExpand<C2, ReadWrite>, x: NativeExpand<i32>, )

impl Barrier

pub fn tma_load_2d<C1: RudaPrimitive, C2: RudaPrimitive<Scalar = C1::Scalar>>( &self, source: &TensorMap<C1, Tiled>, destination: &mut SliceMut<C2>, y: i32, x: i32, )

Copy a tile from a global memory source to a shared memory destination, with the provided offsets.

pub fn __expand_tma_load_2d<C1: RudaPrimitive, C2: RudaPrimitive<Scalar = C1::Scalar>>( scope: &mut Scope, expand: BarrierExpand, source: NativeExpand<TensorMap<C1, Tiled>>, destination: SliceExpand<C2, ReadWrite>, y: NativeExpand<i32>, x: NativeExpand<i32>, )

impl Barrier

pub fn tma_load_3d<C1: RudaPrimitive, C2: RudaPrimitive<Scalar = C1::Scalar>>( &self, source: &TensorMap<C1, Tiled>, destination: &mut SliceMut<C2>, z: i32, y: i32, x: i32, )

Copy a tile from a global memory source to a shared memory destination, with the provided offsets.

pub fn __expand_tma_load_3d<C1: RudaPrimitive, C2: RudaPrimitive<Scalar = C1::Scalar>>( scope: &mut Scope, expand: BarrierExpand, source: NativeExpand<TensorMap<C1, Tiled>>, destination: SliceExpand<C2, ReadWrite>, z: NativeExpand<i32>, y: NativeExpand<i32>, x: NativeExpand<i32>, )

impl Barrier

pub fn tma_load_4d<C1: RudaPrimitive, C2: RudaPrimitive<Scalar = C1::Scalar>>( &self, source: &TensorMap<C1, Tiled>, destination: &mut SliceMut<C2>, w: i32, z: i32, y: i32, x: i32, )

Copy a tile from a global memory source to a shared memory destination, with the provided offsets.

pub fn __expand_tma_load_4d<C1: RudaPrimitive, C2: RudaPrimitive<Scalar = C1::Scalar>>( scope: &mut Scope, expand: BarrierExpand, source: NativeExpand<TensorMap<C1, Tiled>>, destination: SliceExpand<C2, ReadWrite>, w: NativeExpand<i32>, z: NativeExpand<i32>, y: NativeExpand<i32>, x: NativeExpand<i32>, )

impl Barrier

pub fn tma_load_5d<C1: RudaPrimitive, C2: RudaPrimitive<Scalar = C1::Scalar>>( &self, source: &TensorMap<C1, Tiled>, destination: &mut SliceMut<C2>, v: i32, w: i32, z: i32, y: i32, x: i32, )

Copy a tile from a global memory source to a shared memory destination, with the provided offsets.

pub fn __expand_tma_load_5d<C1: RudaPrimitive, C2: RudaPrimitive<Scalar = C1::Scalar>>( scope: &mut Scope, expand: BarrierExpand, source: NativeExpand<TensorMap<C1, Tiled>>, destination: SliceExpand<C2, ReadWrite>, v: NativeExpand<i32>, w: NativeExpand<i32>, z: NativeExpand<i32>, y: NativeExpand<i32>, x: NativeExpand<i32>, )

impl Barrier

pub fn tma_load_im2col_3d<C1: RudaPrimitive, C2: RudaPrimitive<Scalar = C1::Scalar>>( &self, source: &TensorMap<C1, Im2col>, destination: &mut SliceMut<C2>, n: i32, w: i32, c: i32, w_offset: u16, )

Copy a tile from a global memory source to a shared memory destination, with the provided offsets.

pub fn __expand_tma_load_im2col_3d<C1: RudaPrimitive, C2: RudaPrimitive<Scalar = C1::Scalar>>( scope: &mut Scope, expand: BarrierExpand, source: NativeExpand<TensorMap<C1, Im2col>>, destination: SliceExpand<C2, ReadWrite>, n: NativeExpand<i32>, w: NativeExpand<i32>, c: NativeExpand<i32>, w_offset: NativeExpand<u16>, )

impl Barrier

pub fn tma_load_im2col_4d<C1: RudaPrimitive, C2: RudaPrimitive<Scalar = C1::Scalar>>( &self, source: &TensorMap<C1, Im2col>, destination: &mut SliceMut<C2>, n: i32, h: i32, w: i32, c: i32, h_offset: u16, w_offset: u16, )

Copy a tile from a global memory source to a shared memory destination, with the provided offsets.

pub fn __expand_tma_load_im2col_4d<C1: RudaPrimitive, C2: RudaPrimitive<Scalar = C1::Scalar>>( scope: &mut Scope, expand: BarrierExpand, source: NativeExpand<TensorMap<C1, Im2col>>, destination: SliceExpand<C2, ReadWrite>, n: NativeExpand<i32>, h: NativeExpand<i32>, w: NativeExpand<i32>, c: NativeExpand<i32>, h_offset: NativeExpand<u16>, w_offset: NativeExpand<u16>, )

impl Barrier

pub fn tma_load_im2col_5d<C1: RudaPrimitive, C2: RudaPrimitive<Scalar = C1::Scalar>>( &self, source: &TensorMap<C1, Im2col>, destination: &mut SliceMut<C2>, n: i32, d: i32, h: i32, w: i32, c: i32, d_offset: u16, h_offset: u16, w_offset: u16, )

Copy a tile from a global memory source to a shared memory destination, with the provided offsets.

pub fn __expand_tma_load_im2col_5d<C1: RudaPrimitive, C2: RudaPrimitive<Scalar = C1::Scalar>>( scope: &mut Scope, expand: BarrierExpand, source: NativeExpand<TensorMap<C1, Im2col>>, destination: SliceExpand<C2, ReadWrite>, n: NativeExpand<i32>, d: NativeExpand<i32>, h: NativeExpand<i32>, w: NativeExpand<i32>, c: NativeExpand<i32>, d_offset: NativeExpand<u16>, h_offset: NativeExpand<u16>, w_offset: NativeExpand<u16>, )

impl Barrier

pub fn local() -> Self

Create a local barrier object for the current unit. Automatically initialized with an arrival count of 1.

pub fn shared(arrival_count: u32, is_elected: bool) -> Shared<Barrier>

Create a shared memory barrier that can be accesses by all units in the ruda. Initialized by the is_elected unit with an arrival count of arrival_count. This is the number of times arrive or one of its variants needs to be called before the barrier advances.

If all units in the ruda arrive on the barrier, use RUDA_DIM as the arrival count. For other purposes, only a subset may need to arrive.

pub fn shared_uninit() -> Shared<Barrier>

Create a shared memory barrier that can be accesses by all units in the ruda. Only declared, but not initialized.

pub fn init_manual(&self, arrival_count: u32)

Initializes a barrier with a given arrival_count. This is the number of times arrive or one of its variants needs to be called before the barrier advances.

If all units in the ruda arrive on the barrier, use RUDA_DIM as the arrival count. For other purposes, only a subset may need to arrive.

Note

No synchronization or election is performed, this is raw initialization. For shared barriers ensure only one unit performs the initialization, and synchronize the ruda afterwards. There may also be additional synchronization requirements for bulk copy operations, like sync_async_proxy_shared().

pub fn __expand_local(scope: &mut Scope) -> <Self as RudaType>::ExpandType

pub fn __expand_shared( scope: &mut Scope, arrival_count: <u32 as RudaType>::ExpandType, is_elected: <bool as RudaType>::ExpandType, ) -> <Shared<Barrier> as RudaType>::ExpandType

pub fn __expand_shared_uninit( scope: &mut Scope, ) -> <Shared<Barrier> as RudaType>::ExpandType

pub fn __expand_init_manual( scope: &mut Scope, this: &<Self as RudaType>::ExpandType, arrival_count: <u32 as RudaType>::ExpandType, ) -> <() as RudaType>::ExpandType

impl Barrier

pub fn memcpy_async<C: RudaPrimitive>( &self, source: &Slice<C>, destination: &mut SliceMut<C>, )

Copy the source slice to destination

Safety

This will try to copy the whole source slice, so make sure source length <= destination length

pub fn memcpy_async_cooperative<C: RudaPrimitive>( &self, source: &Slice<C>, destination: &mut SliceMut<C>, )

Copy the source slice to destination

Safety

This will try to copy the whole source slice, so make sure source length <= destination length

pub fn memcpy_async_tx<C: RudaPrimitive>( &self, source: &Slice<C>, destination: &mut SliceMut<C>, )

Copy the source slice to destination. Uses transaction count like TMA, so use with expect_tx or arrive_and_expect_tx.

Safety

This will try to copy the whole source slice, so make sure source length <= destination length

pub fn __expand_memcpy_async<C: RudaPrimitive>( scope: &mut Scope, this: &<Self as RudaType>::ExpandType, source: <Slice<C> as RudaType>::ExpandType, destination: <SliceMut<C> as RudaType>::ExpandType, ) -> <() as RudaType>::ExpandType

pub fn __expand_memcpy_async_cooperative<C: RudaPrimitive>( scope: &mut Scope, this: &<Self as RudaType>::ExpandType, source: <Slice<C> as RudaType>::ExpandType, destination: <SliceMut<C> as RudaType>::ExpandType, ) -> <() as RudaType>::ExpandType

pub fn __expand_memcpy_async_tx<C: RudaPrimitive>( scope: &mut Scope, this: &<Self as RudaType>::ExpandType, source: <Slice<C> as RudaType>::ExpandType, destination: <SliceMut<C> as RudaType>::ExpandType, ) -> <() as RudaType>::ExpandType

impl Barrier

pub fn arrive(&self) -> BarrierToken

Arrive at the barrier, decrementing arrival count

pub fn arrive_and_expect_tx( &self, arrival_count: u32, transaction_count: u32, ) -> BarrierToken

Arrive at the barrier, decrementing arrival count. Additionally increments expected count.

pub fn expect_tx(&self, expected_count: u32)

Increments the expected count of the barrier.

pub fn arrive_and_wait(&self)

Wait until all data is loaded

pub fn wait(&self, token: BarrierToken)

Wait at the barrier until all arrivals are done

pub fn wait_parity(&self, phase: u32)

Wait at the barrier until the phase is completed. Doesn’t require a token, but needs phase to be managed manually.

pub fn __expand_arrive( scope: &mut Scope, this: &<Self as RudaType>::ExpandType, ) -> <BarrierToken as RudaType>::ExpandType

pub fn __expand_arrive_and_expect_tx( scope: &mut Scope, this: &<Self as RudaType>::ExpandType, arrival_count: <u32 as RudaType>::ExpandType, transaction_count: <u32 as RudaType>::ExpandType, ) -> <BarrierToken as RudaType>::ExpandType

pub fn __expand_expect_tx( scope: &mut Scope, this: &<Self as RudaType>::ExpandType, expected_count: <u32 as RudaType>::ExpandType, ) -> <() as RudaType>::ExpandType

pub fn __expand_arrive_and_wait( scope: &mut Scope, this: &<Self as RudaType>::ExpandType, ) -> <() as RudaType>::ExpandType

pub fn __expand_wait( scope: &mut Scope, this: &<Self as RudaType>::ExpandType, token: <BarrierToken as RudaType>::ExpandType, ) -> <() as RudaType>::ExpandType

pub fn __expand_wait_parity( scope: &mut Scope, this: &<Self as RudaType>::ExpandType, phase: <u32 as RudaType>::ExpandType, ) -> <() as RudaType>::ExpandType

impl Barrier

pub fn commit_copy_async(&self)

Makes all previous copy_async operations visible on the barrier. Should be called once after all copies have been dispatched, before reading from the shared memory.

Does not count as an arrive in terms of the barrier arrival count. So arrive or arrive_and_wait should still be called afterwards.

pub fn __expand_commit_copy_async( scope: &mut Scope, this: &<Self as RudaType>::ExpandType, ) -> <() as RudaType>::ExpandType

Trait Implementations

impl Clone for Barrier

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Barrier

impl Eq for Barrier

impl NativeAssign for Barrier

fn elem_init_mut(_scope: &mut Scope, elem: ManagedVariable) -> ManagedVariable

impl PartialEq for Barrier

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl RudaPrimitive for Barrier

type Scalar = u32

type Size = Const<1>

type WithScalar<S: Scalar> = S

fn from_const_value(_value: ConstantValue) -> Self

fn as_type(_scope: &Scope) -> Type

Return the element type to use on GPU.

fn as_type_native() -> Option<Type>

Native or static element type.

fn as_type_native_unchecked() -> Type

Native or static element type.

fn size() -> Option<usize>

Only native element types have a size.

fn size_bits() -> Option<usize>

Only native element types have a size.

fn size_bits_unchecked() -> usize

Only native element types have a size.

fn from_expand_elem(elem: ManagedVariable) -> Self::ExpandType

fn into_lit_unchecked(self) -> Self

fn supported_uses<R: Runtime>(client: &ComputeClient<R>) -> EnumSet<TypeUsage>

fn type_size() -> usize

fn type_size_bits() -> usize

fn packing_factor() -> usize

fn vector_size() -> usize

fn __expand_type_size(scope: &Scope) -> usize

fn __expand_type_size_bits(scope: &Scope) -> usize

fn __expand_packing_factor(scope: &Scope) -> usize

fn __expand_vector_size(scope: &Scope) -> usize

impl RudaType for Barrier

type ExpandType = NativeExpand<Barrier>

impl StructuralPartialEq for Barrier