ruvector 0.2.23 → 0.2.25

package/dist/core/neural-perf.d.ts

@@ -0,0 +1,331 @@
+/**
+ * Neural Performance Optimizations
+ *
+ * High-performance utilities for neural embedding operations:
+ * - O(1) LRU Cache with doubly-linked list + hash map
+ * - Parallel batch processing
+ * - Pre-allocated Float32Array buffer pools
+ * - Tensor buffer reuse
+ * - 8x loop unrolling for vector operations
+ */
+export declare const PERF_CONSTANTS: {
+    readonly DEFAULT_CACHE_SIZE: 1000;
+    readonly DEFAULT_BUFFER_POOL_SIZE: 64;
+    readonly DEFAULT_BATCH_SIZE: 32;
+    readonly MIN_PARALLEL_BATCH_SIZE: 8;
+    readonly UNROLL_THRESHOLD: 32;
+};
+/**
+ * High-performance LRU Cache with O(1) get, set, and eviction.
+ * Uses doubly-linked list for ordering + hash map for O(1) lookup.
+ */
+export declare class LRUCache<K, V> {
+    private capacity;
+    private map;
+    private head;
+    private tail;
+    private hits;
+    private misses;
+    constructor(capacity?: number);
+    /**
+     * Get value from cache - O(1)
+     */
+    get(key: K): V | undefined;
+    /**
+     * Set value in cache - O(1)
+     */
+    set(key: K, value: V): void;
+    /**
+     * Check if key exists - O(1)
+     */
+    has(key: K): boolean;
+    /**
+     * Delete key from cache - O(1)
+     */
+    delete(key: K): boolean;
+    /**
+     * Clear entire cache - O(1)
+     */
+    clear(): void;
+    /**
+     * Get cache size
+     */
+    get size(): number;
+    /**
+     * Get cache statistics
+     */
+    getStats(): {
+        size: number;
+        capacity: number;
+        hits: number;
+        misses: number;
+        hitRate: number;
+    };
+    /**
+     * Reset statistics
+     */
+    resetStats(): void;
+    private moveToHead;
+    private addToHead;
+    private removeNode;
+    private evictLRU;
+    /**
+     * Iterate over entries (most recent first)
+     */
+    entries(): Generator<[K, V]>;
+}
+/**
+ * High-performance buffer pool for Float32Arrays.
+ * Eliminates GC pressure by reusing pre-allocated buffers.
+ */
+export declare class Float32BufferPool {
+    private pools;
+    private maxPoolSize;
+    private allocations;
+    private reuses;
+    constructor(maxPoolSize?: number);
+    /**
+     * Acquire a buffer of specified size - O(1) amortized
+     */
+    acquire(size: number): Float32Array;
+    /**
+     * Release a buffer back to the pool - O(1)
+     */
+    release(buffer: Float32Array): void;
+    /**
+     * Pre-warm the pool with buffers of specific sizes
+     */
+    prewarm(sizes: number[], count?: number): void;
+    /**
+     * Clear all pools
+     */
+    clear(): void;
+    /**
+     * Get pool statistics
+     */
+    getStats(): {
+        allocations: number;
+        reuses: number;
+        reuseRate: number;
+        pooledBuffers: number;
+    };
+}
+/**
+ * Manages reusable tensor buffers for intermediate computations.
+ * Reduces allocations in hot paths.
+ */
+export declare class TensorBufferManager {
+    private bufferPool;
+    private workingBuffers;
+    constructor(pool?: Float32BufferPool);
+    /**
+     * Get or create a named working buffer
+     */
+    getWorking(name: string, size: number): Float32Array;
+    /**
+     * Get a temporary buffer (caller must release)
+     */
+    getTemp(size: number): Float32Array;
+    /**
+     * Release a temporary buffer
+     */
+    releaseTemp(buffer: Float32Array): void;
+    /**
+     * Release all working buffers
+     */
+    releaseAll(): void;
+    /**
+     * Get underlying pool for stats
+     */
+    getPool(): Float32BufferPool;
+}
+/**
+ * High-performance vector operations with 8x loop unrolling.
+ * Provides 15-30% speedup on large vectors.
+ */
+export declare const VectorOps: {
+    /**
+     * Dot product with 8x unrolling
+     */
+    dot(a: Float32Array, b: Float32Array): number;
+    /**
+     * Squared L2 norm with 8x unrolling
+     */
+    normSq(a: Float32Array): number;
+    /**
+     * L2 norm
+     */
+    norm(a: Float32Array): number;
+    /**
+     * Cosine similarity - optimized for V8 JIT
+     * Uses 4x unrolling which benchmarks faster than 8x due to register pressure
+     */
+    cosine(a: Float32Array, b: Float32Array): number;
+    /**
+     * Euclidean distance squared with 8x unrolling
+     */
+    distanceSq(a: Float32Array, b: Float32Array): number;
+    /**
+     * Euclidean distance
+     */
+    distance(a: Float32Array, b: Float32Array): number;
+    /**
+     * Add vectors: out = a + b (with 8x unrolling)
+     */
+    add(a: Float32Array, b: Float32Array, out: Float32Array): Float32Array;
+    /**
+     * Subtract vectors: out = a - b (with 8x unrolling)
+     */
+    sub(a: Float32Array, b: Float32Array, out: Float32Array): Float32Array;
+    /**
+     * Scale vector: out = a * scalar (with 8x unrolling)
+     */
+    scale(a: Float32Array, scalar: number, out: Float32Array): Float32Array;
+    /**
+     * Normalize vector in-place
+     */
+    normalize(a: Float32Array): Float32Array;
+    /**
+     * Mean of multiple vectors (with buffer reuse)
+     */
+    mean(vectors: Float32Array[], out: Float32Array): Float32Array;
+};
+export interface BatchResult<T> {
+    results: T[];
+    timing: {
+        totalMs: number;
+        perItemMs: number;
+    };
+}
+/**
+ * Parallel batch processor for embedding operations.
+ * Uses chunking and Promise.all for concurrent processing.
+ */
+export declare class ParallelBatchProcessor {
+    private batchSize;
+    private maxConcurrency;
+    constructor(options?: {
+        batchSize?: number;
+        maxConcurrency?: number;
+    });
+    /**
+     * Process items in parallel batches
+     */
+    processBatch<T, R>(items: T[], processor: (item: T, index: number) => Promise<R> | R): Promise<BatchResult<R>>;
+    /**
+     * Process with synchronous function (uses chunking for better cache locality)
+     */
+    processSync<T, R>(items: T[], processor: (item: T, index: number) => R): BatchResult<R>;
+    /**
+     * Batch similarity search (optimized for many queries)
+     */
+    batchSimilarity(queries: Float32Array[], corpus: Float32Array[], k?: number): Array<Array<{
+        index: number;
+        score: number;
+    }>>;
+    private chunkArray;
+}
+export interface CachedMemoryEntry {
+    id: string;
+    embedding: Float32Array;
+    content: string;
+    score: number;
+}
+/**
+ * High-performance memory store with O(1) LRU caching.
+ */
+export declare class OptimizedMemoryStore {
+    private cache;
+    private bufferPool;
+    private dimension;
+    constructor(options?: {
+        cacheSize?: number;
+        dimension?: number;
+    });
+    /**
+     * Store embedding - O(1)
+     */
+    store(id: string, embedding: Float32Array | number[], content: string): void;
+    /**
+     * Get by ID - O(1)
+     */
+    get(id: string): CachedMemoryEntry | undefined;
+    /**
+     * Search by similarity - O(n) but with optimized vector ops
+     */
+    search(query: Float32Array, k?: number): CachedMemoryEntry[];
+    /**
+     * Delete entry - O(1)
+     */
+    delete(id: string): boolean;
+    /**
+     * Get statistics
+     */
+    getStats(): {
+        cache: ReturnType<LRUCache<string, CachedMemoryEntry>['getStats']>;
+        buffers: ReturnType<Float32BufferPool['getStats']>;
+    };
+}
+declare const _default: {
+    LRUCache: typeof LRUCache;
+    Float32BufferPool: typeof Float32BufferPool;
+    TensorBufferManager: typeof TensorBufferManager;
+    VectorOps: {
+        /**
+         * Dot product with 8x unrolling
+         */
+        dot(a: Float32Array, b: Float32Array): number;
+        /**
+         * Squared L2 norm with 8x unrolling
+         */
+        normSq(a: Float32Array): number;
+        /**
+         * L2 norm
+         */
+        norm(a: Float32Array): number;
+        /**
+         * Cosine similarity - optimized for V8 JIT
+         * Uses 4x unrolling which benchmarks faster than 8x due to register pressure
+         */
+        cosine(a: Float32Array, b: Float32Array): number;
+        /**
+         * Euclidean distance squared with 8x unrolling
+         */
+        distanceSq(a: Float32Array, b: Float32Array): number;
+        /**
+         * Euclidean distance
+         */
+        distance(a: Float32Array, b: Float32Array): number;
+        /**
+         * Add vectors: out = a + b (with 8x unrolling)
+         */
+        add(a: Float32Array, b: Float32Array, out: Float32Array): Float32Array;
+        /**
+         * Subtract vectors: out = a - b (with 8x unrolling)
+         */
+        sub(a: Float32Array, b: Float32Array, out: Float32Array): Float32Array;
+        /**
+         * Scale vector: out = a * scalar (with 8x unrolling)
+         */
+        scale(a: Float32Array, scalar: number, out: Float32Array): Float32Array;
+        /**
+         * Normalize vector in-place
+         */
+        normalize(a: Float32Array): Float32Array;
+        /**
+         * Mean of multiple vectors (with buffer reuse)
+         */
+        mean(vectors: Float32Array[], out: Float32Array): Float32Array;
+    };
+    ParallelBatchProcessor: typeof ParallelBatchProcessor;
+    OptimizedMemoryStore: typeof OptimizedMemoryStore;
+    PERF_CONSTANTS: {
+        readonly DEFAULT_CACHE_SIZE: 1000;
+        readonly DEFAULT_BUFFER_POOL_SIZE: 64;
+        readonly DEFAULT_BATCH_SIZE: 32;
+        readonly MIN_PARALLEL_BATCH_SIZE: 8;
+        readonly UNROLL_THRESHOLD: 32;
+    };
+};
+export default _default;
+//# sourceMappingURL=neural-perf.d.ts.map

package/dist/core/neural-perf.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"neural-perf.d.ts","sourceRoot":"","sources":["../../src/core/neural-perf.ts"],"names":[],"mappings":"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"}