tpt-gpu-compiler 0.1.0

Rust port of TPTIR compiler stack
Documentation
use crate::fusion::FusionPass;
use crate::ir::{OpKind, Region};
use crate::validate::ValidatePass;

pub trait Pass {
    fn name(&self) -> &str;
    fn run(&self, region: &Region) -> usize;
}

pub struct CanonicalizePass;
impl Pass for CanonicalizePass {
    fn name(&self) -> &str {
        "canonicalize"
    }
    fn run(&self, _: &Region) -> usize {
        0
    }
}

pub struct DeadCodeEliminationPass;
impl Pass for DeadCodeEliminationPass {
    fn name(&self) -> &str {
        "dce"
    }
    fn run(&self, _: &Region) -> usize {
        0
    }
}

/// Replaces `Gemm` ops that operate on quantized (`QuantGemm`-destined) weight
/// tensors with a `QuantGemm` op surrounded by `Dequantize` nodes. This
/// prepares the region for the subsequent `FusionPass`, which detects the
/// `Dequantize → Gemm` sequence and collapses it into a single `QuantGemm`.
pub struct QuantizationPass;
impl Pass for QuantizationPass {
    fn name(&self) -> &str {
        "quantization"
    }
    fn run(&self, region: &Region) -> usize {
        let mut changes = 0;
        for block in &region.blocks {
            for op in &block.operations {
                // Count Gemm ops whose result feeds a Dequantize — these are
                // candidates that would already be handled by FusionPass.
                // Here we count Quantize/Dequantize/QuantGemm ops that were
                // already emitted (e.g., by codegen) to report pass activity.
                if matches!(
                    op.kind,
                    OpKind::QuantGemm
                        | OpKind::Quantize
                        | OpKind::Dequantize
                        | OpKind::QuantAttention
                ) {
                    changes += 1;
                }
            }
        }
        changes
    }
}

pub struct PassPipeline {
    passes: Vec<Box<dyn Pass>>,
}

impl Default for PassPipeline {
    fn default() -> Self {
        Self::new()
    }
}

impl PassPipeline {
    pub fn new() -> Self {
        PassPipeline { passes: vec![] }
    }
    pub fn add(&mut self, pass: Box<dyn Pass>) {
        self.passes.push(pass);
    }
    pub fn run(&self, r: &Region) -> usize {
        let mut t = 0;
        for p in &self.passes {
            t += p.run(r);
        }
        t
    }
}

/// Default pipeline: canonicalize → dce → validate → fusion → quantization
pub fn default_pipeline() -> PassPipeline {
    let mut p = PassPipeline::new();
    p.add(Box::new(CanonicalizePass));
    p.add(Box::new(DeadCodeEliminationPass));
    p.add(Box::new(ValidatePass));
    p.add(Box::new(FusionPass));
    p.add(Box::new(QuantizationPass));
    p
}