becm

Author: Frtrillo

benchmark-result.png

@@ -1,30 +1,33 @@
-function generateLogs(n) {
-  const logs = [];
+// Función generadora que "cede" un log a la vez, sin crear un array.
+function* generateLogsStream(n) {
   const start = Date.now() - 7 * 24 * 60 * 60 * 1000; // 7 días atrás
   for (let i = 0; i < n; i++) {
-    logs.push({
-      timestamp: start + i * 60000, // 1 log por minuto
+    // 'yield' entrega el objeto y pausa la función hasta la siguiente iteración del bucle que lo consume.
+    yield {
+      timestamp: start + i * 60000,
       value: Math.random() * 100,
-        userId: Math.floor(Math.random() * 1000), // Simula 1000 usuarios
-        action: Math.random() > 0.5 ? 'click' : 'view', // Simula dos tipos de acciones
-        temperature: Math.random() * 30 + 15, // Temperatura entre 15 y 45 grados
-        temperature2: Math.random() * 30 + 15, // Temperatura entre 15 y 45 grados
-        name: `User${Math.floor(Math.random() * 1000)}`, // Nombre de usuario simulado
-        surname: `Surname${Math.floor(Math.random() * 1000)}`, // Apellido de usuario simulado
-        email: `user${Math.floor(Math.random() * 1000)}@example.com`, // Email simulado
-    });
+      // Los otros campos no son necesarios para el cálculo, así que podemos omitirlos
+      // para que la generación sea aún más rápida en ambos lenguajes.
+      // Si los necesitaras, los añadirías aquí.
+    };
   }
-  return logs;
 }
 
-function benchmark() {
-  const logs = generateLogs(50000000);
+function benchmarkOptimized() {
+  const n = 50000000;
   const interval = 10 * 60 * 1000; // 10 minutos en ms
 
+  console.log("Iniciando benchmark optimizado de Node.js/Bun...");
   const start = performance.now();
 
   const grouped = {};
-  for (const log of logs) {
+  
+  // Creamos el generador. No se ejecuta nada todavía.
+  const logGenerator = generateLogsStream(n);
+
+  // El bucle 'for...of' consumirá el generador, pidiendo un log a la vez.
+  // ¡No se almacena ningún array de 50 millones de logs!
+  for (const log of logGenerator) {
     const bucket = Math.floor(log.timestamp / interval) * interval;
     if (!grouped[bucket]) {
       grouped[bucket] = { sum: 0, count: 0 };
@@ -36,8 +39,8 @@ function benchmark() {
   const averages = Object.values(grouped).map(g => g.sum / g.count);
 
   const end = performance.now();
-  console.log(`Bun JS - Tiempo: ${((end - start) / 1000).toFixed(2)} s`);
+  console.log(`Bun/Node JS (Optimizado) - Tiempo: ${((end - start) / 1000).toFixed(3)} s`);
   console.log(`Buckets calculados: ${averages.length}`);
 }
 
-benchmark();
+benchmarkOptimized();

bun-mastica-historial/benchmark.js

@@ -7,66 +7,44 @@ class Program
 {
     static void Main()
     {
-        var logs = GenerateLogs(50000000);
+        int n = 50000000;
         var interval = TimeSpan.FromMinutes(10);
-
         var sw = Stopwatch.StartNew();
 
-        var grouped = new Dictionary<long, (double sum, int count)>();
-
-        foreach (var log in logs)
-        {
-            var bucket = (long)(log.Timestamp.Ticks / interval.Ticks) * interval.Ticks;
-            if (!grouped.ContainsKey(bucket))
-            {
-                grouped[bucket] = (0, 0);
-            }
-            var current = grouped[bucket];
-            grouped[bucket] = (current.sum + log.Value, current.count + 1);
-        }
-
-        var averages = grouped.Values.Select(g => g.sum / g.count).ToList();
+        // Procesa los datos "al vuelo" sin almacenarlos en una lista
+        var averages = ProcessLogsOnTheFly(n, interval);
 
         sw.Stop();
-        Console.WriteLine($"C# .NET - Tiempo: {sw.Elapsed.TotalSeconds:F3} s");
+        Console.WriteLine($"C# .NET (Optimizado) - Tiempo: {sw.Elapsed.TotalSeconds:F3} s");
         Console.WriteLine($"Buckets calculados: {averages.Count}");
     }
 
-    static List<Log> GenerateLogs(int n)
+    static List<double> ProcessLogsOnTheFly(int n, TimeSpan interval)
     {
-        var logs = new List<Log>(n);
+        var grouped = new Dictionary<long, (double sum, int count)>();
         var start = DateTime.Now.AddDays(-7);
         var rnd = new Random();
 
+        // No creamos una lista gigante. Generamos y procesamos en el mismo bucle.
         for (int i = 0; i < n; i++)
         {
-            logs.Add(new Log
+            // Genera solo los datos que necesitas para esta iteración
+            var timestamp = start.AddMinutes(i);
+            var value = rnd.NextDouble() * 100;
+
+            // El resto de la lógica de procesamiento es idéntica
+            var bucket = (long)(timestamp.Ticks / interval.Ticks) * interval.Ticks;
+            
+            // Usamos TryGetValue para ser un poco más eficientes que ContainsKey + indexer
+            if (!grouped.TryGetValue(bucket, out var current))
             {
-                Timestamp = start.AddMinutes(i),
-                Value = rnd.NextDouble() * 100,
-                UserId = rnd.Next(0, 1000),
-                Action = rnd.NextDouble() > 0.5 ? "click" : "view",
-                Temperature = rnd.NextDouble() * 30 + 15,
-                Temperature2 = rnd.NextDouble() * 30 + 15,
-                Name = $"User{rnd.Next(0,1000)}",
-                Surname = $"Surname{rnd.Next(0,1000)}",
-                Email = $"user{rnd.Next(0,1000)}@example.com"
-            });
+                current = (0, 0);
+            }
+            
+            grouped[bucket] = (current.sum + value, current.count + 1);
         }
 
-        return logs;
+        // El cálculo final es el mismo
+        return grouped.Values.Select(g => g.sum / g.count).ToList();
     }
-}
-
-class Log
-{
-    public DateTime Timestamp { get; set; }
-    public double Value { get; set; }
-    public int UserId { get; set; }
-    public string Action { get; set; } = "";
-    public double Temperature { get; set; }
-    public double Temperature2 { get; set; }
-    public string Name { get; set; } = "";
-    public string Surname { get; set; } = "";
-    public string Email { get; set; } = "";
-}
+}

dotnet-mastica-historial/Program.cs

@@ -19,4 +19,21 @@ C# .NET - Tiempo: 7,123 s
 Buckets calculados: 5000000
 PS C:\Users\frtri\Documents\benchmarksMiiot\miiot-benchmarks> bun run .\bun-mastica-historial\benchmark.js
 Bun JS - Tiempo: 11.40 s
-Buckets calculados: 5000001
+Buckets calculados: 5000001
+
+
+OPTIMIZADO POR QUE NO CABE EN LA MEMORIA Y LO CORTABA EL GARBACE COLLECTOR DE .NET
+
+PS C:\Users\frtri\Documents\benchmarksMiiot\miiot-benchmarks> bun run .\bun-mastica-historial\benchmark.js
+Iniciando benchmark optimizado de Node.js/Bun...
+Bun/Node JS (Optimizado) - Tiempo: 8.083 s
+Buckets calculados: 5000001
+PS C:\Users\frtri\Documents\benchmarksMiiot\miiot-benchmarks> dotnet run --project .\dotnet-mastica-historial\dotnet-mastica-historial.csproj
+C# .NET (Optimizado) - Tiempo: 2,168 s
+Buckets calculados: 5000001
+PS C:\Users\frtri\Documents\benchmarksMiiot\miiot-benchmarks> node .\bun-mastica-historial\benchmark.js
+Iniciando benchmark optimizado de Node.js/Bun...
+Bun/Node JS (Optimizado) - Tiempo: 19.884 s
+Buckets calculados: 5000001
+
+![Resultados del benchmark](benchmark-result.png)