Struct PlanQuantities 

pub struct PlanQuantities {

    pub problem: (usize, usize, usize),
    pub sites_used: usize,
    pub kernel_classes: usize,
    pub n_sems: usize,
    pub tile_macs: u64,
    pub acquires: u64,
    pub reload_tiles: u64,
    pub dram_tiles_site: u64,
    pub dram_tiles_engine: (u64, u64),
    pub pack_tiles: u64,
    pub fill_macs: u64,
    pub drains: u64,
    pub pack_overlaps: bool,
    pub dram_tiles_all: u64,
    pub cb_handoffs: u64,
    pub mcast_blocks: u64,
    pub mcast_tiles: u64,
    pub fill_tiles_engine: (u64, u64),
    pub fill_tiles: u64,
    pub drain_tiles: u64,
    pub fp32_acc: bool,
    pub fidelity: Fidelity,
    pub iterations: u64,
}

The structural quantities of one candidate plan (per the busiest site, plus whole-program totals).

Fields

problem: (usize, usize, usize)

The problem in tiles (mt, nt, kt); points that share a problem, fp32_acc and fidelity are measured alternatives of one another and must be ranked as the simulator ranked them.

sites_used: usize

kernel_classes: usize

n_sems: usize

tile_macs: u64

acquires: u64

reload_tiles: u64

dram_tiles_site: u64

dram_tiles_engine: (u64, u64)

The site’s DRAM traffic split across its movement engines, which run CONCURRENTLY: the engine with the most work sets the pace, so the packing that balances them wins. One entry per engine.

pack_tiles: u64

Tiles the packer writes (every spill and the final output).

fill_macs: u64

Tile-MACs of ONE sub-block: the math the compute pipeline must finish before the packer has anything to overlap with, so a bigger sub-block costs more fill however few of them there are.

drains: u64

Page round-trips the packer’s in-place accumulate needs to return its write pointer.

pack_overlaps: bool

The packer and the math unit overlap. They can only do so when a sub-block fits in HALF the register file, because the engine works one half while the packer drains the other; a sub-block that fills the whole file forces the two to take turns.

dram_tiles_all: u64

cb_handoffs: u64

mcast_blocks: u64

mcast_tiles: u64

fill_tiles_engine: (u64, u64)

Prologue tiles per movement engine: the first block’s operands, which the engines read CONCURRENTLY. Summing them would charge a split arrangement for a serial read it never performs.

fill_tiles: u64

drain_tiles: u64

fp32_acc: bool

fidelity: Fidelity

iterations: u64

Steady-state iterations the site runs: one per K block per work item. The pipeline’s cost is its initiation interval times this, so a term that does not scale with it is setup, not throughput.

Trait Implementations

impl Clone for PlanQuantities

fn clone(&self) -> PlanQuantities

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PlanQuantities

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for PlanQuantities

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for PlanQuantities

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

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 PlanQuantities

impl StructuralPartialEq for PlanQuantities