Struct EnginePlan 

pub struct EnginePlan {
    pub clock_hz: Fact<f64>,
    pub array_dsp_blocks: u32,
    pub array_soft_macs: Fact<f64>,
    pub scale_lanes: u32,
    pub scale_lane_alms: Fact<f64>,
    pub vector_dsp_blocks: u32,
    pub beat: Beat,
    pub state_chunk_lines: u64,
}

How the decode engine spends the device: the multiplier budget, the block-scale lanes, the memory beat and the clock it closes at.

Fields

clock_hz: Fact<f64>

The array’s clock.

array_dsp_blocks: u32

DSP blocks in the 4-bit array, ARRAY_MACS_PER_DSP multiply-adds each per cycle.

array_soft_macs: Fact<f64>

Multiply-adds of a 4-bit weight code and an 8-bit activation code carried in logic beside the DSP blocks.

scale_lanes: u32

Block-scale lanes, each one cycle a weight block at SCALE_LANE_DSPS DSP blocks and its logic.

scale_lane_alms: Fact<f64>

Logic one lane takes: its sub-block multipliers, the exact two-term sum, its rounding.

vector_dsp_blocks: u32

DSP blocks in f32 mode for the vector units, one multiply-add each per cycle.

beat: Beat

state_chunk_lines: u64

Lines of a recurrent state a stream engine reads before it writes them back: the memory’s bus turns twice a chunk, and the engine holds a chunk read ahead and a chunk written behind.

Implementations

impl EnginePlan

pub fn standard() -> EnginePlan

The plan the engine is built to: 768 DSP blocks of f32 vector units, 24,576 soft multiply-adds, as many block-scale lanes as the array’s multiply-adds fill at LANE_MIX a lane cycle, the rest of the DSP blocks in the array, 64 data bits of every beat, and a recurrent state rewritten 512 lines at a time — a value head’s binary16 state of 128 by 128, at 64 bytes a line.

pub fn full_beat() -> EnginePlan

The standard plan reading and writing all 72 bits of every beat.

pub fn array_rate(&self) -> f64

Multiply-adds per second the array retires.

pub fn scale_rate(&self) -> f64

Lane cycles per second the block-scale lanes retire.

pub fn dsp_blocks(&self) -> u32

DSP blocks the plan spends: the array’s, the lanes’, the vector units’.

pub fn alms(&self) -> f64

ALMs the plan’s soft multiply-adds and lanes take, at the modeled 15 a soft multiply-add.

pub fn vector_rate(&self) -> f64

f32 multiply-adds per second the vector units retire.

Trait Implementations

impl Clone for EnginePlan

fn clone(&self) -> EnginePlan

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for EnginePlan

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

Formats the value using the given formatter.

impl PartialEq for EnginePlan

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for EnginePlan

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for EnginePlan

impl StructuralPartialEq for EnginePlan