Enum Protocol 

pub enum Protocol {
    Registered {
        latency: u32,
    },
    StartDone {
        start: String,
        done: String,
    },
    Pipelined {
        start: String,
        done: String,
        ii: u32,
    },
    GoDone {
        go: String,
        done: String,
    },
    EnableDone {
        enable: String,
        done: String,
        clear: String,
    },
    LoadGoRead {
        load: String,
        din: String,
        go: String,
        done: String,
        raddr: String,
        dout: String,
        reset_each_op: bool,
        load_slots: Vec<RegSlot>,
        read_slots: Vec<RegSlot>,
    },
    Beats {
        period: u32,
        drives: Vec<Drive>,
        captures: Vec<u32>,
    },
    Launch {
        start: String,
        busy: String,
        dcr: DcrBus,
        setup: Vec<DcrWrite>,
        flush: Option<u32>,
        bus: LineBus,
    },
}

How the harness hands operands to a candidate and collects its results.

Variants

Registered

A new operation every cycle; its result is valid latency cycles later (0: combinational).

Fields

latency: u32

StartDone

Pulse start with the operands; hold them until done, which marks the result valid. One idle cycle separates operations.

Fields

start: String

done: String

Pipelined

Pulse start every ii cycles with a new operation; each done marks the next result.

Fields

start: String

done: String

ii: u32

GoDone

Hold go high; each one-cycle done marks a result. A component restarts in the very cycle it raises done, so from that cycle on the next operation’s operands are presented (a read issued then answers with them).

Fields

go: String

done: String

EnableDone

Hold enable high with the operands until done, which stays up once raised; then lower enable and raise clear for one cycle, which takes done down, before the next operation — how Spatial’s Fringe drives an accelerator (its command and status registers, the accelerator’s own reset between runs).

Fields

enable: String

done: String

clear: String

LoadGoRead

A register-file engine: one load cycle per load slot puts the slot on din, a go pulse starts it, done marks the results, and one cycle per read slot puts the slot’s index on raddr and takes it from dout. With reset_each_op the DUT’s reset is pulsed before each operation’s loads (an engine whose load counter counts from reset).

Fields

load: String

din: String

go: String

done: String

raddr: String

dout: String

reset_each_op: bool

load_slots: Vec<RegSlot>

read_slots: Vec<RegSlot>

Beats

A fixed beat schedule: every period cycles a call begins; beat t of a call drives the drives of beat t, and the result of the call’s operation j is on the output binds of slot j exactly captures[j] cycles after its beat 0. A call takes the candidate’s whole batch.

Fields

period: u32

drives: Vec<Drive>

captures: Vec<u32>

Launch

A device launched like a GPU kernel: after reset the setup writes go out on its DCR port, one a cycle; then each call raises start for a cycle, waits for busy to rise and to fall, issues the flush DCR read (if any) and waits for its answer, and takes the call’s results from the output regions of bus, which the device reads its operands from and writes its results to.

Fields

start: String

busy: String

dcr: DcrBus

setup: Vec<DcrWrite>

flush: Option<u32>

bus: LineBus

Implementations

impl Protocol

pub fn label(&self) -> String

Trait Implementations

impl Clone for Protocol

fn clone(&self) -> Protocol

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Protocol

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Protocol

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Protocol

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

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 Protocol