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

wafer_core/lib/trace_compare/same_kernel_analyzer.py

@@ -0,0 +1,119 @@
+"""Same kernel analysis - comparing identical kernel names across platforms.
+
+Identifies kernels where AMD and NVIDIA use the same kernel name/pattern
+and compares their performance directly.
+"""
+
+from collections import defaultdict
+from dataclasses import dataclass, field
+from typing import Any
+
+from .aligner import KernelPair, LayerAlignment
+
+
+@dataclass
+class SameKernelComparison:
+    """Comparison of identical kernels across platforms."""
+
+    layer: int
+    kernel_name: str
+    operation: str
+    amd_avg_us: float
+    nvidia_avg_us: float
+    ratio: float
+    gap_us: float
+    amd_count: int
+    nvidia_count: int
+
+
+@dataclass
+class SameKernelAnalysis:
+    """Complete same kernel analysis result."""
+
+    kernels: list[SameKernelComparison] = field(default_factory=list)
+    summary: dict[str, Any] = field(default_factory=dict)
+
+
+def analyze_same_kernels(
+    layer_alignments: list[LayerAlignment],
+) -> SameKernelAnalysis:
+    """Find and compare kernels with identical names across platforms.
+
+    Args:
+        layer_alignments: List of aligned layers
+
+    Returns:
+        SameKernelAnalysis with comparisons
+    """
+    same_kernels: list[SameKernelComparison] = []
+
+    for layer_alignment in layer_alignments:
+        for pair in layer_alignment.kernel_pairs:
+            if pair.is_same_kernel and pair.amd_kernel and pair.nvidia_kernel:
+                same_kernels.append(
+                    SameKernelComparison(
+                        layer=layer_alignment.layer,
+                        kernel_name=pair.amd_kernel,
+                        operation=pair.operation,
+                        amd_avg_us=pair.amd_avg_us,
+                        nvidia_avg_us=pair.nvidia_avg_us,
+                        ratio=pair.ratio,
+                        gap_us=pair.gap_us,
+                        amd_count=pair.amd_count,
+                        nvidia_count=pair.nvidia_count,
+                    )
+                )
+
+    if same_kernels:
+        ratios = [k.ratio for k in same_kernels if k.ratio != float("inf")]
+        avg_ratio = sum(ratios) / len(ratios) if ratios else 1.0
+        amd_faster = sum(1 for k in same_kernels if k.ratio < 1.0)
+        nvidia_faster = sum(1 for k in same_kernels if k.ratio > 1.0)
+    else:
+        avg_ratio = 1.0
+        amd_faster = 0
+        nvidia_faster = 0
+
+    return SameKernelAnalysis(
+        kernels=same_kernels,
+        summary={
+            "total_same_kernels": len(same_kernels),
+            "avg_ratio": avg_ratio,
+            "kernels_where_amd_faster": amd_faster,
+            "kernels_where_nvidia_faster": nvidia_faster,
+        },
+    )
+
+
+def analyze_same_kernels_from_alignment(
+    layer_alignments: list[LayerAlignment],
+) -> dict[str, Any]:
+    """Analyze same kernels from alignment data (for API compatibility).
+
+    Args:
+        layer_alignments: List of aligned layers
+
+    Returns:
+        Dictionary with same kernel analysis results
+    """
+    analysis = analyze_same_kernels(layer_alignments)
+
+    kernels = [
+        {
+            "layer": k.layer,
+            "kernel_name": k.kernel_name,
+            "operation": k.operation,
+            "amd_avg_us": k.amd_avg_us,
+            "nvidia_avg_us": k.nvidia_avg_us,
+            "ratio": k.ratio,
+            "gap_us": k.gap_us,
+            "amd_count": k.amd_count,
+            "nvidia_count": k.nvidia_count,
+        }
+        for k in analysis.kernels
+    ]
+
+    return {
+        "kernels": kernels,
+        "summary": analysis.summary,
+    }

wafer_core/lib/trace_compare/warnings.py

