crackerjack 0.32.0__py3-none-any.whl → 0.33.1__py3-none-any.whl

crackerjack/services/performance_benchmarks.py

@@ -1,628 +1,302 @@
+import asyncio
 import json
 import statistics
-import subprocess
 import time
 import typing as t
-from contextlib import suppress
 from dataclasses import dataclass, field
+from datetime import datetime
 from pathlib import Path
-from typing import Any
 
-from rich.console import Console
-from rich.table import Table
-
-from crackerjack.models.protocols import FileSystemInterface
+from crackerjack.services.logging import get_logger
+from crackerjack.services.memory_optimizer import get_memory_optimizer
+from crackerjack.services.performance_cache import get_performance_cache
+from crackerjack.services.performance_monitor import get_performance_monitor
 
 
 @dataclass
 class BenchmarkResult:
-    name: str
-    duration_seconds: float
-    memory_usage_mb: float = 0.0
-    cpu_percent: float = 0.0
-    iterations: int = 1
-    metadata: dict[str, Any] = field(default_factory=dict)
+    test_name: str
+    baseline_time_seconds: float
+    optimized_time_seconds: float
+    memory_baseline_mb: float
+    memory_optimized_mb: float
+    cache_hits: int = 0
+    cache_misses: int = 0
+    parallel_operations: int = 0
+    sequential_operations: int = 0
+
+    @property
+    def time_improvement_percentage(self) -> float:
+        if self.baseline_time_seconds == 0:
+            return 0.0
+        return (
+            (self.baseline_time_seconds - self.optimized_time_seconds)
+            / self.baseline_time_seconds
+            * 100
+        )
+
+    @property
+    def memory_improvement_percentage(self) -> float:
+        if self.memory_baseline_mb == 0:
+            return 0.0
+        return (
+            (self.memory_baseline_mb - self.memory_optimized_mb)
+            / self.memory_baseline_mb
+            * 100
+        )
+
+    @property
+    def cache_hit_ratio(self) -> float:
+        total = self.cache_hits + self.cache_misses
+        return self.cache_hits / total if total > 0 else 0.0
+
+    @property
+    def parallelization_ratio(self) -> float:
+        total = self.parallel_operations + self.sequential_operations
+        return self.parallel_operations / total if total > 0 else 0.0
 
 
 @dataclass
