benchmark_advanced.ts

import * as fs from 'fs';
import { ChatbotFlowNavigator, Node, Edge, SearchCriteria } from './algorithm.js';

function getMemoryUsage(): number {
  // En Node.js, usar process.memoryUsage()
  return process.memoryUsage().rss / 1024 / 1024; // Convertir a MB
}

function benchmarkTypeScriptAdvanced(nodesFile: string, edgesFile: string, datasetName: string): any {
  console.log(`\n🚀 TYPESCRIPT BENCHMARK - ${datasetName}`);
  console.log('='.repeat(70));
  
  // Forzar garbage collection si está disponible
  if (global.gc) {
    global.gc();
  }
  
  const initialMemory = getMemoryUsage();
  console.log(`📊 Memoria inicial: ${initialMemory.toFixed(2)} MB`);
  
  // 1. Medición de tiempo y memoria para carga de datos
  const startLoad = performance.now();
  
  const nodesData: Node[] = JSON.parse(fs.readFileSync(nodesFile, 'utf-8'));
  const edgesData: Edge[] = JSON.parse(fs.readFileSync(edgesFile, 'utf-8'));
  
  const loadTime = performance.now() - startLoad;
  const memoryAfterLoad = getMemoryUsage();
  const memoryForData = memoryAfterLoad - initialMemory;
  
  console.log(`📁 Datos cargados: ${nodesData.length.toLocaleString()} nodos, ${edgesData.length.toLocaleString()} edges`);
  console.log(`⏱️  Tiempo de carga: ${loadTime.toFixed(3)}ms`);
  console.log(`💾 Memoria para datos JSON: ${memoryForData.toFixed(2)} MB`);
  
  // 2. Medición de inicialización del navegador
  const startInit = performance.now();
  const navigator = new ChatbotFlowNavigator(nodesData, edgesData);
  const initTime = performance.now() - startInit;
  
  const memoryAfterInit = getMemoryUsage();
  const memoryForNavigator = memoryAfterInit - memoryAfterLoad;
  
  console.log(`⏱️  Tiempo de inicialización: ${initTime.toFixed(3)}ms`);
  console.log(`💾 Memoria para estructuras Map: ${memoryForNavigator.toFixed(2)} MB`);
  
  // 3. Benchmark de búsquedas con diferentes criterios
  const testCases = [
    {
      name: "Búsqueda por QUICK_REPLY",
      criteria: { button_type: "QUICK_REPLY" },
      source: "node-START"
    },
    {
      name: "Búsqueda por target específico",
      criteria: { target_contains: "node-000001" },
      source: "node-START"
    },
    {
      name: "Búsqueda combinada",
      criteria: { button_type: "POSTBACK", target_contains: "node-" },
      source: "node-START"
    }
  ];
  
  const iterations = 10000;
  
  for (const testCase of testCases) {
    console.log(`\n🔍 ${testCase.name} (${iterations.toLocaleString()} iteraciones):`);
    
    let totalSearchTime = 0;
    let successfulSearches = 0;
    
    for (let i = 0; i < iterations; i++) {
      const startSearch = performance.now();
      const result = navigator.findNextNode(testCase.source, testCase.criteria);
      totalSearchTime += performance.now() - startSearch;
      
      if (result) {
        successfulSearches++;
      }
    }
    
    const avgSearchTime = (totalSearchTime / iterations) * 1000; // microsegundos
    const successRate = (successfulSearches / iterations) * 100;
    
    console.log(`   ⏱️  Tiempo promedio: ${avgSearchTime.toFixed(3)} μs`);
    console.log(`   ✅ Tasa de éxito: ${successRate.toFixed(1)}%`);
  }
  
  // 4. Memoria total utilizada
  const totalMemory = memoryAfterInit - initialMemory;
  console.log(`\n💾 RESUMEN DE MEMORIA:`);
  console.log(`   • Datos JSON: ${memoryForData.toFixed(2)} MB`);
  console.log(`   • Estructuras Map: ${memoryForNavigator.toFixed(2)} MB`);
  console.log(`   • Total utilizado: ${totalMemory.toFixed(2)} MB`);
  console.log(`   • Eficiencia: ${(totalMemory / nodesData.length * 1000).toFixed(3)} KB por nodo`);
  
  return {
    dataset: datasetName,
    nodes: nodesData.length,
    edges: edgesData.length,
    load_time: loadTime,
    init_time: initTime,
    memory_data: memoryForData,
    memory_structures: memoryForNavigator,
    memory_total: totalMemory,
    memory_per_node: totalMemory / nodesData.length * 1000
  };
}

function runAllBenchmarks(): any[] {
  const datasets = [
    ["data/nodes.json", "data/edges.json", "Dataset Original (11 nodos)"],
    ["data/nodes_1000.json", "data/edges_1000.json", "Dataset Mediano (1K nodos)"],
    ["data/nodes_5000.json", "data/edges_5000.json", "Dataset Grande (5K nodos)"],
    ["data/nodes_10000.json", "data/edges_10000.json", "Dataset Muy Grande (10K nodos)"]
  ];
  
  const results: any[] = [];
  
  for (const [nodesFile, edgesFile, name] of datasets) {
    try {
      const result = benchmarkTypeScriptAdvanced(nodesFile, edgesFile, name);
      results.push(result);
    } catch (error) {
      console.log(`⚠️  Error procesando ${name}: ${error}`);
      continue;
    }
  }
  
  // Mostrar resumen comparativo
  console.log(`\n🏆 RESUMEN COMPARATIVO - TYPESCRIPT`);
  console.log('='.repeat(80));
  console.log(`${'Dataset'.padEnd(30)} ${'Nodos'.padEnd(8)} ${'Memoria'.padEnd(10)} ${'KB/nodo'.padEnd(10)} ${'Init(ms)'.padEnd(10)}`);
  console.log('-'.repeat(80));
  
  for (const result of results) {
    console.log(`${result.dataset.padEnd(30)} ${result.nodes.toLocaleString().padEnd(8)} ` +
                `${result.memory_total.toFixed(2).padEnd(10)} ${result.memory_per_node.toFixed(3).padEnd(10)} ` +
                `${result.init_time.toFixed(3).padEnd(10)}`);
  }
  
  return results;
}

// Ejecutar benchmarks
const results = runAllBenchmarks();