@@ -0,0 +1,99 @@
+"""Warning detection and reporting for trace analysis.
+
+Detects issues with trace data quality and provides actionable suggestions.
+"""
+
+from dataclasses import dataclass
+from typing import Literal
+
+
+@dataclass(frozen=True)
+class TraceWarning:
+    """A warning about trace data quality or analysis limitations."""
+
+    code: str  # e.g., "NO_PHASE_ANNOTATIONS", "NO_PYTHON_STACKS"
+    severity: Literal["info", "warning", "error"]
+    message: str
+    suggestion: str
+
+
+def detect_warnings(
+    events: list[dict],
+    kernel_names: list[str],
+    phases: list[dict] | None = None,
+    layers_detected: int = 0,
+    total_kernels: int = 0,
+) -> list[TraceWarning]:
+    """Detect warnings from trace data.
+    
+    Args:
+        events: All trace events
+        kernel_names: List of all kernel names
+        phases: Optional list of phase events (for checking phase annotations)
+        layers_detected: Number of layers detected
+        total_kernels: Total number of kernels
+        
+    Returns:
+        List of warnings
+    """
+    warnings: list[TraceWarning] = []
+    
+    # Check for phase annotations
+    has_phase_annotations = any(
+        ev.get("cat") == "user_annotation" and ev.get("name", "").startswith("execute_context")
+        for ev in events
+    )
+    
+    if not has_phase_annotations:
+        warnings.append(
+            TraceWarning(
+                code="NO_PHASE_ANNOTATIONS",
+                severity="warning",
+                message="No vLLM phase annotations found. Phase analysis (prefill/decode) will be unavailable.",
+                suggestion="Ensure you're using vLLM v1.0+ with profiling enabled. Re-profile with torch.profiler.profile() to capture phase markers.",
+            )
+        )
+    
+    # Check for Python stack traces
+    has_python_stacks = any(
+        ev.get("cat") == "python_function"
+        for ev in events
+    )
+    
+    if not has_python_stacks:
+        warnings.append(
+            TraceWarning(
+                code="NO_PYTHON_STACKS",
+                severity="info",
+                message="No Python stack traces available. CPU→kernel mapping will be limited.",
+                suggestion="Re-profile with with_stack=True: torch.profiler.profile(with_stack=True) for better CPU operator identification.",
+            )
+        )
+    
+    # Check for high percentage of unknown kernels
+    if total_kernels > 0:
+        unknown_count = sum(1 for name in kernel_names if "unknown" in name.lower() or name == "Other")
+        unknown_percentage = (unknown_count / total_kernels) * 100
+        
+        if unknown_percentage > 20:
+            warnings.append(
+                TraceWarning(
+                    code="HIGH_UNKNOWN_KERNELS",
+                    severity="warning",
+                    message=f"{unknown_percentage:.1f}% of kernels are classified as 'Unknown'. Kernel registry may be outdated.",
+                    suggestion="Update kernel pattern registry or report unrecognized kernel patterns for support.",
+                )
+            )
+    
+    # Check for layer detection failure
+    if layers_detected == 0 and total_kernels > 100:
+        warnings.append(
+            TraceWarning(
+                code="LAYER_DETECTION_FAILED",
+                severity="warning",
+                message="No transformer layers detected. Layer-wise analysis unavailable.",
+                suggestion="This may indicate a non-transformer model (e.g., SSM/Mamba) or insufficient correlation data. Check model architecture.",
+            )
+        )
+    
+    return warnings

