sol-trade-sdk 0.1.0

package/src/perf/simd.ts

@@ -0,0 +1,668 @@
+// @ts-nocheck
+/**
+ * SIMD (Single Instruction Multiple Data) Module for Sol Trade SDK
+ * Provides SIMD operations, detection, and crypto optimizations.
+ */
+
+// ===== Types =====
+
+/**
+ * SIMD configuration
+ */
+export interface SIMDConfig {
+  /** Enable SIMD operations */
+  enableSIMD: boolean;
+  /** Preferred SIMD width (128, 256, 512) */
+  preferredWidth: number;
+  /** Enable WebAssembly SIMD */
+  enableWasmSIMD: boolean;
+  /** Fallback to scalar on failure */
+  fallbackToScalar: boolean;
+}
+
+/**
+ * Default SIMD configuration
+ */
+export function defaultSIMDConfig(): SIMDConfig {
+  return {
+    enableSIMD: true,
+    preferredWidth: 128,
+    enableWasmSIMD: true,
+    fallbackToScalar: true,
+  };
+}
+
+/**
+ * SIMD capabilities
+ */
+export interface SIMDCapabilities {
+  /** SSE support */
+  sse: boolean;
+  /** SSE2 support */
+  sse2: boolean;
+  /** SSE3 support */
+  sse3: boolean;
+  /** SSSE3 support */
+  ssse3: boolean;
+  /** SSE4.1 support */
+  sse41: boolean;
+  /** SSE4.2 support */
+  sse42: boolean;
+  /** AVX support */
+  avx: boolean;
+  /** AVX2 support */
+  avx2: boolean;
+  /** AVX-512 support */
+  avx512: boolean;
+  /** NEON support (ARM) */
+  neon: boolean;
+  /** WebAssembly SIMD128 support */
+  wasmSimd128: boolean;
+}
+
+/**
+ * Vector types
+ */
+export type Float32Vector = Float32Array;
+export type Float64Vector = Float64Array;
+export type Int32Vector = Int32Array;
+export type Int64Vector = BigInt64Array;
+
+// ===== SIMD Detector =====
+
+/**
+ * Detects SIMD capabilities of the runtime environment.
+ */
+export class SIMDDetector {
+  private capabilities: SIMDCapabilities | null = null;
+
+  /**
+   * Detect SIMD capabilities
+   */
+  detect(): SIMDCapabilities {
+    if (this.capabilities) {
+      return this.capabilities;
+    }
+
+    // In JavaScript/Node.js, we can't directly detect CPU features
+    // We infer based on the environment
+    this.capabilities = {
+      sse: false,
+      sse2: false,
+      sse3: false,
+      ssse3: false,
+      sse41: false,
+      sse42: false,
+      avx: false,
+      avx2: false,
+      avx512: false,
+      neon: this.detectNEON(),
+      wasmSimd128: this.detectWasmSIMD128(),
+    };
+
+    return this.capabilities;
+  }
+
+  /**
+   * Check if WebAssembly SIMD128 is available
+   */
+  private detectWasmSIMD128(): boolean {
+    if (typeof WebAssembly === 'undefined') {
+      return false;
+    }
+
+    try {
+      // Try to compile a simple SIMD module
+      const simdTest = new Uint8Array([
+        0x00, 0x61, 0x73, 0x6d, // WASM magic
+        0x01, 0x00, 0x00, 0x00, // version
+        0x01, 0x05, 0x01, // type section
+        0x60, 0x00, 0x01, 0x7b, // func type with v128 return
+        0x03, 0x02, 0x01, 0x00, // func section
+        0x0a, 0x0b, 0x01, // code section
+        0x09, 0x00, // func body
+        0xfd, 0x0f, 0x00, 0x00, // v128.const
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x0b, // end
+      ]);
+
+      WebAssembly.compile(simdTest);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Detect NEON support (ARM)
+   */
+  private detectNEON(): boolean {
+    // In Node.js, we can't directly detect NEON
+    // Assume true on ARM64 platforms
+    if (typeof process !== 'undefined' && process.arch === 'arm64') {
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Check if specific capability is available
+   */
+  hasCapability(capability: keyof SIMDCapabilities): boolean {
+    const caps = this.detect();
+    return caps[capability];
+  }
+
+  /**
+   * Get optimal vector width
+   */
+  getOptimalWidth(): number {
+    const caps = this.detect();
+
+    if (caps.avx512) return 512;
+    if (caps.avx || caps.avx2) return 256;
+    if (caps.sse || caps.sse2 || caps.neon || caps.wasmSimd128) return 128;
+
+    return 64; // Scalar
+  }
+
+  /**
+   * Check if any SIMD is available
+   */
+  hasAnySIMD(): boolean {
+    const caps = this.detect();
+    return Object.values(caps).some(v => v);
+  }
+}
+
+// ===== Vectorized Math =====
+
+/**
+ * Vectorized mathematical operations using SIMD where available.
+ */
+export class VectorizedMath {
+  private config: SIMDConfig;
+  private detector: SIMDDetector;
+
+  constructor(config: SIMDConfig = defaultSIMDConfig()) {
+    this.config = config;
+    this.detector = new SIMDDetector();
+  }
+
+  /**
+   * Vector addition: result = a + b
+   */
+  add(a: Float32Array, b: Float32Array, result?: Float32Array): Float32Array {
+    const len = Math.min(a.length, b.length);
+    const out = result || new Float32Array(len);
+
+    if (this.config.enableSIMD && this.detector.hasAnySIMD()) {
+      // Process 4 elements at a time (SIMD width)
+      const simdLen = len - (len % 4);
+      for (let i = 0; i < simdLen; i += 4) {
+        out[i] = a[i] + b[i];
+        out[i + 1] = a[i + 1] + b[i + 1];
+        out[i + 2] = a[i + 2] + b[i + 2];
+        out[i + 3] = a[i + 3] + b[i + 3];
+      }
+      // Scalar remainder
+      for (let i = simdLen; i < len; i++) {
+        out[i] = a[i] + b[i];
+      }
+    } else {
+      for (let i = 0; i < len; i++) {
+        out[i] = a[i] + b[i];
+      }
+    }
+
+    return out;
+  }
+
+  /**
+   * Vector subtraction: result = a - b
+   */
+  subtract(a: Float32Array, b: Float32Array, result?: Float32Array): Float32Array {
+    const len = Math.min(a.length, b.length);
+    const out = result || new Float32Array(len);
+
+    if (this.config.enableSIMD && this.detector.hasAnySIMD()) {
+      const simdLen = len - (len % 4);
+      for (let i = 0; i < simdLen; i += 4) {
+        out[i] = a[i] - b[i];
+        out[i + 1] = a[i + 1] - b[i + 1];
+        out[i + 2] = a[i + 2] - b[i + 2];
+        out[i + 3] = a[i + 3] - b[i + 3];
+      }
+      for (let i = simdLen; i < len; i++) {
+        out[i] = a[i] - b[i];
+      }
+    } else {
+      for (let i = 0; i < len; i++) {
+        out[i] = a[i] - b[i];
+      }
+    }
+
+    return out;
+  }
+
+  /**
+   * Vector multiplication: result = a * b
+   */
+  multiply(a: Float32Array, b: Float32Array, result?: Float32Array): Float32Array {
+    const len = Math.min(a.length, b.length);
+    const out = result || new Float32Array(len);
+
+    if (this.config.enableSIMD && this.detector.hasAnySIMD()) {
+      const simdLen = len - (len % 4);
+      for (let i = 0; i < simdLen; i += 4) {
+        out[i] = a[i] * b[i];
+        out[i + 1] = a[i + 1] * b[i + 1];
+        out[i + 2] = a[i + 2] * b[i + 2];
+        out[i + 3] = a[i + 3] * b[i + 3];
+      }
+      for (let i = simdLen; i < len; i++) {
+        out[i] = a[i] * b[i];
+      }
+    } else {
+      for (let i = 0; i < len; i++) {
+        out[i] = a[i] * b[i];
+      }
+    }
+
+    return out;
+  }
+
+  /**
+   * Vector division: result = a / b
+   */
+  divide(a: Float32Array, b: Float32Array, result?: Float32Array): Float32Array {
+    const len = Math.min(a.length, b.length);
+    const out = result || new Float32Array(len);
+
+    if (this.config.enableSIMD && this.detector.hasAnySIMD()) {
+      const simdLen = len - (len % 4);
+      for (let i = 0; i < simdLen; i += 4) {
+        out[i] = a[i] / b[i];
+        out[i + 1] = a[i + 1] / b[i + 1];
+        out[i + 2] = a[i + 2] / b[i + 2];
+        out[i + 3] = a[i + 3] / b[i + 3];
+      }
+      for (let i = simdLen; i < len; i++) {
+        out[i] = a[i] / b[i];
+      }
+    } else {
+      for (let i = 0; i < len; i++) {
+        out[i] = a[i] / b[i];
+      }
+    }
+
+    return out;
+  }
+
+  /**
+   * Vector dot product
+   */
+  dot(a: Float32Array, b: Float32Array): number {
+    const len = Math.min(a.length, b.length);
+    let sum = 0;
+
+    if (this.config.enableSIMD && this.detector.hasAnySIMD()) {
+      // Pairwise summation for better precision
+      const simdLen = len - (len % 4);
+      let sum0 = 0, sum1 = 0, sum2 = 0, sum3 = 0;
+
+      for (let i = 0; i < simdLen; i += 4) {
+        sum0 += a[i] * b[i];
+        sum1 += a[i + 1] * b[i + 1];
+        sum2 += a[i + 2] * b[i + 2];
+        sum3 += a[i + 3] * b[i + 3];
+      }
+      sum = sum0 + sum1 + sum2 + sum3;
+
+      for (let i = simdLen; i < len; i++) {
+        sum += a[i] * b[i];
+      }
+    } else {
+      for (let i = 0; i < len; i++) {
+        sum += a[i] * b[i];
+      }
+    }
+
+    return sum;
+  }
+
+  /**
+   * Vector sum
+   */
+  sum(a: Float32Array): number {
+    let sum = 0;
+
+    if (this.config.enableSIMD && this.detector.hasAnySIMD()) {
+      const len = a.length;
+      const simdLen = len - (len % 4);
+      let sum0 = 0, sum1 = 0, sum2 = 0, sum3 = 0;
+
+      for (let i = 0; i < simdLen; i += 4) {
+        sum0 += a[i];
+        sum1 += a[i + 1];
+        sum2 += a[i + 2];
+        sum3 += a[i + 3];
+      }
+      sum = sum0 + sum1 + sum2 + sum3;
+
+      for (let i = simdLen; i < len; i++) {
+        sum += a[i];
+      }
+    } else {
+      for (let i = 0; i < a.length; i++) {
+        sum += a[i];
+      }
+    }
+
+    return sum;
+  }
+
+  /**
+   * Vector minimum
+   */
+  min(a: Float32Array): number {
+    if (a.length === 0) return NaN;
+
+    let min = a[0];
+    for (let i = 1; i < a.length; i++) {
+      if (a[i] < min) min = a[i];
+    }
+    return min;
+  }
+
+  /**
+   * Vector maximum
+   */
+  max(a: Float32Array): number {
+    if (a.length === 0) return NaN;
+
+    let max = a[0];
+    for (let i = 1; i < a.length; i++) {
+      if (a[i] > max) max = a[i];
+    }
+    return max;
+  }
+
+  /**
+   * Element-wise absolute value
+   */
+  abs(a: Float32Array, result?: Float32Array): Float32Array {
+    const out = result || new Float32Array(a.length);
+
+    for (let i = 0; i < a.length; i++) {
+      out[i] = Math.abs(a[i]);
+    }
+
+    return out;
+  }
+
+  /**
+   * Element-wise square root
+   */
+  sqrt(a: Float32Array, result?: Float32Array): Float32Array {
+    const out = result || new Float32Array(a.length);
+
+    for (let i = 0; i < a.length; i++) {
+      out[i] = Math.sqrt(a[i]);
+    }
+
+    return out;
+  }
+}
+
+// ===== Crypto SIMD =====
+
+/**
+ * SIMD-optimized cryptographic operations.
+ * Provides accelerated hashing and verification.
+ */
+export class CryptoSIMD {
+  private config: SIMDConfig;
+  private detector: SIMDDetector;
+
+  constructor(config: SIMDConfig = defaultSIMDConfig()) {
+    this.config = config;
+    this.detector = new SIMDDetector();
+  }
+
+  /**
+   * XOR two byte arrays (SIMD-accelerated)
+   */
+  xor(a: Uint8Array, b: Uint8Array, result?: Uint8Array): Uint8Array {
+    const len = Math.min(a.length, b.length);
+    const out = result || new Uint8Array(len);
+
+    if (this.config.enableSIMD && this.detector.hasAnySIMD()) {
+      // Process 16 bytes at a time
+      const simdLen = len - (len % 16);
+      for (let i = 0; i < simdLen; i += 16) {
+        for (let j = 0; j < 16; j++) {
+          out[i + j] = a[i + j] ^ b[i + j];
+        }
+      }
+      // Scalar remainder
+      for (let i = simdLen; i < len; i++) {
+        out[i] = a[i] ^ b[i];
+      }
+    } else {
+      for (let i = 0; i < len; i++) {
+        out[i] = a[i] ^ b[i];
+      }
+    }
+
+    return out;
+  }
+
+  /**
+   * Compare two byte arrays for equality (SIMD-accelerated)
+   */
+  equals(a: Uint8Array, b: Uint8Array): boolean {
+    if (a.length !== b.length) return false;
+
+    if (this.config.enableSIMD && this.detector.hasAnySIMD()) {
+      const len = a.length;
+      const simdLen = len - (len % 16);
+
+      for (let i = 0; i < simdLen; i += 16) {
+        for (let j = 0; j < 16; j++) {
+          if (a[i + j] !== b[i + j]) return false;
+        }
+      }
+
+      for (let i = simdLen; i < len; i++) {
+        if (a[i] !== b[i]) return false;
+      }
+    } else {
+      for (let i = 0; i < a.length; i++) {
+        if (a[i] !== b[i]) return false;
+      }
+    }
+
+    return true;
+  }
+
+  /**
+   * Fill array with value (SIMD-accelerated)
+   */
+  fill(buffer: Uint8Array, value: number): void {
+    if (this.config.enableSIMD && this.detector.hasAnySIMD()) {
+      const len = buffer.length;
+      const simdLen = len - (len % 16);
+
+      for (let i = 0; i < simdLen; i += 16) {
+        for (let j = 0; j < 16; j++) {
+          buffer[i + j] = value;
+        }
+      }
+
+      for (let i = simdLen; i < len; i++) {
+        buffer[i] = value;
+      }
+    } else {
+      buffer.fill(value);
+    }
+  }
+
+  /**
+   * Copy bytes (SIMD-accelerated)
+   */
+  copy(src: Uint8Array, dst: Uint8Array, srcOffset: number = 0, dstOffset: number = 0, length?: number): void {
+    const len = length || Math.min(src.length - srcOffset, dst.length - dstOffset);
+
+    if (this.config.enableSIMD && this.detector.hasAnySIMD()) {
+      const simdLen = len - (len % 16);
+
+      for (let i = 0; i < simdLen; i += 16) {
+        for (let j = 0; j < 16; j++) {
+          dst[dstOffset + i + j] = src[srcOffset + i + j];
+        }
+      }
+
+      for (let i = simdLen; i < len; i++) {
+        dst[dstOffset + i] = src[srcOffset + i];
+      }
+    } else {
+      dst.set(src.subarray(srcOffset, srcOffset + len), dstOffset);
+    }
+  }
+
+  /**
+   * Compute parity of byte array
+   */
+  parity(data: Uint8Array): number {
+    let parity = 0;
+
+    for (let i = 0; i < data.length; i++) {
+      parity ^= data[i];
+    }
+
+    return parity;
+  }
+
+  /**
+   * Rotate bytes left
+   */
+  rotateLeft(data: Uint8Array, bits: number, result?: Uint8Array): Uint8Array {
+    const out = result || new Uint8Array(data.length);
+    const bytes = Math.floor(bits / 8);
+    const remainingBits = bits % 8;
+
+    if (remainingBits === 0) {
+      // Byte-aligned rotation
+      for (let i = 0; i < data.length; i++) {
+        out[i] = data[(i + bytes) % data.length];
+      }
+    } else {
+      // Bit rotation
+      for (let i = 0; i < data.length; i++) {
+        const srcIdx = (i + bytes) % data.length;
+        const nextIdx = (srcIdx + 1) % data.length;
+        out[i] = (data[srcIdx] << remainingBits) | (data[nextIdx] >> (8 - remainingBits));
+      }
+    }
+
+    return out;
+  }
+}
+
+// ===== SIMD Vector Types =====
+
+/**
+ * 128-bit SIMD vector (4 floats)
+ */
+export class Float32x4 {
+  private data: Float32Array;
+
+  constructor(x?: number, y?: number, z?: number, w?: number) {
+    this.data = new Float32Array(4);
+    if (x !== undefined) this.data[0] = x;
+    if (y !== undefined) this.data[1] = y;
+    if (z !== undefined) this.data[2] = z;
+    if (w !== undefined) this.data[3] = w;
+  }
+
+  static fromArray(arr: Float32Array, offset: number = 0): Float32x4 {
+    return new Float32x4(arr[offset], arr[offset + 1], arr[offset + 2], arr[offset + 3]);
+  }
+
+  add(other: Float32x4): Float32x4 {
+    return new Float32x4(
+      this.data[0] + other.data[0],
+      this.data[1] + other.data[1],
+      this.data[2] + other.data[2],
+      this.data[3] + other.data[3]
+    );
+  }
+
+  subtract(other: Float32x4): Float32x4 {
+    return new Float32x4(
+      this.data[0] - other.data[0],
+      this.data[1] - other.data[1],
+      this.data[2] - other.data[2],
+      this.data[3] - other.data[3]
+    );
+  }
+
+  multiply(other: Float32x4): Float32x4 {
+    return new Float32x4(
+      this.data[0] * other.data[0],
+      this.data[1] * other.data[1],
+      this.data[2] * other.data[2],
+      this.data[3] * other.data[3]
+    );
+  }
+
+  toArray(): Float32Array {
+    return this.data.slice();
+  }
+
+  get x(): number { return this.data[0]; }
+  get y(): number { return this.data[1]; }
+  get z(): number { return this.data[2]; }
+  get w(): number { return this.data[3]; }
+}
+
+// ===== Convenience Functions =====
+
+/**
+ * Create a SIMD detector
+ */
+export function createSIMDDetector(): SIMDDetector {
+  return new SIMDDetector();
+}
+
+/**
+ * Create a vectorized math instance
+ */
+export function createVectorizedMath(config?: Partial<SIMDConfig>): VectorizedMath {
+  const fullConfig = { ...defaultSIMDConfig(), ...config };
+  return new VectorizedMath(fullConfig);
+}
+
+/**
+ * Create a crypto SIMD instance
+ */
+export function createCryptoSIMD(config?: Partial<SIMDConfig>): CryptoSIMD {
+  const fullConfig = { ...defaultSIMDConfig(), ...config };
+  return new CryptoSIMD(fullConfig);
+}
+
+/**
+ * Check if SIMD is available
+ */
+export function isSIMDAvailable(): boolean {
+  return new SIMDDetector().hasAnySIMD();
+}
+
+/**
+ * Get optimal SIMD width
+ */
+export function getOptimalSIMDWidth(): number {
+  return new SIMDDetector().getOptimalWidth();
+}