wafer-core 0.1.25__py3-none-any.whl → 0.1.27__py3-none-any.whl

wafer_core/lib/trace_compare/fusion_analyzer.py

@@ -0,0 +1,356 @@
+"""Fusion analysis using aligned kernel pairs.
+
+Detects kernel fusion patterns at the kernel-pair level within aligned layers.
+
+Key insight: When one platform has an operation type like "RMSNorm+GEMM" (containing '+'),
+that platform IS fusing. The OTHER platform runs the components separately.
+"""
+
+from collections import Counter, defaultdict
+from dataclasses import dataclass, field
+from typing import Any
+
+from .aligner import KernelPair, LayerAlignment
+
+
+# Maps fused operation names to their component operations
+FUSED_OPERATION_COMPONENTS: dict[str, list[str]] = {
+    "RMSNorm+GEMM": ["RMSNorm", "Dense GEMM"],
+    "SwiGLU+GEMM": ["SwiGLU", "Dense GEMM"],
+    "MoE GEMM+SwiGLU": ["MoE GEMM", "SwiGLU"],
+    "Embedding+RMSNorm+GEMM": ["Elementwise", "RMSNorm", "Dense GEMM"],  # Embedding is often Elementwise
+}
+
+
+@dataclass
+class FusionPattern:
+    """A detected fusion pattern."""
+
+    layer: int
+    operation: str  # The fused operation name (e.g., "RMSNorm+GEMM")
+    fused_platform: str  # Platform that fuses (has fewer kernels)
+    fused_kernel: str  # The actual fused kernel name
+    unfused_kernels: list[str]  # List of separate kernels on the other platform
+    count: int
+    evidence: str
+
+
+@dataclass
+class FusionAnalysis:
+    """Complete fusion analysis result."""
+
+    patterns: list[FusionPattern] = field(default_factory=list)
+    summary: dict[str, Any] = field(default_factory=dict)
+
+
+def _is_fused_operation(operation: str) -> bool:
+    """Check if an operation type represents a fused operation.
+    
+    Operations like 'RMSNorm+GEMM', 'MoE GEMM+SwiGLU' indicate fusion.
+    Also handles 'Fused (Unknown)' from heuristic detection.
+    """
+    return "+" in operation or operation == "Fused (Unknown)"
+
+
+def _get_component_operations(fused_op: str) -> list[str]:
+    """Get the component operations for a fused operation type."""
+    if fused_op in FUSED_OPERATION_COMPONENTS:
+        return FUSED_OPERATION_COMPONENTS[fused_op]
+    
+    # Parse from the operation name itself (e.g., "RMSNorm+GEMM" -> ["RMSNorm", "GEMM"])
+    if "+" in fused_op:
+        parts = [p.strip() for p in fused_op.split("+")]
+        # Map shorthand to full names
+        mapping = {
+            "GEMM": "Dense GEMM",
+            "SwiGLU": "Triton Fused",
+        }
+        return [mapping.get(p, p) for p in parts]
+    
+    return []
+
+
+def _find_component_kernels(
+    layer_alignment: LayerAlignment,
+    component_ops: list[str],
+    platform: str,
+) -> list[str]:
+    """Find kernels for component operations on the specified platform.
+    
+    Args:
+        layer_alignment: Layer alignment data
+        component_ops: List of operation types to look for (e.g., ["RMSNorm", "Dense GEMM"])
+        platform: "AMD" or "NVIDIA"
+    
+    Returns:
+        List of kernel names found for these operations
+    """
+    found_kernels: list[str] = []
+    
+    for pair in layer_alignment.kernel_pairs:
+        if pair.operation in component_ops:
+            if platform == "AMD" and pair.amd_kernel and pair.amd_count > 0:
+                found_kernels.append(pair.amd_kernel)
+            elif platform == "NVIDIA" and pair.nvidia_kernel and pair.nvidia_count > 0:
+                found_kernels.append(pair.nvidia_kernel)
+    
+    return found_kernels
+
+
+def detect_fusion_in_aligned_layers(
+    layer_alignments: list[LayerAlignment],
+) -> FusionAnalysis:
+    """Detect fusion patterns from aligned layer data.
+
+    Args:
+        layer_alignments: List of aligned layers
+
+    Returns:
+        FusionAnalysis with detected patterns
+    """
+    fusion_patterns: list[FusionPattern] = []
+    
+    # Track patterns we've already seen to avoid duplicates
+    seen_patterns: set[tuple[int, str, str]] = set()  # (layer, operation, fused_platform)
+
+    for layer_alignment in layer_alignments:
+        for pair in layer_alignment.kernel_pairs:
+            is_fused_op = _is_fused_operation(pair.operation)
+            
+            # Case 1: AMD has a kernel for this operation, NVIDIA doesn't
+            if pair.amd_kernel and pair.amd_count > 0 and (pair.nvidia_kernel is None or pair.nvidia_count == 0):
+                if is_fused_op:
+                    # AMD HAS the fused kernel → AMD is fusing
+                    # Find what NVIDIA runs separately
+                    component_ops = _get_component_operations(pair.operation)
+                    unfused_kernels = _find_component_kernels(layer_alignment, component_ops, "NVIDIA")
+                    
+                    pattern_key = (layer_alignment.layer, pair.operation, "AMD")
+                    if pattern_key not in seen_patterns:
+                        seen_patterns.add(pattern_key)
+                        
+                        if unfused_kernels:
+                            evidence = f"AMD fuses {' + '.join(component_ops)} into {pair.amd_kernel}, NVIDIA runs {len(unfused_kernels)} separate kernels"
+                        else:
+                            evidence = f"AMD fuses into {pair.amd_kernel}, NVIDIA runs components separately"
+                        
+                        fusion_patterns.append(
+                            FusionPattern(
+                                layer=layer_alignment.layer,
+                                operation=pair.operation,
+                                fused_platform="AMD",
+                                fused_kernel=pair.amd_kernel,
+                                unfused_kernels=unfused_kernels if unfused_kernels else component_ops,
+                                count=pair.amd_count,
+                                evidence=evidence,
+                            )
+                        )
+                else:
+                    # Regular case: AMD has a kernel that NVIDIA fuses into something else
+                    # This means NVIDIA is fusing (it doesn't need this separate kernel)
+                    pattern_key = (layer_alignment.layer, pair.operation, "NVIDIA")
+                    if pattern_key not in seen_patterns:
+                        seen_patterns.add(pattern_key)
+                        
+                        evidence = f"AMD runs {pair.amd_kernel} separately ({pair.amd_count}x), NVIDIA fuses this operation"
+                        
+                        fusion_patterns.append(
+                            FusionPattern(
+                                layer=layer_alignment.layer,
+                                operation=pair.operation,
+                                fused_platform="NVIDIA",
+                                fused_kernel="(fused into nearby kernel)",
+                                unfused_kernels=[pair.amd_kernel],
+                                count=pair.amd_count,
+                                evidence=evidence,
+                            )
+                        )
+            
+            # Case 2: NVIDIA has a kernel for this operation, AMD doesn't
+            elif pair.nvidia_kernel and pair.nvidia_count > 0 and (pair.amd_kernel is None or pair.amd_count == 0):
+                if is_fused_op:
+                    # NVIDIA HAS the fused kernel → NVIDIA is fusing
+                    # Find what AMD runs separately
+                    component_ops = _get_component_operations(pair.operation)
+                    unfused_kernels = _find_component_kernels(layer_alignment, component_ops, "AMD")
+                    
+                    pattern_key = (layer_alignment.layer, pair.operation, "NVIDIA")
+                    if pattern_key not in seen_patterns:
+                        seen_patterns.add(pattern_key)
+                        
+                        if unfused_kernels:
+                            evidence = f"NVIDIA fuses {' + '.join(component_ops)} into {pair.nvidia_kernel}, AMD runs {len(unfused_kernels)} separate kernels"
+                        else:
+                            evidence = f"NVIDIA fuses into {pair.nvidia_kernel}, AMD runs components separately"
+                        
+                        fusion_patterns.append(
+                            FusionPattern(
+                                layer=layer_alignment.layer,
+                                operation=pair.operation,
+                                fused_platform="NVIDIA",
+                                fused_kernel=pair.nvidia_kernel,
+                                unfused_kernels=unfused_kernels if unfused_kernels else component_ops,
+                                count=pair.nvidia_count,
+                                evidence=evidence,
+                            )
+                        )
+                else:
+                    # Regular case: NVIDIA has a kernel that AMD fuses into something else
+                    pattern_key = (layer_alignment.layer, pair.operation, "AMD")
+                    if pattern_key not in seen_patterns:
+                        seen_patterns.add(pattern_key)
+                        
+                        evidence = f"NVIDIA runs {pair.nvidia_kernel} separately ({pair.nvidia_count}x), AMD fuses this operation"
+                        
+                        fusion_patterns.append(
+                            FusionPattern(
+                                layer=layer_alignment.layer,
+                                operation=pair.operation,
+                                fused_platform="AMD",
+                                fused_kernel="(fused into nearby kernel)",
+                                unfused_kernels=[pair.nvidia_kernel],
+                                count=pair.nvidia_count,
+                                evidence=evidence,
+                            )
+                        )
+            
+            # Case 3: Both have kernels but with very different counts (partial fusion)
+            elif (
+                pair.amd_kernel
+                and pair.nvidia_kernel
+                and pair.amd_count > 0
+                and pair.nvidia_count > 0
+            ):
+                count_ratio = pair.amd_count / pair.nvidia_count if pair.nvidia_count > 0 else float('inf')
+                
+                if count_ratio > 1.5:
+                    # AMD runs more → NVIDIA fuses some instances
+                    pattern_key = (layer_alignment.layer, pair.operation, "NVIDIA")
+                    if pattern_key not in seen_patterns:
+                        seen_patterns.add(pattern_key)
+                        
+                        evidence = (
+                            f"AMD runs {pair.amd_kernel} {count_ratio:.1f}x more "
+                            f"({pair.amd_count} vs {pair.nvidia_count}), NVIDIA partially fuses"
+                        )
+                        
+                        fusion_patterns.append(
+                            FusionPattern(
+                                layer=layer_alignment.layer,
+                                operation=pair.operation,
+                                fused_platform="NVIDIA",
+                                fused_kernel=pair.nvidia_kernel,
+                                unfused_kernels=[pair.amd_kernel],
+                                count=pair.amd_count - pair.nvidia_count,
+                                evidence=evidence,
+                            )
+                        )
+                
+                elif count_ratio < 0.67:
+                    # NVIDIA runs more → AMD fuses some instances
+                    inverse_ratio = pair.nvidia_count / pair.amd_count if pair.amd_count > 0 else float('inf')
+                    pattern_key = (layer_alignment.layer, pair.operation, "AMD")
+                    if pattern_key not in seen_patterns:
+                        seen_patterns.add(pattern_key)
+                        
+                        evidence = (
+                            f"NVIDIA runs {pair.nvidia_kernel} {inverse_ratio:.1f}x more "
+                            f"({pair.nvidia_count} vs {pair.amd_count}), AMD partially fuses"
+                        )
+                        
+                        fusion_patterns.append(
+                            FusionPattern(
+                                layer=layer_alignment.layer,
+                                operation=pair.operation,
+                                fused_platform="AMD",
+                                fused_kernel=pair.amd_kernel,
+                                unfused_kernels=[pair.nvidia_kernel],
+                                count=pair.nvidia_count - pair.amd_count,
+                                evidence=evidence,
+                            )
+                        )
+
+    # Aggregate patterns by operation type and fused platform
+    aggregated: dict[tuple[str, str], FusionPattern] = {}
+    for pattern in fusion_patterns:
+        key = (pattern.operation, pattern.fused_platform)
+        if key in aggregated:
+            existing = aggregated[key]
+            existing.count += pattern.count
+            # Merge unfused kernels (deduplicate)
+            for k in pattern.unfused_kernels:
+                if k not in existing.unfused_kernels:
+                    existing.unfused_kernels.append(k)
+        else:
+            aggregated[key] = FusionPattern(
+                layer=pattern.layer,
+                operation=pattern.operation,
+                fused_platform=pattern.fused_platform,
+                fused_kernel=pattern.fused_kernel,
+                unfused_kernels=list(pattern.unfused_kernels),
+                count=pattern.count,
+                evidence=pattern.evidence,
+            )
+
+    amd_fuses = sum(1 for p in aggregated.values() if p.fused_platform == "AMD")
+    nvidia_fuses = sum(1 for p in aggregated.values() if p.fused_platform == "NVIDIA")
+
+    return FusionAnalysis(
+        patterns=list(aggregated.values()),
+        summary={
+            "amd_fuses": amd_fuses,
+            "nvidia_fuses": nvidia_fuses,
+            "total_fusion_opportunities": len(aggregated),
+        },
+    )
+
+
+def analyze_fusion_from_alignment(
+    layer_alignments: list[LayerAlignment],
+) -> dict[str, Any]:
+    """Analyze fusion from alignment data (for API compatibility).
+
+    Args:
+        layer_alignments: List of aligned layers
+
+    Returns:
+        Dictionary with fusion analysis results (compatible with old API)
+    """
+    fusion_analysis = detect_fusion_in_aligned_layers(layer_alignments)
+
+    fusion_opportunities = []
+    fusion_mappings = []
+
+    for pattern in fusion_analysis.patterns:
+        unfused_platform = "NVIDIA" if pattern.fused_platform == "AMD" else "AMD"
+        
+        fusion_opportunities.append(
+            {
+                "kernel_type": pattern.operation,
+                "layer": pattern.layer,
+                "fused_by": pattern.fused_platform,
+                "fused_kernel": pattern.fused_kernel,
+                "unfused_kernels": pattern.unfused_kernels,
+                "count": pattern.count,
+                "evidence": pattern.evidence,
+            }
+        )
+
+        fusion_mappings.append(
+            {
+                "fused_platform": pattern.fused_platform,
+                "fused_kernel_type": pattern.operation,
+                "fused_kernel_name": pattern.fused_kernel,
+                "unfused_platform": unfused_platform,
+                "unfused_sequence": pattern.unfused_kernels,
+                "pattern_count": pattern.count,
+                "evidence": pattern.evidence,
+                "layer": pattern.layer,
+            }
+        )
+
+    return {
+        "fusion_opportunities": fusion_opportunities,
+        "fusion_mappings": fusion_mappings,
+        "summary": fusion_analysis.summary,
+    }