{wafer_core-0.1.26.dist-info → wafer_core-0.1.27.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wafer-core
-Version: 0.1.26
+Version: 0.1.27
 Summary: Core utilities and environments for Wafer GPU kernel optimization
 Requires-Python: >=3.10
 Requires-Dist: aiohttp>=3.9.0
@@ -15,12 +15,14 @@ Requires-Dist: dash-svg>=0.0.11
 Requires-Dist: dash>=3.0.0
 Requires-Dist: dnspython>=2.8.0
 Requires-Dist: httpx>=0.25.0
+Requires-Dist: ijson>=3.2.0
 Requires-Dist: kaleido==0.2.1
 Requires-Dist: markdownify>=0.11.0
 Requires-Dist: matplotlib>=3.0.0
 Requires-Dist: modal>=0.64.0
 Requires-Dist: numpy>=1.17.5
 Requires-Dist: openai>=1.0.0
+Requires-Dist: orjson>=3.9.0
 Requires-Dist: pandas~=3.0.0
 Requires-Dist: paramiko>=3.0.0
 Requires-Dist: paramiko>=3.4.0

{wafer_core-0.1.26.dist-info → wafer_core-0.1.27.dist-info}/RECORD

@@ -318,12 +318,20 @@ wafer_core/lib/rocprofiler/systems/run/analyzer.py,sha256=Qg3M8-kCKdV82ehn6Ta20N
 wafer_core/lib/rocprofiler/systems/run/profiler.py,sha256=aiQLsDnfQHSeCM5zLnO4VlbTmREYnAtiuT50Eq6uWfg,8387
 wafer_core/lib/rocprofiler/systems/sample/__init__.py,sha256=31rNmLPQ7OVhvlOEEOwPKgk8_qrCidj6AmzDXexQJ_o,288
 wafer_core/lib/rocprofiler/systems/sample/profiler.py,sha256=CYZPTzNXd48LoCfmY6h_5RSYEdWYccuv3-t4YncHJLE,7384
-wafer_core/lib/trace_compare/__init__.py,sha256=G5vmiQnuweiF9vjK1FC4ZIy-tzuHiaLMs7QBnir8OJw,800
-wafer_core/lib/trace_compare/analyzer.py,sha256=o0SI1PsehpgxeUPQEB9708W_Q_ILiO5apgqVLe2xE8A,14541
-wafer_core/lib/trace_compare/classifier.py,sha256=sE1K007GVk_Up2g59SVUIZ7BThf0yHNjGsZ9AyM_Ah8,6028
+wafer_core/lib/trace_compare/PERFORMANCE.md,sha256=jkJh7ApZi8H7NKTcz8v0LNtwSFtIUqY88e3QbL749ww,3823
+wafer_core/lib/trace_compare/__init__.py,sha256=CyUPbPQDYhVLCFFA7S_jNSilG3OgqYjmHSKfR5X11go,1377
+wafer_core/lib/trace_compare/aligner.py,sha256=6HplOHCUIb0cMXA-Lu-91T-hKVTMK4bk8Ei-v7HE1G4,13471
+wafer_core/lib/trace_compare/analyzer.py,sha256=m-waAiU5S72M9J4kUwIy9fPWUecg_oOUczri8Na6xUY,29360
+wafer_core/lib/trace_compare/api.py,sha256=JSRTcd7eZK1Z8l18TFEiA5A8ENJS1TMz7oIiw1KBbAs,8796
+wafer_core/lib/trace_compare/architecture.py,sha256=8bqlAJQeJLBHblyXvFV-w55PIKiVQDPjDQZ8Jx4tuGg,2110
+wafer_core/lib/trace_compare/classifier.py,sha256=CDGzY9TY-I5wRuEGsu4mTCdljqVTOnLWyFLyNgmkGXI,16864
 wafer_core/lib/trace_compare/formatter.py,sha256=GNrCZ45ueBN05CEXjOtTuKvTI8z-g-ZZFil-ni3sWVY,37962
-wafer_core/lib/trace_compare/fusion_analyzer.py,sha256=LwYTBjL_gHCvydfgFp-L9f_qfXq3GenJHRemygly4H8,36482
-wafer_core/lib/trace_compare/loader.py,sha256=E7-OS4uMqvJhGLyxKQNnAgK33YECrSjuCssUT_X0LQA,11728
+wafer_core/lib/trace_compare/fusion_analyzer.py,sha256=bD_CJ3JoVg_N6vxJJULd6G8l_-O5qnLuXKDEDItcQtg,15489
+wafer_core/lib/trace_compare/kernel_registry.yaml,sha256=0-knXwsF3pR1x1JdIz-aWaH-5xDgTylh53E47Kf6nHo,9808
+wafer_core/lib/trace_compare/layer_segmentation.py,sha256=kI_Y1e9nrKZfdwfcrGo4h7gpMxqXI_xkgXk46zuFen4,4642
+wafer_core/lib/trace_compare/loader.py,sha256=zBHI0r7CX_wJ2mz0_-s0lm9KGSdaVaq7OKyxUL6KIlw,23997
+wafer_core/lib/trace_compare/same_kernel_analyzer.py,sha256=sp81NJGVJeYdAfRQRgMbB5HcGTOneF1Rau3rbLPfpv4,3489
+wafer_core/lib/trace_compare/warnings.py,sha256=B1HxFt-v1mDqLT2aD5bSm1Yn88bfPYnM-wui0WBF3xM,3548
 wafer_core/lib/tracelens/__init__.py,sha256=AkHdmOnKlBO4RpsAqVVGe7MOfv6E6uhEaC_iKrYeMPI,2002
 wafer_core/lib/tracelens/comparator.py,sha256=71YEPfjBi7_24u1oQuPerNtFsN0sDQ5CT_uBi0XLllw,3460
 wafer_core/lib/tracelens/finder.py,sha256=HpbN8TuRNbbBytPYOmkBkfsFVBReQqVgsvFX-mBrln4,2459
@@ -679,6 +687,6 @@ wafer_core/utils/modal_execution/modal_app.py,sha256=VfS2cX8gHtnlPXemmMcEwDPeQdh
 wafer_core/utils/modal_execution/modal_config.py,sha256=7cGX9TGqilQ3qxI3OFGXV5orjtyRU-PEDOJ4vP2oxno,4421
 wafer_core/utils/modal_execution/modal_execution.py,sha256=gChjnV6jqA3A7IRP3DfvV5cSfm_MN0X4f7JZufXgdZE,24594
 wafer_core/utils/modal_execution/test_modal.py,sha256=_jqou_hrLs1Daf1590Pnb0a_lXMMa2rczAPpW9HpoNQ,8153
-wafer_core-0.1.26.dist-info/METADATA,sha256=xzTIIcsmbJkA06hTdoRb4uXZj2ud1-wnV7EXdLOSOe4,1420
-wafer_core-0.1.26.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-wafer_core-0.1.26.dist-info/RECORD,,
+wafer_core-0.1.27.dist-info/METADATA,sha256=NYiI9hCaVd9RCCAfd8Ys0UwTMju6wiyaT7nsk4gsB8A,1477
+wafer_core-0.1.27.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+wafer_core-0.1.27.dist-info/RECORD,,