Struct LayerPlacement 

pub struct LayerPlacement {
    pub input: Device,
    pub hidden: Vec<Device>,
    pub output: Device,
}

Where each layer of a LayerParallelism model runs: the device of its input layer, of each hidden layer, and of its output layer.

Fields

input: Device

Where the input layer runs.

hidden: Vec<Device>

Where each hidden layer runs, in forward order.

output: Device

Where the output layer runs.

Implementations

impl LayerPlacement

pub fn new(stages: &[LayerStage]) -> Self

One device per hidden layer, read off the stages in order. The input layer runs on the first stage’s device and the output layer on the last stage’s, so a stage of no hidden layers gives one of them a device to itself.

Panics

Panics when stages is empty.

pub fn devices(&self) -> Vec<Device>

Every device a layer runs on, each once, in forward order: the input layer’s first.

pub fn stages(&self) -> Vec<LayerStage>

Each device’s run of consecutive hidden layers, in forward order.

pub fn even(devices: &[Device], num_hidden_layers: usize) -> Self

The hidden layers shared out in order across devices, as evenly as the count allows: when it does not divide, the first devices take one layer more. Devices past the layer count are left out rather than given a stage with nothing to run; new places those on purpose.

Panics

Panics when devices is empty.

pub fn by_memory(devices: &[DeviceMemory], memory: &LayerMemory) -> Option<Self>

The layers in order across devices, in runs sized to each device’s capacity: the device using the largest share of its capacity uses as small a share as a split in order allows, so every device keeps about the same fraction free. A layer too large for what a device has left moves on to the next, and devices past the last run are left out.

None when the layers do not fit on devices at all.

Trait Implementations

impl Clone for LayerPlacement

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for LayerPlacement

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for LayerPlacement

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for LayerPlacement