@plures/pluresdb 1.4.0

package/legacy/benchmarks/memory-benchmarks.ts

@@ -0,0 +1,350 @@
+#!/usr/bin/env -S deno run -A
+
+import { GunDB } from "../core/database.ts";
+
+interface MemoryMetrics {
+  operation: string;
+  initialMemory: number;
+  finalMemory: number;
+  memoryIncrease: number;
+  recordCount: number;
+  memoryPerRecord: number;
+}
+
+class MemoryBenchmark {
+  private results: MemoryMetrics[] = [];
+
+  private getMemoryUsage(): number {
+    return (performance as any).memory?.usedJSHeapSize || 0;
+  }
+
+  async measureMemoryUsage(
+    operation: string,
+    recordCount: number,
+    operationFn: () => Promise<void>,
+  ): Promise<MemoryMetrics> {
+    console.log(`Measuring memory usage for: ${operation}`);
+
+    // Force garbage collection if available
+    if ((globalThis as any).gc) {
+      (globalThis as any).gc();
+    }
+
+    const initialMemory = this.getMemoryUsage();
+
+    await operationFn();
+
+    // Force garbage collection if available
+    if ((globalThis as any).gc) {
+      (globalThis as any).gc();
+    }
+
+    const finalMemory = this.getMemoryUsage();
+    const memoryIncrease = finalMemory - initialMemory;
+    const memoryPerRecord = memoryIncrease / recordCount;
+
+    const metrics: MemoryMetrics = {
+      operation,
+      initialMemory,
+      finalMemory,
+      memoryIncrease,
+      recordCount,
+      memoryPerRecord,
+    };
+
+    this.results.push(metrics);
+
+    console.log(
+      `  Initial Memory: ${(initialMemory / 1024 / 1024).toFixed(2)}MB`,
+    );
+    console.log(`  Final Memory: ${(finalMemory / 1024 / 1024).toFixed(2)}MB`);
+    console.log(
+      `  Memory Increase: ${(memoryIncrease / 1024 / 1024).toFixed(2)}MB`,
+    );
+    console.log(`  Memory per Record: ${memoryPerRecord.toFixed(2)} bytes`);
+    console.log();
+
+    return metrics;
+  }
+
+  printSummary() {
+    console.log("\n" + "=".repeat(80));
+    console.log("MEMORY USAGE SUMMARY");
+    console.log("=".repeat(80));
+
+    this.results.forEach((result) => {
+      console.log(`${result.operation}:`);
+      console.log(`  Records: ${result.recordCount.toLocaleString()}`);
+      console.log(
+        `  Memory Increase: ${
+          (result.memoryIncrease / 1024 / 1024).toFixed(2)
+        }MB`,
+      );
+      console.log(
+        `  Memory per Record: ${result.memoryPerRecord.toFixed(2)} bytes`,
+      );
+      console.log();
+    });
+  }
+}
+
+async function runMemoryBenchmarks() {
+  const benchmark = new MemoryBenchmark();
+  const db = new GunDB();
+
+  try {
+    const kvPath = await Deno.makeTempFile({
+      prefix: "kv_",
+      suffix: ".sqlite",
+    });
+    await db.ready(kvPath);
+
+    console.log("Starting Memory Benchmarks...\n");
+
+    // Benchmark 1: Small Records
+    await benchmark.measureMemoryUsage(
+      "Small Records (100 bytes)",
+      1000,
+      async () => {
+        for (let i = 0; i < 1000; i++) {
+          await db.put(`small:${i}`, {
+            id: i,
+            data: "x".repeat(100),
+            timestamp: Date.now(),
+          });
+        }
+      },
+    );
+
+    // Benchmark 2: Medium Records
+    await benchmark.measureMemoryUsage(
+      "Medium Records (1KB)",
+      1000,
+      async () => {
+        for (let i = 0; i < 1000; i++) {
+          await db.put(`medium:${i}`, {
+            id: i,
+            data: "x".repeat(1024),
+            timestamp: Date.now(),
+            metadata: { size: "medium", type: "test" },
+          });
+        }
+      },
+    );
+
+    // Benchmark 3: Large Records
+    await benchmark.measureMemoryUsage(
+      "Large Records (10KB)",
+      100,
+      async () => {
+        for (let i = 0; i < 100; i++) {
+          await db.put(`large:${i}`, {
+            id: i,
+            data: "x".repeat(10 * 1024),
+            timestamp: Date.now(),
+            metadata: { size: "large", type: "test" },
+            additional: "y".repeat(1024),
+          });
+        }
+      },
+    );
+
+    // Benchmark 4: Vector Data
+    await benchmark.measureMemoryUsage(
+      "Vector Data (100 dimensions)",
+      500,
+      async () => {
+        for (let i = 0; i < 500; i++) {
+          const vector = Array.from({ length: 100 }, () => Math.random());
+          await db.put(`vector:${i}`, {
+            id: i,
+            text: `Document ${i} with vector data`,
+            vector: vector,
+            timestamp: Date.now(),
+          });
+        }
+      },
+    );
+
+    // Benchmark 5: Nested Objects
+    await benchmark.measureMemoryUsage("Nested Objects", 500, async () => {
+      for (let i = 0; i < 500; i++) {
+        await db.put(`nested:${i}`, {
+          id: i,
+          user: {
+            name: `User ${i}`,
+            email: `user${i}@example.com`,
+            profile: {
+              age: 20 + (i % 50),
+              location: `City ${i}`,
+              preferences: {
+                theme: i % 2 === 0 ? "dark" : "light",
+                notifications: true,
+                privacy: "public",
+              },
+            },
+          },
+          metadata: {
+            created: Date.now(),
+            updated: Date.now(),
+            version: 1,
+          },
+        });
+      }
+    });
+
+    // Benchmark 6: Subscriptions Memory Usage
+    await benchmark.measureMemoryUsage("Subscriptions", 1000, async () => {
+      const subscriptions: Array<() => void> = [];
+      for (let i = 0; i < 1000; i++) {
+        const unsubscribe = db.on(`sub:${i}`, () => {});
+        subscriptions.push(unsubscribe);
+      }
+
+      // Store subscriptions for cleanup
+      (globalThis as any).subscriptions = subscriptions;
+    });
+
+    // Clean up subscriptions
+    if ((globalThis as any).subscriptions) {
+      ((globalThis as any).subscriptions as Array<() => void>).forEach((
+        unsubscribe,
+      ) => unsubscribe());
+      delete (globalThis as any).subscriptions;
+    }
+
+    // Benchmark 7: Type System Memory Usage
+    await benchmark.measureMemoryUsage("Type System", 1000, async () => {
+      for (let i = 0; i < 1000; i++) {
+        await db.put(`type:${i}`, { name: `Item ${i}` });
+        await db.setType(`type:${i}`, "TestItem");
+      }
+    });
+
+    // Benchmark 8: CRDT Operations Memory Usage
+    await benchmark.measureMemoryUsage("CRDT Operations", 1000, async () => {
+      for (let i = 0; i < 1000; i++) {
+        await db.put(`crdt:${i}`, {
+          value: i,
+          timestamp: Date.now(),
+          vectorClock: { peer1: i, peer2: i * 2 },
+        });
+      }
+    });
+
+    benchmark.printSummary();
+  } finally {
+    await db.close();
+  }
+}
+
+async function runMemoryLeakTests() {
+  console.log("\n" + "=".repeat(80));
+  console.log("MEMORY LEAK TESTS");
+  console.log("=".repeat(80));
+
+  const db = new GunDB();
+  try {
+    const kvPath = await Deno.makeTempFile({
+      prefix: "kv_",
+      suffix: ".sqlite",
+    });
+    await db.ready(kvPath);
+
+    // Test 1: Subscription Memory Leaks
+    console.log("Testing subscription memory leaks...");
+
+    const initialMemory = (performance as any).memory?.usedJSHeapSize || 0;
+
+    // Create and destroy many subscriptions
+    for (let cycle = 0; cycle < 10; cycle++) {
+      const subscriptions: Array<() => void> = [];
+
+      for (let i = 0; i < 100; i++) {
+        subscriptions.push(db.on(`leak:${cycle}:${i}`, () => {}));
+      }
+
+      // Destroy all subscriptions
+      subscriptions.forEach((unsubscribe) => unsubscribe());
+
+      // Force garbage collection if available
+      if ((globalThis as any).gc) {
+        (globalThis as any).gc();
+      }
+    }
+
+    const finalMemory = (performance as any).memory?.usedJSHeapSize || 0;
+    const memoryIncrease = finalMemory - initialMemory;
+
+    console.log(
+      `Memory increase after subscription cycles: ${
+        (memoryIncrease / 1024).toFixed(2)
+      }KB`,
+    );
+
+    if (memoryIncrease > 1024 * 1024) {
+      // More than 1MB
+      console.log("⚠️  Potential memory leak detected in subscriptions");
+    } else {
+      console.log("✓ No significant memory leak in subscriptions");
+    }
+
+    // Test 2: CRUD Operations Memory Leaks
+    console.log("\nTesting CRUD operations memory leaks...");
+
+    const crudInitialMemory = (performance as any).memory?.usedJSHeapSize || 0;
+
+    // Perform many CRUD operations
+    for (let cycle = 0; cycle < 100; cycle++) {
+      for (let i = 0; i < 100; i++) {
+        await db.put(`leak:${cycle}:${i}`, {
+          data: `Cycle ${cycle} Item ${i}`,
+        });
+        await db.get(`leak:${cycle}:${i}`);
+        await db.delete(`leak:${cycle}:${i}`);
+      }
+
+      // Force garbage collection if available
+      if ((globalThis as any).gc) {
+        (globalThis as any).gc();
+      }
+    }
+
+    const crudFinalMemory = (performance as any).memory?.usedJSHeapSize || 0;
+    const crudMemoryIncrease = crudFinalMemory - crudInitialMemory;
+
+    console.log(
+      `Memory increase after CRUD cycles: ${
+        (crudMemoryIncrease / 1024).toFixed(2)
+      }KB`,
+    );
+
+    if (crudMemoryIncrease > 1024 * 1024) {
+      // More than 1MB
+      console.log("⚠️  Potential memory leak detected in CRUD operations");
+    } else {
+      console.log("✓ No significant memory leak in CRUD operations");
+    }
+  } finally {
+    await db.close();
+  }
+}
+
+async function main() {
+  console.log("PluresDB Memory Benchmarks");
+  console.log("===========================\n");
+
+  try {
+    await runMemoryBenchmarks();
+    await runMemoryLeakTests();
+
+    console.log("\nMemory benchmarks completed successfully!");
+  } catch (error) {
+    console.error("Memory benchmark failed:", error);
+    Deno.exit(1);
+  }
+}
+
+if (import.meta.main) {
+  await main();
+}

