Refactor Benchmark classes for improved memory tracking and analysis; enhance output formatting and add detailed statistics display

Author: rcalicdan

src/Benchmark/Utils/BenchmarkAnalyzer.php

@@ -35,69 +35,69 @@ public function analyze(array $runs): array
         ];
     }
 
-     private function filterOutliers(array $runs): array
+    private function filterOutliers(array $runs): array
     {
         $times = array_column($runs, 'duration_ms');
-        
+
         if (count($times) < 50) {
             return $runs;
         }
-        
+
         $mean = array_sum($times) / count($times);
         $variance = array_sum(array_map(fn($x) => pow($x - $mean, 2), $times)) / count($times);
         $stdDev = sqrt($variance);
-        
+
         $threshold = $this->config->getOutlierThreshold();
         $filteredRuns = [];
         $outliersRemoved = 0;
-        
+
         foreach ($runs as $run) {
             $zScore = abs(($run['duration_ms'] - $mean) / $stdDev);
-            
+
             if ($zScore <= $threshold) {
                 $filteredRuns[] = $run;
             } else {
                 $outliersRemoved++;
             }
         }
-        
+
         if (count($filteredRuns) < $this->config->getMinRunsAfterFilter()) {
             return $this->filterOutliersWithThreshold($runs, $threshold * 1.5);
         }
-        
+
         if (!empty($filteredRuns)) {
             $filteredRuns[0]['outliers_removed'] = $outliersRemoved;
             $filteredRuns[0]['original_run_count'] = count($runs);
         }
-        
+
         return $filteredRuns;
     }
-    
+
     private function filterOutliersWithThreshold(array $runs, float $threshold): array
     {
         $times = array_column($runs, 'duration_ms');
         $mean = array_sum($times) / count($times);
         $variance = array_sum(array_map(fn($x) => pow($x - $mean, 2), $times)) / count($times);
         $stdDev = sqrt($variance);
-        
+
         $filteredRuns = [];
         $outliersRemoved = 0;
-        
+
         foreach ($runs as $run) {
             $zScore = abs(($run['duration_ms'] - $mean) / $stdDev);
-            
+
             if ($zScore <= $threshold) {
                 $filteredRuns[] = $run;
             } else {
                 $outliersRemoved++;
             }
         }
-        
+
         if (!empty($filteredRuns)) {
             $filteredRuns[0]['outliers_removed'] = $outliersRemoved;
             $filteredRuns[0]['original_run_count'] = count($runs);
         }
-        
+
         return $filteredRuns;
     }
 
@@ -120,23 +120,27 @@ private function analyzeTiming(array $runs, array $times): array
 
     private function analyzeMemoryUsage(array $runs): array
     {
-        $memoryNets = array_column($runs, 'memory_net');
+        $memoryNets = array_column($runs, 'memory_net'); 
+        $memoryDeltas = array_column($runs, 'memory_delta');
+        $memoryRetained = array_column($runs, 'memory_retained');
+
         $initializationCost = $runs[0]['memory_net'] ?? 0;
 
-        // Calculate growth after initialization (skip first run)
         $subsequentRuns = array_slice($memoryNets, 1);
         $avgGrowthAfterInit = empty($subsequentRuns) ? 0 : array_sum($subsequentRuns) / count($subsequentRuns);
 
-        $hasLeak = $avgGrowthAfterInit > 10240; // More than 10KB average growth
+        $hasLeak = $avgGrowthAfterInit > 10240; 
 
         return [
             'initialization_cost' => $initializationCost,
-            'avg_memory_delta' => array_sum(array_column($runs, 'memory_delta')) / count($runs),
-            'avg_memory_net' => array_sum($memoryNets) / count($memoryNets),
+            'avg_memory_delta' => array_sum($memoryDeltas) / count($memoryDeltas), 
+            'avg_memory_net' => array_sum($memoryNets) / count($memoryNets), 
+            'avg_memory_retained' => array_sum($memoryRetained) / count($memoryRetained), 
             'avg_growth_after_init' => $avgGrowthAfterInit,
             'has_leak' => $hasLeak,
             'leak_severity' => $this->getLeakSeverity($avgGrowthAfterInit),
-            'peak_memory' => max(array_column($runs, 'memory_after'))
+            'peak_memory' => max(array_column($runs, 'memory_after')), 
+            'peak_memory_after_gc' => max(array_column($runs, 'memory_after_gc')) 
         ];
     }
 