-class PerformanceReport:
-    total_duration: float
-    workflow_benchmarks: list[BenchmarkResult] = field(default_factory=list)
-    test_benchmarks: dict[str, Any] = field(default_factory=dict)
-    hook_performance: dict[str, float] = field(default_factory=dict)
-    file_operation_stats: dict[str, float] = field(default_factory=dict)
-    recommendations: list[str] = field(default_factory=list)
-    baseline_comparison: dict[str, float] = field(default_factory=dict)
-
-
-class PerformanceBenchmarkService:
-    def __init__(
-        self,
-        filesystem: FileSystemInterface,
-        console: Console | None = None,
-    ) -> None:
-        self.filesystem = filesystem
-        self.console = console or Console()
-        self.project_root = Path.cwd()
-        self.benchmarks_dir = self.project_root / ".benchmarks"
-        self.history_file = self.benchmarks_dir / "performance_history.json"
-
-        self.benchmarks_dir.mkdir(exist_ok=True)
-
-    def run_comprehensive_benchmark(
-        self,
-        run_tests: bool = True,
-        run_hooks: bool = True,
-        iterations: int = 1,
-    ) -> PerformanceReport:
-        self.console.print(
-            "[cyan]🚀 Starting comprehensive performance benchmark...[/ cyan]",
+class BenchmarkSuite:
+    suite_name: str
+    results: list[BenchmarkResult] = field(default_factory=list)
+    run_timestamp: datetime = field(default_factory=datetime.now)
+
+    @property
+    def average_time_improvement(self) -> float:
+        if not self.results:
+            return 0.0
+        improvements = [r.time_improvement_percentage for r in self.results]
+        return statistics.mean(improvements)
+
+    @property
+    def average_memory_improvement(self) -> float:
+        if not self.results:
+            return 0.0
+        improvements = [r.memory_improvement_percentage for r in self.results]
+        return statistics.mean(improvements)
+
+    @property
+    def overall_cache_hit_ratio(self) -> float:
+        total_hits = sum(r.cache_hits for r in self.results)
+        total_misses = sum(r.cache_misses for r in self.results)
+        total = total_hits + total_misses
+        return total_hits / total if total > 0 else 0.0
+
+    def add_result(self, result: BenchmarkResult) -> None:
+        self.results.append(result)
+
+
+class PerformanceBenchmarker:
+    def __init__(self) -> None:
+        self._logger = get_logger("crackerjack.benchmarker")
+        self._monitor = get_performance_monitor()
+        self._memory_optimizer = get_memory_optimizer()
+        self._cache = get_performance_cache()
+
+        self._test_iterations = 3
+        self._warmup_iterations = 1
+
+    async def run_comprehensive_benchmark(self) -> BenchmarkSuite:
+        self._logger.info("Starting comprehensive performance benchmark")
+
+        suite = BenchmarkSuite("Phase 3 Optimization Benchmark")
+
+        suite.add_result(await self._benchmark_memory_optimization())
+
+        suite.add_result(await self._benchmark_caching_performance())
+
+        suite.add_result(await self._benchmark_async_workflows())
+
+        self._logger.info(
+            f"Benchmark complete. Average improvements: "
+            f"Time: {suite.average_time_improvement: .1f}%, "
+            f"Memory: {suite.average_memory_improvement: .1f}%, "
+            f"Cache ratio: {suite.overall_cache_hit_ratio: .2f}"
         )
 
-        start_time = time.time()
-        report = self._initialize_performance_report()
+        return suite
 
-        self._run_requested_benchmarks(report, run_tests, run_hooks, iterations)
-        self._finalize_performance_report(report, start_time)
+    async def _benchmark_memory_optimization(self) -> BenchmarkResult:
+        self._logger.debug("Benchmarking memory optimization")
 
-        return report
+        baseline_start = time.time()
+        baseline_memory_start = self._memory_optimizer.record_checkpoint(
+            "baseline_start"
+        )
 
-    def _initialize_performance_report(self) -> PerformanceReport:
-        return PerformanceReport(total_duration=0.0)
+        heavy_objects = []
+        for i in range(50):
+            obj = {
+                "data": f"heavy_data_{i}" * 100,
+                "metadata": {"created": time.time(), "index": i},
+                "payload": list[t.Any](range(100)),
+            }
+            heavy_objects.append(obj)
 
-    def _run_requested_benchmarks(
-        self,
-        report: PerformanceReport,
-        run_tests: bool,
-        run_hooks: bool,
-        iterations: int,
-    ) -> None:
-        if run_tests:
-            report.test_benchmarks = self._benchmark_test_suite(iterations)
+        baseline_time = time.time() - baseline_start
+        baseline_memory_peak = self._memory_optimizer.record_checkpoint("baseline_peak")
 
-        if run_hooks:
-            report.hook_performance = self._benchmark_hooks(iterations)
+        del heavy_objects
 
-        report.workflow_benchmarks = self._benchmark_workflow_components(iterations)
-        report.file_operation_stats = self._benchmark_file_operations()
+        optimized_start = time.time()
+        optimized_memory_start = self._memory_optimizer.record_checkpoint(
+            "optimized_start"
+        )
 
-    def _finalize_performance_report(
-        self,
-        report: PerformanceReport,
-        start_time: float,
-    ) -> None:
-        report.total_duration = time.time() - start_time
-        report.recommendations = self._generate_performance_recommendations(report)
-        report.baseline_comparison = self._compare_with_baseline(report)
-        self._save_performance_history(report)
-
-    def _benchmark_test_suite(self, iterations: int = 1) -> dict[str, Any]:
-        self.console.print("[dim]📊 Benchmarking test suite...[/ dim]")
-
-        benchmark_results = {}
-
-        try:
-            for i in range(iterations):
-                start_time = time.time()
-
-                result = subprocess.run(
-                    [
-                        "uv",
-                        "run",
-                        "pytest",
-                        "--benchmark-only",
-                        "--benchmark-json=.benchmarks/test_benchmark.json",
-                        "--tb=no",
-                        "-q",
-                    ],
-                    check=False,
-                    capture_output=True,
-                    text=True,
-                    timeout=300,
-                )
-
-                duration = time.time() - start_time
-
-                benchmark_file = self.benchmarks_dir / "test_benchmark.json"
-                if benchmark_file.exists():
-                    with benchmark_file.open() as f:
-                        benchmark_data = json.load(f)
-
-                    benchmark_results[f"iteration_{i + 1}"] = {
-                        "total_duration": duration,
-                        "benchmark_data": benchmark_data,
-                        "success": result.returncode == 0,
-                    }
-                else:
-                    benchmark_results[f"iteration_{i + 1}"] = {
-                        "total_duration": duration,
-                        "success": result.returncode == 0,
-                        "note": "No benchmark tests found",
-                    }
-
-        except subprocess.TimeoutExpired:
-            benchmark_results["error"] = "Test benchmarking timed out"
-        except Exception as e:
-            benchmark_results["error"] = f"Test benchmarking failed: {e}"
-
-        return benchmark_results
-
-    def _benchmark_hooks(self, iterations: int = 1) -> dict[str, float]:
-        self.console.print("[dim]🔧 Benchmarking hooks performance...[/ dim]")
-
-        hook_performance = {}
-
-        hooks_to_test = [
-            "trailing-whitespace",
-            "end-of-file-fixer",
-            "ruff-format",
-            "ruff-check",
-            "gitleaks",
-            "pyright",
-            "bandit",
-            "vulture",
-        ]
-
-        for hook_name in hooks_to_test:
-            durations: list[float] = []
-
-            for _i in range(iterations):
-                try:
-                    start_time = time.time()
-                    subprocess.run(
-                        [
-                            "uv",
-                            "run",
-                            "pre-commit",
-                            "run",
-                            hook_name,
-                            "--all-files",
-                        ],
-                        check=False,
-                        capture_output=True,
-                        text=True,
-                        timeout=300,  # Fixed: Use 300s to match pytest config
-                    )
-                    duration = time.time() - start_time
-                    durations.append(duration)
-                except subprocess.TimeoutExpired:
-                    durations.append(300.0)  # Fixed: Use 300s to match timeout
-                except Exception:
-                    durations.append(float("inf"))
-
-            if durations and all(d != float("inf") for d in durations):
-                hook_performance[hook_name] = {
-                    "mean_duration": statistics.mean(durations),
-                    "min_duration": min(durations),
-                    "max_duration": max(durations),
-                }
+        from crackerjack.services.memory_optimizer import LazyLoader
 
-        return hook_performance
+        lazy_objects = []
+        for i in range(50):
 
-    def _benchmark_workflow_components(
-        self,
-        iterations: int = 1,
-    ) -> list[BenchmarkResult]:
-        self.console.print("[dim]⚙️ Benchmarking workflow components...[/ dim]")
+            def create_heavy_object(index: int = i) -> dict[str, t.Any]:
+                return {
+                    "data": f"heavy_data_{index}" * 100,
+                    "metadata": {"created": time.time(), "index": index},
+                    "payload": list[t.Any](range(100)),
+                }
+
+            lazy_obj = LazyLoader(create_heavy_object, f"heavy_object_{i}")
+            lazy_objects.append(lazy_obj)
 
-        results = []
+        optimized_time = time.time() - optimized_start
+        optimized_memory_peak = self._memory_optimizer.record_checkpoint(
+            "optimized_peak"
+        )
 
-        start_time = time.time()
-        python_files = list(self.project_root.rglob("*.py"))
-        file_discovery_duration = time.time() - start_time
+        del lazy_objects
 
-        results.append(
-            BenchmarkResult(
-                name="file_discovery",
-                duration_seconds=file_discovery_duration,
-                metadata={"files_found": len(python_files)},
-            ),
+        return BenchmarkResult(
+            test_name="memory_optimization",
+            baseline_time_seconds=baseline_time,
+            optimized_time_seconds=optimized_time,
+            memory_baseline_mb=max(0, baseline_memory_peak - baseline_memory_start),
+            memory_optimized_mb=max(0, optimized_memory_peak - optimized_memory_start),
         )
 
-        start_time = time.time()
-        pyproject_path = self.project_root / "pyproject.toml"
-        if pyproject_path.exists():
-            with suppress(Exception):
-                import tomllib
-
-                with pyproject_path.open("rb") as f:
-                    tomllib.load(f)
-                config_load_duration = time.time() - start_time
-
-                results.append(
-                    BenchmarkResult(
-                        name="config_loading",
-                        duration_seconds=config_load_duration,
-                    ),
-                )
-
-        return results
-
-    def _benchmark_file_operations(self) -> dict[str, float]:
-        stats = {}
-
-        test_files = list(self.project_root.glob("*.py"))[:10]
-        if test_files:
-            start_time = time.time()
-            for file_path in test_files:
-                with suppress(Exception):
-                    file_path.read_text(encoding="utf-8")
-            read_duration = time.time() - start_time
-            stats["file_read_ops"] = read_duration / len(test_files)
-
-        return stats
-
-    def _generate_performance_recommendations(
-        self,
-        report: PerformanceReport,
-    ) -> list[str]:
-        recommendations = []
-
-        self._add_test_suite_recommendations(report, recommendations)
-        self._add_hook_performance_recommendations(report, recommendations)
-        self._add_component_performance_recommendations(report, recommendations)
-        self._add_overall_performance_recommendations(report, recommendations)
-
-        return recommendations
-
-    def _add_test_suite_recommendations(
-        self,
-        report: PerformanceReport,
-        recommendations: list[str],
-    ) -> None:
-        if not report.test_benchmarks:
-            return
+    async def _benchmark_caching_performance(self) -> BenchmarkResult:
+        self._logger.debug("Benchmarking caching performance")
 
-        for iteration_data in report.test_benchmarks.values():
-            if self._is_slow_test_iteration(iteration_data):
-                recommendations.append(
-                    "Consider optimizing test suite-execution time exceeds 1 minute",
-                )
-                break
+        self._cache.clear()
 
-    def _is_slow_test_iteration(self, iteration_data: Any) -> bool:
-        return (
-            isinstance(iteration_data, dict)
-            and iteration_data.get("total_duration", 0) > 60
-        )
+        baseline_start = time.time()
 
-    def _add_hook_performance_recommendations(
-        self,
-        report: PerformanceReport,
-        recommendations: list[str],
-    ) -> None:
-        slow_hooks = self._identify_slow_hooks(report.hook_performance)
-        if slow_hooks:
-            recommendations.append(self._format_slow_hooks_message(slow_hooks))
-
-    def _identify_slow_hooks(
-        self,
-        hook_performance: dict[str, float],
-    ) -> list[tuple[str, float]]:
-        slow_hooks = []
-        for hook_name, perf_data in hook_performance.items():
-            if isinstance(perf_data, dict):
-                mean_duration = perf_data.get("mean_duration", 0)
-                if mean_duration > 30:
-                    slow_hooks.append((hook_name, mean_duration))
-        return slow_hooks
-
-    def _format_slow_hooks_message(self, slow_hooks: list[tuple[str, float]]) -> str:
-        hooks_info = ", ".join(f"{h}({d: .1f}s)" for h, d in slow_hooks[:3])
-        return (
-            f"Slow hooks detected: {hooks_info}. "
-            "Consider hook optimization or selective execution."
-        )
+        for i in range(10):
+            await self._simulate_expensive_operation(f"operation_{i % 3}")
 
-    def _add_component_performance_recommendations(
-        self,
-        report: PerformanceReport,
-        recommendations: list[str],
-    ) -> None:
-        slow_components = self._identify_slow_components(report.workflow_benchmarks)
-        if slow_components:
-            components_names = ", ".join(c.name for c in slow_components)
-            recommendations.append(
-                f"Slow workflow components: {components_names}. "
-                "Consider caching or optimization.",
-            )
-
-    def _identify_slow_components(
-        self,
-        workflow_benchmarks: list[BenchmarkResult],
-    ) -> list[BenchmarkResult]:
-        return [b for b in workflow_benchmarks if b.duration_seconds > 5]
-
-    def _add_overall_performance_recommendations(
-        self,
-        report: PerformanceReport,
-        recommendations: list[str],
-    ) -> None:
-        if report.total_duration > 300:
-            recommendations.append(
-                "Overall workflow execution is slow. Consider enabling --skip-hooks "
-                "during development iterations.",
-            )
-
-    def _compare_with_baseline(
-        self,
-        current_report: PerformanceReport,
-    ) -> dict[str, float]:
-        baseline_comparison = {}
-
-        try:
-            history = self._load_performance_history()
-            if not history:
-                return baseline_comparison
-
-            self._add_overall_performance_comparison(
-                current_report,
-                history,
-                baseline_comparison,
-            )
-            self._add_component_performance_comparison(
-                current_report,
-                history,
-                baseline_comparison,
-            )
-
-        except Exception as e:
-            baseline_comparison["error"] = f"Could not load baseline: {e}"
-
-        return baseline_comparison
-
-    def _load_performance_history(self) -> list[dict[str, Any]] | None:
-        if not self.history_file.exists():
-            return None
-
-        with self.history_file.open() as f:
-            history = json.load(f)
-
-        return history if history and len(history) > 1 else None
-
-    def _add_overall_performance_comparison(
-        self,
-        current_report: PerformanceReport,
-        history: list[dict[str, Any]],
-        comparison: dict[str, Any],
-    ) -> None:
-        recent_runs = history[-5:]
-        baseline_duration = statistics.median(
-            [r["total_duration"] for r in recent_runs],
+        baseline_time = time.time() - baseline_start
+
+        optimized_start = time.time()
+        cache_stats_start = self._cache.get_stats()
+
+        for i in range(10):
+            await self._simulate_cached_operation(f"operation_{i % 3}")
+
+        optimized_time = time.time() - optimized_start
+        cache_stats_end = self._cache.get_stats()
+
+        cache_hits = cache_stats_end.hits - cache_stats_start.hits
+        cache_misses = cache_stats_end.misses - cache_stats_start.misses
+
+        return BenchmarkResult(
+            test_name="caching_performance",
+            baseline_time_seconds=baseline_time,
+            optimized_time_seconds=optimized_time,
+            memory_baseline_mb=0.0,
+            memory_optimized_mb=0.0,
+            cache_hits=cache_hits,
+            cache_misses=cache_misses,
         )
 
-        performance_change = (
-            (current_report.total_duration - baseline_duration) / baseline_duration
-        ) * 100
-        comparison["overall_performance_change_percent"] = performance_change
+    async def _benchmark_async_workflows(self) -> BenchmarkResult:
+        self._logger.debug("Benchmarking async workflows")
 
-    def _add_component_performance_comparison(
-        self,
-        current_report: PerformanceReport,
-        history: list[dict[str, Any]],
-        comparison: dict[str, Any],
-    ) -> None:
-        recent_runs = history[-5:]
-        if not recent_runs:
-            return
-
-        component_durations = recent_runs[-1].get("component_durations", {})
-
-        for component in current_report.workflow_benchmarks:
-            if component.name in component_durations:
-                old_duration = component_durations[component.name]
-                change = self._calculate_performance_change(
-                    component.duration_seconds,
-                    old_duration,
-                )
-                comparison[f"{component.name}_change_percent"] = change
-
-    def _calculate_performance_change(
-        self,
-        current_duration: float,
-        old_duration: float,
-    ) -> float:
-        return ((current_duration - old_duration) / old_duration) * 100
-
-    def _save_performance_history(self, report: PerformanceReport) -> None:
-        try:
-            history = []
-            if self.history_file.exists():
-                with self.history_file.open() as f:
-                    history = json.load(f)
-
-            record = {
-                "timestamp": time.time(),
-                "total_duration": report.total_duration,
-                "component_durations": {
-                    c.name: c.duration_seconds for c in report.workflow_benchmarks
-                },
-                "hook_durations": {
-                    hook: (perf["mean_duration"] if isinstance(perf, dict) else perf)
-                    for hook, perf in report.hook_performance.items()
-                },
-                "recommendations_count": len(report.recommendations),
-            }
+        baseline_start = time.time()
 
-            history.append(record)
+        for i in range(5):
+            await self._simulate_io_operation(f"seq_{i}", 0.01)
 
-            history = history[-50:]
+        baseline_time = time.time() - baseline_start
 
-            with self.history_file.open("w") as f:
-                json.dump(history, f, indent=2)
+        optimized_start = time.time()
 
-        except Exception as e:
-            self.console.print(
-                f"[yellow]⚠️[/ yellow] Could not save performance history: {e}",
-            )
+        tasks = [self._simulate_io_operation(f"par_{i}", 0.01) for i in range(5)]
+        await asyncio.gather(*tasks)
 
-    def display_performance_report(self, report: PerformanceReport) -> None:
-        self.console.print(
-            "\n[bold cyan]🚀 Performance Benchmark Report[/ bold cyan]\n"
+        optimized_time = time.time() - optimized_start
+
+        return BenchmarkResult(
+            test_name="async_workflows",
+            baseline_time_seconds=baseline_time,
+            optimized_time_seconds=optimized_time,
+            memory_baseline_mb=0.0,
+            memory_optimized_mb=0.0,
+            parallel_operations=5,
+            sequential_operations=5,
         )
 
-        self._display_overall_stats(report)
-        self._display_workflow_components(report)
-        self._display_hook_performance(report)
-        self._display_baseline_comparison(report)
-        self._display_recommendations(report)
+    async def _simulate_expensive_operation(self, operation_id: str) -> str:
+        await asyncio.sleep(0.002)
 
-        self.console.print(
-            f"\n[dim]📁 Benchmark data saved to: {self.benchmarks_dir}[/ dim]",
-        )
+        result = ""
+        for i in range(100):
+            result += f"{operation_id}_{i}"
+
+        return result[:50]
 
-    def _display_overall_stats(self, report: PerformanceReport) -> None:
-        self.console.print(
-            f"[green]⏱️ Total Duration: {report.total_duration: .2f}s[/ green]",
+    async def _simulate_cached_operation(self, operation_id: str) -> str:
+        cached_result = await self._cache.get_async(f"expensive_op: {operation_id}")
+        if cached_result is not None:
+            return str(cached_result)
+
+        result = await self._simulate_expensive_operation(operation_id)
+        await self._cache.set_async(
+            f"expensive_op: {operation_id}", result, ttl_seconds=60
         )
 
-    def _display_workflow_components(self, report: PerformanceReport) -> None:
-        if not report.workflow_benchmarks:
-            return
-
-        table = Table(title="Workflow Component Performance")
-        table.add_column("Component", style="cyan")
-        table.add_column("Duration (s)", style="yellow", justify="right")
-        table.add_column("Metadata", style="dim")
-
-        for benchmark in report.workflow_benchmarks:
-            metadata_str = ", ".join(f"{k}={v}" for k, v in benchmark.metadata.items())
-            table.add_row(
-                benchmark.name,
-                f"{benchmark.duration_seconds: .3f}",
-                metadata_str,
-            )
-
-        self.console.print(table)
-        self.console.print()
-
-    def _display_hook_performance(self, report: PerformanceReport) -> None:
-        if not report.hook_performance:
-            return
-
-        table = Table(title="Hook Performance Analysis")
-        table.add_column("Hook", style="cyan")
-        table.add_column("Mean (s)", style="yellow", justify="right")
-        table.add_column("Min (s)", style="green", justify="right")
-        table.add_column("Max (s)", style="red", justify="right")
-
-        for hook_name, perf_data in report.hook_performance.items():
-            if isinstance(perf_data, dict):
-                table.add_row(
-                    hook_name,
-                    f"{perf_data.get('mean_duration', 0): .2f}",
-                    f"{perf_data.get('min_duration', 0): .2f}",
-                    f"{perf_data.get('max_duration', 0): .2f}",
-                )
-
-        self.console.print(table)
-        self.console.print()
-
-    def _display_baseline_comparison(self, report: PerformanceReport) -> None:
-        if not report.baseline_comparison:
-            return
-
-        self._print_comparison_header()
-        self._print_comparison_metrics(report.baseline_comparison)
-        self.console.print()
-
-    def _print_comparison_header(self) -> None:
-        self.console.print("[bold]📊 Performance Comparison[/ bold]")
-
-    def _print_comparison_metrics(self, baseline_comparison: dict[str, t.Any]) -> None:
-        for metric, value in baseline_comparison.items():
-            if isinstance(value, float | int) and "percent" in metric:
-                color = "green" if value < 0 else "red" if value > 10 else "yellow"
-                direction = "faster" if value < 0 else "slower"
-                self.console.print(
-                    f" {metric}: [{color}]{abs(value): .1f}% {direction}[/{color}]",
-                )
-
-    def _display_recommendations(self, report: PerformanceReport) -> None:
-        if report.recommendations:
-            self.console.print(
-                "[bold yellow]💡 Performance Recommendations[/ bold yellow]",
-            )
-            for i, rec in enumerate(report.recommendations, 1):
-                self.console.print(f" {i}. {rec}")
-        else:
-            self.console.print("[green]✨ No performance issues detected ![/ green]")
-
-    def get_performance_trends(self, days: int = 7) -> dict[str, Any]:
-        try:
-            recent_history = self._get_recent_history(days)
-            if not recent_history:
-                return self._handle_insufficient_trend_data()
-
-            trends = {}
-            self._add_duration_trends(recent_history, trends)
-            self._add_component_trends(recent_history, trends)
-            trends["data_points"] = len(recent_history)
-
-            return trends
-
-        except Exception as e:
-            return {"error": f"Could not analyze trends: {e}"}
-
-    def _get_recent_history(self, days: int) -> list[dict[str, Any]] | None:
-        if not self.history_file.exists():
-            return None
-
-        with self.history_file.open() as f:
-            history = json.load(f)
-
-        cutoff_time = time.time() - (days * 86400)
-        recent_history = [r for r in history if r.get("timestamp", 0) > cutoff_time]
-
-        return recent_history if len(recent_history) >= 2 else None
-
-    def _handle_insufficient_trend_data(self) -> dict[str, str]:
-        if not self.history_file.exists():
-            return {"error": "No performance history available"}
-        return {"error": "Insufficient data for trend analysis"}
-
-    def _add_duration_trends(
-        self, recent_history: list[dict[str, Any]], trends: dict[str, Any]
-    ) -> None:
-        durations = [r["total_duration"] for r in recent_history]
-        trends["duration_trend"] = {
-            "current": durations[-1],
-            "average": statistics.mean(durations),
-            "trend": self._determine_trend_direction(durations),
-        }
+        return result
 
-    def _add_component_trends(
-        self, recent_history: list[dict[str, Any]], trends: dict[str, Any]
+    async def _simulate_io_operation(self, operation_id: str, duration: float) -> str:
+        await asyncio.sleep(duration)
+        return f"result_{operation_id}"
+
+    def export_benchmark_results(
+        self, suite: BenchmarkSuite, output_path: Path
     ) -> None:
-        component_trends = {}
-        latest_components = recent_history[-1].get("component_durations", {})
-
-        for component in latest_components:
-            component_durations = self._extract_component_durations(
-                recent_history,
-                component,
-            )
-            if len(component_durations) >= 2:
-                component_trends[component] = {
-                    "current": component_durations[-1],
-                    "average": statistics.mean(component_durations),
-                    "trend": self._determine_trend_direction(component_durations),
+        data = {
+            "suite_name": suite.suite_name,
+            "run_timestamp": suite.run_timestamp.isoformat(),
+            "summary": {
+                "average_time_improvement_percentage": suite.average_time_improvement,
+                "average_memory_improvement_percentage": suite.average_memory_improvement,
+                "overall_cache_hit_ratio": suite.overall_cache_hit_ratio,
+                "total_tests": len(suite.results),
+            },
+            "results": [
+                {
+                    "test_name": r.test_name,
+                    "baseline_time_seconds": r.baseline_time_seconds,
+                    "optimized_time_seconds": r.optimized_time_seconds,
+                    "time_improvement_percentage": r.time_improvement_percentage,
+                    "memory_baseline_mb": r.memory_baseline_mb,
+                    "memory_optimized_mb": r.memory_optimized_mb,
+                    "memory_improvement_percentage": r.memory_improvement_percentage,
+                    "cache_hits": r.cache_hits,
+                    "cache_misses": r.cache_misses,
+                    "cache_hit_ratio": r.cache_hit_ratio,
+                    "parallel_operations": r.parallel_operations,
+                    "sequential_operations": r.sequential_operations,
+                    "parallelization_ratio": r.parallelization_ratio,
                 }
+                for r in suite.results
+            ],
+        }
+
+        with output_path.open("w") as f:
+            json.dump(data, f, indent=2)
+
+        self._logger.info(f"Exported benchmark results to {output_path}")
+
 
-        trends["component_trends"] = component_trends
-
-    def _extract_component_durations(
-        self,
-        recent_history: list[dict[str, Any]],
-        component: str,
-    ) -> list[float]:
-        return [
-            r.get("component_durations", {}).get(component)
-            for r in recent_history
-            if component in r.get("component_durations", {})
-        ]
-
-    def _determine_trend_direction(self, durations: list[float]) -> str:
-        current = durations[-1]
-        historical_average = statistics.mean(durations[:-1])
-        return "improving" if current < historical_average else "degrading"
+def get_benchmarker() -> PerformanceBenchmarker:
+    return PerformanceBenchmarker()