machine-dialect 0.1.0a1__py3-none-any.whl

machine_dialect/mir/tests/test_optimization_reporter.py

@@ -0,0 +1,318 @@
+"""Tests for optimization reporter."""
+
+from machine_dialect.mir.reporting.optimization_reporter import (
+    ModuleMetrics,
+    OptimizationReporter,
+    PassMetrics,
+)
+
+
+class TestPassMetrics:
+    """Test PassMetrics functionality."""
+
+    def test_pass_metrics_creation(self) -> None:
+        """Test creating pass metrics."""
+        metrics = PassMetrics(
+            pass_name="constant-propagation",
+            phase="early",
+            metrics={"constants_propagated": 10},
+            before_stats={"instructions": 100},
+            after_stats={"instructions": 90},
+            time_ms=5.5,
+        )
+
+        assert metrics.pass_name == "constant-propagation"
+        assert metrics.phase == "early"
+        assert metrics.metrics["constants_propagated"] == 10
+        assert metrics.time_ms == 5.5
+
+    def test_get_improvement(self) -> None:
+        """Test calculating improvement percentage."""
+        metrics = PassMetrics(
+            pass_name="dce",
+            before_stats={"instructions": 100, "blocks": 10},
+            after_stats={"instructions": 80, "blocks": 8},
+        )
+
+        # 20% reduction in instructions
+        assert metrics.get_improvement("instructions") == 20.0
+
+        # 20% reduction in blocks
+        assert metrics.get_improvement("blocks") == 20.0
+
+        # No change for missing metric
+        assert metrics.get_improvement("missing") == 0.0
+
+    def test_get_improvement_zero_before(self) -> None:
+        """Test improvement calculation with zero before value."""
+        metrics = PassMetrics(
+            pass_name="test",
+            before_stats={"count": 0},
+            after_stats={"count": 10},
+        )
+
+        assert metrics.get_improvement("count") == 0.0
+
+
+class TestModuleMetrics:
+    """Test ModuleMetrics functionality."""
+
+    def test_module_metrics_creation(self) -> None:
+        """Test creating module metrics."""
+        metrics = ModuleMetrics(
+            module_name="test_module",
+            optimization_level=2,
+        )
+
+        assert metrics.module_name == "test_module"
+        assert metrics.optimization_level == 2
+        assert metrics.total_time_ms == 0.0
+        assert len(metrics.pass_metrics) == 0
+
+    def test_add_pass_metrics(self) -> None:
+        """Test adding pass metrics."""
+        module_metrics = ModuleMetrics("test")
+
+        pass1 = PassMetrics("pass1", time_ms=10.0)
+        pass2 = PassMetrics("pass2", time_ms=15.0)
+
+        module_metrics.add_pass_metrics(pass1)
+        module_metrics.add_pass_metrics(pass2)
+
+        assert len(module_metrics.pass_metrics) == 2
+        assert module_metrics.total_time_ms == 25.0
+
+    def test_get_summary(self) -> None:
+        """Test getting module summary."""
+        module_metrics = ModuleMetrics(
+            module_name="test",
+            optimization_level=2,
+        )
+
+        # Add some pass metrics
+        pass1 = PassMetrics(
+            pass_name="constant-propagation",
+            metrics={"constants_propagated": 5},
+            before_stats={"instructions": 100},
+            after_stats={"instructions": 95},
+            time_ms=2.0,
+        )
+
+        pass2 = PassMetrics(
+            pass_name="dce",
+            metrics={"dead_removed": 10},
+            before_stats={"instructions": 95},
+            after_stats={"instructions": 85},
+            time_ms=3.0,
+        )
+
+        module_metrics.add_pass_metrics(pass1)
+        module_metrics.add_pass_metrics(pass2)
+
+        summary = module_metrics.get_summary()
+
+        assert summary["module_name"] == "test"
+        assert summary["optimization_level"] == 2
+        assert summary["total_passes"] == 2
+        assert summary["total_time_ms"] == 5.0
+        assert "constant-propagation" in summary["passes_applied"]
+        assert "dce" in summary["passes_applied"]
+
+        # Check aggregated metrics
+        assert summary["total_metrics"]["constants_propagated"] == 5
+        assert summary["total_metrics"]["dead_removed"] == 10
+
+        # Check improvements
+        assert "instructions" in summary["improvements"]
+
+
+class TestOptimizationReporter:
+    """Test OptimizationReporter functionality."""
+
+    def test_reporter_creation(self) -> None:
+        """Test creating optimization reporter."""
+        reporter = OptimizationReporter("my_module")
+
+        assert reporter.module_metrics.module_name == "my_module"
+        assert reporter.current_pass is None
+
+    def test_pass_tracking(self) -> None:
+        """Test tracking optimization passes."""
+        reporter = OptimizationReporter("test")
+
+        # Start a pass
+        reporter.start_pass(
+            "constant-propagation",
+            phase="early",
+            before_stats={"instructions": 100},
+        )
+
+        assert reporter.current_pass is not None
+        assert reporter.current_pass.pass_name == "constant-propagation"
+
+        # End the pass
+        reporter.end_pass(
+            metrics={"constants_propagated": 5},
+            after_stats={"instructions": 95},
+            time_ms=2.5,
+        )
+
+        assert reporter.current_pass is None
+        assert len(reporter.module_metrics.pass_metrics) == 1
+
+        pass_metrics = reporter.module_metrics.pass_metrics[0]
+        assert pass_metrics.pass_name == "constant-propagation"
+        assert pass_metrics.metrics["constants_propagated"] == 5
+        assert pass_metrics.time_ms == 2.5
+
+    def test_multiple_passes(self) -> None:
+        """Test tracking multiple optimization passes."""
+        reporter = OptimizationReporter("test")
+
+        # First pass
+        reporter.start_pass("pass1", before_stats={"size": 1000})
+        reporter.end_pass(
+            metrics={"changes": 10},
+            after_stats={"size": 900},
+            time_ms=5.0,
+        )
+
+        # Second pass
+        reporter.start_pass("pass2", before_stats={"size": 900})
+        reporter.end_pass(
+            metrics={"changes": 5},
+            after_stats={"size": 850},
+            time_ms=3.0,
+        )
+
+        assert len(reporter.module_metrics.pass_metrics) == 2
+        assert reporter.module_metrics.total_time_ms == 8.0
+
+    def test_function_metrics(self) -> None:
+        """Test adding function-specific metrics."""
+        reporter = OptimizationReporter("test")
+
+        reporter.add_function_metrics(
+            "main",
+            {
+                "instructions": 50,
+                "blocks": 5,
+                "loops": 2,
+            },
+        )
+
+        reporter.add_function_metrics(
+            "helper",
+            {
+                "instructions": 20,
+                "blocks": 2,
+                "loops": 0,
+            },
+        )
+
+        assert len(reporter.module_metrics.function_metrics) == 2
+        assert reporter.module_metrics.function_metrics["main"]["loops"] == 2
+        assert reporter.module_metrics.function_metrics["helper"]["instructions"] == 20
+
+    def test_optimization_level(self) -> None:
+        """Test setting optimization level."""
+        reporter = OptimizationReporter("test")
+        reporter.set_optimization_level(3)
+
+        assert reporter.module_metrics.optimization_level == 3
+
+    def test_generate_summary(self) -> None:
+        """Test generating text summary."""
+        reporter = OptimizationReporter("test_module")
+        reporter.set_optimization_level(2)
+
+        # Add a pass
+        reporter.start_pass(
+            "constant-propagation",
+            before_stats={"instructions": 100},
+        )
+        reporter.end_pass(
+            metrics={"constants_propagated": 10},
+            after_stats={"instructions": 90},
+            time_ms=5.0,
+        )
+
+        summary = reporter.generate_summary()
+
+        assert "Module: test_module" in summary
+        assert "Optimization Level: 2" in summary
+        assert "Total Passes: 1" in summary
+        assert "Total Time: 5.00ms" in summary
+        assert "constant-propagation" in summary
+        assert "instructions: 10.0% reduction" in summary
+        assert "constants_propagated: 10" in summary
+
+    def test_generate_detailed_report(self) -> None:
+        """Test generating detailed report."""
+        reporter = OptimizationReporter("test_module")
+
+        # Add multiple passes
+        reporter.start_pass("pass1", before_stats={"size": 1000})
+        reporter.end_pass(
+            metrics={"optimized": 5},
+            after_stats={"size": 950},
+            time_ms=2.0,
+        )
+
+        reporter.start_pass("pass2", before_stats={"size": 950})
+        reporter.end_pass(
+            metrics={"optimized": 3},
+            after_stats={"size": 920},
+            time_ms=1.5,
+        )
+
+        # Add function metrics
+        reporter.add_function_metrics(
+            "main",
+            {"complexity": 10, "lines": 50},
+        )
+
+        report = reporter.generate_detailed_report()
+
+        assert "OPTIMIZATION REPORT" in report
+        assert "DETAILED PASS STATISTICS" in report
+        assert "Pass: pass1" in report
+        assert "Pass: pass2" in report
+        assert "Time: 2.00ms" in report
+        assert "Time: 1.50ms" in report
+        assert "FUNCTION METRICS" in report
+        assert "Function: main" in report
+        assert "complexity: 10" in report
+
+    def test_get_report_data(self) -> None:
+        """Test getting raw report data."""
+        reporter = OptimizationReporter("test")
+
+        reporter.start_pass("test_pass")
+        reporter.end_pass(metrics={"changes": 5})
+
+        data = reporter.get_report_data()
+
+        assert isinstance(data, ModuleMetrics)
+        assert data.module_name == "test"
+        assert len(data.pass_metrics) == 1
+
+    def test_empty_reporter(self) -> None:
+        """Test reporter with no passes."""
+        reporter = OptimizationReporter("empty")
+
+        summary = reporter.generate_summary()
+
+        assert "Module: empty" in summary
+        assert "Total Passes: 0" in summary
+        assert "Total Time: 0.00ms" in summary
+
+    def test_end_pass_without_start(self) -> None:
+        """Test ending a pass without starting one."""
+        reporter = OptimizationReporter("test")
+
+        # This should not crash
+        reporter.end_pass(metrics={"test": 1})
+
+        # No pass should be recorded
+        assert len(reporter.module_metrics.pass_metrics) == 0

