wafer-core 0.1.26__py3-none-any.whl → 0.1.28__py3-none-any.whl

wafer_core/lib/trace_compare/fusion_analyzer.py

@@ -1,144 +1,45 @@
 """Fusion analysis for detecting kernel fusion differences between platforms.
 
-Detects fusion differences between AMD and NVIDIA by analyzing how many kernels
-each platform launches for the same logical operations.
+Detects fusion differences between AMD and NVIDIA by analyzing:
+1. Kernel types unique to each platform (one platform fuses them away)
+2. Sequence patterns (what comes before/after unique kernels)
+3. Count imbalances (one platform has significantly more calls)
+
+This is the pattern-based approach which is more reliable than alignment-based detection.
 """
 
-import json
 from collections import Counter, defaultdict
-from pathlib import Path
+from dataclasses import dataclass, field
 from typing import Any
 
-from .classifier import classify_kernel
-
-
-def _load_trace_for_fusion(
-    file_path: str | Path,
-) -> tuple[str, str, list[dict[str, Any]], dict[int, list[dict[str, Any]]]]:
-    """Load trace and group kernels by correlation ID.
-
-    Args:
-        file_path: Path to trace file
-
-    Returns:
-        Tuple of (platform, gpu_name, all_kernels, corr_groups)
-    """
-    with open(file_path, "rb") as f:
-        trace = json.load(f)
-
-    # Detect platform
-    props = trace.get("deviceProperties", [{}])[0]
-    is_amd = trace.get("roctracer_version") or props.get("warpSize") == 64
-    platform = "AMD" if is_amd else "NVIDIA"
-    gpu_name = props.get("name", "MI300X" if is_amd else "Unknown GPU")
-
-    # Get all kernel events
-    events = trace.get("traceEvents", [])
-    kernels = [e for e in events if e.get("cat") == "kernel"]
-
-    # Group by correlation ID
-    corr_groups: dict[int, list[dict[str, Any]]] = defaultdict(list)
-    for k in kernels:
-        corr_id = k.get("args", {}).get("correlation")
-        if corr_id is not None:
-            corr_groups[corr_id].append(k)
+from .classifier import classify, Op
 
-    return platform, gpu_name, kernels, dict(corr_groups)
 
+@dataclass
+class FusionPattern:
+    """A detected fusion pattern."""
 
-def _analyze_correlation_group(
-    kernels: list[dict[str, Any]],
-) -> tuple[dict[str, int], dict[str, float]]:
-    """Analyze kernel composition within a correlation group.
+    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
 
-    Args:
-        kernels: List of kernel events in the group
-
-    Returns:
-        Tuple of (counts, timings) where counts maps kernel types to counts
-        and timings maps kernel types to total duration in microseconds
-    """
-    counts: Counter[str] = Counter()
-    timings: dict[str, float] = defaultdict(float)
-
-    for k in kernels:
-        kernel_type = classify_kernel(k.get("name", ""))
-        counts[kernel_type] += 1
-        timings[kernel_type] += k.get("dur", 0)
-
-    return dict(counts), dict(timings)
 
+@dataclass
+class FusionAnalysis:
+    """Complete fusion analysis result."""
 
-def _match_correlation_groups(
-    amd_groups: dict[int, list[dict[str, Any]]],
-    nv_groups: dict[int, list[dict[str, Any]]],
-    size_tolerance: float = 0.25,
-) -> list[tuple[int, int]]:
-    """Match AMD and NVIDIA correlation groups by size and composition.
+    patterns: list[FusionPattern] = field(default_factory=list)
+    summary: dict[str, Any] = field(default_factory=dict)
 
-    Since correlation IDs don't match between platforms, we match groups that
-    have similar sizes (within tolerance) and likely represent the same operation.
-
-    Args:
-        amd_groups: AMD correlation groups
-        nv_groups: NVIDIA correlation groups
-        size_tolerance: Groups match if sizes are within this fraction (25% default, increased for better matching)
-
-    Returns:
-        List of (amd_corr_id, nv_corr_id) pairs
-    """
-    matches = []
-    used_nv_ids: set[int] = set()
 
