Struct LoopFabric 

pub struct LoopFabric {

    pub n_in: usize,
    pub n_state: usize,
    pub init: Vec<Src>,
    pub lo: Src,
    pub hi: Src,
    pub invariants: Vec<Src>,
    pub body: Vec<LoopCell>,
    pub next: Vec<Src>,
    pub result_state: usize,
    pub seq_input: Option<usize>,
    pub epilogue: Vec<LoopCell>,
    pub epilogue_result: Src,
    pub prologue_heap: Vec<LoopCell>,
    pub seq_heap_ptr: Option<Src>,
}

A counted-loop residual lowered to a CGRA: a fixed BODY datapath (SSA over the current loop-carried state + the induction variable + loop invariants, INCLUDING predicated select tiles for data-dependent branches) driven by a sequential controller that clocks the state through the body once per induction value in the inclusive range lo..=hi.

Fields

n_in: usize

Circuit input arity (the function’s parameters become circuit inputs in0..).

n_state: usize

Number of loop-carried state registers (the accumulators).

init: Vec<Src>

Initial value of each state register, as a Src over the circuit inputs / constants.

lo: Src

Inclusive induction range: the induction variable takes lo, lo+1, …, hi. Over inputs.

hi: Src

invariants: Vec<Src>

Loop-invariant values read by the body (fixed across iterations), as Src over inputs.

body: Vec<LoopCell>

The body as SSA LoopCells. Body-input convention for Src::In(k): 0..n_state = the current state registers, n_state = the induction variable, n_state+1+j = invariant j.

next: Vec<Src>

For each state register, the Src (over body inputs / body vals) giving its NEXT value after one execution of the body.

result_state: usize

Which state register holds the loop’s result (returned after the loop).

seq_input: Option<usize>

Some(k) marks a SEQUENCE loop (Repeat for x in xs) rather than a numeric range loop: input k is the iterated Seq (a memory array), the induction range is 0..=len-1 derived from the sequence’s length at eval time, and the body reads xs[iv] through a LoopCell::MemRead tile. None is a plain counted range loop (lo/hi are the numeric bounds). This is “collections as a spatial resource”: the induction variable IS the address generator streaming the array.

epilogue: Vec<LoopCell>

The POST-LOOP transform (an epilogue island): straight-line LoopCells over the loop’s FINAL state (Src::In(i) = final value of state register i), computing the returned value when the function does more than return an accumulator (e.g. Return (sum 1..n) * 2). Empty when the loop result IS a carried register — then Self::result_state names it. This is the first CFG COMPOSITION: a loop island feeding a transform island, sequenced into one whole-function fabric.

epilogue_result: Src

When epilogue is non-empty, the Src (over the final state / epilogue vals) giving the result.

prologue_heap: Vec<LoopCell>

The PROLOGUE HEAP ISLAND: straight-line LoopCells that build any LOCAL collection the loop iterates (Let ps be [(1,2),(3,4)] → HeapAlloc/HeapWrite). Evaluated ONCE before the loop into a shared heap; the loop body then reads/writes that same heap. Empty for a numeric / parameter-sequence loop.

seq_heap_ptr: Option<Src>

Some(ptr) marks a FOREACH OVER A LOCAL HEAP LIST (Repeat for (a,b) in ps, ps a local): ptr (a Src over the prologue-heap island) is the iterated list’s pointer, its length is heap[ptr], and element iv is heap[ptr + 1 + iv] — the body destructures it via HeapRead with the heap threaded. Distinct from Self::seq_input (a scalar parameter array). ptr is passed to the body as the FINAL invariant so the element-address generator can read it.

Trait Implementations

impl Clone for LoopFabric

fn clone(&self) -> LoopFabric

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for LoopFabric

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

Formats the value using the given formatter.