Backend Lowering Plans

Graph-aware lowering data for backend execution.

GraphExecutionPlan chooses a capsule for each runtime-relevant IR node. A GraphLoweringPlan groups those choices into backend calls. The conservative lowering in this file coalesces adjacent nodes only when they use the same operation and the exact same capsule contract. More aggressive fusion can be added later as new capsules with their own contracts.

inductive NN.Backend.GroupingKind : Type

Why adjacent planned nodes share one audit/scheduling group. This does not assert kernel fusion.

• singleton : GroupingKind
• sameCapsuleRun : GroupingKind

def NN.Backend.instReprGroupingKind.repr : GroupingKind → ℕ → Std.Format

@[implicit_reducible]

instance NN.Backend.instReprGroupingKind : Repr GroupingKind

structure NN.Backend.LoweredKernelGroup : Type

One lowered backend call, with source IR nodes kept for audit and debugging.

• nodeIds : List ℕ
• kinds : List IR.OpKind
• op : BackendOp
• capsule : KernelCapsule
• groupingKind : GroupingKind

def NN.Backend.instReprLoweredKernelGroup.repr : LoweredKernelGroup → ℕ → Std.Format

@[implicit_reducible]

instance NN.Backend.instReprLoweredKernelGroup : Repr LoweredKernelGroup

structure NN.Backend.GraphLoweringPlan : Type

Graph lowering plan: backend groups in execution order.

• groups : List LoweredKernelGroup

@[implicit_reducible]

instance NN.Backend.instReprGraphLoweringPlan : Repr GraphLoweringPlan

def NN.Backend.instReprGraphLoweringPlan.repr : GraphLoweringPlan → ℕ → Std.Format

def NN.Backend.LoweredKernelGroup.toPlannedKernel (g : LoweredKernelGroup) : PlannedKernel

Erase lowering metadata to the older single-kernel execution-plan row.

def NN.Backend.LoweredKernelGroup.hasTrustedExternal (g : LoweredKernelGroup) : Bool

Whether this lowered group crosses a trusted-external boundary.

def NN.Backend.LoweredKernelGroup.canAppend (g : LoweredKernelGroup) (k : IR.PlannedNodeKernel) : Bool

Whether a planned node can be appended to this lowered backend group.

def NN.Backend.LoweredKernelGroup.appendNode (g : LoweredKernelGroup) (k : IR.PlannedNodeKernel) : LoweredKernelGroup

Append a node to an existing backend group, preserving source-node provenance.

def NN.Backend.GraphLoweringPlan.nodeIds (p : GraphLoweringPlan) : List ℕ

Source IR node ids covered by the lowering plan, in execution order.

def NN.Backend.GraphLoweringPlan.capsuleNames (p : GraphLoweringPlan) : List String

Selected capsule names, in lowering order.

def NN.Backend.GraphLoweringPlan.toExecutionPlan (p : GraphLoweringPlan) : ExecutionPlan

Erase lowering metadata to the audit/execution-plan view.

def NN.Backend.GraphLoweringPlan.audit (p : GraphLoweringPlan) : ExecutionAudit

Audit the selected backend boundaries of the lowering plan.

def NN.Backend.GraphLoweringPlan.hasTrustedExternal (p : GraphLoweringPlan) : Bool

Whether any lowered group crosses a trusted-external boundary.

def NN.Backend.IR.PlannedNodeKernel.toSingletonLoweredGroup (k : PlannedNodeKernel) : LoweredKernelGroup

Lower one graph-planned node to a singleton backend group.

def NN.Backend.IR.GraphExecutionPlan.toSingletonLoweringPlan (p : GraphExecutionPlan) : GraphLoweringPlan

Default lowering: one backend group per runtime-relevant IR node.

structure NN.Backend.IR.GraphExecutionPlan.LoweringState : Type

Fold state for conservative same-boundary lowering.

• groupsRev : List LoweredKernelGroup

@[implicit_reducible]

instance NN.Backend.IR.GraphExecutionPlan.instReprLoweringState : Repr LoweringState

def NN.Backend.IR.GraphExecutionPlan.instReprLoweringState.repr : LoweringState → ℕ → Std.Format

def NN.Backend.IR.GraphExecutionPlan.LoweringState.pushKernel (s : LoweringState) (k : PlannedNodeKernel) : LoweringState

Add one planned node to the lowering state, coalescing with the previous group when safe.

def NN.Backend.IR.GraphExecutionPlan.toCoalescedLoweringPlan (p : GraphExecutionPlan) : GraphLoweringPlan

Conservative grouping: adjacent nodes with the same backend boundary share one audit/scheduling group.

This does not claim that one kernel invocation implements the group. A future fused capsule must declare its multi-node pattern and execution contract explicitly.