package/legacy/benchmarks/run-benchmarks.ts

@@ -0,0 +1,315 @@
+#!/usr/bin/env -S deno run -A
+
+import { GunDB } from "../core/database.ts";
+
+interface BenchmarkResult {
+  name: string;
+  operations: number;
+  totalTime: number;
+  averageTime: number;
+  operationsPerSecond: number;
+  memoryUsage?: number;
+}
+
+class BenchmarkRunner {
+  private results: BenchmarkResult[] = [];
+
+  async runBenchmark(
+    name: string,
+    operations: number,
+    operation: () => Promise<void>,
+  ): Promise<BenchmarkResult> {
+    console.log(`Running benchmark: ${name} (${operations} operations)`);
+
+    const startTime = performance.now();
+    const startMemory = (performance as any).memory?.usedJSHeapSize || 0;
+
+    for (let i = 0; i < operations; i++) {
+      await operation();
+    }
+
+    const endTime = performance.now();
+    const endMemory = (performance as any).memory?.usedJSHeapSize || 0;
+
+    const totalTime = endTime - startTime;
+    const averageTime = totalTime / operations;
+    const operationsPerSecond = (operations / totalTime) * 1000;
+    const memoryUsage = endMemory - startMemory;
+
+    const result: BenchmarkResult = {
+      name,
+      operations,
+      totalTime,
+      averageTime,
+      operationsPerSecond,
+      memoryUsage,
+    };
+
+    this.results.push(result);
+    console.log(
+      `  ✓ ${operationsPerSecond.toFixed(2)} ops/sec (${
+        averageTime.toFixed(2)
+      }ms avg)`,
+    );
+
+    return result;
+  }
+
+  printSummary() {
+    console.log("\n" + "=".repeat(80));
+    console.log("BENCHMARK SUMMARY");
+    console.log("=".repeat(80));
+
+    this.results.forEach((result) => {
+      console.log(`${result.name}:`);
+      console.log(`  Operations: ${result.operations.toLocaleString()}`);
+      console.log(`  Total Time: ${result.totalTime.toFixed(2)}ms`);
+      console.log(`  Average Time: ${result.averageTime.toFixed(2)}ms`);
+      console.log(`  Operations/sec: ${result.operationsPerSecond.toFixed(2)}`);
+      if (result.memoryUsage) {
+        console.log(
+          `  Memory Usage: ${(result.memoryUsage / 1024 / 1024).toFixed(2)}MB`,
+        );
+      }
+      console.log();
+    });
+  }
+}
+
+async function runCoreBenchmarks() {
+  const runner = new BenchmarkRunner();
+  const db = new GunDB();
+
+  try {
+    const kvPath = await Deno.makeTempFile({
+      prefix: "kv_",
+      suffix: ".sqlite",
+    });
+    await db.ready(kvPath);
+
+    console.log("Starting Core Database Benchmarks...\n");
+
+    // Benchmark 1: Basic CRUD Operations
+    await runner.runBenchmark("Basic CRUD Operations", 1000, async () => {
+      const id = `crud:${Math.random()}`;
+      await db.put(id, { value: Math.random(), timestamp: Date.now() });
+      await db.get(id);
+      await db.delete(id);
+    });
+
+    // Benchmark 2: Bulk Insert
+    await runner.runBenchmark("Bulk Insert", 5000, async () => {
+      const id = `bulk:${Math.random()}`;
+      await db.put(id, {
+        data: "x".repeat(100),
+        timestamp: Date.now(),
+        random: Math.random(),
+      });
+    });
+
+    // Benchmark 3: Bulk Read
+    // First populate with data
+    for (let i = 0; i < 1000; i++) {
+      await db.put(`read:${i}`, { value: i, data: `Data ${i}` });
+    }
+
+    let readCount = 0;
+    await runner.runBenchmark("Bulk Read", 1000, async () => {
+      await db.get(`read:${readCount % 1000}`);
+      readCount++;
+    });
+
+    // Benchmark 4: Vector Search
+    // First populate with documents
+    for (let i = 0; i < 100; i++) {
+      await db.put(`doc:${i}`, {
+        text:
+          `Document ${i} about machine learning and artificial intelligence`,
+        content:
+          `This is document number ${i} containing information about AI and ML algorithms`,
+      });
+    }
+
+    const searchQueries = [
+      "machine learning",
+      "artificial intelligence",
+      "neural networks",
+      "deep learning",
+      "data science",
+    ];
+
+    let queryCount = 0;
+    await runner.runBenchmark("Vector Search", 100, async () => {
+      const query = searchQueries[queryCount % searchQueries.length];
+      await db.vectorSearch(query, 10);
+      queryCount++;
+    });
+
+    // Benchmark 5: Subscription Performance
+    const subscriptions: Array<() => void> = [];
+    for (let i = 0; i < 100; i++) {
+      subscriptions.push(db.on(`sub:${i}`, () => {}));
+    }
+
+    let updateCount = 0;
+    await runner.runBenchmark("Subscription Updates", 500, async () => {
+      await db.put(`sub:${updateCount % 100}`, {
+        update: updateCount,
+        timestamp: Date.now(),
+      });
+      updateCount++;
+    });
+
+    // Clean up subscriptions
+    subscriptions.forEach((unsubscribe) => unsubscribe());
+
+    // Benchmark 6: Type System Operations
+    await runner.runBenchmark("Type System Operations", 1000, async () => {
+      const id = `type:${Math.random()}`;
+      await db.put(id, { name: `Item ${Math.random()}` });
+      await db.setType(id, "TestItem");
+      await db.instancesOf("TestItem");
+    });
+
+    runner.printSummary();
+  } finally {
+    await db.close();
+  }
+}
+
+async function runNetworkBenchmarks() {
+  const runner = new BenchmarkRunner();
+
+  console.log("Starting Network Benchmarks...\n");
+
+  // Benchmark 1: WebSocket Connection Performance
+  const db = new GunDB();
+  try {
+    const kvPath = await Deno.makeTempFile({
+      prefix: "kv_",
+      suffix: ".sqlite",
+    });
+    await db.ready(kvPath);
+
+    const port = 18000 + Math.floor(Math.random() * 10000);
+    await db.serve({ port });
+
+    const serverUrl = `ws://localhost:${port}`;
+
+    await runner.runBenchmark("WebSocket Connections", 10, async () => {
+      const clientDb = new GunDB();
+      const clientKv = await Deno.makeTempFile({
+        prefix: "kv_client_",
+        suffix: ".sqlite",
+      });
+      await clientDb.ready(clientKv);
+
+      const connectionPromise = new Promise<void>((resolve, reject) => {
+        const ws = new WebSocket(serverUrl);
+        ws.onopen = () => {
+          ws.close();
+          resolve();
+        };
+        ws.onerror = reject;
+        setTimeout(() => reject(new Error("Connection timeout")), 5000);
+      });
+
+      await connectionPromise;
+      await clientDb.close();
+    });
+  } finally {
+    await db.close();
+  }
+
+  runner.printSummary();
+}
+
+async function runMemoryBenchmarks() {
+  const runner = new BenchmarkRunner();
+  const db = new GunDB();
+
+  try {
+    const kvPath = await Deno.makeTempFile({
+      prefix: "kv_",
+      suffix: ".sqlite",
+    });
+    await db.ready(kvPath);
+
+    console.log("Starting Memory Benchmarks...\n");
+
+    // Benchmark 1: Memory Usage with Large Datasets
+    const initialMemory = (performance as any).memory?.usedJSHeapSize || 0;
+
+    await runner.runBenchmark("Large Dataset Memory Usage", 1000, async () => {
+      const id = `memory:${Math.random()}`;
+      await db.put(id, {
+        data: "x".repeat(1024), // 1KB per record
+        timestamp: Date.now(),
+        random: Math.random(),
+      });
+    });
+
+    const finalMemory = (performance as any).memory?.usedJSHeapSize || 0;
+    const memoryIncrease = finalMemory - initialMemory;
+
+    console.log(
+      `Memory Usage: ${
+        (memoryIncrease / 1024 / 1024).toFixed(2)
+      }MB for 1000 records`,
+    );
+    console.log(
+      `Memory per record: ${(memoryIncrease / 1000).toFixed(2)} bytes`,
+    );
+
+    // Benchmark 2: Subscription Memory Usage
+    const subscriptionMemory = (performance as any).memory?.usedJSHeapSize || 0;
+
+    const subscriptions: Array<() => void> = [];
+    await runner.runBenchmark("Subscription Memory Usage", 1000, async () => {
+      const id = `sub:${Math.random()}`;
+      const unsubscribe = db.on(id, () => {});
+      subscriptions.push(unsubscribe);
+    });
+
+    const afterSubscriptionMemory =
+      (performance as any).memory?.usedJSHeapSize || 0;
+    const subscriptionMemoryIncrease = afterSubscriptionMemory -
+      subscriptionMemory;
+
+    console.log(
+      `Subscription Memory: ${
+        (subscriptionMemoryIncrease / 1024).toFixed(2)
+      }KB for 1000 subscriptions`,
+    );
+    console.log(
+      `Memory per subscription: ${
+        (subscriptionMemoryIncrease / 1000).toFixed(2)
+      } bytes`,
+    );
+
+    // Clean up subscriptions
+    subscriptions.forEach((unsubscribe) => unsubscribe());
+  } finally {
+    await db.close();
+  }
+}
+
+async function main() {
+  console.log("PluresDB Benchmark Suite");
+  console.log("========================\n");
+
+  try {
+    await runCoreBenchmarks();
+    await runNetworkBenchmarks();
+    await runMemoryBenchmarks();
+
+    console.log("All benchmarks completed successfully!");
+  } catch (error) {
+    console.error("Benchmark failed:", error);
+    Deno.exit(1);
+  }
+}
+
+if (import.meta.main) {
+  await main();
+}