machine_dialect/mir/tests/test_pass_manager.py

@@ -0,0 +1,294 @@
+"""Tests for the pass manager and optimization framework."""
+
+from machine_dialect.mir.basic_block import BasicBlock
+from machine_dialect.mir.mir_function import MIRFunction
+from machine_dialect.mir.mir_instructions import (
+    BinaryOp,
+    LoadConst,
+    Return,
+)
+from machine_dialect.mir.mir_module import MIRModule
+from machine_dialect.mir.mir_types import MIRType
+from machine_dialect.mir.mir_values import Constant, Temp
+from machine_dialect.mir.optimization_config import (
+    OptimizationConfig,
+    OptimizationPipeline,
+)
+from machine_dialect.mir.optimizations import register_all_passes
+from machine_dialect.mir.pass_manager import PassManager
+
+
+def create_test_module() -> MIRModule:
+    """Create a test module with optimization opportunities.
+
+    Returns:
+        A test MIR module.
+    """
+    module = MIRModule("test")
+
+    # Create main function with constant folding opportunities
+    main_func = MIRFunction("main")
+
+    # Create basic blocks
+    entry = BasicBlock("entry")
+    main_func.cfg.add_block(entry)
+    main_func.cfg.set_entry_block(entry)
+
+    # Add instructions with optimization opportunities
+    t0 = Temp(MIRType.INT, 0)
+    t1 = Temp(MIRType.INT, 1)
+    t2 = Temp(MIRType.INT, 2)
+    t3 = Temp(MIRType.INT, 3)
+    t4 = Temp(MIRType.INT, 4)
+
+    # Constant folding opportunity: 2 + 3 = 5
+    entry.add_instruction(LoadConst(t0, Constant(2, MIRType.INT), (1, 1)))
+    entry.add_instruction(LoadConst(t1, Constant(3, MIRType.INT), (1, 1)))
+    entry.add_instruction(BinaryOp(t2, "+", t0, t1, (1, 1)))
+
+    # Strength reduction opportunity: x * 4 -> x << 2
+    entry.add_instruction(LoadConst(t3, Constant(4, MIRType.INT), (1, 1)))
+    entry.add_instruction(BinaryOp(t4, "*", t2, t3, (1, 1)))
+
+    # Return result
+    entry.add_instruction(Return((1, 1), t4))
+
+    module.add_function(main_func)
+    return module
+
+
+def test_pass_manager_creation() -> None:
+    """Test creating a pass manager."""
+    pm = PassManager()
+    assert pm is not None
+    assert pm.registry is not None
+    assert pm.analysis_manager is not None
+    assert pm.scheduler is not None
+
+
+def test_register_passes() -> None:
+    """Test registering optimization passes."""
+    pm = PassManager()
+    register_all_passes(pm)
+
+    # Check that passes are registered
+    passes = pm.registry.list_passes()
+    assert "dce" in passes
+    assert "constant-propagation" in passes
+    assert "cse" in passes
+    assert "strength-reduction" in passes
+    assert "use-def-chains" in passes
+    assert "loop-analysis" in passes
+
+
+def test_optimization_pipeline() -> None:
+    """Test getting optimization pipeline for different levels."""
+    config0 = OptimizationConfig.from_level(0)
+    passes0 = OptimizationPipeline.get_passes(config0)
+    assert len(passes0) == 0  # No optimizations at -O0
+
+    config1 = OptimizationConfig.from_level(1)
+    passes1 = OptimizationPipeline.get_passes(config1)
+    assert "constant-propagation" in passes1
+    assert "dce" in passes1
+
+    config2 = OptimizationConfig.from_level(2)
+    passes2 = OptimizationPipeline.get_passes(config2)
+    assert "cse" in passes2
+    assert len(passes2) > len(passes1)
+
+    config3 = OptimizationConfig.from_level(3)
+    passes3 = OptimizationPipeline.get_passes(config3)
+    assert len(passes3) >= len(passes2)
+
+
+def test_run_optimizations() -> None:
+    """Test running optimizations on a module."""
+    module = create_test_module()
+    pm = PassManager()
+    register_all_passes(pm)
+
+    # Run basic optimizations
+    config = OptimizationConfig.from_level(1)
+    passes = OptimizationPipeline.get_passes(config)
+
+    modified = pm.run_passes(module, passes, config.level)
+    # Module should be modified by optimizations
+    assert modified or len(passes) == 0
+
+    # Check statistics
+    stats = pm.get_statistics()
+    assert isinstance(stats, dict)
+
+
+def test_constant_propagation() -> None:
+    """Test constant propagation pass."""
+    from machine_dialect.mir.optimizations.constant_propagation import (
+        ConstantPropagation,
+    )
+
+    module = create_test_module()
+    func = module.get_function("main")
+    assert func is not None
+
+    # Run constant propagation
+    cp_pass = ConstantPropagation()
+    cp_pass.initialize()
+    cp_pass.run_on_function(func)
+    cp_pass.finalize()
+
+    # Check that constants were propagated
+    stats = cp_pass.get_stats()
+    # May or may not have propagated depending on exact implementation
+    assert stats is not None
+
+
+def test_dead_code_elimination() -> None:
+    """Test dead code elimination pass."""
+    from machine_dialect.mir.analyses.use_def_chains import UseDefChainsAnalysis
+    from machine_dialect.mir.optimizations.dce import DeadCodeElimination
+
+    # Create function with dead code
+    func = MIRFunction("test")
+    entry = BasicBlock("entry")
+    func.cfg.add_block(entry)
+    func.cfg.set_entry_block(entry)
+
+    # Dead instruction: result not used
+    t0 = Temp(MIRType.INT, 0)
+    t1 = Temp(MIRType.INT, 1)
+    entry.add_instruction(LoadConst(t0, Constant(42, MIRType.INT), (1, 1)))
+    entry.add_instruction(BinaryOp(t1, "+", t0, t0, (1, 1)))  # Dead if t1 not used
+    entry.add_instruction(Return((1, 1), t0))  # Only t0 is used
+
+    # First build use-def chains
+    use_def = UseDefChainsAnalysis()
+    chains = use_def.run_on_function(func)
+
+    # Run DCE
+    dce_pass = DeadCodeElimination()
+    dce_pass.analysis_manager = type("", (), {"get_analysis": lambda _, __, ___: chains})()
+    dce_pass.initialize()
+    modified = dce_pass.run_on_function(func)
+    dce_pass.finalize()
+
+    # Should have removed dead instruction
+    assert modified or len(entry.instructions) == 2
+
+
+def test_strength_reduction() -> None:
+    """Test strength reduction pass."""
+    from machine_dialect.mir.optimizations.strength_reduction import StrengthReduction
+
+    func = MIRFunction("test")
+    entry = BasicBlock("entry")
+    func.cfg.add_block(entry)
+    func.cfg.set_entry_block(entry)
+
+    # Multiplication by power of 2
+    t0 = Temp(MIRType.INT, 0)
+    t1 = Temp(MIRType.INT, 1)
+    entry.add_instruction(LoadConst(t0, Constant(10, MIRType.INT), (1, 1)))
+    entry.add_instruction(BinaryOp(t1, "*", t0, Constant(8, MIRType.INT), (1, 1)))
+    entry.add_instruction(Return((1, 1), t1))
+
+    # Run strength reduction
+    sr_pass = StrengthReduction()
+    sr_pass.initialize()
+    sr_pass.run_on_function(func)
+    sr_pass.finalize()
+
+    # Should have converted multiply to shift
+    stats = sr_pass.get_stats()
+    assert stats.get("multiply_to_shift", 0) >= 0
+
+
+def test_cse() -> None:
+    """Test common subexpression elimination."""
+    from machine_dialect.mir.optimizations.cse import CommonSubexpressionElimination
+
+    func = MIRFunction("test")
+    entry = BasicBlock("entry")
+    func.cfg.add_block(entry)
+    func.cfg.set_entry_block(entry)
+
+    # Common subexpression: t0 + t1 computed twice
+    t0 = Temp(MIRType.INT, 0)
+    t1 = Temp(MIRType.INT, 1)
+    t2 = Temp(MIRType.INT, 2)
+    t3 = Temp(MIRType.INT, 3)
+
+    entry.add_instruction(LoadConst(t0, Constant(5, MIRType.INT), (1, 1)))
+    entry.add_instruction(LoadConst(t1, Constant(7, MIRType.INT), (1, 1)))
+    entry.add_instruction(BinaryOp(t2, "+", t0, t1, (1, 1)))  # First computation
+    entry.add_instruction(BinaryOp(t3, "+", t0, t1, (1, 1)))  # Same computation
+    entry.add_instruction(Return((1, 1), t3))
+
+    # Run CSE
+    cse_pass = CommonSubexpressionElimination()
+    cse_pass.initialize()
+    cse_pass.run_on_function(func)
+    cse_pass.finalize()
+
+    # Should have eliminated common subexpression
+    stats = cse_pass.get_stats()
+    assert stats.get("local_cse_eliminated", 0) >= 0
+
+
+def test_analysis_caching() -> None:
+    """Test that analyses are cached properly."""
+    from machine_dialect.mir.analyses.use_def_chains import UseDefChainsAnalysis
+
+    pm = PassManager()
+    register_all_passes(pm)
+
+    module = create_test_module()
+    func = module.get_function("main")
+    assert func is not None  # Type narrowing for MyPy
+
+    # Register and run analysis
+    analysis = UseDefChainsAnalysis()
+    pm.analysis_manager.register_analysis("use-def-chains", analysis)
+
+    # First call should compute
+    result1 = pm.analysis_manager.get_analysis("use-def-chains", func)
+    assert result1 is not None
+
+    # Second call should use cache
+    result2 = pm.analysis_manager.get_analysis("use-def-chains", func)
+    assert result2 is result1  # Same object
+
+    # Invalidate and recompute
+    pm.analysis_manager.invalidate(["use-def-chains"])
+    result3 = pm.analysis_manager.get_analysis("use-def-chains", func)
+    # May or may not be same object depending on implementation
+    assert result3 is not None
+
+
+def test_full_optimization_pipeline() -> None:
+    """Test complete optimization pipeline."""
+    module = create_test_module()
+    pm = PassManager()
+    register_all_passes(pm)
+
+    # Get initial instruction count
+    initial_count = sum(
+        len(block.instructions) for func in module.functions.values() for block in func.cfg.blocks.values()
+    )
+
+    # Run O2 optimizations
+    config = OptimizationConfig.from_level(2)
+    passes = OptimizationPipeline.get_passes(config)
+    pm.run_passes(module, passes, config.level)
+
+    # Get final instruction count
+    final_count = sum(
+        len(block.instructions) for func in module.functions.values() for block in func.cfg.blocks.values()
+    )
+
+    # Should have same or fewer instructions after optimization
+    assert final_count <= initial_count
+
+    # Check that we collected statistics
+    stats = pm.get_statistics()
+    assert len(stats) > 0 if passes else True

