Struct UnitModel 

pub struct UnitModel {
    pub tile_latency: usize,
    pub func: HashMap<FuncUnit, (usize, usize)>,
    pub default_func: (usize, usize),
    pub pipeline_depth: usize,
    pub register_turnaround: usize,
    pub cite: &'static str,
}

Per-cell timing: how many cycles a cell’s result takes (latency) and how many cycles the cell’s unit is busy per iteration (occupancy, the resource II). A fully pipelined unit has occupancy 1 whatever its latency; a sequential unit (an iterative divider) has occupancy == latency.

Fields

tile_latency: usize

Latency / occupancy of every combinational tile (arith, select, vector, memory read).

func: HashMap<FuncUnit, (usize, usize)>

Per functional unit: (latency, occupancy). Units absent here default to default_func.

default_func: (usize, usize)

pipeline_depth: usize

The unit’s pipeline depth: a result leaves the unit no earlier than this many cycles after its inputs enter, however short its datapath (0 for an ideal unit whose latency is the datapath’s).

register_turnaround: usize

Cycles between a carried register’s write (when its value leaves the pipeline) and the next iteration’s read of it: the turnaround a loop-carried dependency pays. 0 for ideal forwarding.

cite: &'static str

Where the numbers come from.

Implementations

impl UnitModel

pub fn ideal_pipelined() -> UnitModel

The ideal fully pipelined PCU: every tile and FU accepts a new operand every cycle (Plasticine ISCA’17 §3.1: “multi-stage, reconfigurable SIMD pipeline” — one stage per FU, pipeline registers between).

pub fn plasticine_pcu(stages: usize) -> UnitModel

The ISCA’17 PCU as the public toolchain simulates it: one-cycle FU stages, a result leaves the stages-deep pipeline stages cycles after entering it however short the datapath, and a carried register written at the pipeline’s end is read at its start one cycle later — so any loop-carried dependency that fits one PCU costs stages + 1 per iteration. CALIBRATED against Tungsten on our own emitted loops (benchmarks/silicon/plasticine_calibration.json): on the 6-stage PCU, 1,000 iterations of s = s + i simulate in 7,003 cycles, 30 of s = s*3 + i in 213, 12 of a four-op chain in 87, and 1,000 iterations with no carried dependency in 1,009.

pub fn sky_fabric(bits: usize) -> UnitModel

Our own fabric’s units: the shared iterative divider family is SEQUENTIAL (occupancy = latency = bits cycles, one quotient bit per cycle); everything else is a one-cycle tile.

pub fn latency(&self, cell: &LoopCell) -> usize

pub fn occupancy(&self, cell: &LoopCell) -> usize

Trait Implementations

impl Clone for UnitModel

fn clone(&self) -> UnitModel

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for UnitModel

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

Formats the value using the given formatter.

impl PartialEq for UnitModel

fn eq(&self, other: &UnitModel) -> 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 StructuralPartialEq for UnitModel