machine-dialect 0.1.0a1__py3-none-any.whl

machine_dialect/mir/reporting/report_formatter.py

@@ -0,0 +1,289 @@
+"""Report formatters for optimization reports.
+
+This module provides different output formats for optimization reports
+including text, HTML, and JSON.
+"""
+
+import json
+from abc import ABC, abstractmethod
+from typing import Any
+
+from machine_dialect.mir.reporting.optimization_reporter import ModuleMetrics
+
+
+class ReportFormatter(ABC):
+    """Abstract base class for report formatters."""
+
+    @abstractmethod
+    def format(self, metrics: ModuleMetrics) -> str:
+        """Format the metrics into a report.
+
+        Args:
+            metrics: Module metrics to format.
+
+        Returns:
+            Formatted report as a string.
+        """
+        pass
+
+
+class TextReportFormatter(ReportFormatter):
+    """Formats reports as plain text."""
+
+    def __init__(self, detailed: bool = True) -> None:
+        """Initialize text formatter.
+
+        Args:
+            detailed: Whether to include detailed per-pass statistics.
+        """
+        self.detailed = detailed
+
+    def format(self, metrics: ModuleMetrics) -> str:
+        """Format metrics as text report.
+
+        Args:
+            metrics: Module metrics.
+
+        Returns:
+            Text report.
+        """
+        lines = []
+        summary = metrics.get_summary()
+
+        # Header
+        lines.append("=" * 70)
+        lines.append(f"OPTIMIZATION REPORT - {summary['module_name']}")
+        lines.append("=" * 70)
+        lines.append("")
+
+        # Summary section
+        lines.append("SUMMARY")
+        lines.append("-" * 30)
+        lines.append(f"Optimization Level: {summary['optimization_level']}")
+        lines.append(f"Total Passes Run: {summary['total_passes']}")
+        lines.append(f"Total Time: {summary['total_time_ms']:.2f}ms")
+
+        if summary["total_time_ms"] > 0:
+            avg_time = summary["total_time_ms"] / summary["total_passes"]
+            lines.append(f"Average Pass Time: {avg_time:.2f}ms")
+        lines.append("")
+
+        # Passes applied
+        if summary["passes_applied"]:
+            lines.append("PASSES APPLIED")
+            lines.append("-" * 30)
+            for i, pass_name in enumerate(summary["passes_applied"], 1):
+                lines.append(f"{i:2}. {pass_name}")
+            lines.append("")
+
+        # Overall improvements
+        if summary["improvements"]:
+            lines.append("OVERALL IMPROVEMENTS")
+            lines.append("-" * 30)
+            for metric, improvement in sorted(summary["improvements"].items()):
+                if improvement > 0:
+                    lines.append(f"  {metric:30} {improvement:6.1f}% reduction")
+                elif improvement < 0:
+                    lines.append(f"  {metric:30} {-improvement:6.1f}% increase")
+            lines.append("")
+
+        # Total metrics
+        if summary["total_metrics"]:
+            lines.append("TOTAL OPTIMIZATIONS")
+            lines.append("-" * 30)
+            for metric, value in sorted(summary["total_metrics"].items()):
+                if value > 0:
+                    lines.append(f"  {metric:30} {value:6}")
+            lines.append("")
+
+        # Detailed pass statistics
+        if self.detailed and metrics.pass_metrics:
+            lines.append("=" * 70)
+            lines.append("DETAILED PASS STATISTICS")
+            lines.append("=" * 70)
+
+            for i, pass_metrics in enumerate(metrics.pass_metrics, 1):
+                lines.append("")
+                lines.append(f"[{i}] {pass_metrics.pass_name}")
+                lines.append("-" * 50)
+                lines.append(f"    Phase: {pass_metrics.phase}")
+                lines.append(f"    Time: {pass_metrics.time_ms:.2f}ms")
+
+                if pass_metrics.metrics:
+                    lines.append("    Changes:")
+                    for key, value in sorted(pass_metrics.metrics.items()):
+                        if value > 0:
+                            lines.append(f"      - {key}: {value}")
+
+                # Calculate improvements
+                improvements = []
+                for key in pass_metrics.before_stats:
+                    if key in pass_metrics.after_stats:
+                        before = pass_metrics.before_stats[key]
+                        after = pass_metrics.after_stats[key]
+                        if before != after:
+                            improvement = pass_metrics.get_improvement(key)
+                            improvements.append((key, before, after, improvement))
+
+                if improvements:
+                    lines.append("    Impact:")
+                    for key, before, after, improvement in improvements:
+                        if improvement > 0:
+                            lines.append(f"      - {key}: {before} → {after} (-{improvement:.1f}%)")
+                        else:
+                            lines.append(f"      - {key}: {before} → {after} (+{-improvement:.1f}%)")
+
+        # Function metrics
+        if metrics.function_metrics:
+            lines.append("")
+            lines.append("=" * 70)
+            lines.append("FUNCTION-LEVEL STATISTICS")
+            lines.append("=" * 70)
+
+            for func_name, func_metrics in metrics.function_metrics.items():
+                lines.append("")
+                lines.append(f"Function: {func_name}")
+                lines.append("-" * 30)
+                for key, value in sorted(func_metrics.items()):
+                    lines.append(f"  {key:20} {value}")
+
+        lines.append("")
+        lines.append("=" * 70)
+        return "\n".join(lines)
+
+
+class HTMLReportFormatter(ReportFormatter):
+    """Formats reports as HTML."""
+
+    def format(self, metrics: ModuleMetrics) -> str:
+        """Format metrics as HTML report.
+
+        Args:
+            metrics: Module metrics.
+
+        Returns:
+            HTML report.
+        """
+        summary = metrics.get_summary()
+
+        html = []
+        html.append("<!DOCTYPE html>")
+        html.append("<html>")
+        html.append("<head>")
+        html.append("<title>Optimization Report</title>")
+        html.append("<style>")
+        html.append(
+            """
+            body { font-family: monospace; margin: 20px; }
+            h1 { color: #333; }
+            h2 { color: #666; border-bottom: 2px solid #ddd; }
+            table { border-collapse: collapse; width: 100%; margin: 20px 0; }
+            th, td { border: 1px solid #ddd; padding: 8px; text-align: left; }
+            th { background-color: #f2f2f2; }
+            .improvement { color: green; font-weight: bold; }
+            .regression { color: red; font-weight: bold; }
+            .metric { background-color: #f9f9f9; }
+            .pass-header { background-color: #e9e9e9; font-weight: bold; }
+        """
+        )
+        html.append("</style>")
+        html.append("</head>")
+        html.append("<body>")
+
+        # Header
+        html.append(f"<h1>Optimization Report - {summary['module_name']}</h1>")
+
+        # Summary
+        html.append("<h2>Summary</h2>")
+        html.append("<table>")
+        html.append(f"<tr><td>Optimization Level</td><td>{summary['optimization_level']}</td></tr>")
+        html.append(f"<tr><td>Total Passes</td><td>{summary['total_passes']}</td></tr>")
+        html.append(f"<tr><td>Total Time</td><td>{summary['total_time_ms']:.2f}ms</td></tr>")
+        html.append("</table>")
+
+        # Passes Applied
+        if summary["passes_applied"]:
+            html.append("<h2>Passes Applied</h2>")
+            html.append("<ol>")
+            for pass_name in summary["passes_applied"]:
+                html.append(f"<li>{pass_name}</li>")
+            html.append("</ol>")
+
+        # Improvements
+        if summary["improvements"]:
+            html.append("<h2>Overall Improvements</h2>")
+            html.append("<table>")
+            html.append("<tr><th>Metric</th><th>Improvement</th></tr>")
+            for metric, improvement in sorted(summary["improvements"].items()):
+                if improvement > 0:
+                    html.append(f"<tr><td>{metric}</td><td class='improvement'>-{improvement:.1f}%</td></tr>")
+                elif improvement < 0:
+                    html.append(f"<tr><td>{metric}</td><td class='regression'>+{-improvement:.1f}%</td></tr>")
+            html.append("</table>")
+
+        # Detailed Pass Statistics
+        if metrics.pass_metrics:
+            html.append("<h2>Detailed Pass Statistics</h2>")
+            html.append("<table>")
+            html.append("<tr><th>Pass</th><th>Phase</th><th>Time (ms)</th><th>Metrics</th></tr>")
+
+            for pass_metrics in metrics.pass_metrics:
+                metrics_str = ", ".join(f"{k}: {v}" for k, v in pass_metrics.metrics.items() if v > 0)
+                html.append("<tr>")
+                html.append(f"<td>{pass_metrics.pass_name}</td>")
+                html.append(f"<td>{pass_metrics.phase}</td>")
+                html.append(f"<td>{pass_metrics.time_ms:.2f}</td>")
+                html.append(f"<td>{metrics_str or 'N/A'}</td>")
+                html.append("</tr>")
+
+            html.append("</table>")
+
+        html.append("</body>")
+        html.append("</html>")
+
+        return "\n".join(html)
+
+
+class JSONReportFormatter(ReportFormatter):
+    """Formats reports as JSON."""
+
+    def format(self, metrics: ModuleMetrics) -> str:
+        """Format metrics as JSON report.
+
+        Args:
+            metrics: Module metrics.
+
+        Returns:
+            JSON report.
+        """
+        data: dict[str, Any] = {
+            "module_name": metrics.module_name,
+            "optimization_level": metrics.optimization_level,
+            "total_time_ms": metrics.total_time_ms,
+            "summary": metrics.get_summary(),
+            "passes": [],
+            "functions": metrics.function_metrics,
+        }
+
+        # Add detailed pass information
+        for pass_metrics in metrics.pass_metrics:
+            pass_data: dict[str, Any] = {
+                "name": pass_metrics.pass_name,
+                "phase": pass_metrics.phase,
+                "time_ms": pass_metrics.time_ms,
+                "metrics": pass_metrics.metrics,
+                "before_stats": pass_metrics.before_stats,
+                "after_stats": pass_metrics.after_stats,
+                "improvements": {},
+            }
+
+            # Calculate improvements
+            for key in pass_metrics.before_stats:
+                if key in pass_metrics.after_stats:
+                    improvement = pass_metrics.get_improvement(key)
+                    if improvement != 0:
+                        pass_data["improvements"][key] = improvement
+
+            data["passes"].append(pass_data)
+
+        return json.dumps(data, indent=2)