wafer_core/lib/trace_compare/kernel_registry.yaml

@@ -0,0 +1,349 @@
+# Kernel Pattern Registry
+# Version: 2025-01
+# Last updated: 2025-01-28
+# Update when: New GPU architecture, new library version, new model architecture
+
+version: "2025-01"
+
+# ============================================================================
+# SUPPORTED HARDWARE
+# ============================================================================
+# NVIDIA:
+#   - SM100 (Blackwell): B200, B100
+#   - SM90 (Hopper): H100, H200
+#   - SM89 (Ada Lovelace): L40, RTX 4090
+#   - SM80 (Ampere): A100, A10, A30
+#
+# AMD:
+#   - CDNA 4 (gfx950): MI355X
+#   - CDNA 3 (gfx942): MI300X, MI300A, MI325X
+#   - CDNA 2 (gfx90a): MI250X, MI210
+#
+# Note: MI325X uses same gfx942 ISA as MI300X but with 256GB HBM3e memory
+# ============================================================================
+
+attention:
+  nvidia:
+    # SM100 (Blackwell B200/B100) - 'a' suffix = prefill/context, 'f' suffix = decode/forgen
+    - pattern: "fmhaSm100a*"
+      hardware: "SM100 (Blackwell)"
+      library: "Flash Attention 3"
+      phase: prefill
+    - pattern: "fmhaSm100f*"
+      hardware: "SM100 (Blackwell)"
+      library: "Flash Attention 3"
+      phase: decode
+    # SM90 (Hopper H100/H200) - Flash Attention 2/3
+    - pattern: "fmhaSm90*"
+      hardware: "SM90 (Hopper)"
+      library: "Flash Attention 3"
+    - pattern: "flash::flash_fwd_kernel*"
+      hardware: "SM90 (Hopper)"
+      library: "Flash Attention 2"
+      phase: prefill
+    - pattern: "flash_fwd_*"
+      hardware: "SM90 (Hopper)"
+      library: "Flash Attention 2"
+    - pattern: "fmha_v2_*flash_attention_forward*"
+      hardware: "SM90 (Hopper)"
+      library: "Flash Attention 2"
+      phase: prefill
+    - pattern: "fmha_v2_*"
+      hardware: "SM90 (Hopper)"
+      library: "Flash Attention 2"
+    # SM89 (Ada Lovelace L40/RTX 4090)
+    - pattern: "fmhaSm89*"
+      hardware: "SM89 (Ada Lovelace)"
+      library: "Flash Attention"
+    # SM80 (Ampere A100/A10)
+    - pattern: "fmhaSm80*"
+      hardware: "SM80 (Ampere)"
+      library: "Flash Attention"
+    - pattern: "fmha_*"
+      hardware: "SM80 (Ampere)"
+      library: "Flash Attention"
+    # Generic phase patterns (fallback)
+    - pattern: "*Context*"
+      phase: prefill
+    - pattern: "*context*"
+      phase: prefill
+    - pattern: "*ForGen*"
+      phase: decode
+    - pattern: "*forgen*"
+      phase: decode
+  amd:
+    # CDNA 4 (MI355X - gfx950) - Composable Kernel v2
+    - pattern: "*ck_fmha_*"
+      hardware: "CDNA 4 (MI355X)"
+      library: "Composable Kernel"
+    - pattern: "*flash_attn_ck*"
+      hardware: "CDNA 4 (MI355X)"
+      library: "Composable Kernel"
+    # CDNA 3 (MI300X/MI325X - gfx942) - Composable Kernel unified attention
+    - pattern: "*unified_attention_2d*"
+      hardware: "CDNA 3 (MI300X/MI325X)"
+      phase: prefill
+      library: "Composable Kernel"
+    - pattern: "*unified_attention_3d*"
+      hardware: "CDNA 3 (MI300X/MI325X)"
+      phase: decode
+      library: "Composable Kernel"
+    - pattern: "kernel_unified_attention_2d*"
+      hardware: "CDNA 3 (MI300X/MI325X)"
+      phase: prefill
+      library: "Composable Kernel"
+    - pattern: "kernel_unified_attention_3d*"
+      hardware: "CDNA 3 (MI300X/MI325X)"
+      phase: decode
+      library: "Composable Kernel"
+    - pattern: "attention_2d*"
+      phase: prefill
+      library: "Composable Kernel"
+    - pattern: "attention_3d*"
+      phase: decode
+      library: "Composable Kernel"
+    # Triton Flash Attention (works on all AMD GPUs)
+    - pattern: "triton_*flash*"
+      library: "Triton Flash Attention"
+    - pattern: "triton_*attention*"
+      library: "Triton"
+
+gemm:
+  nvidia:
+    # cuBLASLt (H100/H200 optimized)
+    - pattern: "nvjet_*"
+      library: "cuBLASLt"
+      hardware: "SM90+ (Hopper/Blackwell)"
+    - pattern: "void cublasLt*"
+      library: "cuBLASLt"
+    # CUTLASS (all architectures)
+    - pattern: "cutlass*gemm*"
+      library: "CUTLASS 3.x"
+    - pattern: "cutlass_*"
+      library: "CUTLASS"
+    # cuBLAS legacy
+    - pattern: "cublas*"
+      library: "cuBLAS"
+    # FP8 GEMM (H100+ specific)
+    - pattern: "*fp8*gemm*"
+      library: "cuBLASLt FP8"
+      hardware: "SM90+ (Hopper)"
+    - pattern: "*e4m3*"
+      library: "cuBLASLt FP8"
+      hardware: "SM90+ (Hopper)"
+  amd:
+    # Tensile (all CDNA architectures)
+    - pattern: "Cijk_*"
+      library: "Tensile"
+    - pattern: "Custom_Cijk_*"
+      library: "Tensile"
+    # hipBLASLt (MI300X/MI325X/MI355X optimized)
+    - pattern: "wvSplitK*"
+      library: "hipBLASLt"
+      hardware: "CDNA 3/4 (MI300X/MI325X/MI355X)"
+    - pattern: "hipblaslt*"
+      library: "hipBLASLt"
+    - pattern: "hipblas*"
+      library: "hipBLAS"
+    # FP8 GEMM (MI300X+ specific)
+    - pattern: "*fp8*"
+      library: "hipBLASLt FP8"
+      hardware: "CDNA 3+ (MI300X/MI325X/MI355X)"
+    # CDNA 4 specific (MI355X - gfx950)
+    - pattern: "*gfx950*"
+      library: "Tensile"
+      hardware: "CDNA 4 (MI355X)"
+    # ISA-specific patterns (gfx942 = MI300X/MI325X, gfx950 = MI355X)
+    - pattern: "*ISA942*"
+      library: "Tensile"
+      hardware: "CDNA 3 (MI300X/MI325X)"
+    - pattern: "*ISA950*"
+      library: "Tensile"
+      hardware: "CDNA 4 (MI355X)"
+
+ssm:
+  both:
+    - pattern: "selective_scan*"
+      model: "Mamba"
+    - pattern: "ssd_*"
+      model: "Mamba-2"
+    - pattern: "causal_conv1d*"
+      model: "Mamba"
+    - pattern: "mamba_*"
+      model: "Mamba"
+
+rmsnorm:
+  both:
+    # Fused RMSNorm+GEMM patterns (AMD Triton fuses these)
+    # Key indicator: *rocm_unquantized_gemm* in kernel name
+    - pattern: "triton_*rocm_unquantized_gemm*rsqrt*"
+      library: "Triton"
+      fused_with: "GEMM"
+    - pattern: "triton_*rsqrt*rocm_unquantized_gemm*"
+      library: "Triton"
+      fused_with: "GEMM"
+    - pattern: "triton_*rsqrt*gemm*"
+      library: "Triton"
+      fused_with: "GEMM"
+    - pattern: "triton_*gemm*rsqrt*"
+      library: "Triton"
+      fused_with: "GEMM"
+    # Non-fused RMSNorm (no gemm in name)
+    - pattern: "triton_*rsqrt*"
+      library: "Triton"
+    - pattern: "*rmsnorm*"
+      library: "Various"
+
+moe:
+  both:
+    - pattern: "_matmul_ogs_*"
+      library: "Triton"
+    - pattern: "bmm_*dynbatch*"
+      library: "Triton"
+    - pattern: "*routing*"
+      library: "Various"
+    - pattern: "*topk*"
+      library: "Various"
+    - pattern: "fused_moe_kernel*"
+      library: "vLLM"
+    - pattern: "*vllm::moe::*"
+      library: "vLLM"
+    - pattern: "*moe_align_block_size*"
+      library: "vLLM"
+    - pattern: "*count_and_sort_expert*"
+      library: "vLLM"
+    - pattern: "*topkGatingSoftmax*"
+      library: "vLLM"
+
+# Activation functions (SwiGLU, SiLU, etc.)
+activation:
+  both:
+    # Fused SwiGLU+GEMM (AMD Triton fuses these)
+    - pattern: "triton_*rocm_unquantized_gemm*silu*"
+      operation: "SwiGLU+GEMM"
+      library: "Triton"
+      fused_with: "GEMM"
+    - pattern: "triton_*silu*rocm_unquantized_gemm*"
+      operation: "SwiGLU+GEMM"
+      library: "Triton"
+      fused_with: "GEMM"
+    - pattern: "triton_*gemm*silu*"
+      operation: "SwiGLU+GEMM"
+      library: "Triton"
+      fused_with: "GEMM"
+    - pattern: "triton_*silu*gemm*"
+      operation: "SwiGLU+GEMM"
+      library: "Triton"
+      fused_with: "GEMM"
+    # Non-fused activation
+    - pattern: "*act_and_mul_kernel*"
+      operation: "SwiGLU"
+      library: "vLLM"
+    - pattern: "triton_*silu*"
+      operation: "SiLU"
+      library: "Triton"
+    - pattern: "*silu_kernel*"
+      operation: "SiLU"
+      library: "vLLM"
+    - pattern: "*gelu*"
+      operation: "GELU"
+      library: "Various"
+
+# KV Cache operations
+kv_cache:
+  both:
+    - pattern: "*reshape_and_cache*"
+      library: "vLLM"
+    - pattern: "*concat_and_cache*"
+      library: "vLLM"
+    - pattern: "*cache_mla*"
+      library: "vLLM"
+
+# Softmax operations
+softmax:
+  both:
+    - pattern: "*SoftMax*"
+      library: "PyTorch"
+    - pattern: "*softmax*"
+      library: "PyTorch"
+
+# Triton fused operations (more specific patterns)
+triton:
+  both:
+    - pattern: "triton_poi_fused_mul*silu*"
+      operation: "SwiGLU"
+      library: "Triton"
+    - pattern: "triton_poi_fused*"
+      operation: "Pointwise"
+      library: "Triton"
+    - pattern: "triton_red_fused*"
+      operation: "Reduction"
+      library: "Triton"
+    - pattern: "triton_per_fused*"
+      operation: "Persistent"
+      library: "Triton"
+
+# Reduce/Scan operations
+reduce:
+  nvidia:
+    - pattern: "*cub::*Reduce*"
+      library: "CUB"
+    - pattern: "*cub::*Scan*"
+      library: "CUB"
+    - pattern: "*splitKreduce*"
+      library: "cuBLASLt"
+      note: "GEMM epilogue reduction"
+  amd:
+    - pattern: "*rocprim::*reduce*"
+      library: "rocPRIM"
+    - pattern: "*rocprim::*scan*"
+      library: "rocPRIM"
+    - pattern: "reduce_segments*"
+      library: "vLLM"
+
+# Sorting operations
+sorting:
+  nvidia:
+    - pattern: "*RadixSort*"
+      library: "CUB"
+    - pattern: "*DeviceSort*"
+      library: "CUB"
+  amd:
+    - pattern: "*rocprim::*sort*"
+      library: "rocPRIM"
+    - pattern: "*rocprim::*merge*"
+      library: "rocPRIM"
+
+# Memory/Copy operations
+memory:
+  both:
+    - pattern: "*memcpy*"
+      library: "CUDA/HIP Runtime"
+    - pattern: "*direct_copy*"
+      library: "PyTorch"
+    - pattern: "*copy_page_indices*"
+      library: "vLLM"
+    - pattern: "*rocclr_copyBuffer*"
+      library: "AMD ROCclr"
+    - pattern: "*rocprim::*transform*"
+      library: "rocPRIM"
+
+# Indexing/Scatter-Gather operations
+indexing:
+  both:
+    - pattern: "*scatter_gather*"
+      library: "PyTorch"
+    - pattern: "*index_elementwise*"
+      library: "PyTorch"
+    - pattern: "*fill_reverse_indices*"
+      library: "PyTorch"
+
+# Elementwise operations (fallback patterns)
+elementwise:
+  both:
+    - pattern: "at::native::*elementwise*"
+      library: "PyTorch"
+    - pattern: "at::native::*vectorized*"
+      library: "PyTorch"
+    - pattern: "*distribution_elementwise*"
+      library: "PyTorch"