michaelschiemer/tests/debug/test-circular-memory-buffer.php

<?php

declare(strict_types=1);

require_once __DIR__ . '/../../vendor/autoload.php';

use App\Framework\Core\ValueObjects\Byte;
use App\Framework\Discovery\Memory\CircularMemoryBuffer;
use App\Framework\Discovery\Memory\DiscoveryMemoryManager;
use App\Framework\Discovery\ValueObjects\MemoryStrategy;

echo "🔍 Testing CircularMemoryBuffer Integration\n";
echo "==========================================\n\n";

// Test 1: Basic CircularMemoryBuffer functionality
echo "✅ Test 1: CircularMemoryBuffer Basic Operations\n";
$buffer = new CircularMemoryBuffer(maxSize: 5);

// Add some sample memory values
$samples = [
    Byte::fromMegabytes(100),
    Byte::fromMegabytes(105),
    Byte::fromMegabytes(110),
    Byte::fromMegabytes(108),
    Byte::fromMegabytes(112),
];

foreach ($samples as $i => $sample) {
    $buffer->add($sample);
    echo "  Added sample " . ($i + 1) . ": {$sample->toHumanReadable()}\n";
}

echo "  Buffer count: {$buffer->getCount()}\n";
echo "  Buffer is full: " . ($buffer->isFull() ? 'Yes' : 'No') . "\n";
echo "  Latest sample: " . ($buffer->getLatest()?->toHumanReadable() ?? 'None') . "\n";

// Add more samples to test overflow
echo "\n  Adding overflow samples...\n";
$buffer->add(Byte::fromMegabytes(115));
$buffer->add(Byte::fromMegabytes(118));

echo "  New latest sample: " . ($buffer->getLatest()?->toHumanReadable() ?? 'None') . "\n";
echo "  Recent 3 samples: " . implode(', ', array_map(fn ($b) => $b->toHumanReadable(), $buffer->getRecentSamples(3))) . "\n";

// Test 2: DiscoveryMemoryManager integration
echo "\n✅ Test 2: DiscoveryMemoryManager with CircularMemoryBuffer\n";
$memoryLimit = Byte::fromMegabytes(512);
$strategy = MemoryStrategy::ADAPTIVE;

$memoryManager = new DiscoveryMemoryManager(
    strategy: $strategy,
    memoryLimit: $memoryLimit,
    memoryPressureThreshold: 0.8
);

echo "  Memory manager created with strategy: {$strategy->value}\n";
echo "  Memory limit: {$memoryLimit->toHumanReadable()}\n";

// Test memory status
$status = $memoryManager->getMemoryStatus('test-context');
echo "  Current memory status: {$status->status->value}\n";
echo "  Current usage: {$status->currentUsage->toHumanReadable()}\n";
echo "  Available memory: {$status->availableMemory->toHumanReadable()}\n";

// Test 3: Memory leak detection with CircularMemoryBuffer
echo "\n✅ Test 3: Memory Leak Detection\n";

// Create a buffer with gradually increasing memory usage (simulating a leak)
$leakBuffer = new CircularMemoryBuffer(maxSize: 20);
$baseMemory = 100;

for ($i = 0; $i < 20; $i++) {
    // Simulate gradual memory increase (leak pattern)
    $memoryUsage = $baseMemory + ($i * 2); // 2MB increase per iteration
    $leakBuffer->add(Byte::fromMegabytes($memoryUsage));
}

echo "  Created leak simulation with 20 samples\n";
echo "  Memory progression: {$leakBuffer->getSamples()[0]->toHumanReadable()} → {$leakBuffer->getLatest()->toHumanReadable()}\n";

// Test leak detection
$leakInfo = $memoryManager->checkForMemoryLeaks($leakBuffer, 'leak-test');
if ($leakInfo !== null) {
    echo "  🚨 Memory leak detected!\n";
    echo "    Severity: {$leakInfo->severity->value}\n";
    echo "    Growth rate: {$leakInfo->growthRate->toHumanReadable()}/sample\n";
    echo "    Window size: {$leakInfo->windowSize} samples\n";
} else {
    echo "  ✅ No memory leak detected\n";
}

// Test 4: Memory Guard with CircularMemoryBuffer
echo "\n✅ Test 4: MemoryGuard Integration\n";
$memoryGuard = $memoryManager->createMemoryGuard(
    emergencyCallback: function () {
        echo "    🚨 Emergency callback triggered!\n";
    }
);

// Simulate multiple memory checks
for ($i = 0; $i < 5; $i++) {
    $result = $memoryGuard->check();
    echo "  Check #{$result->checkNumber}: Status={$result->memoryStatus->status->value}, " .
         "Usage={$result->memoryStatus->currentUsage->toHumanReadable()}, " .
         "Actions=" . count($result->actions) . "\n";
}

// Test guard statistics
$stats = $memoryGuard->getStatistics();
echo "\n  Guard Statistics:\n";
echo "    Total checks: {$stats->totalChecks}\n";
echo "    Average usage: {$stats->averageUsage->toHumanReadable()}\n";
echo "    Peak usage: {$stats->peakUsage->toHumanReadable()}\n";
echo "    History size: {$stats->historySize}\n";
echo "    Emergency mode: " . ($stats->emergencyMode ? 'Yes' : 'No') . "\n";

// Test 5: CircularMemoryBuffer Statistics
echo "\n✅ Test 5: CircularMemoryBuffer Statistics\n";
$bufferStats = $buffer->getStatistics();
echo "  Buffer Statistics:\n";
foreach ($bufferStats as $key => $value) {
    echo "    {$key}: {$value}\n";
}

// Test reset functionality
echo "\n✅ Test 6: Reset Functionality\n";
echo "  Before reset - Count: {$buffer->getCount()}\n";
$buffer->clear();
echo "  After reset - Count: {$buffer->getCount()}\n";
echo "  Is empty: " . ($buffer->getCount() === 0 ? 'Yes' : 'No') . "\n";

echo "\n🎉 All CircularMemoryBuffer tests completed successfully!\n";
echo "   Memory-optimized Discovery System is working correctly.\n\n";

// Performance comparison simulation
echo "📊 Performance Comparison (Simulation)\n";
echo "=====================================\n";
echo "Old Array-Based Approach:\n";
echo "  - Memory: O(n) growing with operations\n";
echo "  - array_slice(): O(n) copy operation\n";
echo "  - Memory leak risk: High\n\n";

echo "New CircularMemoryBuffer Approach:\n";
echo "  - Memory: O(1) constant size\n";
echo "  - getRecentSamples(): O(k) efficient retrieval\n";
echo "  - Memory leak risk: None\n";
echo "  - Fixed memory footprint: ~" . ($buffer->getMaxSize() * 8) . " bytes\n";

echo "\n✨ Discovery System Memory Optimization: SUCCESSFUL! ✨\n";