Struct Relay 

pub struct Relay<'a> { /* private fields */ }

One output box, relayed by the cubes a Levels::across split hands it: each contracts its own run, then takes its turn at the box’s carry in the order of the runs. The first turn writes its partial, each after adds its own into what is there a line at a time, and the last hands the sum on to the output. The carry is the TileArg the relay was opened on; the turns are passed on through turns, one counter a cube (Partitioning::relay_counters).

A cube opens its accumulator on the relayed tile, takes its turn with take, drains into the tile, and passes it on with pass, every unit of the cube reaching both. A sum whose partials must be rescaled against one another before they add, as an online softmax’s are, reads and rescales what the turns before it left (carried) in its turn, then drains as any other. The relay publishes a turn’s lines at device scope before passing the box on and acquires them after taking it, so it runs only where the runtime hands one cube’s writes to another within a dispatch (device_memory_scope), and reads its turn with a u32 atomic add, which every GPU runtime offers. A waiting cube holds its place on the device: the relay rests on a box’s earlier runs having started by the time a later one waits, which a grid whose runs are neighbours gives.

Implementations

impl<'a> Relay<'a>

pub fn has_turn(&self) -> bool

Whether this cube’s run holds a tile, and so takes a turn: a cube past the last such run holds nothing and never meets the box. Uniform across the cube.

pub fn tile(&self) -> Tile

This cube’s box of the carry, relayed: what its accumulator opens on, starting from the monoid’s identity, and what it drains into once it has taken its turn. The first turn replaces what the box held; every later one adds into it.

pub fn carried(&self) -> Tile

This cube’s box of the carry as the turns before this one left it, to read and to rescale in place once this cube has taken its turn and before it drains. It holds nothing on the first turn, whose drain replaces it.

pub fn is_first(&self) -> bool

Whether this cube takes its box’s first turn, whose drain replaces what the carry held. Uniform across the cube.

pub fn is_last(&self) -> bool

Whether this cube takes its box’s last turn, whose carry pass hands on to the output. Uniform across the cube.

pub fn take(&self)

Wait for this cube’s turn at its box, and acquire what the turns before it wrote. Every unit of the cube reaches it.

The counter is read with fetch_add(0). On Metal, an atomic load spinning on the counter can keep returning the value it first read long after the previous turn’s store has landed, and the cube then never leaves the loop. A plain load serves once the Metal backend’s atomic load reads the counter coherently on every spin.

pub fn pass(&self, out: &mut Tile)

Hand the box on: to the next turn, or, on the last, into out with a cast, once every plane’s lines of the carry are in. Every unit of the cube reaches it.

pub fn __expand_has_turn( scope: &Scope, this: &<Self as CubeType>::ExpandType, ) -> <bool as CubeType>::ExpandType

Whether this cube’s run holds a tile, and so takes a turn: a cube past the last such run holds nothing and never meets the box. Uniform across the cube.

pub fn __expand_tile( scope: &Scope, this: &<Self as CubeType>::ExpandType, ) -> <Tile as CubeType>::ExpandType

This cube’s box of the carry, relayed: what its accumulator opens on, starting from the monoid’s identity, and what it drains into once it has taken its turn. The first turn replaces what the box held; every later one adds into it.

pub fn __expand_carried( scope: &Scope, this: &<Self as CubeType>::ExpandType, ) -> <Tile as CubeType>::ExpandType

This cube’s box of the carry as the turns before this one left it, to read and to rescale in place once this cube has taken its turn and before it drains. It holds nothing on the first turn, whose drain replaces it.

pub fn __expand_is_first( scope: &Scope, this: &<Self as CubeType>::ExpandType, ) -> <bool as CubeType>::ExpandType

Whether this cube takes its box’s first turn, whose drain replaces what the carry held. Uniform across the cube.

pub fn __expand_is_last( scope: &Scope, this: &<Self as CubeType>::ExpandType, ) -> <bool as CubeType>::ExpandType

Whether this cube takes its box’s last turn, whose carry pass hands on to the output. Uniform across the cube.

pub fn __expand_take(scope: &Scope, this: &<Self as CubeType>::ExpandType)

Wait for this cube’s turn at its box, and acquire what the turns before it wrote. Every unit of the cube reaches it.

The counter is read with fetch_add(0). On Metal, an atomic load spinning on the counter can keep returning the value it first read long after the previous turn’s store has landed, and the cube then never leaves the loop. A plain load serves once the Metal backend’s atomic load reads the counter coherently on every spin.

pub fn __expand_pass( scope: &Scope, this: &<Self as CubeType>::ExpandType, out: &mut <Tile as CubeType>::ExpandType, )

Hand the box on: to the next turn, or, on the last, into out with a cast, once every plane’s lines of the carry are in. Every unit of the cube reaches it.

Trait Implementations

impl<'a> CubeType for Relay<'a>

type ExpandType = RelayExpand<'a>