use alloc::vec::Vec;
use crate::compiled::capture::CapturedGraph;
use crate::err::Result;
use crate::shapes::error::OperationKind;
fn builtin_operation(identity: &crate::exec::OperationIdentity) -> Option<OperationKind> {
match identity {
crate::exec::OperationIdentity::Builtin(operation) => Some(*operation),
crate::exec::OperationIdentity::Custom(_) => None,
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum FusionBlocker {
GraphOutput,
IncompatibleOps,
MultipleProducers,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct FusionCandidate {
pub producer_idx: usize,
pub consumer_idx: usize,
pub producer_op: OperationKind,
pub consumer_op: OperationKind,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct FusedKernel {
pub source_node_indices: Vec<usize>,
pub primary_op: OperationKind,
}
#[derive(Debug, Default, Clone, Copy, PartialEq, Eq)]
pub struct FusionPass;
impl FusionPass {
#[must_use]
fn can_fuse(producer: OperationKind, consumer: OperationKind) -> bool {
use OperationKind::*;
let is_pointwise = |op| {
matches!(
op,
Add | Sub
| Mul
| Div
| Relu
| Gelu
| Sigmoid
| Tanh
| Swish
| Neg
| Abs
| Exp
| Sqrt
| Log
)
};
is_pointwise(producer) && is_pointwise(consumer)
}
pub fn find_candidates(&self, graph: &CapturedGraph) -> Vec<FusionCandidate> {
let mut candidates = Vec::new();
for (i, node) in graph.nodes.iter().enumerate() {
if i + 1 >= graph.nodes.len() {
break;
}
let next = &graph.nodes[i + 1];
let producer_outputs = &node.outputs;
let consumer_inputs = &next.inputs;
let is_chained = producer_outputs
.iter()
.any(|out_id| consumer_inputs.contains(out_id));
let output_is_graph_output = producer_outputs
.iter()
.any(|out_id| graph.outputs.contains(out_id));
let Some(producer) = builtin_operation(&node.operation) else {
continue;
};
let Some(consumer) = builtin_operation(&next.operation) else {
continue;
};
if is_chained && !output_is_graph_output && Self::can_fuse(producer, consumer) {
candidates.push(FusionCandidate {
producer_idx: i,
consumer_idx: i + 1,
producer_op: producer,
consumer_op: consumer,
});
}
}
candidates
}
pub fn apply(
&self,
graph: &CapturedGraph,
candidates: &[FusionCandidate],
) -> Result<(CapturedGraph, Vec<FusedKernel>)> {
if candidates.is_empty() {
return Ok((graph.clone(), Vec::new()));
}
let _ = (graph, candidates);
Err(crate::err::Error::Msg(
"compiled fusion has no executable fused descriptor lowering".into(),
))
}
}