machine_dialect/mir/ssa_construction.py

@@ -0,0 +1,342 @@
+"""SSA (Static Single Assignment) construction for MIR.
+
+This module implements SSA construction with dominance frontier calculation
+and phi node insertion for the MIR representation.
+"""
+
+from collections import OrderedDict, defaultdict
+
+from machine_dialect.mir.basic_block import CFG, BasicBlock
+from machine_dialect.mir.mir_function import MIRFunction
+from machine_dialect.mir.mir_instructions import Copy, LoadConst, LoadVar, MIRInstruction, Phi, StoreVar
+from machine_dialect.mir.mir_values import Variable
+
+
+class DominanceInfo:
+    """Dominance information for a control flow graph."""
+
+    def __init__(self, cfg: CFG) -> None:
+        """Initialize dominance information.
+
+        Args:
+            cfg: The control flow graph to analyze.
+        """
+        self.cfg = cfg
+        self.dominators: dict[BasicBlock, set[BasicBlock]] = {}
+        self.immediate_dominators: dict[BasicBlock, BasicBlock | None] = {}
+        self.dominance_frontier: dict[BasicBlock, set[BasicBlock]] = {}
+        self.dominator_tree_children: dict[BasicBlock, set[BasicBlock]] = defaultdict(set)
+
+        self._compute_dominators()
+        self._compute_immediate_dominators()
+        self._compute_dominance_frontier()
+
+    def _compute_dominators(self) -> None:
+        """Compute dominators for all blocks using iterative algorithm."""
+        entry = self.cfg.entry_block
+        if not entry:
+            return
+
+        # Initialize dominators
+        blocks = list(self.cfg.blocks.values())
+        self.dominators[entry] = {entry}
+
+        # All other blocks are initially dominated by all blocks
+        for block in blocks:
+            if block != entry:
+                self.dominators[block] = set(blocks)
+
+        # Iterate until fixed point
+        changed = True
+        while changed:
+            changed = False
+            for block in blocks:
+                if block == entry:
+                    continue
+
+                # Compute new dominators
+                new_doms = set(blocks)
+                for pred in block.predecessors:
+                    if pred in self.dominators:
+                        new_doms &= self.dominators[pred]
+                new_doms.add(block)
+
+                # Check if changed
+                if new_doms != self.dominators[block]:
+                    self.dominators[block] = new_doms
+                    changed = True
+
+    def _compute_immediate_dominators(self) -> None:
+        """Compute immediate dominators from dominator sets."""
+        for block in self.dominators:
+            # Immediate dominator is the unique dominator that doesn't
+            # dominate any other dominators
+            doms = self.dominators[block] - {block}
+            if not doms:
+                self.immediate_dominators[block] = None
+                continue
+
+            # Find the immediate dominator
+            idom = None
+            for dom in doms:
+                # Check if dom dominates any other dominator
+                is_immediate = True
+                for other in doms:
+                    if other != dom and dom in self.dominators.get(other, set()):
+                        is_immediate = False
+                        break
+                if is_immediate:
+                    idom = dom
+                    break
+
+            self.immediate_dominators[block] = idom
+            if idom:
+                self.dominator_tree_children[idom].add(block)
+
+    def _compute_dominance_frontier(self) -> None:
+        """Compute dominance frontier for all blocks."""
+        # Initialize empty frontiers
+        for block in self.dominators:
+            self.dominance_frontier[block] = set()
+
+        # For each block
+        for block in self.dominators:
+            # Check each successor
+            for succ in block.successors:
+                # Walk up dominator tree from block
+                runner: BasicBlock | None = block
+                while runner and runner != self.immediate_dominators.get(succ):
+                    self.dominance_frontier[runner].add(succ)
+                    runner = self.immediate_dominators.get(runner)
+
+    def dominates(self, a: BasicBlock, b: BasicBlock) -> bool:
+        """Check if block a dominates block b.
+
+        Args:
+            a: Potential dominator block.
+            b: Block to check.
+
+        Returns:
+            True if a dominates b.
+        """
+        return a in self.dominators.get(b, set())
+
+    def strictly_dominates(self, a: BasicBlock, b: BasicBlock) -> bool:
+        """Check if block a strictly dominates block b.
+
+        Args:
+            a: Potential dominator block.
+            b: Block to check.
+
+        Returns:
+            True if a strictly dominates b (dominates and a != b).
+        """
+        return a != b and self.dominates(a, b)
+
+
+class SSAConstructor:
+    """Constructs SSA form for MIR functions."""
+
+    def __init__(self, function: MIRFunction) -> None:
+        """Initialize SSA constructor.
+
+        Args:
+            function: The function to convert to SSA form.
+        """
+        self.function = function
+        self.dominance = DominanceInfo(function.cfg)
+        self.variable_definitions: dict[Variable, set[BasicBlock]] = defaultdict(set)
+        self.variable_uses: dict[Variable, set[BasicBlock]] = defaultdict(set)
+        self.phi_nodes: dict[tuple[BasicBlock, Variable], Phi] = {}
+        self.variable_stacks: dict[Variable, list[Variable]] = defaultdict(list)
+        self.version_counters: dict[str, int] = defaultdict(int)
+
+    def construct_ssa(self) -> None:
+        """Convert the function to SSA form."""
+        self._collect_variable_info()
+        self._insert_phi_nodes()
+        self._rename_variables()
+
+    def _collect_variable_info(self) -> None:
+        """Collect information about variable definitions and uses."""
+        for block in self.function.cfg.blocks.values():
+            for inst in block.instructions:
+                # Check for variable definitions
+                for def_val in inst.get_defs():
+                    if isinstance(def_val, Variable):
+                        self.variable_definitions[def_val].add(block)
+
+                # Check for variable uses
+                for use_val in inst.get_uses():
+                    if isinstance(use_val, Variable):
+                        self.variable_uses[use_val].add(block)
+
+    def _insert_phi_nodes(self) -> None:
+        """Insert phi nodes at dominance frontiers."""
+        # For each variable
+        for var in self.variable_definitions:
+            # Get blocks where variable is defined
+            def_blocks = self.variable_definitions[var]
+
+            # Compute iterated dominance frontier
+            worklist = list(def_blocks)
+            phi_blocks = set()
+            processed = set()
+
+            while worklist:
+                block = worklist.pop()
+                if block in processed:
+                    continue
+                processed.add(block)
+
+                # Add phi nodes at dominance frontier
+                for df_block in self.dominance.dominance_frontier.get(block, set()):
+                    if df_block not in phi_blocks:
+                        phi_blocks.add(df_block)
+
+                        # Create phi node
+                        phi_var = self._new_version(var)
+                        # TODO: Review if (0, 0) is the best approach for generated phi nodes' source location
+                        phi = Phi(phi_var, [], (0, 0))  # Default source location for generated phi nodes
+
+                        # Insert phi in phi_nodes list
+                        df_block.phi_nodes.append(phi)
+                        self.phi_nodes[(df_block, var)] = phi
+
+                        # Phi node is also a definition
+                        if df_block not in def_blocks:
+                            worklist.append(df_block)
+
+    def _rename_variables(self) -> None:
+        """Rename variables to SSA form."""
+        entry = self.function.cfg.entry_block
+        if entry:
+            self._rename_block(entry, set())
+
+    def _rename_block(self, block: BasicBlock, visited: set[BasicBlock]) -> None:
+        """Rename variables in a block and its dominated blocks.
+
+        Args:
+            block: The block to process.
+            visited: Set of already visited blocks.
+        """
+        if block in visited:
+            return
+        visited.add(block)
+
+        # Save stack state
+        stack_state: dict[Variable, int] = {}
+        for var in self.variable_stacks:
+            stack_state[var] = len(self.variable_stacks[var])
+
+        # Process phi nodes first
+        for phi in block.phi_nodes:
+            # Find original variable for this phi
+            for (phi_block, var), stored_phi in self.phi_nodes.items():
+                if phi_block == block and stored_phi == phi:
+                    # Push new version (phi.dest is MIRValue but should be Variable)
+                    if isinstance(phi.dest, Variable):
+                        self.variable_stacks[var].append(phi.dest)
+                    break
+
+        # Rebuild instruction list, preserving LoadConst and other non-Variable instructions
+        new_instructions: list[MIRInstruction] = []
+        temp_definitions = OrderedDict()  # Track LoadConst for ordering
+
+        # Rename uses and definitions
+        for inst in block.instructions:
+            if isinstance(inst, Phi):
+                continue  # Already handled in phi_nodes list
+
+            # Special handling for LoadConst - preserve as-is
+            if isinstance(inst, LoadConst):
+                # LoadConst defines a Temp, not a Variable, so don't rename
+                # Just preserve the instruction
+                new_instructions.append(inst)
+                if hasattr(inst.dest, "name"):
+                    temp_definitions[inst.dest] = inst
+                continue
+
+            # Rename uses for Variable-based instructions
+            if isinstance(inst, StoreVar):
+                # Special case: StoreVar uses source, defines var
+                if isinstance(inst.source, Variable):
+                    if self.variable_stacks[inst.source]:
+                        inst.source = self.variable_stacks[inst.source][-1]
+            elif isinstance(inst, LoadVar):
+                # Special case: LoadVar uses var, defines dest
+                if self.variable_stacks[inst.var]:
+                    inst.var = self.variable_stacks[inst.var][-1]
+            else:
+                # General case: rename all uses
+                for use_val in inst.get_uses():
+                    if isinstance(use_val, Variable):
+                        if self.variable_stacks[use_val]:
+                            inst.replace_use(use_val, self.variable_stacks[use_val][-1])
+
+            # Rename definitions
+            for def_val in inst.get_defs():
+                if isinstance(def_val, Variable):
+                    new_var = self._new_version(def_val)
+                    if isinstance(inst, StoreVar):
+                        inst.var = new_var
+                    elif isinstance(inst, Copy) and inst.dest == def_val:
+                        inst.dest = new_var
+                    # Push new version
+                    self.variable_stacks[def_val].append(new_var)
+
+            new_instructions.append(inst)
+
+        # Replace the instruction list with the rebuilt one
+        block.instructions = new_instructions
+
+        # Update phi nodes in successors
+        for succ in block.successors:
+            # Phi nodes are now in the phi_nodes list, not instructions
+            for phi in succ.phi_nodes:
+                # Find original variable for this phi
+                for (phi_block, var), stored_phi in self.phi_nodes.items():
+                    if phi_block == succ and stored_phi == phi:
+                        # Add incoming value from this block
+                        if self.variable_stacks[var]:
+                            phi.add_incoming(
+                                self.variable_stacks[var][-1],
+                                block.label,
+                            )
+                        break
+
+        # Process dominated blocks
+        for child in self.dominance.dominator_tree_children.get(block, set()):
+            self._rename_block(child, visited)
+
+        # Restore stack state
+        for var, old_size in stack_state.items():
+            while len(self.variable_stacks[var]) > old_size:
+                self.variable_stacks[var].pop()
+
+    def _new_version(self, var: Variable) -> Variable:
+        """Create a new SSA version of a variable.
+
+        Args:
+            var: The original variable.
+
+        Returns:
+            A new versioned variable.
+        """
+        base_name = var.name
+        version = self.version_counters[base_name]
+        self.version_counters[base_name] += 1
+
+        # Create new variable with version number
+        new_var = Variable(base_name, var.type, version=version)
+        return new_var
+
+
+def construct_ssa(function: MIRFunction) -> None:
+    """Convert a MIR function to SSA form.
+
+    Args:
+        function: The function to convert.
+    """
+    constructor = SSAConstructor(function)
+    constructor.construct_ssa()

machine_dialect/mir/tests/__init__.py

@@ -0,0 +1 @@
+"""Tests for Machine Dialect™ MIR."""