semantic-ds-toolkit/dist/src/optimization/batch-processor-v2.d.ts

Performance-first semantic layer for modern data stacks - Stable Column Anchors & intelligent inference

import { ColumnData } from '../types/anchor.types';
export interface OptimizedBatchOptions {
    batchSize: number;
    maxWorkers: number;
    useSharedMemory: boolean;
    enableSIMD: boolean;
    objectPooling: boolean;
    streamingMode: boolean;
    memoryLimit: number;
}
export interface ProcessingResult {
    data: any[];
    throughput: number;
    latency: number;
    memoryEfficiency: number;
    cpuUtilization?: number;
}
export interface SharedBufferMetadata {
    length: number;
    type: 'Float32Array' | 'Float64Array' | 'Uint8Array';
    offset: number;
    byteLength: number;
}
export declare class ObjectPool<T> {
    private pool;
    private factory;
    private reset;
    private maxSize;
    constructor(factory: () => T, reset: (obj: T) => void, maxSize?: number);
    acquire(): T;
    release(obj: T): void;
    getSize(): number;
}
export declare class RingBuffer {
    private buffer;
    private writePtr;
    private readPtr;
    private size;
    private view;
    constructor(size: number);
    write(data: Uint8Array): boolean;
    read(length: number): Uint8Array | null;
    available(): number;
    used(): number;
    getBuffer(): SharedArrayBuffer;
}
export declare class SIMDOperations {
    static processColumnsSIMD(data: Float32Array, results: Float32Array): void;
    static xxHash32(input: number): number;
    static vectorSum(values: Float64Array): number;
    static vectorDot(a: Float64Array, b: Float64Array): number;
    static vectorDistance(a: Float64Array, b: Float64Array): number;
}
export declare class WorkerPool {
    private workers;
    private availableWorkers;
    private jobQueue;
    private workerScript;
    constructor(size?: number);
    private generateWorkerScript;
    private initializeWorkers;
    private handleWorkerMessage;
    private handleWorkerError;
    process(data: ArrayBuffer | SharedArrayBuffer, metadata: SharedBufferMetadata): Promise<any>;
    private processNextJob;
    destroy(): void;
}
export declare class OptimizedBatchProcessorV2 {
    private options;
    private workerPool;
    private columnPool;
    private resultPool;
    private ringBuffer;
    private processingStats;
    constructor(options: OptimizedBatchOptions);
    processColumns(columns: ColumnData[], processor: (column: ColumnData) => any): Promise<ProcessingResult>;
    private processStandardBatch;
    private processWithWorkers;
    private processStreamingBatch;
    private processBatchChunk;
    private processBatchSIMD;
    private optimizeColumnForProcessing;
    private createBatches;
    private createDataStream;
    private updateStats;
    private simpleHash;
    benchmark(testData: ColumnData[], processor: (column: ColumnData) => any, iterations?: number): Promise<{
        averageThroughput: number;
        peakThroughput: number;
        averageLatency: number;
        memoryEfficiency: number;
        p50Latency: number;
        p99Latency: number;
    }>;
    getStats(): {
        totalRows: number;
        totalTime: number;
        peakThroughput: number;
        averageThroughput: number;
        memoryUsage: number;
    };
    cleanup(): void;
}
export declare const optimizedBatchProcessor: OptimizedBatchProcessorV2;
//# sourceMappingURL=batch-processor-v2.d.ts.map