Merge pull request #30 from danleh/sqlite-scoring

Move sqlite Wasm benchmark to first, worst, average scoring

Author: kmiller68

JetStreamDriver.js

@@ -2001,17 +2001,17 @@ const BENCHMARKS = [
         worstCaseCount: 2,
         testGroup: WasmGroup
     }),
-    new WasmLegacyBenchmark({
+    new WasmEMCCBenchmark({
         name: "sqlite3-wasm",
         files: [
-            "./sqlite3/polyfills.js",
-            "./sqlite3/build/jswasm/speedtest1.js",
             "./sqlite3/benchmark.js",
+            "./sqlite3/build/jswasm/speedtest1.js",
         ],
         preload: {
             wasmBinary: "./sqlite3/build/jswasm/speedtest1.wasm"
         },
-        benchmarkClass: WasmLegacyBenchmark,
+        iterations: 15,
+        worstCaseCount: 2,
         testGroup: WasmGroup
     }),
     new WasmLegacyBenchmark({

sqlite3/benchmark.js

@@ -2,72 +2,97 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-const inJetStreamRunner = typeof globalThis.benchmarkTime !== "undefined";
-if (!inJetStreamRunner) {
-  load("polyfills.js");
+// First, some polyfills for missing browser APIs in JavaScript shells.
+// Since the generated JavaScript code of SQLite immediately uses some of them,
+// we need to load and run this code before the generated `speedtest1.js` in the
+// JetStream driver.
 
-  // Exports `sqlite3InitModule()` and contains the main code.
-  load("build/jswasm/speedtest1.js");
+// Empty `URLSearchParams` has just the same interface as a `Map`.
+globalThis.URLSearchParams = Map;
 
-  // Load Wasm binary from disk.
-  globalThis.Module = {
-    wasmBinary: read("build/jswasm/speedtest1.wasm", "binary"),
-  };
+// `TextEncoder` and `TextDecoder`. These are called only a few times with short
+// ASCII strings, so this is sufficient and not performance-critical.
+class TextEncoder {
+  encode(string) {
+    return Uint8Array.from(string, (char) => {
+      let byte = char.codePointAt(0);
+      if (byte > 0x7f)
+        throw new Error("TextEncoder polyfill only supports ASCII");
+      return byte;
+    });
+  }
+}
+class TextDecoder {
+  decode(array) {
+    for (let byte of array) {
+      if (byte > 0x7f)
+        throw new Error("TextDecoder polyfill only supports ASCII");
+    }
+    return String.fromCharCode.apply(null, array);
+  }
 }
 
+// Now, some configuration options for when we initialize SQLite.
+
+// Use JetStream functions instead of `console.log` and friends.
+globalThis.sqlite3ApiConfig = {
+  log: print,
+  debug: print,
+  warn: print,
+  error: print,
+};
+
 // Make sure we never initialize OPFS by removing one of it's APIs (see
 // `installOpfsVfs` in the generated JavaScript code of sqlite).
 // We never want to use it anyway (see VFS config below) and this way we don't
 // waste cycles on the browser runner to initialize it.
 delete globalThis.FileSystemHandle;
 
-// Simplified from inline JavaScript in `speedtest1.html`.
-function runTests(sqlite3Module) {
-  // Configure the VFS to use.
-  // Don't use OPFS, WASMFS (which is on top of OPFS), or kvvfs, since they all
-  // use persistent browser storage (localStorage or OPFS), which is not
-  // available in JavaScript shells.
-  // Also don't use memfs, since that crashes with a NULL function pointer.
-  // Instead, make the default VFS explicit.
-  const capi = sqlite3Module.capi
-  console.log("Available SQLite VFS:", capi.sqlite3_js_vfs_list());
-  const vfs = "unix";
-  console.log("Using VFS:", vfs);
-  const pVfs = capi.sqlite3_vfs_find(vfs);
-  if (!pVfs) {
-    console.error("Error: Unknown VFS:", vfs);
-    return;
-  }
+class Benchmark {
+  sqlite3Module;
 
-  // These arguments should match the upstream browser runner `speedtest1.html`.
-  let argv = [
-    "speedtest1",
-    "--singlethread",
-    //"--nomutex",
-    //"--nosync",
-    //"--memdb", // note that memdb trumps the filename arg
-    "--nomemstat",
-    "--big-transactions" /*important for tests 410 and 510!*/,
-    "--size", "20", // To speedup, default is 100 (and takes about 4s).
-    "--vfs", vfs, // See VFS comment above.
-  ];
+  async runIteration() {
+    if (!this.sqlite3Module) {
+      // Defined in the generated SQLite JavaScript code.
+      // Different in details but seemingly related/inspired by Emscripten code.
+      this.sqlite3Module = await sqlite3InitModule(Module);
+    }
 
-  console.log("Calling main with argv:", argv);
-  const wasm = sqlite3Module.wasm;
-  wasm.scopedAllocPush();  // Required for `scopedAllocMainArgv()`.
-  wasm.xCall("wasm_main", argv.length, wasm.scopedAllocMainArgv(argv));
-  wasm.scopedAllocPop();
-}
+    // The following is simplified from inline JavaScript in `speedtest1.html`.
+    
+    // Configure the VFS to use.
+    // Don't use OPFS, WASMFS (which is on top of OPFS), or kvvfs, since they
+    // all use persistent browser storage (localStorage or OPFS), which is not
+    // available in JavaScript shells.
+    // Also don't use memfs, since that crashes with a NULL function pointer.
+    // Instead, make the default VFS explicit.
+    const capi = this.sqlite3Module.capi
+    print("Available SQLite VFS:", capi.sqlite3_js_vfs_list());
+    const vfs = "unix";
+    print("Using VFS:", vfs);
+    const pVfs = capi.sqlite3_vfs_find(vfs);
+    if (!pVfs) {
+      throw new Error("Unknown VFS:", vfs);
+    }
 
-async function doRun() {
-  let start = benchmarkTime();
-  const sqliteModule = await sqlite3InitModule(Module);
-  reportCompileTime(benchmarkTime() - start);
+    // These arguments should match the upstream browser runner in 
+    // `speedtest1.html`, except for the --size parameter.
+    let argv = [
+      "speedtest1",
+      "--singlethread",
+      //"--nomutex",
+      //"--nosync",
+      //"--memdb", // note that memdb trumps the filename arg
+      "--nomemstat",
+      "--big-transactions" /*important for tests 410 and 510!*/,
+      "--size", "10", // To speedup, default is 100 (and takes about 4s).
+      "--vfs", vfs, // See VFS comment above.
+    ];
 
-  start = benchmarkTime();
-  runTests(sqliteModule);
-  reportRunTime(benchmarkTime() - start);
-}
-if (!inJetStreamRunner) {
-  sqlite3InitModule(Module).then(runTests);
+    print("Calling main with argv:", argv);
+    const wasm = this.sqlite3Module.wasm;
+    wasm.scopedAllocPush();  // Required for `scopedAllocMainArgv()`.
+    wasm.xCall("wasm_main", argv.length, wasm.scopedAllocMainArgv(argv));
+    wasm.scopedAllocPop();
+  }
 }

sqlite3/build.log

@@ -1,10 +1,10 @@
-Built on 2024-12-05 14:24:19+01:00
+Built on 2025-01-21T15:10:24Z
 
 Toolchain versions
-emcc (Emscripten gcc/clang-like replacement + linker emulating GNU ld) 3.1.71 (4171ae200b77a6c266b0e1ebb507d61d1ade3501)
+emcc (Emscripten gcc/clang-like replacement + linker emulating GNU ld) 3.1.73 (ac676d5e437525d15df5fd46bc2c208ec6d376a3)
 wasm-strip 1.0.34
 
-Getting sources from https://sqlite.org/2024/sqlite-src-3470100.zip
+Getting sources from https://sqlite.org/2025/sqlite-src-3480000.zip
 
 Building...
 Copying files from sqlite-src-*/ext/wasm/ into build/

sqlite3/build.sh

@@ -1,10 +1,9 @@
 #!/bin/bash
 
-set -e
-set -o pipefail
+set -eo pipefail
 
 # Cleanup old files.
-rm sqlite-src-*.zip
+rm -f sqlite-src-*.zip
 rm -rf sqlite-src-*/
 rm -rf build/
 
@@ -17,7 +16,7 @@ emcc --version | head -n1 | tee -a "$BUILD_LOG"
 echo -e "wasm-strip $(wasm-strip --version)\n" | tee -a "$BUILD_LOG"
 
 # Check https://sqlite.org/download.html and update the source link, if needed.
-SQLITE_SRC_URL="https://sqlite.org/2024/sqlite-src-3470100.zip"
+SQLITE_SRC_URL="https://sqlite.org/2025/sqlite-src-3480000.zip"
 echo -e "Getting sources from $SQLITE_SRC_URL\n" | tee -a "$BUILD_LOG"
 SQLITE_SRC_FILE="$(basename $SQLITE_SRC_URL)"
 curl -o "$SQLITE_SRC_FILE" $SQLITE_SRC_URL