Struct WorkloadRow 

pub struct WorkloadRow {

    pub name: String,
    pub kind: String,
    pub target: String,
    pub provenance: String,
    pub par: usize,
    pub par_capacity: usize,
    pub router: String,
    pub stages: Vec<StageRow>,
    pub pipeline_ii: usize,
    pub critical_stage: String,
    pub buffers: Vec<BufferRow>,
    pub pcu_used: usize,
    pub pcu_total: usize,
    pub pcu_utilization_pct: f64,
    pub pmu_used: usize,
    pub pmu_total: usize,
    pub pmu_utilization_pct: f64,
    pub fu_utilization_pct: f64,
    pub ag_stages: usize,
    pub total_hops: usize,
    pub max_hops: usize,
    pub max_link_occupancy: usize,
    pub vector_links: usize,
    pub routed_statically: bool,
    pub iterations: usize,
    pub fill_cycles: usize,
    pub compute_cycles: usize,
    pub operand_stall_cycles: usize,
    pub dram_bytes: usize,
    pub dram_cycles: usize,
    pub modeled_cycles: usize,
    pub bound: String,
    pub throughput_iters_per_cycle: f64,
    pub gflops: Option<f64>,
    pub pct_of_peak_fp32: Option<f64>,
    pub operands: Option<Vec<OperandRow>>,
    pub channels: Vec<ChannelRow>,
    pub control: Option<ControlRow>,
    pub certificate: Option<CertificateRow>,
    pub certificate_omitted: Option<String>,
    pub vm_anchor: Option<VmAnchor>,
    pub gemm: Option<GemmRow>,
}

One (workload, target) row of the report.

Fields

name: String

kind: String

counted_loop or gemm.

target: String

provenance: String

par: usize

Unrolled instances placed (a counted loop’s recurrence forbids unrolling: 1).

par_capacity: usize

The widest unroll the mesh’s PCU/PMU capacity allows — par is at most this; when it is less, the static vector network, not capacity, bounded the unroll.

router: String

The private place-and-route engine’s rung that produced the routes (pnr-negotiated, pnr-exact), or why none did.

stages: Vec<StageRow>

pipeline_ii: usize

critical_stage: String

buffers: Vec<BufferRow>

pcu_used: usize

pcu_total: usize

pcu_utilization_pct: f64

pmu_used: usize

pmu_total: usize

pmu_utilization_pct: f64

fu_utilization_pct: f64

ag_stages: usize

Address-generator stages across every unrolled instance.

total_hops: usize

max_hops: usize

max_link_occupancy: usize

vector_links: usize

routed_statically: bool

iterations: usize

Iterations one unrolled instance runs.

fill_cycles: usize

compute_cycles: usize

operand_stall_cycles: usize

Cycles the MAC waits for operands on top of compute_cycles: a K-chunked reduction’s first chunk loads before any compute starts, and a chunk whose load outlasts its compute stalls for the difference.

dram_bytes: usize

dram_cycles: usize

modeled_cycles: usize

bound: String

compute or dram.

throughput_iters_per_cycle: f64

gflops: Option<f64>

pct_of_peak_fp32: Option<f64>

operands: Option<Vec<OperandRow>>

Per operand: how the compiler decided to feed the unrolled instances, and what it cost.

channels: Vec<ChannelRow>

The synthesized control plane: one entry per inter-stage channel.

control: Option<ControlRow>

The control nets those channels need, and whether they route.

certificate: Option<CertificateRow>

certificate_omitted: Option<String>

vm_anchor: Option<VmAnchor>

gemm: Option<GemmRow>

Trait Implementations

impl Clone for WorkloadRow

fn clone(&self) -> WorkloadRow

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for WorkloadRow

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for WorkloadRow

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for WorkloadRow

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for WorkloadRow