tpt-gpu-compiler 0.1.0

Rust port of TPTIR compiler stack
Documentation
//! Operator fusion pass.
//!
//! Implements the `FusionPass` that merges adjacent operations:
//! - Elementwise chains: add → mul → add → single fused op
//! - matmul + softmax + matmul → Flash Attention pattern
//! - conv + bn + relu → fused convolution pattern

use crate::ir::{Block, OpKind, Region};

/// Represents a fused operation pattern.
#[derive(Debug, Clone)]
pub enum FusedPattern {
    /// Elementwise chain: multiple ops fused into one.
    ElementwiseChain { ops: Vec<String> },
    /// Flash Attention: matmul → softmax → matmul.
    FlashAttention,
    /// Conv + BN + ReLU fusion.
    ConvBnRelu,
    /// Dequantize → Gemm → single QuantGemm (avoids materializing f32 weights).
    QuantGemmFuse,
}

/// Result of pattern matching.
#[derive(Debug, Clone)]
pub struct FusionResult {
    pub pattern: FusedPattern,
    pub start_op: usize,
    pub end_op: usize,
}

/// Detect fusible patterns in a block of operations.
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() {
        // Check for Flash Attention pattern: matmul → softmax → matmul
        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)
        {
            // This is a simplified check; in practice we'd verify the
            // actual semantics of the operations
            results.push(FusionResult {
                pattern: FusedPattern::FlashAttention,
                start_op: i,
                end_op: i + 2,
            });
            i += 3;
            continue;
        }

        // Check for elementwise chain: add/sub/mul/div sequence
        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;
            }
        }

        // Check for Conv + BN + ReLU pattern
        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;
        }

        // Check for QuantGemmFuse pattern: Dequantize → Gemm
        // Fuses into a single QuantGemm, avoiding f32 weight materialization.
        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
}

/// Apply fusion to a region.
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
}

/// The FusionPass struct for use in pass pipelines.
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 &region.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());
    }
}