CtrEditor/tsnet_benchmark_suite.py

#!/usr/bin/env python3
"""
TSNet Phase 2 - Performance Benchmark Test
Mediciones detalladas de rendimiento del sistema TSNet
"""

import requests
import time
import statistics
from datetime import datetime


class TSNetBenchmarkSuite:
    def __init__(self, base_url="http://localhost:5006"):
        self.base_url = base_url
        self.benchmarks = []

    def send_request(self, method, params=None, timeout=30):
        """Enviar request con medición de tiempo"""
        start_time = time.time()
        try:
            payload = {
                "jsonrpc": "2.0",
                "method": method,
                "id": int(time.time() * 1000),
            }
            if params:
                payload["params"] = params

            response = requests.post(self.base_url, json=payload, timeout=timeout)
            elapsed = time.time() - start_time

            if response.status_code == 200:
                result = response.json()
                success = "error" not in result
                return success, result, elapsed
            return False, {"error": f"HTTP {response.status_code}"}, elapsed

        except Exception as e:
            elapsed = time.time() - start_time
            return False, {"error": f"Exception: {str(e)}"}, elapsed

    def log_benchmark(self, test_name, elapsed_time, success, details=""):
        """Registrar resultado de benchmark"""
        status = "✅" if success else "❌"
        print(f"{status} {test_name}: {elapsed_time:.3f}s")
        if details:
            print(f"   {details}")

        self.benchmarks.append(
            {
                "test": test_name,
                "elapsed": elapsed_time,
                "success": success,
                "details": details,
                "timestamp": datetime.now(),
            }
        )

    def benchmark_object_creation(self, iterations=5):
        """Benchmark: Creación de objetos hidráulicos"""
        print("\n⏱️ Benchmarking Object Creation...")

        times = []
        object_types = ["osHydTank", "osHydPump", "osHydPipe"]

        for i in range(iterations):
            start_time = time.time()
            created_objects = []

            for j, obj_type in enumerate(object_types):
                success, result, _ = self.send_request(
                    "create_object",
                    {"type": obj_type, "x": float(i * 3 + j), "y": float(i)},
                )
                if success:
                    created_objects.append(obj_type)

            elapsed = time.time() - start_time
            times.append(elapsed)

            # Limpiar objetos creados
            if created_objects:
                success, result, _ = self.send_request("list_objects")
                if success and "result" in result:
                    objects = result["result"].get("objects", [])
                    if objects:
                        object_ids = [str(obj["id"]["Value"]) for obj in objects]
                        self.send_request("delete_objects", {"ids": object_ids})

        avg_time = statistics.mean(times)
        std_dev = statistics.stdev(times) if len(times) > 1 else 0

        self.log_benchmark(
            f"Object Creation ({iterations} iterations)",
            avg_time,
            True,
            f"Avg: {avg_time:.3f}s ± {std_dev:.3f}s",
        )

    def benchmark_tsnet_registration(self, iterations=3):
        """Benchmark: Registro de objetos en TSNet"""
        print("\n⏱️ Benchmarking TSNet Registration...")

        # Crear objetos de prueba primero
        test_objects = []
        for i, obj_type in enumerate(["osHydTank", "osHydPump", "osHydPipe"]):
            success, result, _ = self.send_request(
                "create_object", {"type": obj_type, "x": float(i), "y": 0.0}
            )
            if success:
                test_objects.append(obj_type)

        if not test_objects:
            self.log_benchmark(
                "TSNet Registration", 0, False, "No test objects created"
            )
            return

        times = []

        for i in range(iterations):
            code = f"""
import time
start_time = time.time()

try:
    # Reset manager
    app.tsnetSimulationManager.ResetAllCalculatedValues()
    
    # Register all hydraulic objects
    registered_count = 0
    for obj in app.ObjetosSimulables:
        if obj.GetType().Name.startswith("osHyd"):
            obj.CheckData()
            app.tsnetSimulationManager.RegisterHydraulicObject(obj)
            registered_count += 1
    
    elapsed = time.time() - start_time
    result = f"{{elapsed:.4f}},{registered_count}"
    
except Exception as e:
    elapsed = time.time() - start_time
    result = f"{{elapsed:.4f}},0,ERROR:{str(e)}"

print(result)
"""

            success, response, _ = self.send_request("execute_python", {"code": code})

            if success and "result" in response:
                output = str(response["result"])
                try:
                    parts = output.strip().split(",")
                    elapsed = float(parts[0])
                    times.append(elapsed)
                except:
                    pass

        if times:
            avg_time = statistics.mean(times)
            std_dev = statistics.stdev(times) if len(times) > 1 else 0
            self.log_benchmark(
                f"TSNet Registration ({iterations} iterations)",
                avg_time,
                True,
                f"Avg: {avg_time:.3f}s ± {std_dev:.3f}s, {len(test_objects)} objects",
            )
        else:
            self.log_benchmark("TSNet Registration", 0, False, "No valid measurements")

    def benchmark_configuration_validation(self, iterations=5):
        """Benchmark: Validación de configuraciones"""
        print("\n⏱️ Benchmarking Configuration Validation...")

        times = []

        for i in range(iterations):
            code = f"""
import time
start_time = time.time()

try:
    # Ensure objects are registered
    for obj in app.ObjetosSimulables:
        if obj.GetType().Name.startswith("osHyd"):
            obj.CheckData()
            app.tsnetSimulationManager.RegisterHydraulicObject(obj)
    
    # Validate configurations
    config_errors = app.tsnetSimulationManager.ValidateAllConfigurations()
    
    elapsed = time.time() - start_time
    result = f"{{elapsed:.4f}},{len(config_errors)}"
    
except Exception as e:
    elapsed = time.time() - start_time
    result = f"{{elapsed:.4f}},-1,ERROR:{str(e)}"

print(result)
"""

            success, response, _ = self.send_request("execute_python", {"code": code})

            if success and "result" in response:
                output = str(response["result"])
                try:
                    parts = output.strip().split(",")
                    elapsed = float(parts[0])
                    times.append(elapsed)
                except:
                    pass

        if times:
            avg_time = statistics.mean(times)
            std_dev = statistics.stdev(times) if len(times) > 1 else 0
            self.log_benchmark(
                f"Configuration Validation ({iterations} iterations)",
                avg_time,
                True,
                f"Avg: {avg_time:.3f}s ± {std_dev:.3f}s",
            )

    def benchmark_network_rebuild(self, iterations=3):
        """Benchmark: Reconstrucción de red"""
        print("\n⏱️ Benchmarking Network Rebuild...")

        times = []

        for i in range(iterations):
            code = f"""
import time
start_time = time.time()

try:
    # Rebuild network
    app.tsnetSimulationManager.RebuildNetwork()
    
    elapsed = time.time() - start_time
    result = f"{{elapsed:.4f}}"
    
except Exception as e:
    elapsed = time.time() - start_time
    result = f"{{elapsed:.4f}},ERROR:{str(e)}"

print(result)
"""

            success, response, _ = self.send_request("execute_python", {"code": code})

            if success and "result" in response:
                output = str(response["result"])
                try:
                    elapsed = float(output.strip().split(",")[0])
                    times.append(elapsed)
                except:
                    pass

        if times:
            avg_time = statistics.mean(times)
            std_dev = statistics.stdev(times) if len(times) > 1 else 0
            self.log_benchmark(
                f"Network Rebuild ({iterations} iterations)",
                avg_time,
                True,
                f"Avg: {avg_time:.3f}s ± {std_dev:.3f}s",
            )

    def benchmark_full_simulation_cycle(self, iterations=3):
        """Benchmark: Ciclo completo de simulación"""
        print("\n⏱️ Benchmarking Full Simulation Cycle...")

        times = []

        for i in range(iterations):
            start_time = time.time()

            success, response, _ = self.send_request(
                "execute_python", {"code": "app.RunTSNetSimulationSync()"}, timeout=60
            )

            elapsed = time.time() - start_time

            if success:
                times.append(elapsed)

        if times:
            avg_time = statistics.mean(times)
            std_dev = statistics.stdev(times) if len(times) > 1 else 0
            self.log_benchmark(
                f"Full Simulation Cycle ({iterations} iterations)",
                avg_time,
                True,
                f"Avg: {avg_time:.3f}s ± {std_dev:.3f}s",
            )

    def benchmark_memory_usage(self):
        """Benchmark: Uso de memoria"""
        print("\n⏱️ Benchmarking Memory Usage...")

        code = """
import gc
import sys

try:
    # Force garbage collection
    gc.collect()
    
    # Get object counts before
    before_objects = len(gc.get_objects())
    
    # Perform TSNet operations
    app.tsnetSimulationManager.ResetAllCalculatedValues()
    
    for obj in app.ObjetosSimulables:
        if obj.GetType().Name.startswith("osHyd"):
            obj.CheckData()
            app.tsnetSimulationManager.RegisterHydraulicObject(obj)
    
    app.tsnetSimulationManager.ValidateAllConfigurations()
    app.tsnetSimulationManager.RebuildNetwork()
    
    # Get object counts after
    after_objects = len(gc.get_objects())
    
    # Clean up
    app.tsnetSimulationManager.ResetAllCalculatedValues()
    gc.collect()
    
    final_objects = len(gc.get_objects())
    
    result = f"Before: {before_objects}, After: {after_objects}, Final: {final_objects}"
    
except Exception as e:
    result = f"ERROR: {str(e)}"

print(result)
"""

        success, response, _ = self.send_request("execute_python", {"code": code})

        if success and "result" in response:
            output = str(response["result"])
            self.log_benchmark("Memory Usage Analysis", 0, True, output)
        else:
            self.log_benchmark("Memory Usage Analysis", 0, False, "Failed to analyze")

    def run_benchmarks(self):
        """Ejecutar todos los benchmarks"""
        print("🏁 TSNet Phase 2 - Performance Benchmark Suite")
        print("=" * 60)
        print(f"Started at: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")

        # Verificar conectividad
        success, _, _ = self.send_request("get_ctreditor_status")
        if not success:
            print("❌ Cannot connect to CtrEditor MCP server")
            return

        # Limpiar workspace
        print("\n🧹 Preparing test environment...")
        success, result, _ = self.send_request("list_objects")
        if success and "result" in result:
            objects = result["result"].get("objects", [])
            if objects:
                object_ids = [str(obj["id"]["Value"]) for obj in objects]
                self.send_request("delete_objects", {"ids": object_ids})
                print(f"   Cleaned {len(object_ids)} existing objects")

        # Ejecutar benchmarks
        benchmarks = [
            lambda: self.benchmark_object_creation(5),
            lambda: self.benchmark_tsnet_registration(3),
            lambda: self.benchmark_configuration_validation(5),
            lambda: self.benchmark_network_rebuild(3),
            lambda: self.benchmark_full_simulation_cycle(2),
            self.benchmark_memory_usage,
        ]

        for benchmark_func in benchmarks:
            try:
                benchmark_func()
                time.sleep(1)  # Pausa entre benchmarks
            except Exception as e:
                print(f"❌ Benchmark failed: {str(e)}")

        # Generar reporte
        self.generate_performance_report()

    def generate_performance_report(self):
        """Generar reporte de rendimiento"""
        print("\n" + "=" * 60)
        print("📊 PERFORMANCE BENCHMARK REPORT")
        print("=" * 60)

        # Estadísticas por categoría
        successful_benchmarks = [b for b in self.benchmarks if b["success"]]

        if successful_benchmarks:
            print(
                f"Successful Benchmarks: {len(successful_benchmarks)}/{len(self.benchmarks)}"
            )

            # Top 3 más rápidos
            timed_benchmarks = [b for b in successful_benchmarks if b["elapsed"] > 0]
            if timed_benchmarks:
                fastest = sorted(timed_benchmarks, key=lambda x: x["elapsed"])[:3]
                print("\n🚀 Fastest Operations:")
                for i, bench in enumerate(fastest, 1):
                    print(f"   {i}. {bench['test']}: {bench['elapsed']:.3f}s")

                # Más lentos
                slowest = sorted(
                    timed_benchmarks, key=lambda x: x["elapsed"], reverse=True
                )[:3]
                print("\n⏳ Slowest Operations:")
                for i, bench in enumerate(slowest, 1):
                    print(f"   {i}. {bench['test']}: {bench['elapsed']:.3f}s")

            # Análisis de rendimiento
            total_time = sum(b["elapsed"] for b in timed_benchmarks)
            avg_time = total_time / len(timed_benchmarks) if timed_benchmarks else 0

            print(f"\n📈 Performance Summary:")
            print(f"   Total Benchmark Time: {total_time:.3f}s")
            print(f"   Average Operation Time: {avg_time:.3f}s")

            # Evaluación de rendimiento
            if avg_time < 0.1:
                performance_rating = "🚀 Excellent"
            elif avg_time < 0.5:
                performance_rating = "✅ Good"
            elif avg_time < 2.0:
                performance_rating = "⚠️ Acceptable"
            else:
                performance_rating = "❌ Needs Optimization"

            print(f"   Performance Rating: {performance_rating}")

        print(f"\nCompleted at: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")


def main():
    benchmark_suite = TSNetBenchmarkSuite()
    benchmark_suite.run_benchmarks()


if __name__ == "__main__":
    main()