src/Benchmark/Utils/BenchmarkExecutor.php

@@ -22,7 +22,7 @@ public function execute(string $name, callable $callback): array
 
         if ($this->config->isOutputEnabled()) {
             echo "🚀 Running benchmark: {$name}\n";
-            echo str_repeat('-', 50)."\n";
+            echo str_repeat('-', 50) . "\n";
         }
 
         $runs = [];
@@ -76,16 +76,13 @@ private function executeWarmup(callable $callback): void
 
     private function executeRun(callable $callback, bool $isWarmup = false, int $runNumber = 0, int $baselineMemory = 0): array
     {
-        // Pre-run measurements
         $memoryBefore = $this->config->isMemoryTrackingEnabled() ? memory_get_usage(true) : 0;
         $peakBefore = $this->config->isMemoryTrackingEnabled() ? memory_get_peak_usage(true) : 0;
 
-        // Timing
         $startTime = $this->config->isHighPrecisionEnabled() && function_exists('hrtime')
             ? hrtime(true)
             : microtime(true);
 
-        // Execute callback
         $result = null;
         $exception = null;
 
@@ -95,17 +92,20 @@ private function executeRun(callable $callback, bool $isWarmup = false, int $run
             $exception = $e;
         }
 
-        // Post-run measurements
         $duration = $this->calculateDuration($startTime);
         $memoryAfter = $this->config->isMemoryTrackingEnabled() ? memory_get_usage(true) : 0;
         $peakAfter = $this->config->isMemoryTrackingEnabled() ? memory_get_peak_usage(true) : 0;
 
-        // Force garbage collection if enabled
+        $actualMemoryDelta = $memoryAfter - $memoryBefore;
+        $actualNetUsage = $memoryAfter - $baselineMemory;
+
+        $memoryAfterGc = $memoryAfter;
         if ($this->config->isGarbageCollectionEnabled() && $this->config->isMemoryTrackingEnabled()) {
             $this->environment->forceGarbageCollection();
+            $memoryAfterGc = memory_get_usage(true);
         }
 
-        $memoryAfterGc = $this->config->isMemoryTrackingEnabled() ? memory_get_usage(true) : 0;
+        $retainedMemory = $memoryAfterGc - $baselineMemory;
 
         return [
             'run_number' => $runNumber,
@@ -115,8 +115,9 @@ private function executeRun(callable $callback, bool $isWarmup = false, int $run
             'memory_before' => $memoryBefore,
             'memory_after' => $memoryAfter,
             'memory_after_gc' => $memoryAfterGc,
-            'memory_delta' => $memoryAfter - $memoryBefore,
-            'memory_net' => $memoryAfterGc - $baselineMemory,
+            'memory_delta' => $actualMemoryDelta,
+            'memory_net' => $actualNetUsage,
+            'memory_retained' => $retainedMemory,
             'peak_memory_delta' => $peakAfter - $peakBefore,
             'result' => $result,
             'exception' => $exception,
@@ -129,11 +130,11 @@ private function calculateDuration(float|int $startTime): float
         if ($this->config->isHighPrecisionEnabled() && function_exists('hrtime')) {
             $endTime = hrtime(true);
 
-            return ($endTime - $startTime) / 1e6; 
+            return ($endTime - $startTime) / 1e6;
         } else {
             $endTime = microtime(true);
 
-            return ($endTime - $startTime) * 1000; 
+            return ($endTime - $startTime) * 1000;
         }
     }
 
@@ -151,9 +152,9 @@ private function displayRunResult(array $run): void
         }
 
         if ($run['exception']) {
-            $output .= ' ❌ ERROR: '.$run['exception']->getMessage();
+            $output .= ' ❌ ERROR: ' . $run['exception']->getMessage();
         }
 
-        echo $output."\n";
+        echo $output . "\n";
     }
 }