perf: WASM SIMD for int64 aggregates + parallel column reads

Two performance optimizations:

1. Int64 aggregates now use WASM SIMD (sumInt64Buffer, minInt64Buffer,
   maxInt64Buffer) instead of a JS loop over BigInt64Array. This was
   the single largest compute bottleneck — ~50% slower than the float64
   path which already used WASM.

2. ScanOperator now reads all columns for a page in parallel via
   Promise.all() instead of sequential awaits. For a 5-column table,
   this overlaps 5 R2 range requests instead of waiting for each one.

Author: teamchong

src/operators.ts

@@ -82,19 +82,24 @@ export class ScanOperator implements Operator {
 
         const scanStart = Date.now();
 
-        // Read + decode this page for all columns
+        // Read all columns for this page in parallel (overlaps R2 range requests)
         const pageInfoMap = new Map<string, { buf: ArrayBuffer; pageInfo: PageInfo }>();
+        const readPromises: Promise<void>[] = [];
         for (const col of frag.columns) {
           const colPage = col.pages[pi];
           if (!colPage) continue;
           if (!this.query.vectorSearch && canSkipPage(colPage, this.query.filters, col.name)) {
             this.pagesSkipped++;
             continue;
           }
-          const buf = await frag.readPage(col, colPage);
-          this.bytesRead += buf.byteLength;
-          pageInfoMap.set(col.name, { buf, pageInfo: colPage });
+          readPromises.push(
+            frag.readPage(col, colPage).then(buf => {
+              this.bytesRead += buf.byteLength;
+              pageInfoMap.set(col.name, { buf, pageInfo: colPage });
+            }),
+          );
         }
+        await Promise.all(readPromises);
 
         // Decode columns for this single page
         const decoded = decodePageBatch(pageInfoMap, frag.columns, this.wasm);
@@ -1005,13 +1010,16 @@ export class WasmAggregateOperator implements Operator {
           } else if (col.dtype === "int64") {
             const count = buf.byteLength >> 3;
             acc[ai].count += count;
-            // For int64 we need to read values as BigInt64Array
-            const view = new BigInt64Array(buf);
-            for (const v of view) {
-              const n = Number(v);
-              acc[ai].sum += n;
-              if (n < acc[ai].min) acc[ai].min = n;
-              if (n > acc[ai].max) acc[ai].max = n;
+            if (agg.fn === "sum" || agg.fn === "avg") {
+              acc[ai].sum += Number(this.wasm.sumInt64(buf));
+            }
+            if (agg.fn === "min") {
+              const v = Number(this.wasm.minInt64(buf));
+              if (v < acc[ai].min) acc[ai].min = v;
+            }
+            if (agg.fn === "max") {
+              const v = Number(this.wasm.maxInt64(buf));
+              if (v > acc[ai].max) acc[ai].max = v;
             }
           }
         }

src/wasm-engine.ts

@@ -549,6 +549,36 @@ export class WasmEngine {
     return this.exports.avgFloat64Buffer(ptr >> 3, numElements);
   }
 
+  /** SIMD sum of Int64 buffer. Returns 0n for empty input. */
+  sumInt64(buf: ArrayBuffer): bigint {
+    if (buf.byteLength === 0) return 0n;
+    const numElements = buf.byteLength >> 3;
+    const ptr = this.exports.alloc(buf.byteLength);
+    if (!ptr) return 0n;
+    new Uint8Array(this.exports.memory.buffer, ptr, buf.byteLength).set(new Uint8Array(buf));
+    return this.exports.sumInt64Buffer(ptr >> 3, numElements);
+  }
+
+  /** SIMD min of Int64 buffer. Returns MAX_SAFE_INTEGER for empty input. */
+  minInt64(buf: ArrayBuffer): bigint {
+    if (buf.byteLength === 0) return BigInt(Number.MAX_SAFE_INTEGER);
+    const numElements = buf.byteLength >> 3;
+    const ptr = this.exports.alloc(buf.byteLength);
+    if (!ptr) return BigInt(Number.MAX_SAFE_INTEGER);
+    new Uint8Array(this.exports.memory.buffer, ptr, buf.byteLength).set(new Uint8Array(buf));
+    return this.exports.minInt64Buffer(ptr >> 3, numElements);
+  }
+
+  /** SIMD max of Int64 buffer. Returns MIN_SAFE_INTEGER for empty input. */
+  maxInt64(buf: ArrayBuffer): bigint {
+    if (buf.byteLength === 0) return BigInt(Number.MIN_SAFE_INTEGER);
+    const numElements = buf.byteLength >> 3;
+    const ptr = this.exports.alloc(buf.byteLength);
+    if (!ptr) return BigInt(Number.MIN_SAFE_INTEGER);
+    new Uint8Array(this.exports.memory.buffer, ptr, buf.byteLength).set(new Uint8Array(buf));
+    return this.exports.maxInt64Buffer(ptr >> 3, numElements);
+  }
+
   /** Load a fragment file into the WASM fragment reader. */
   loadFragment(data: ArrayBuffer): boolean {
     const ptr = this.exports.alloc(data.byteLength);