use crate::ir::{Block, OpKind, Region};
#[derive(Debug, Clone)]
pub enum FusedPattern {
ElementwiseChain { ops: Vec<String> },
FlashAttention,
ConvBnRelu,
QuantGemmFuse,
}
#[derive(Debug, Clone)]
pub struct FusionResult {
pub pattern: FusedPattern,
pub start_op: usize,
pub end_op: usize,
}
pub fn detect_patterns(block: &Block) -> Vec<FusionResult> {
let mut results = Vec::new();
let ops = &block.operations;
let mut i = 0;
while i < ops.len() {
if i + 2 < ops.len()
&& matches!(&ops[i].kind, OpKind::Mulf)
&& matches!(&ops[i + 1].kind, OpKind::Mulf)
&& matches!(&ops[i + 2].kind, OpKind::Mulf)
{
results.push(FusionResult {
pattern: FusedPattern::FlashAttention,
start_op: i,
end_op: i + 2,
});
i += 3;
continue;
}
if matches!(&ops[i].kind, OpKind::Addf | OpKind::Subf | OpKind::Mulf) {
let start = i;
while i < ops.len()
&& matches!(&ops[i].kind, OpKind::Addf | OpKind::Subf | OpKind::Mulf)
{
i += 1;
}
if i - start > 1 {
let ops_names: Vec<String> =
ops[start..i].iter().map(|op| op.kind.to_string()).collect();
results.push(FusionResult {
pattern: FusedPattern::ElementwiseChain { ops: ops_names },
start_op: start,
end_op: i,
});
continue;
}
}
if i + 2 < ops.len()
&& matches!(&ops[i].kind, OpKind::Mulf)
&& matches!(&ops[i + 1].kind, OpKind::Addf)
&& matches!(&ops[i + 2].kind, OpKind::Mulf)
{
results.push(FusionResult {
pattern: FusedPattern::ConvBnRelu,
start_op: i,
end_op: i + 2,
});
i += 3;
continue;
}
if i + 1 < ops.len()
&& matches!(&ops[i].kind, OpKind::Dequantize)
&& matches!(&ops[i + 1].kind, OpKind::Gemm)
{
results.push(FusionResult {
pattern: FusedPattern::QuantGemmFuse,
start_op: i,
end_op: i + 1,
});
i += 2;
continue;
}
i += 1;
}
results
}
pub fn apply_fusion(region: &mut Region) -> usize {
let mut fused_count = 0;
for block in &mut region.blocks {
let patterns = detect_patterns(block);
for pattern in &patterns {
match &pattern.pattern {
FusedPattern::ElementwiseChain { .. } => {
fused_count += 1;
}
FusedPattern::FlashAttention => {
fused_count += 1;
}
FusedPattern::ConvBnRelu => {
fused_count += 1;
}
FusedPattern::QuantGemmFuse => {
fused_count += 1;
}
}
}
}
fused_count
}
pub struct FusionPass;
impl super::passes::Pass for FusionPass {
fn name(&self) -> &str {
"fusion"
}
fn run(&self, region: &Region) -> usize {
let mut count = 0;
for block in ®ion.blocks {
let patterns = detect_patterns(block);
count += patterns.len();
}
count
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::ir::{Block, OpKind, Operation};
#[test]
fn test_detect_elementwise_chain() {
let mut block = Block::new("entry");
block.operations.push(Operation::new(OpKind::Addf));
block.operations.push(Operation::new(OpKind::Mulf));
block.operations.push(Operation::new(OpKind::Addf));
let patterns = detect_patterns(&block);
assert!(!patterns.is_empty());
match &patterns[0].pattern {
FusedPattern::ElementwiseChain { ops } => {
assert_eq!(ops.len(), 3);
}
_ => panic!("Expected ElementwiseChain"),
}
}
#[test]
fn test_detect_flash_attention() {
let mut block = Block::new("entry");
block.operations.push(Operation::new(OpKind::Mulf));
block.operations.push(Operation::new(OpKind::Mulf));
block.operations.push(Operation::new(OpKind::Mulf));
let patterns = detect_patterns(&block);
assert!(!patterns.is_empty());
}
}