Struct Rewriter 

pub struct Rewriter<'a> {
    pub s: Slots,
    pub g: &'a TensorGraph,
    pub shim: &'a dyn Shim,
    pub fired: Vec<Fired>,
    pub rule: &'static str,
    pub building: ClassId,
    pub report: Vec<Decision>,
}

The graph being rewritten: its slots, the lifted graph’s tensors, the chip’s shim, what has fired, the rule running and every decision made.

Fields

s: Slots

g: &'a TensorGraph

shim: &'a dyn Shim

fired: Vec<Fired>

rule: &'static str

building: ClassId

The class the running rule builds, for a candidate that is a placement on a lifted op.

report: Vec<Decision>

Implementations

impl Rewriter<'_>

pub fn allows(&mut self, op: &Op) -> bool

Whether the chip runs op whole: the shim reads the op against the graph’s tensors. A candidate it does not run is reported refused, with the chip’s reason.

pub fn carried(&self, t: &str) -> bool

The tensors the graph’s host reads across steps: they stay whole wherever they are computed.

pub fn observed(&self, t: &str) -> bool

pub fn record(&mut self, rule: &'static str, class: ClassId, at: usize)

impl Rewriter<'_>

pub fn fuse( &mut self, rule: &'static str, class: ClassId, at: usize, gone: &[usize], ins: Vec<(String, Access)>, out: String, dst: Dst, )

Fold the ops of gone into the op at at as one op of class defined by those ops as they stand — a member a rule built keeps its own class and parts — in the order their slots run, its operands ins (with their accesses), landing where dst says, keeping every result computed inside that anything else reads; one firing of rule.

pub fn absorb( &mut self, rule: &'static str, class: ClassId, at: usize, gone: &[usize], )

Fold the slots of gone into the op at at, its symbol and operands unchanged: a placement, whose meaning the op’s new access or destination carries.

pub fn admits(&mut self, op: &Op) -> bool

Whether the candidate op would run whole on the chip.