machine_dialect/mir/tests/test_pass_registration.py

@@ -0,0 +1,64 @@
+"""Test that all passes are properly registered."""
+
+import importlib
+import inspect
+import pkgutil
+
+from machine_dialect.mir.optimization_pass import AnalysisPass, OptimizationPass, Pass
+from machine_dialect.mir.optimizations import register_all_passes
+from machine_dialect.mir.pass_manager import PassManager
+
+
+class TestPassRegistration:
+    """Test that all pass classes are registered."""
+
+    def test_all_passes_registered(self) -> None:
+        """Verify that all Pass subclasses are registered."""
+        # Get all registered passes
+        pm = PassManager()
+        register_all_passes(pm)
+        registered_names = set(pm.registry._passes.keys())
+
+        # Find all Pass subclasses
+        all_pass_classes = set()
+
+        # Import all modules in mir.analyses and mir.optimizations
+        import machine_dialect.mir.analyses as analyses_pkg
+        import machine_dialect.mir.optimizations as opt_pkg
+
+        for pkg in [analyses_pkg, opt_pkg]:
+            for _importer, modname, ispkg in pkgutil.iter_modules(pkg.__path__, prefix=pkg.__name__ + "."):
+                if not ispkg:
+                    try:
+                        module = importlib.import_module(modname)
+                        for name, obj in inspect.getmembers(module, inspect.isclass):
+                            # Check if it's a concrete Pass subclass
+                            if (
+                                issubclass(obj, Pass)
+                                and obj not in [Pass, OptimizationPass, AnalysisPass]
+                                and not inspect.isabstract(obj)
+                                # Exclude base classes that contain "Pass" in name but are abstract
+                                and not (name.endswith("Pass") and name != obj.__name__)
+                            ):
+                                # Try to instantiate to get the pass name
+                                try:
+                                    instance = obj()
+                                    info = instance.get_info()
+                                    all_pass_classes.add(info.name)
+                                except (TypeError, AttributeError):
+                                    # Skip abstract classes or classes with required args
+                                    pass
+                    except ImportError:
+                        # Some modules might have additional dependencies
+                        pass
+
+        # Check that all found passes are registered
+        unregistered = all_pass_classes - registered_names
+
+        assert unregistered == set(), (
+            f"Found unregistered passes: {sorted(unregistered)}. "
+            f"Add them to register_all_passes() in mir/optimizations/__init__.py"
+        )
+
+        # Also verify we have a reasonable number of passes
+        assert len(registered_names) > 10, f"Expected at least 10 registered passes, found {len(registered_names)}"