-    # Pre-compute compositions for all groups to avoid redundant analysis
-    amd_comps = {id: _analyze_correlation_group(kernels)[0] for id, kernels in amd_groups.items()}
-    nv_comps = {id: _analyze_correlation_group(kernels)[0] for id, kernels in nv_groups.items()}
-
-    # Build size-indexed lookup for NVIDIA groups for faster filtering
-    nv_by_size = [(id, len(kernels)) for id, kernels in nv_groups.items()]
-
-    # Sort AMD groups by size (largest first for better matching)
-    amd_sorted = sorted(amd_groups.items(), key=lambda x: len(x[1]), reverse=True)
-
-    for amd_id, amd_kernels in amd_sorted:
-        amd_size = len(amd_kernels)
-        amd_comp = amd_comps[amd_id]
-
-        # Calculate size bounds for matching
-        min_size = amd_size / (1 + size_tolerance)
-        max_size = amd_size * (1 + size_tolerance)
-
-        # Find best matching NVIDIA group
-        best_match = None
-        best_score = float("inf")
-
-        for nv_id, nv_size in nv_by_size:
-            if nv_id in used_nv_ids:
-                continue
-
-            # Quick size filter
-            if nv_size < min_size or nv_size > max_size:
-                continue
-
-            # Use pre-computed composition
-            nv_comp = nv_comps[nv_id]
-
-            # Simple similarity: number of shared kernel types
-            shared_types = set(amd_comp.keys()) & set(nv_comp.keys())
-            similarity = len(shared_types)
-
-            # Prefer matches with more shared types and closer sizes
-            score = abs(amd_size - nv_size) - (similarity * 10)
-
-            if score < best_score:
-                best_score = score
-                best_match = nv_id
-
-        if best_match is not None:
-            matches.append((amd_id, best_match))
-            used_nv_ids.add(best_match)
-
-    return matches
+def _classify_kernel(name: str, platform: str = "AMD") -> str:
+    """Classify a kernel name to its operation type."""
+    op, _pattern = classify(name, platform)
+    return op.value
 
 
 def _find_fusion_mappings(
@@ -146,6 +47,7 @@ def _find_fusion_mappings(
     trace2_kernels: list[dict],
     trace1_name: str = "Trace1",
     trace2_name: str = "Trace2",
+    trace1_platform: str = "AMD",
 ) -> list[dict]:
     """Find fusion mappings by analyzing kernel execution sequence patterns.
 
@@ -157,29 +59,21 @@ def _find_fusion_mappings(
         trace2_kernels: List of kernel events from second trace
         trace1_name: Name of first platform (e.g., "AMD")
         trace2_name: Name of second platform (e.g., "NVIDIA")
+        trace1_platform: Platform string for classification ("AMD" or "NVIDIA")
 
     Returns:
-        List of mapping dictionaries, each containing:
-            - fused_platform: Which platform fuses the operations
-            - fused_kernel_type: The single fused kernel type
-            - unfused_platform: Which platform runs them separately
-            - unfused_sequence: List of kernel types run separately
-            - pattern_count: How many times this pattern appears
-            - pattern_confidence: Fraction of occurrences following this pattern
-            - evidence: Human-readable description
+        List of mapping dictionaries with fusion details
     """
-    from collections import defaultdict
-    from wafer_core.lib.trace_compare.classifier import classify_kernel
-    
     mappings = []
+    trace2_platform = "NVIDIA" if trace1_platform == "AMD" else "AMD"
 
     # Sort kernels by timestamp
-    trace1_sorted = sorted(trace1_kernels, key=lambda k: k.get('ts', 0))
-    trace2_sorted = sorted(trace2_kernels, key=lambda k: k.get('ts', 0))
+    trace1_sorted = sorted(trace1_kernels, key=lambda k: k.get("ts", 0))
+    trace2_sorted = sorted(trace2_kernels, key=lambda k: k.get("ts", 0))
 
     # Classify all kernels
-    trace1_types = [classify_kernel(k.get('name', '')) for k in trace1_sorted]
-    trace2_types = [classify_kernel(k.get('name', '')) for k in trace2_sorted]
+    trace1_types = [_classify_kernel(k.get("name", ""), trace1_platform) for k in trace1_sorted]
+    trace2_types = [_classify_kernel(k.get("name", ""), trace2_platform) for k in trace2_sorted]
 
     # Find kernel types unique to each trace
     trace1_type_set = set(trace1_types)
@@ -190,30 +84,34 @@ def _find_fusion_mappings(
 
     # For each unique type in trace1, find common sequence patterns
     for unique_type in trace1_only:
+        # Skip "Other" since it's too generic
+        if unique_type == "Other":
+            continue
+
         # Find all occurrences of this type
         indices = [i for i, t in enumerate(trace1_types) if t == unique_type]
 
         if len(indices) < 5:  # Need enough samples to be meaningful
             continue
 
-        # Analyze what comes before/after each occurrence
-        before_types = defaultdict(int)
+        # Analyze what comes before each occurrence
+        before_types: dict[str, int] = defaultdict(int)
 
         for idx in indices:
             if idx > 0:
                 before_types[trace1_types[idx - 1]] += 1
 
-        # Find the most common pattern (e.g., "Attention → Reduce")
-        most_common_before = max(before_types.items(), key=lambda x: x[1]) if before_types else (None, 0)
+        # Find the most common pattern
+        if not before_types:
+            continue
+        most_common_before = max(before_types.items(), key=lambda x: x[1])
 
         # If there's a strong pattern (>80% of occurrences)
         if most_common_before[1] / len(indices) > 0.8:
-            # This suggests: Trace2 likely fuses [before_type + unique_type] into [before_type]
             fusion_candidate = most_common_before[0]
 
             # Verify trace2 has this type
             if fusion_candidate in trace2_type_set:
-                # Count occurrences to compare
                 trace1_fusion_count = trace1_types.count(fusion_candidate)
                 trace2_fusion_count = trace2_types.count(fusion_candidate)
 
@@ -225,15 +123,18 @@ def _find_fusion_mappings(
                     "unfused_sequence": [fusion_candidate, unique_type],
                     "unfused_count_per_type": {
                         fusion_candidate: trace1_fusion_count,
-                        unique_type: len(indices)
+                        unique_type: len(indices),
                     },
                     "pattern_count": len(indices),
                     "pattern_confidence": most_common_before[1] / len(indices),
-                    "evidence": f"{trace1_name} runs {fusion_candidate}+{unique_type} separately, {trace2_name} fuses into {fusion_candidate}"
+                    "evidence": f"{trace1_name} runs {fusion_candidate}+{unique_type} separately, {trace2_name} fuses into {fusion_candidate}",
                 })
 
     # Also check trace2-only types
     for unique_type in trace2_only:
+        if unique_type == "Other":
+            continue
+
         indices = [i for i, t in enumerate(trace2_types) if t == unique_type]
 
         if len(indices) < 5:
@@ -245,7 +146,9 @@ def _find_fusion_mappings(
             if idx > 0:
                 before_types[trace2_types[idx - 1]] += 1
 
-        most_common_before = max(before_types.items(), key=lambda x: x[1]) if before_types else (None, 0)
+        if not before_types:
+            continue
+        most_common_before = max(before_types.items(), key=lambda x: x[1])
 
         if most_common_before[1] / len(indices) > 0.8:
             fusion_candidate = most_common_before[0]
@@ -262,629 +165,300 @@ def _find_fusion_mappings(
                     "unfused_sequence": [fusion_candidate, unique_type],
                     "unfused_count_per_type": {
                         fusion_candidate: trace2_fusion_count,
-                        unique_type: len(indices)
+                        unique_type: len(indices),
                     },
                     "pattern_count": len(indices),
                     "pattern_confidence": most_common_before[1] / len(indices),
-                    "evidence": f"{trace2_name} runs {fusion_candidate}+{unique_type} separately, {trace1_name} fuses into {fusion_candidate}"
-                })
-
-    # NEW: Check for partial fusion patterns (kernel exists on both platforms but with different counts)
-    # If one platform has significantly fewer calls (>1.3x ratio), look for fusion patterns
-    common_types = trace1_type_set & trace2_type_set
-
-    for ktype in common_types:
-        trace1_count = trace1_types.count(ktype)
-        trace2_count = trace2_types.count(ktype)
-
-        # Check if there's a significant imbalance (one has >1.3x more)
-        if trace1_count == 0 or trace2_count == 0:
-            continue
-
-        ratio = max(trace1_count, trace2_count) / min(trace1_count, trace2_count)
-
-        if ratio < 1.3 or trace1_count + trace2_count < 100:
-            continue
-
-        # Determine which platform has more (unfused) and which has fewer (fused)
-        if trace1_count > trace2_count:
-            # Trace1 has more separate calls, Trace2 likely fuses
-            unfused_platform = trace1_name
-            fused_platform = trace2_name
-            unfused_count = trace1_count
-            fused_count = trace2_count
-
-            # Find what Trace2 might be fusing this into
-            # Use the most common kernel type in Trace2 as a likely fusion target
-            trace2_type_counts = defaultdict(int)
-            for t in trace2_types:
-                if t != ktype and t != "Other":  # Skip the imbalanced type itself and "Other"
-                    trace2_type_counts[t] += 1
-
-            if trace2_type_counts:
-                # Use the most common type as the fusion target
-                fusion_target = max(trace2_type_counts.items(), key=lambda x: x[1])[0]
-
-                mappings.append({
-                    "fused_platform": fused_platform,
-                    "fused_kernel_type": fusion_target,
-                    "fused_count": fused_count,
-                    "unfused_platform": unfused_platform,
-                    "unfused_sequence": [ktype],
-                    "unfused_count_per_type": {
-                        ktype: unfused_count
-                    },
-                    "pattern_count": unfused_count - fused_count,
-                    "pattern_confidence": (unfused_count - fused_count) / unfused_count,
-                    "evidence": f"{unfused_platform} calls {ktype} {ratio:.1f}x more ({unfused_count} vs {fused_count}), {fused_platform} likely fuses into {fusion_target}"
-                })
-        else:
-            # Trace2 has more separate calls, Trace1 likely fuses
-            unfused_platform = trace2_name
-            fused_platform = trace1_name
-            unfused_count = trace2_count
-            fused_count = trace1_count
-
-            # Find what Trace1 might be fusing this into
-            # Use the most common kernel type in Trace1 as a likely fusion target
-            trace1_type_counts = defaultdict(int)
-            for t in trace1_types:
-                if t != ktype and t != "Other":  # Skip the imbalanced type itself and "Other"
-                    trace1_type_counts[t] += 1
-
-            if trace1_type_counts:
-                fusion_target = max(trace1_type_counts.items(), key=lambda x: x[1])[0]
-
-                mappings.append({
-                    "fused_platform": fused_platform,
-                    "fused_kernel_type": fusion_target,
-                    "fused_count": fused_count,
-                    "unfused_platform": unfused_platform,
-                    "unfused_sequence": [ktype],
-                    "unfused_count_per_type": {
-                        ktype: unfused_count
-                    },
-                    "pattern_count": unfused_count - fused_count,
-                    "pattern_confidence": (unfused_count - fused_count) / unfused_count,
-                    "evidence": f"{unfused_platform} calls {ktype} {ratio:.1f}x more ({unfused_count} vs {fused_count}), {fused_platform} likely fuses into {fusion_target}"
+                    "evidence": f"{trace2_name} runs {fusion_candidate}+{unique_type} separately, {trace1_name} fuses into {fusion_candidate}",
                 })
 
     return mappings
 
 
-def _detect_intra_type_fusion(
+def _find_count_imbalance_fusions(
     trace1_kernels: list[dict],
     trace2_kernels: list[dict],
-    trace1_name: str,
-    trace2_name: str,
+    trace1_name: str = "Trace1",
+    trace2_name: str = "Trace2",
+    trace1_platform: str = "AMD",
 ) -> list[dict]:
-    """Detect intra-type fusion where consecutive same-type kernels are fused.
+    """Find fusions by looking for significant count imbalances.
 
-    Example: AMD runs Sort→Sort→Sort (42 calls) while NVIDIA runs Sort→Sort (10 calls)
-    This indicates NVIDIA has a more efficient Sort implementation that fuses operations.
+    When one platform has significantly more kernel calls of a type (>1.5x),
+    it suggests the other platform fuses those operations.
     """
-    from wafer_core.lib.trace_compare.classifier import classify_kernel
-
-    def analyze_chains(kernels):
-        """Find chains of consecutive same-type kernels"""
-        sorted_kernels = sorted(kernels, key=lambda k: k.get('ts', 0))
-        types = [classify_kernel(k['name']) for k in sorted_kernels]
-
-        chains = defaultdict(list)
-        i = 0
-        while i < len(types):
-            ktype = types[i]
-            count = 0
-            while i < len(types) and types[i] == ktype:
-                count += 1
-                i += 1
-            chains[ktype].append(count)
-
-        return chains
-
-    trace1_chains = analyze_chains(trace1_kernels)
-    trace2_chains = analyze_chains(trace2_kernels)
-
     mappings = []
-    all_types = set(trace1_chains.keys()) | set(trace2_chains.keys())
+    trace2_platform = "NVIDIA" if trace1_platform == "AMD" else "AMD"
 
-    for ktype in all_types:
-        t1_lengths = trace1_chains.get(ktype, [])
-        t2_lengths = trace2_chains.get(ktype, [])
+    # Classify all kernels
+    trace1_types = [_classify_kernel(k.get("name", ""), trace1_platform) for k in trace1_kernels]
+    trace2_types = [_classify_kernel(k.get("name", ""), trace2_platform) for k in trace2_kernels]
 
-        # Skip if not enough data
-        if len(t1_lengths) < 5 and len(t2_lengths) < 5:
-            continue
+    # Count by type
+    trace1_counts = Counter(trace1_types)
+    trace2_counts = Counter(trace2_types)
 
-        # Filter to chains with multiple kernels
-        t1_multi = [l for l in t1_lengths if l > 1]
-        t2_multi = [l for l in t2_lengths if l > 1]
+    # Find common types with significant differences
+    common_types = set(trace1_counts.keys()) & set(trace2_counts.keys())
 
-        if not t1_multi and not t2_multi:
+    for ktype in common_types:
+        if ktype == "Other":
             continue
 
-        t1_total = sum(t1_lengths)
-        t2_total = sum(t2_lengths)
-        t1_chains = len(t1_multi) if t1_multi else len(t1_lengths)
-        t2_chains = len(t2_multi) if t2_multi else len(t2_lengths)
+        trace1_count = trace1_counts[ktype]
+        trace2_count = trace2_counts[ktype]
 
-        if t1_chains == 0 or t2_chains == 0:
+        # Skip trivial counts
+        if trace1_count + trace2_count < 50:
             continue
 
-        t1_avg_chain = sum(t1_multi) / len(t1_multi) if t1_multi else 1.0
-        t2_avg_chain = sum(t2_multi) / len(t2_multi) if t2_multi else 1.0
-
-        chain_ratio = max(t1_avg_chain, t2_avg_chain) / min(t1_avg_chain, t2_avg_chain)
-
-        # Significant intra-fusion if chains are 2x+ different
-        if chain_ratio > 2.0 and abs(t1_total - t2_total) > 100:
-            if t1_avg_chain > t2_avg_chain:
-                unfused_platform = trace1_name
-                fused_platform = trace2_name
-                unfused_chains = t1_chains
-                fused_chains = t2_chains
-                unfused_avg = t1_avg_chain
-                fused_avg = t2_avg_chain
-                unfused_total = t1_total
-                fused_total = t2_total
-            else:
-                unfused_platform = trace2_name
-                fused_platform = trace1_name
-                unfused_chains = t2_chains
-                fused_chains = t1_chains
-                unfused_avg = t2_avg_chain
-                fused_avg = t1_avg_chain
-                unfused_total = t2_total
-                fused_total = t1_total
-
-            mappings.append({
-                "fused_platform": fused_platform,
-                "fused_kernel_type": ktype,
-                "fused_count": fused_total,
-                "unfused_platform": unfused_platform,
-                "unfused_sequence": [ktype, ktype],  # Same type repeated
-                "unfused_count_per_type": {ktype: unfused_total},
-                "pattern_count": unfused_total - fused_total,
-                "pattern_confidence": min(unfused_chains, fused_chains) / max(unfused_chains, fused_chains),
-                "evidence": f"{unfused_platform} runs {ktype} in chains of {unfused_avg:.0f} calls ({unfused_chains} chains, {unfused_total:,} total), {fused_platform} fuses to {fused_avg:.0f} calls ({fused_chains} chains, {fused_total:,} total) - {chain_ratio:.1f}x more efficient"
-            })
-
-    return mappings
-
-
-def _find_partial_fusion_via_groups(
-    trace1_large: dict[int, list[dict]],
-    trace2_large: dict[int, list[dict]],
-    matches: list[tuple[int, int]],
-    trace1_name: str,
-    trace2_name: str,
-) -> list[dict]:
-    """Find partial fusion patterns by analyzing correlation group differences.
-
-    When one platform has fewer of a kernel type, check what kernel types the
-    other platform has MORE of in those same groups - those are likely fusion targets.
-    """
-    from collections import Counter
-    from wafer_core.lib.trace_compare.classifier import classify_kernel
-
-    mappings = []
-
-    # For each matched pair, track kernel type counts
-    trace1_all_types = []
-    trace2_all_types = []
-
-    for trace1_cid, trace2_cid in matches:
-        trace1_ktypes = [classify_kernel(k.get("name", "")) for k in trace1_large[trace1_cid]]
-        trace2_ktypes = [classify_kernel(k.get("name", "")) for k in trace2_large[trace2_cid]]
-        trace1_all_types.extend(trace1_ktypes)
-        trace2_all_types.extend(trace2_ktypes)
-
-    # Find kernel types with significant imbalances
-    trace1_counts = Counter(trace1_all_types)
-    trace2_counts = Counter(trace2_all_types)
-    all_types = set(trace1_counts.keys()) | set(trace2_counts.keys())
-
-    for ktype in all_types:
-        trace1_count = trace1_counts.get(ktype, 0)
-        trace2_count = trace2_counts.get(ktype, 0)
-
+        # Check if there's a significant imbalance (>1.5x)
         if trace1_count == 0 or trace2_count == 0:
-            continue  # Handled by sequence-based detection
+            continue
 
         ratio = max(trace1_count, trace2_count) / min(trace1_count, trace2_count)
 
-        if ratio < 1.3 or trace1_count + trace2_count < 100:
-            continue  # Not significant
+        if ratio < 1.5:
+            continue
 
-        # Determine which platform has fewer (fuses more)
+        # Determine which platform has more (unfused) and which has fewer (fused)
         if trace1_count > trace2_count:
             unfused_platform = trace1_name
             fused_platform = trace2_name
             unfused_count = trace1_count
             fused_count = trace2_count
-
-            # Find groups where trace1 has this kernel but trace2 doesn't
-            fusion_targets = Counter()
-            groups_analyzed = 0
-
-            for trace1_cid, trace2_cid in matches:
-                trace1_ktypes = [classify_kernel(k.get("name", "")) for k in trace1_large[trace1_cid]]
-                trace2_ktypes = [classify_kernel(k.get("name", "")) for k in trace2_large[trace2_cid]]
-
-                trace1_has = ktype in trace1_ktypes
-                trace2_has = ktype in trace2_ktypes
-
-                if trace1_has and not trace2_has:
-                    # What does trace2 have MORE of in this group?
-                    trace1_kcounts = Counter(trace1_ktypes)
-                    trace2_kcounts = Counter(trace2_ktypes)
-
-                    for other_type in set(trace2_kcounts.keys()):
-                        if other_type == ktype or other_type == "Other":
-                            continue
-                        diff = trace2_kcounts[other_type] - trace1_kcounts.get(other_type, 0)
-                        if diff > 0:
-                            fusion_targets[other_type] += diff
-
-                    groups_analyzed += 1
-
-            if fusion_targets and groups_analyzed >= 5:
-                # Report top fusion targets
-                top_targets = fusion_targets.most_common(3)
-                target_str = ", ".join(f"{t[0]} (+{t[1]})" for t in top_targets)
-
-                mappings.append({
-                    "fused_platform": fused_platform,
-                    "fused_kernel_type": top_targets[0][0],
-                    "fused_count": fused_count,
-                    "unfused_platform": unfused_platform,
-                    "unfused_sequence": [ktype],
-                    "unfused_count_per_type": {ktype: unfused_count},
-                    "pattern_count": unfused_count - fused_count,
-                    "pattern_confidence": groups_analyzed / len(matches) if matches else 0,
-                    "evidence": f"{unfused_platform} calls {ktype} {ratio:.1f}x more ({unfused_count} vs {fused_count}). In {groups_analyzed} groups where {unfused_platform} has {ktype}, {fused_platform} has more: {target_str}"
-                })
         else:
-            # Symmetric case for trace2 > trace1
             unfused_platform = trace2_name
             fused_platform = trace1_name
             unfused_count = trace2_count
             fused_count = trace1_count
 
-            fusion_targets = Counter()
-            groups_analyzed = 0
+        mappings.append({
+            "fused_platform": fused_platform,
+            "fused_kernel_type": ktype,
+            "fused_count": fused_count,
+            "unfused_platform": unfused_platform,
+            "unfused_sequence": [ktype],
+            "unfused_count_per_type": {ktype: unfused_count},
+            "pattern_count": unfused_count - fused_count,
+            "pattern_confidence": (unfused_count - fused_count) / unfused_count,
+            "evidence": f"{unfused_platform} calls {ktype} {ratio:.1f}x more ({unfused_count} vs {fused_count}), {fused_platform} likely fuses",
+        })
 
-            for trace1_cid, trace2_cid in matches:
-                trace1_ktypes = [classify_kernel(k.get("name", "")) for k in trace1_large[trace1_cid]]
-                trace2_ktypes = [classify_kernel(k.get("name", "")) for k in trace2_large[trace2_cid]]
+    return mappings
 
-                trace1_has = ktype in trace1_ktypes
-                trace2_has = ktype in trace2_ktypes
 
-                if trace2_has and not trace1_has:
-                    trace1_kcounts = Counter(trace1_ktypes)
-                    trace2_kcounts = Counter(trace2_ktypes)
+def _find_explicit_fused_operations(
+    trace1_kernels: list[dict],
+    trace2_kernels: list[dict],
+    trace1_name: str = "Trace1",
+    trace2_name: str = "Trace2",
+    trace1_platform: str = "AMD",
+) -> list[dict]:
+    """Find explicit fused operations (kernels with '+' in their classification).
 
-                    for other_type in set(trace1_kcounts.keys()):
-                        if other_type == ktype or other_type == "Other":
-                            continue
-                        diff = trace1_kcounts[other_type] - trace2_kcounts.get(other_type, 0)
-                        if diff > 0:
-                            fusion_targets[other_type] += diff
+    These are operations like 'RMSNorm+GEMM' that are explicitly classified as fused.
+    """
+    mappings = []
+    trace2_platform = "NVIDIA" if trace1_platform == "AMD" else "AMD"
+
+    def get_fused_ops(kernels: list[dict], platform: str) -> dict[str, list[str]]:
+        """Get fused operations and their kernel names."""
+        fused_ops: dict[str, list[str]] = defaultdict(list)
+        for k in kernels:
+            name = k.get("name", "")
+            op, _pattern = classify(name, platform)
+            if "+" in op.value or op == Op.FUSED_UNKNOWN:
+                fused_ops[op.value].append(name)
+        return dict(fused_ops)
+
+    trace1_fused = get_fused_ops(trace1_kernels, trace1_platform)
+    trace2_fused = get_fused_ops(trace2_kernels, trace2_platform)
+
+    # Find fused operations unique to trace1
+    for fused_op, kernels in trace1_fused.items():
+        if fused_op not in trace2_fused:
+            # Parse components from the fused op name
+            if "+" in fused_op:
+                components = [c.strip() for c in fused_op.split("+")]
+            else:
+                components = [fused_op]
 
-                    groups_analyzed += 1
+            mappings.append({
+                "fused_platform": trace1_name,
+                "fused_kernel_type": fused_op,
+                "fused_count": len(kernels),
+                "unfused_platform": trace2_name,
+                "unfused_sequence": components,
+                "unfused_count_per_type": {c: 0 for c in components},  # Unknown
+                "pattern_count": len(kernels),
+                "pattern_confidence": 1.0,
+                "evidence": f"{trace1_name} fuses {' + '.join(components)} into {fused_op} ({len(kernels)} calls)",
+                "fused_kernel_names": kernels[:3],  # Sample of kernel names
+            })
 
-            if fusion_targets and groups_analyzed >= 5:
-                top_targets = fusion_targets.most_common(3)
-                target_str = ", ".join(f"{t[0]} (+{t[1]})" for t in top_targets)
+    # Find fused operations unique to trace2
+    for fused_op, kernels in trace2_fused.items():
+        if fused_op not in trace1_fused:
+            if "+" in fused_op:
+                components = [c.strip() for c in fused_op.split("+")]
+            else:
+                components = [fused_op]
 
-                mappings.append({
-                    "fused_platform": fused_platform,
-                    "fused_kernel_type": top_targets[0][0],
-                    "fused_count": fused_count,
-                    "unfused_platform": unfused_platform,
-                    "unfused_sequence": [ktype],
-                    "unfused_count_per_type": {ktype: unfused_count},
-                    "pattern_count": unfused_count - fused_count,
-                    "pattern_confidence": groups_analyzed / len(matches) if matches else 0,
-                    "evidence": f"{unfused_platform} calls {ktype} {ratio:.1f}x more ({unfused_count} vs {fused_count}). In {groups_analyzed} groups where {unfused_platform} has {ktype}, {fused_platform} has more: {target_str}"
-                })
+            mappings.append({
+                "fused_platform": trace2_name,
+                "fused_kernel_type": fused_op,
+                "fused_count": len(kernels),
+                "unfused_platform": trace1_name,
+                "unfused_sequence": components,
+                "unfused_count_per_type": {c: 0 for c in components},
+                "pattern_count": len(kernels),
+                "pattern_confidence": 1.0,
+                "evidence": f"{trace2_name} fuses {' + '.join(components)} into {fused_op} ({len(kernels)} calls)",
+                "fused_kernel_names": kernels[:3],
+            })
 
     return mappings
 
 
-def analyze_fusion_differences(
-    amd_trace_path: str | Path,
-    nv_trace_path: str | Path,
-    min_group_size: int = 50,
-) -> dict[str, Any]:
-    """Main fusion analysis function.
+def detect_fusion_patterns(
+    amd_kernels: list[dict],
+    nvidia_kernels: list[dict],
+) -> FusionAnalysis:
+    """Detect fusion patterns using pattern-based analysis.
+
+    This is the main entry point for fusion detection. It combines:
+    1. Explicit fused operations (kernels classified with '+' in name)
+    2. Sequence pattern analysis (unique kernel types with consistent patterns)
+    3. Count imbalance analysis (one platform has significantly more calls)
 
     Args:
-        amd_trace_path: Path to AMD trace
-        nv_trace_path: Path to NVIDIA trace
-        min_group_size: Only analyze correlation groups with at least this many kernels
+        amd_kernels: List of AMD kernel events
+        nvidia_kernels: List of NVIDIA kernel events
 
     Returns:
-        Dictionary with analysis results containing:
-            - metadata: trace info
-            - global_counts: kernel type distribution across entire trace
-            - fusion_opportunities: significant fusion differences
-            - fusion_mappings: actual kernel-to-kernel mappings (NEW)
+        FusionAnalysis with detected patterns
     """
-    # Load traces (maintain order - don't swap)
-    trace1_platform, trace1_gpu, trace1_kernels, trace1_corr_groups = _load_trace_for_fusion(
-        amd_trace_path
-    )
-    trace2_platform, trace2_gpu, trace2_kernels, trace2_corr_groups = _load_trace_for_fusion(
-        nv_trace_path
-    )
+    all_mappings: list[dict] = []
 
-    # Filter to "significant" correlation groups
-    trace1_large = {
-        cid: kernels
-        for cid, kernels in trace1_corr_groups.items()
-        if len(kernels) >= min_group_size
-    }
-    trace2_large = {
-        cid: kernels
-        for cid, kernels in trace2_corr_groups.items()
-        if len(kernels) >= min_group_size
-    }
-
-    # Match correlation groups between platforms
-    matches = _match_correlation_groups(trace1_large, trace2_large)
-
-    # Analyze differences in matched groups
-    fusion_diffs: dict[str, dict[str, Any]] = defaultdict(
-        lambda: {
-            "trace1_count": 0,
-            "trace2_count": 0,
-            "trace1_time_us": 0,
-            "trace2_time_us": 0,
-            "groups_with_diff": 0,
-            "total_groups": 0,
-        }
+    # 1. Find explicit fused operations (highest confidence)
+    explicit_fusions = _find_explicit_fused_operations(
+        amd_kernels, nvidia_kernels,
+        trace1_name="AMD", trace2_name="NVIDIA",
+        trace1_platform="AMD",
     )
+    all_mappings.extend(explicit_fusions)
 
-    # NEW: Collect actual fusion mappings
-    all_fusion_mappings = []
-
-    for trace1_cid, trace2_cid in matches:
-        trace1_comp, trace1_times = _analyze_correlation_group(trace1_large[trace1_cid])
-        trace2_comp, trace2_times = _analyze_correlation_group(trace2_large[trace2_cid])
-
-        # Find all kernel types in either platform
-        all_types = set(trace1_comp.keys()) | set(trace2_comp.keys())
-
-        for ktype in all_types:
-            trace1_count = trace1_comp.get(ktype, 0)
-            trace2_count = trace2_comp.get(ktype, 0)
-            trace1_time = trace1_times.get(ktype, 0)
-            trace2_time = trace2_times.get(ktype, 0)
-
-            fusion_diffs[ktype]["trace1_count"] += trace1_count
-            fusion_diffs[ktype]["trace2_count"] += trace2_count
-            fusion_diffs[ktype]["trace1_time_us"] += trace1_time
-            fusion_diffs[ktype]["trace2_time_us"] += trace2_time
-            fusion_diffs[ktype]["total_groups"] += 1
-
-            if trace1_count != trace2_count:
-                fusion_diffs[ktype]["groups_with_diff"] += 1
-
-        # NEW: Find actual kernel mappings in this correlation group
-        group_mappings = _find_fusion_mappings(
-            trace1_large[trace1_cid],
-            trace2_large[trace2_cid],
-            trace1_name=trace1_platform,
-            trace2_name=trace2_platform
-        )
-        # Add correlation ID context to each mapping
-        for mapping in group_mappings:
-            mapping["correlation_group_trace1"] = trace1_cid
-            mapping["correlation_group_trace2"] = trace2_cid
-        all_fusion_mappings.extend(group_mappings)
-
-    # Also get global counts for context
-    global_trace1_counts: Counter[str] = Counter(
-        [classify_kernel(k.get("name", "")) for k in trace1_kernels]
+    # 2. Find sequence-based fusions
+    sequence_fusions = _find_fusion_mappings(
+        amd_kernels, nvidia_kernels,
+        trace1_name="AMD", trace2_name="NVIDIA",
+        trace1_platform="AMD",
     )
-    global_trace2_counts: Counter[str] = Counter(
-        [classify_kernel(k.get("name", "")) for k in trace2_kernels]
+    # Deduplicate: skip if same fused_kernel_type already found
+    existing_types = {m["fused_kernel_type"] for m in all_mappings}
+    for fusion in sequence_fusions:
+        if fusion["fused_kernel_type"] not in existing_types:
+            all_mappings.append(fusion)
+            existing_types.add(fusion["fused_kernel_type"])
+
+    # 3. Find count-imbalance fusions
+    count_fusions = _find_count_imbalance_fusions(
+        amd_kernels, nvidia_kernels,
+        trace1_name="AMD", trace2_name="NVIDIA",
+        trace1_platform="AMD",
     )
-
-    # Build results
-    results: dict[str, Any] = {
-        "metadata": {
-            "trace1_gpu": trace1_gpu,
-            "trace2_gpu": trace2_gpu,
-            "trace1_total_kernels": len(trace1_kernels),
-            "trace2_total_kernels": len(trace2_kernels),
-            "trace1_correlation_groups": len(trace1_large),
-            "trace2_correlation_groups": len(trace2_large),
-            "matched_groups": len(matches),
-        },
-        "global_counts": {},
-        "fusion_opportunities": [],
-        "fusion_mappings": all_fusion_mappings,  # NEW: Include actual mappings
-    }
-
-    # Global counts for all kernel types
-    all_ktypes = set(global_trace1_counts.keys()) | set(global_trace2_counts.keys())
-    for ktype in all_ktypes:
-        trace1_total = global_trace1_counts.get(ktype, 0)
-        trace2_total = global_trace2_counts.get(ktype, 0)
-
-        if trace1_total > 0 or trace2_total > 0:
-            results["global_counts"][ktype] = {
-                "trace1_count": trace1_total,
-                "trace2_count": trace2_total,
-                "ratio": trace1_total / trace2_total if trace2_total > 0 else float("inf"),
-            }
-
-    # Fusion opportunities from matched correlation groups
-    for ktype, stats in fusion_diffs.items():
-        trace1_avg = (
-            stats["trace1_count"] / stats["total_groups"]
-            if stats["total_groups"] > 0
-            else 0
-        )
-        trace2_avg = (
-            stats["trace2_count"] / stats["total_groups"]
-            if stats["total_groups"] > 0
-            else 0
-        )
-        trace1_time_ms = stats["trace1_time_us"] / 1000
-        trace2_time_ms = stats["trace2_time_us"] / 1000
-
-        # Calculate significance
-        diff_ratio = trace1_avg / trace2_avg if trace2_avg > 0 else float("inf")
-        reverse_ratio = trace2_avg / trace1_avg if trace1_avg > 0 else float("inf")
-
-        # Only report if there's a significant difference
-        # Either: one platform has it and the other doesn't (ratio > 10)
-        # Or: one platform has significantly more (ratio > 2.0)
-        is_significant = (
-            (diff_ratio > 10.0 or reverse_ratio > 10.0)
-            or (  # One platform doesn't have it
-                (diff_ratio > 2.0 or reverse_ratio > 2.0)
-                and stats["trace1_count"] + stats["trace2_count"] > 20  # Significant difference  # Not trivial counts
+    # Deduplicate
+    for fusion in count_fusions:
+        if fusion["fused_kernel_type"] not in existing_types:
+            all_mappings.append(fusion)
+            existing_types.add(fusion["fused_kernel_type"])
+
+    # Convert to FusionPattern objects
+    patterns: list[FusionPattern] = []
+    for mapping in all_mappings:
+        fused_kernel_names = mapping.get("fused_kernel_names", [])
+        fused_kernel = fused_kernel_names[0] if fused_kernel_names else mapping["fused_kernel_type"]
+        
+        patterns.append(
+            FusionPattern(
+                layer=0,  # Pattern-based analysis doesn't track layers
+                operation=mapping["fused_kernel_type"],
+                fused_platform=mapping["fused_platform"],
+                fused_kernel=fused_kernel,
+                unfused_kernels=mapping["unfused_sequence"],
+                count=mapping["pattern_count"],
+                evidence=mapping["evidence"],
             )
         )
 
-        if is_significant:
-            # Determine who fuses (who has FEWER calls = more fusion)
-            if diff_ratio > 1.5:
-                fused_by = trace2_platform  # Trace 2 has fewer calls, so it fuses more
-                ratio = diff_ratio
-            else:
-                fused_by = trace1_platform  # Trace 1 has fewer calls, so it fuses more
-                ratio = reverse_ratio
-
-            # Calculate time ratio (who's faster for this operation)
-            time_ratio = trace1_time_ms / trace2_time_ms if trace2_time_ms > 0 else float("inf")
-
-            results["fusion_opportunities"].append(
-                {
-                    "kernel_type": ktype,
-                    "trace1_total": stats["trace1_count"],
-                    "trace2_total": stats["trace2_count"],
-                    "trace1_avg_per_group": trace1_avg,
-                    "trace2_avg_per_group": trace2_avg,
-                    "trace1_time_ms": trace1_time_ms,
-                    "trace2_time_ms": trace2_time_ms,
-                    "time_ratio": time_ratio,
-                    "ratio": ratio,
-                    "fused_by": fused_by,
-                    "groups_affected": stats["groups_with_diff"],
-                    "total_groups": stats["total_groups"],
-                }
-            )
+    amd_fuses = sum(1 for p in patterns if p.fused_platform == "AMD")
+    nvidia_fuses = sum(1 for p in patterns if p.fused_platform == "NVIDIA")
 
-    # ADDITIONAL: Check global counts for significant differences not captured above
-    # This catches patterns like Sort that may be in small groups or distributed differently
-    for ktype in all_ktypes:
-        # Skip if already added from correlation group analysis
-        if any(opp["kernel_type"] == ktype for opp in results["fusion_opportunities"]):
-            continue
+    return FusionAnalysis(
+        patterns=patterns,
+        summary={
+            "amd_fuses": amd_fuses,
+            "nvidia_fuses": nvidia_fuses,
+            "total_fusion_opportunities": len(patterns),
+        },
+    )
 
-        trace1_total = global_trace1_counts.get(ktype, 0)
-        trace2_total = global_trace2_counts.get(ktype, 0)
 
-        # Skip trivial counts
-        if trace1_total + trace2_total < 100:
-            continue
+def analyze_fusion_from_alignment(
+    layer_alignments: list[Any],
+    amd_kernels: list[dict] | None = None,
+    nvidia_kernels: list[dict] | None = None,
+) -> dict[str, Any]:
+    """Analyze fusion from kernel data (for API compatibility).
 
-        # Calculate global ratio
-        global_ratio = trace1_total / trace2_total if trace2_total > 0 else float("inf")
-        global_reverse_ratio = trace2_total / trace1_total if trace1_total > 0 else float("inf")
+    Args:
+        layer_alignments: List of aligned layers (unused - kept for API compatibility)
+        amd_kernels: Optional list of AMD kernel events for pattern-based analysis
+        nvidia_kernels: Optional list of NVIDIA kernel events for pattern-based analysis
 
-        # Check if globally significant (more aggressive threshold for comprehensive detection)
-        is_globally_significant = (
-            (global_ratio > 2.0 or global_reverse_ratio > 2.0)
-            and (trace1_total + trace2_total > 100)
+    Returns:
+        Dictionary with fusion analysis results
+    """
+    # If raw kernels provided, use pattern-based analysis (preferred)
+    if amd_kernels is not None and nvidia_kernels is not None:
+        fusion_analysis = detect_fusion_patterns(amd_kernels, nvidia_kernels)
+    else:
+        # Fallback: empty analysis if no kernel data
+        fusion_analysis = FusionAnalysis(
+            patterns=[],
+            summary={"amd_fuses": 0, "nvidia_fuses": 0, "total_fusion_opportunities": 0},
         )
 
-        if is_globally_significant:
-            # Get timing info from all kernels (not just matched groups)
-            trace1_time = sum(
-                k.get("dur", 0) for k in trace1_kernels
-                if classify_kernel(k.get("name", "")) == ktype
-            ) / 1000  # Convert to ms
-            trace2_time = sum(
-                k.get("dur", 0) for k in trace2_kernels
-                if classify_kernel(k.get("name", "")) == ktype
-            ) / 1000
-
-            # Determine who fuses (who has FEWER calls = more fusion)
-            if global_ratio > 1.5:
-                fused_by = "Trace 2"  # Trace 2 has fewer calls
-                ratio = global_ratio
-            else:
-                fused_by = "Trace 1"  # Trace 1 has fewer calls
-                ratio = global_reverse_ratio
-
-            time_ratio = trace1_time / trace2_time if trace2_time > 0 else float("inf")
-
-            results["fusion_opportunities"].append(
-                {
-                    "kernel_type": ktype,
-                    "trace1_total": trace1_total,
-                    "trace2_total": trace2_total,
-                    "trace1_avg_per_group": trace1_total / len(matches) if matches else 0,
-                    "trace2_avg_per_group": trace2_total / len(matches) if matches else 0,
-                    "trace1_time_ms": trace1_time,
-                    "trace2_time_ms": trace2_time,
-                    "time_ratio": time_ratio,
-                    "ratio": ratio,
-                    "fused_by": fused_by,
-                    "groups_affected": 0,  # Unknown for global analysis
-                    "total_groups": len(matches),
-                }
-            )
-
-    # Sort by impact (ratio * total count)
-    results["fusion_opportunities"].sort(
-        key=lambda x: x["ratio"] * (x["trace1_total"] + x["trace2_total"]), reverse=True
-    )
-
-    # ADD PARTIAL FUSION MAPPINGS using correlation group differential analysis
-    # This catches patterns like Sort that exist on both platforms but with different frequencies
-    partial_mappings = _find_partial_fusion_via_groups(
-        trace1_large,
-        trace2_large,
-        matches,
-        trace1_name=trace1_platform,
-        trace2_name=trace2_platform
-    )
-    all_fusion_mappings.extend(partial_mappings)
-
-    # DETECT INTRA-TYPE FUSION (same kernel type fused with itself, like Sort chains)
-    # Do this FIRST since it's more accurate than the fallback global analysis
-    intra_mappings = _detect_intra_type_fusion(
-        trace1_kernels,
-        trace2_kernels,
-        trace1_name=trace1_platform,
-        trace2_name=trace2_platform
-    )
-    all_fusion_mappings.extend(intra_mappings)
-
-    # Collect kernel types already handled by intra-type fusion
-    intra_handled_types = set(m["fused_kernel_type"] for m in intra_mappings)
-
-    # ALSO ADD GLOBAL FUSION MAPPINGS for kernels not in large correlation groups
-    # Skip types already handled by intra-type fusion (more accurate)
-    global_mappings = _find_fusion_mappings(
-        trace1_kernels,
-        trace2_kernels,
-        trace1_name=trace1_platform,
-        trace2_name=trace2_platform
-    )
-    # Filter: skip if already handled or if evidence is duplicate
-    existing_evidence = set(m["evidence"] for m in all_fusion_mappings)
-    for mapping in global_mappings:
-        ktype = mapping["unfused_sequence"][0] if mapping["unfused_sequence"] else None
-        if ktype not in intra_handled_types and mapping["evidence"] not in existing_evidence:
-            all_fusion_mappings.append(mapping)
-
-    return results
+    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,
+    }