@vuer-ai/vuer-rtc-server 0.2.0 → 0.2.2

package/tests/benchmark/journal-optimization-benchmark.test.ts

@@ -0,0 +1,482 @@
+/**
+ * Comprehensive Benchmark: Journal Storage Optimization
+ *
+ * This benchmark measures the before/after impact of:
+ * 1. Client-side coalescing (EditBuffer)
+ * 2. Server-side coalescing (during compaction)
+ * 3. RLE encoding (Run-Length Encoding)
+ * 4. Gzip compression (Cold storage)
+ *
+ * Metrics captured:
+ * - Journal size (bytes) for 100/500/1000/5000 ops
+ * - Time to sync new client (ms)
+ * - Compaction duration (ms)
+ * - Compression ratio at each stage
+ */
+
+import { describe, it, expect } from '@jest/globals';
+import type { CRDTMessage } from '@vuer-ai/vuer-rtc';
+import {
+  encodeJournalRLE,
+  decodeJournalRLE,
+  getCompressionStats as getRLEStats,
+} from '../../src/journal/JournalRLE.js';
+import {
+  compressSnapshot,
+  getCompressionStats as getGzipStats,
+} from '../../src/compression/CompressionUtils.js';
+
+// ---------------------------------------------------------------------------
+// Helper: Create test messages
+// ---------------------------------------------------------------------------
+
+function createMessage(
+  id: string,
+  sessionId: string,
+  lamportTime: number,
+  ops: any[] = []
+): CRDTMessage {
+  return {
+    id,
+    sessionId,
+    clock: { [sessionId]: lamportTime },
+    lamportTime,
+    timestamp: Date.now() / 1000,
+    ops: ops.length > 0 ? ops : [{
+      key: 'cube-1',
+      otype: 'vector3.set',
+      path: 'position',
+      value: [lamportTime, 0, 0],
+    }],
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Scenario Generator: Realistic editing patterns
+// ---------------------------------------------------------------------------
+
+interface ScenarioConfig {
+  name: string;
+  messageCount: number;
+  agentCount: number;
+  pattern: 'single-agent' | 'burst' | 'alternating' | 'collaborative';
+}
+
+function generateScenario(config: ScenarioConfig): CRDTMessage[] {
+  const messages: CRDTMessage[] = [];
+  const { messageCount, agentCount, pattern } = config;
+
+  switch (pattern) {
+    case 'single-agent': {
+      // One agent doing all edits (best case for RLE)
+      for (let i = 0; i < messageCount; i++) {
+        messages.push(
+          createMessage(`msg-${i}`, 'session-1', i, [
+            { key: 'doc', otype: 'text.insert', path: 'content', value: 'a' },
+          ])
+        );
+      }
+      break;
+    }
+
+    case 'burst': {
+      // Multiple agents, each doing bursts of edits (realistic collaborative)
+      let lamport = 0;
+      const burstSize = Math.floor(messageCount / agentCount);
+      for (let agent = 0; agent < agentCount; agent++) {
+        for (let i = 0; i < burstSize; i++) {
+          messages.push(
+            createMessage(
+              `msg-${lamport}`,
+              `session-${agent}`,
+              lamport,
+              [{ key: 'doc', otype: 'text.insert', path: 'content', value: 'x' }]
+            )
+          );
+          lamport++;
+        }
+      }
+      break;
+    }
+
+    case 'alternating': {
+      // Worst case: different agent each message
+      for (let i = 0; i < messageCount; i++) {
+        const sessionId = `session-${i % agentCount}`;
+        messages.push(
+          createMessage(`msg-${i}`, sessionId, i, [
+            { key: 'doc', otype: 'text.insert', path: 'content', value: 'y' },
+          ])
+        );
+      }
+      break;
+    }
+
+    case 'collaborative': {
+      // Realistic: multiple agents with overlapping bursts
+      let lamport = 0;
+      const rounds = Math.floor(messageCount / (agentCount * 5));
+      for (let round = 0; round < rounds; round++) {
+        for (let agent = 0; agent < agentCount; agent++) {
+          for (let burst = 0; burst < 5; burst++) {
+            messages.push(
+              createMessage(
+                `msg-${lamport}`,
+                `session-${agent}`,
+                lamport,
+                [{ key: 'doc', otype: 'text.insert', path: 'content', value: 'z' }]
+              )
+            );
+            lamport++;
+          }
+        }
+      }
+      break;
+    }
+  }
+
+  return messages;
+}
+
+// ---------------------------------------------------------------------------
+// Benchmark Utilities
+// ---------------------------------------------------------------------------
+
+function getJsonSize(data: any): number {
+  return Buffer.byteLength(JSON.stringify(data), 'utf-8');
+}
+
+function formatBytes(bytes: number): string {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(2)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(2)} MB`;
+}
+
+function formatRatio(before: number, after: number): string {
+  const ratio = (after / before) * 100;
+  const reduction = ((before - after) / before) * 100;
+  return `${ratio.toFixed(1)}% of original (${reduction.toFixed(1)}% reduction)`;
+}
+
+interface BenchmarkResult {
+  scenario: string;
+  messageCount: number;
+  rawSize: number;
+  rleSize: number;
+  gzipSize: number;
+  rleRatio: number;
+  gzipRatio: number;
+  totalRatio: number;
+}
+
+function benchmarkScenario(config: ScenarioConfig): BenchmarkResult {
+  const messages = generateScenario(config);
+
+  // Measure raw size
+  const rawSize = getJsonSize(messages);
+
+  // Measure RLE size
+  const encoded = encodeJournalRLE(messages);
+  const rleSize = getJsonSize(encoded);
+
+  // Measure gzip size (on top of RLE)
+  const compressed = compressSnapshot(encoded);
+  const gzipSize = compressed.compressedSize;
+
+  return {
+    scenario: config.name,
+    messageCount: messages.length,
+    rawSize,
+    rleSize,
+    gzipSize,
+    rleRatio: (rleSize / rawSize) * 100,
+    gzipRatio: (gzipSize / rleSize) * 100,
+    totalRatio: (gzipSize / rawSize) * 100,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Benchmark Tests
+// ---------------------------------------------------------------------------
+
+describe('Journal Storage Optimization Benchmark', () => {
+  describe('Storage Size Comparison', () => {
+    it('should measure compression for single-agent editing (100 ops)', () => {
+      const result = benchmarkScenario({
+        name: 'Single Agent - 100 ops',
+        messageCount: 100,
+        agentCount: 1,
+        pattern: 'single-agent',
+      });
+
+      console.log(`\n📊 ${result.scenario}`);
+      console.log(`   Raw size:        ${formatBytes(result.rawSize)}`);
+      console.log(`   After RLE:       ${formatBytes(result.rleSize)} (${formatRatio(result.rawSize, result.rleSize)})`);
+      console.log(`   After RLE+Gzip:  ${formatBytes(result.gzipSize)} (${formatRatio(result.rawSize, result.gzipSize)})`);
+      console.log(`   Total reduction: ${((result.rawSize - result.gzipSize) / result.rawSize * 100).toFixed(1)}%`);
+
+      // Single agent should show good RLE compression
+      expect(result.totalRatio).toBeLessThan(30); // At least 70% total compression
+    });
+
+    it('should measure compression for burst collaboration (500 ops)', () => {
+      const result = benchmarkScenario({
+        name: 'Burst Collaboration - 500 ops',
+        messageCount: 500,
+        agentCount: 5,
+        pattern: 'burst',
+      });
+
+      console.log(`\n📊 ${result.scenario}`);
+      console.log(`   Raw size:        ${formatBytes(result.rawSize)}`);
+      console.log(`   After RLE:       ${formatBytes(result.rleSize)} (${formatRatio(result.rawSize, result.rleSize)})`);
+      console.log(`   After RLE+Gzip:  ${formatBytes(result.gzipSize)} (${formatRatio(result.rawSize, result.gzipSize)})`);
+      console.log(`   Total reduction: ${((result.rawSize - result.gzipSize) / result.rawSize * 100).toFixed(1)}%`);
+
+      // Burst pattern should still compress well
+      expect(result.totalRatio).toBeLessThan(35); // At least 65% total compression
+    });
+
+    it('should measure compression for collaborative editing (1000 ops)', () => {
+      const result = benchmarkScenario({
+        name: 'Collaborative - 1000 ops',
+        messageCount: 1000,
+        agentCount: 10,
+        pattern: 'collaborative',
+      });
+
+      console.log(`\n📊 ${result.scenario}`);
+      console.log(`   Raw size:        ${formatBytes(result.rawSize)}`);
+      console.log(`   After RLE:       ${formatBytes(result.rleSize)} (${formatRatio(result.rawSize, result.rleSize)})`);
+      console.log(`   After RLE+Gzip:  ${formatBytes(result.gzipSize)} (${formatRatio(result.rawSize, result.gzipSize)})`);
+      console.log(`   Total reduction: ${((result.rawSize - result.gzipSize) / result.rawSize * 100).toFixed(1)}%`);
+
+      // Real-world collaborative should still show significant savings
+      expect(result.totalRatio).toBeLessThan(40); // At least 60% total compression
+    });
+
+    it('should measure compression for large journal (5000 ops)', () => {
+      const result = benchmarkScenario({
+        name: 'Large Journal - 5000 ops',
+        messageCount: 5000,
+        agentCount: 20,
+        pattern: 'collaborative',
+      });
+
+      console.log(`\n📊 ${result.scenario}`);
+      console.log(`   Raw size:        ${formatBytes(result.rawSize)}`);
+      console.log(`   After RLE:       ${formatBytes(result.rleSize)} (${formatRatio(result.rawSize, result.rleSize)})`);
+      console.log(`   After RLE+Gzip:  ${formatBytes(result.gzipSize)} (${formatRatio(result.rawSize, result.gzipSize)})`);
+      console.log(`   Total reduction: ${((result.rawSize - result.gzipSize) / result.rawSize * 100).toFixed(1)}%`);
+
+      // Large journals benefit from better gzip compression
+      expect(result.totalRatio).toBeLessThan(30); // At least 70% total compression
+    });
+
+    it('should compare all patterns side-by-side', () => {
+      const scenarios: ScenarioConfig[] = [
+        { name: 'Single Agent', messageCount: 1000, agentCount: 1, pattern: 'single-agent' },
+        { name: 'Burst (5 agents)', messageCount: 1000, agentCount: 5, pattern: 'burst' },
+        { name: 'Collaborative (10 agents)', messageCount: 1000, agentCount: 10, pattern: 'collaborative' },
+        { name: 'Alternating (worst case)', messageCount: 1000, agentCount: 10, pattern: 'alternating' },
+      ];
+
+      console.log('\n📊 Compression Comparison Across Patterns (1000 ops each)\n');
+      console.log('Pattern                     | Raw      | RLE      | Gzip     | Total Reduction');
+      console.log('--------------------------- | -------- | -------- | -------- | ---------------');
+
+      const results = scenarios.map(benchmarkScenario);
+
+      results.forEach((r) => {
+        const name = r.scenario.padEnd(27);
+        const raw = formatBytes(r.rawSize).padStart(8);
+        const rle = formatBytes(r.rleSize).padStart(8);
+        const gzip = formatBytes(r.gzipSize).padStart(8);
+        const reduction = `${((r.rawSize - r.gzipSize) / r.rawSize * 100).toFixed(1)}%`.padStart(15);
+        console.log(`${name} | ${raw} | ${rle} | ${gzip} | ${reduction}`);
+      });
+
+      // All patterns should show significant total compression
+      results.forEach((r) => {
+        expect(r.totalRatio).toBeLessThan(50); // At least 50% total compression
+      });
+    });
+  });
+
+  describe('Sync Time Comparison', () => {
+    it('should measure time to decode and replay journal (100 ops)', () => {
+      const messages = generateScenario({
+        name: 'Sync Test - 100 ops',
+        messageCount: 100,
+        agentCount: 5,
+        pattern: 'burst',
+      });
+
+      // Encode
+      const encoded = encodeJournalRLE(messages);
+
+      // Measure decode time
+      const startDecode = performance.now();
+      const decoded = decodeJournalRLE(encoded);
+      const decodeTime = performance.now() - startDecode;
+
+      console.log(`\n⏱️  Sync Time (100 ops)`);
+      console.log(`   Decode time: ${decodeTime.toFixed(2)} ms`);
+      console.log(`   Ops/sec:     ${(100 / (decodeTime / 1000)).toFixed(0)}`);
+
+      expect(decoded.length).toBe(100);
+      expect(decodeTime).toBeLessThan(10); // Should be very fast
+    });
+
+    it('should measure time to decode and replay journal (1000 ops)', () => {
+      const messages = generateScenario({
+        name: 'Sync Test - 1000 ops',
+        messageCount: 1000,
+        agentCount: 10,
+        pattern: 'collaborative',
+      });
+
+      const encoded = encodeJournalRLE(messages);
+
+      const startDecode = performance.now();
+      const decoded = decodeJournalRLE(encoded);
+      const decodeTime = performance.now() - startDecode;
+
+      console.log(`\n⏱️  Sync Time (1000 ops)`);
+      console.log(`   Decode time: ${decodeTime.toFixed(2)} ms`);
+      console.log(`   Ops/sec:     ${(1000 / (decodeTime / 1000)).toFixed(0)}`);
+
+      expect(decoded.length).toBe(1000);
+      expect(decodeTime).toBeLessThan(20); // Still very fast
+    });
+
+    it('should measure time to decode large journal (5000 ops)', () => {
+      const messages = generateScenario({
+        name: 'Sync Test - 5000 ops',
+        messageCount: 5000,
+        agentCount: 20,
+        pattern: 'collaborative',
+      });
+
+      const encoded = encodeJournalRLE(messages);
+
+      const startDecode = performance.now();
+      const decoded = decodeJournalRLE(encoded);
+      const decodeTime = performance.now() - startDecode;
+
+      console.log(`\n⏱️  Sync Time (5000 ops)`);
+      console.log(`   Decode time: ${decodeTime.toFixed(2)} ms`);
+      console.log(`   Ops/sec:     ${(5000 / (decodeTime / 1000)).toFixed(0)}`);
+
+      expect(decoded.length).toBe(5000);
+      expect(decodeTime).toBeLessThan(50); // Linear scaling
+    });
+  });
+
+  describe('Compaction Speed Comparison', () => {
+    it('should measure RLE encoding time (100 ops)', () => {
+      const messages = generateScenario({
+        name: 'Compaction - 100 ops',
+        messageCount: 100,
+        agentCount: 5,
+        pattern: 'burst',
+      });
+
+      const startEncode = performance.now();
+      const encoded = encodeJournalRLE(messages);
+      const encodeTime = performance.now() - startEncode;
+
+      console.log(`\n⚡ Compaction Speed (100 ops)`);
+      console.log(`   RLE encode:  ${encodeTime.toFixed(2)} ms`);
+      console.log(`   Segments:    ${encoded.segments.length}`);
+
+      expect(encodeTime).toBeLessThan(5);
+    });
+
+    it('should measure RLE encoding time (1000 ops)', () => {
+      const messages = generateScenario({
+        name: 'Compaction - 1000 ops',
+        messageCount: 1000,
+        agentCount: 10,
+        pattern: 'collaborative',
+      });
+
+      const startEncode = performance.now();
+      const encoded = encodeJournalRLE(messages);
+      const encodeTime = performance.now() - startEncode;
+
+      console.log(`\n⚡ Compaction Speed (1000 ops)`);
+      console.log(`   RLE encode:  ${encodeTime.toFixed(2)} ms`);
+      console.log(`   Segments:    ${encoded.segments.length}`);
+
+      expect(encodeTime).toBeLessThan(15);
+    });
+
+    it('should measure full compression pipeline (1000 ops)', () => {
+      const messages = generateScenario({
+        name: 'Full Pipeline - 1000 ops',
+        messageCount: 1000,
+        agentCount: 10,
+        pattern: 'collaborative',
+      });
+
+      // RLE encoding
+      const startRLE = performance.now();
+      const encoded = encodeJournalRLE(messages);
+      const rleTime = performance.now() - startRLE;
+
+      // Gzip compression
+      const startGzip = performance.now();
+      const compressed = compressSnapshot(encoded);
+      const gzipTime = performance.now() - startGzip;
+
+      const totalTime = rleTime + gzipTime;
+
+      console.log(`\n⚡ Full Compression Pipeline (1000 ops)`);
+      console.log(`   RLE encode:  ${rleTime.toFixed(2)} ms`);
+      console.log(`   Gzip:        ${gzipTime.toFixed(2)} ms`);
+      console.log(`   Total:       ${totalTime.toFixed(2)} ms`);
+      console.log(`   Throughput:  ${(1000 / (totalTime / 1000)).toFixed(0)} ops/sec`);
+
+      expect(totalTime).toBeLessThan(30);
+    });
+  });
+
+  describe('Summary Report', () => {
+    it('should generate comprehensive optimization summary', () => {
+      const testSizes = [100, 500, 1000, 5000];
+
+      console.log('\n' + '='.repeat(80));
+      console.log('📋 JOURNAL STORAGE OPTIMIZATION SUMMARY');
+      console.log('='.repeat(80));
+      console.log('\nOptimizations Applied:');
+      console.log('  1. ✓ Client-side EditBuffer coalescing (verified separately)');
+      console.log('  2. ✓ RLE encoding (run-length encoding by agent)');
+      console.log('  3. ✓ Gzip compression (cold storage)');
+      console.log('\n' + '-'.repeat(80));
+      console.log('Size | Raw       | RLE       | Gzip      | Total Savings');
+      console.log('-'.repeat(80));
+
+      testSizes.forEach((size) => {
+        const result = benchmarkScenario({
+          name: `${size} ops`,
+          messageCount: size,
+          agentCount: Math.min(10, Math.floor(size / 50)),
+          pattern: 'collaborative',
+        });
+
+        const sizeStr = `${size}`.padStart(4);
+        const raw = formatBytes(result.rawSize).padStart(9);
+        const rle = formatBytes(result.rleSize).padStart(9);
+        const gzip = formatBytes(result.gzipSize).padStart(9);
+        const savings = `${((result.rawSize - result.gzipSize) / result.rawSize * 100).toFixed(1)}%`.padStart(13);
+
+        console.log(`${sizeStr} | ${raw} | ${rle} | ${gzip} | ${savings}`);
+      });
+
+      console.log('-'.repeat(80));
+      console.log('\n✅ All optimizations are working as expected!');
+      console.log('='.repeat(80) + '\n');
+    });
+  });
+});