Merge branch 'main' into 2025-10-27_js-tokens

Author: camillobruni

JetStreamDriver.js

@@ -40,7 +40,7 @@ if (!isInBrowser && JetStreamParams.prefetchResources) {
 
     // Load a polyfill for TextEncoder/TextDecoder in shells. Used when
     // decompressing a prefetched resource and converting it to text.
-    load("./polyfills/fast-text-encoding/1.0.3/text.js");
+    load("./utils/polyfills/fast-text-encoding/1.0.3/text.js");
 }
 
 // Used for the promise representing the current benchmark run.
@@ -906,7 +906,8 @@ class Benchmark {
         if (this.plan.preload) {
             let preloadCode = "";
             for (let [ variableName, blobURLOrPath ] of this.preloads) {
-                console.log(variableName, blobURLOrPath);
+                console.assert(variableName?.length > 0, "Invalid preload name.");
+                console.assert(blobURLOrPath?.length > 0, "Invalid preload data.");
                 preloadCode += `JetStream.preload[${JSON.stringify(variableName)}] = "${blobURLOrPath}";\n`;
             }
             scripts.add(preloadCode);
@@ -1062,8 +1063,8 @@ class Benchmark {
 
         if (this.plan.preload) {
             this.preloads = [];
-            for (let prop of Object.getOwnPropertyNames(this.plan.preload)) {
-                promises.push(this.loadBlob("preload", prop, this.plan.preload[prop]).then((blobData) => {
+            for (const [name, resource] of Object.entries(this.plan.preload)) {
+                promises.push(this.loadBlob("preload", name, resource).then((blobData) => {
                     if (!globalThis.allIsGood)
                         return;
                     this.preloads.push([ blobData.prop, blobData.blobURL ]);
@@ -1072,7 +1073,7 @@ class Benchmark {
                     // We'll try again later in retryPrefetchResourceForBrowser(). Don't throw an error.
                     if (!this.failedPreloads)
                         this.failedPreloads = { };
-                    this.failedPreloads[prop] = true;
+                    this.failedPreloads[name] = true;
                     JetStream.counter.failedPreloadResources++;
                 }));
             }
@@ -1129,9 +1130,8 @@ class Benchmark {
         }
 
         if (this.plan.preload) {
-            for (const prop of Object.getOwnPropertyNames(this.plan.preload)) {
-                const resource = this.plan.preload[prop];
-                const allDone = await this.retryPrefetchResource("preload", prop, resource);
+            for (const [name, resource] of Object.entries(this.plan.preload)) {
+                const allDone = await this.retryPrefetchResource("preload", name, resource);
                 if (allDone)
                     return true; // All resources loaded, nothing more to do.
             }
@@ -1151,21 +1151,21 @@ class Benchmark {
         if (!this.plan.preload) {
             return;
         }
-        for (let [name, file] of Object.entries(this.plan.preload)) {
-            const compressed = isCompressed(file);
+        for (let [name, resource] of Object.entries(this.plan.preload)) {
+            const compressed = isCompressed(resource);
             if (compressed && !JetStreamParams.prefetchResources) {
-                file = uncompressedName(file);
+                resource = uncompressedName(resource);
             }
 
             if (JetStreamParams.prefetchResources) {
-                let bytes = new Int8Array(read(file, "binary"));
+                let bytes = new Int8Array(read(resource, "binary"));
                 if (compressed) {
                     bytes = zlib.decompress(bytes);
                 }
-                this.shellPrefetchedResources[file] = bytes;
+                this.shellPrefetchedResources[resource] = bytes;
             }
 
-            this.preloads.push([name, file]);
+            this.preloads.push([name, resource]);
         }
     }
 
@@ -1755,10 +1755,10 @@ class WasmLegacyBenchmark extends Benchmark {
         }
 
         str += "};\n";
-
-        const keys = Object.keys(this.plan.preload);
-        for (let i = 0; i < keys.length; ++i) {
-            str += `JetStream.loadBlob("${keys[i]}", "${this.plan.preload[keys[i]]}", () => {\n`;
+        let preloadCount = 0;
+        for (const [name, resource] of Object.entries(this.plan.preload)) {
+            preloadCount++;
+            str += `JetStream.loadBlob(${JSON.stringify(name)}, "${resource}", () => {\n`;
         }
         if (this.plan.async) {
             str += `doRun().catch((e) => {
@@ -1769,7 +1769,7 @@ class WasmLegacyBenchmark extends Benchmark {
         } else {
             str += `doRun();`
         }
-        for (let i = 0; i < keys.length; ++i) {
+        for (let i = 0; i < preloadCount; ++i) {
             str += `})`;
         }
         str += `;`;
@@ -2256,6 +2256,21 @@ let BENCHMARKS = [
         ],
         tags: ["default", "js", "Proxy"],
     }),
+    new AsyncBenchmark({
+        name: "mobx-startup",
+        files: [
+            "./utils/StartupBenchmark.js",
+            "./mobx/benchmark.js",
+        ],
+        preload: {
+            // Debug Sources for nicer profiling.
+            // BUNDLE: "./mobx/dist/bundle.es6.js",
+            BUNDLE: "./mobx/dist/bundle.es6.min.js",
+        },
+        tags: ["default", "js", "mobx", "startup", "es6"],
+        iterations: 30,
+        worstCaseCount: 3,
+    }),
     new AsyncBenchmark({
         name: "jsdom-d3-startup",
         files: [
@@ -2437,7 +2452,7 @@ let BENCHMARKS = [
     new WasmEMCCBenchmark({
         name: "sqlite3-wasm",
         files: [
-            "./polyfills/fast-text-encoding/1.0.3/text.js",
+            "./utils/polyfills/fast-text-encoding/1.0.3/text.js",
             "./sqlite3/benchmark.js",
             "./sqlite3/build/jswasm/speedtest1.js",
         ],
@@ -2502,7 +2517,7 @@ let BENCHMARKS = [
     new AsyncBenchmark({
         name: "transformersjs-bert-wasm",
         files: [
-            "./polyfills/fast-text-encoding/1.0.3/text.js",
+            "./utils/polyfills/fast-text-encoding/1.0.3/text.js",
             "./transformersjs/benchmark.js",
             "./transformersjs/task-bert.js",
         ],
@@ -2524,7 +2539,7 @@ let BENCHMARKS = [
     new AsyncBenchmark({
         name: "transformersjs-whisper-wasm",
         files: [
-            "./polyfills/fast-text-encoding/1.0.3/text.js",
+            "./utils/polyfills/fast-text-encoding/1.0.3/text.js",
             "./transformersjs/benchmark.js",
             "./transformersjs/task-whisper.js",
         ],
@@ -2547,7 +2562,7 @@ let BENCHMARKS = [
         iterations: 5,
         worstCaseCount: 1,
         allowUtf16: true,
-        tags: ["default", "Wasm", "transformersjs"],
+        tags: ["Wasm", "transformersjs"],
     }),
     new WasmLegacyBenchmark({
         name: "tfjs-wasm",
@@ -2608,6 +2623,68 @@ let BENCHMARKS = [
         allowUtf16: true,
         tags: ["default", "Wasm"],
     }),
+    new AsyncBenchmark({
+        name: "babylonjs-startup-es5",
+        files: [
+            "./utils/StartupBenchmark.js",
+            "./babylonjs/benchmark/startup.js",
+        ],
+        preload: {
+            BUNDLE: "./babylonjs/dist/bundle.es5.min.js",
+        },
+        arguments: {
+            expectedCacheCommentCount: 23988,
+        },
+        tags: ["startup",  "js", "class", "es5", "babylonjs"],
+        iterations: 10,
+    }),
+    new AsyncBenchmark({
+        name: "babylonjs-startup-es6",
+        files: [
+            "./utils/StartupBenchmark.js",
+            "./babylonjs/benchmark/startup.js",
+        ],
+        preload: {
+            BUNDLE: "./babylonjs/dist/bundle.es6.min.js",
+        },
+        arguments: {
+            expectedCacheCommentCount: 21222,
+        },
+        tags: ["Default",  "js", "startup", "class", "es6", "babylonjs"],
+        iterations: 10,
+    }),
+    new AsyncBenchmark({
+        name: "babylonjs-scene-es5",
+        files: [
+            // Use non-minified sources for easier profiling:
+            // "./babylonjs/dist/bundle.es5.js",
+            "./babylonjs/dist/bundle.es5.min.js",
+            "./babylonjs/benchmark/scene.js",
+        ],
+        preload: {
+            PARTICLES_BLOB: "./babylonjs/data/particles.json",
+            PIRATE_FORT_BLOB: "./babylonjs/data/pirateFort.glb",
+            CANNON_BLOB: "./babylonjs/data/cannon.glb",
+        },
+        tags: ["scene", "js",  "es5", "babylonjs"],
+        iterations: 5,
+    }),
+    new AsyncBenchmark({
+        name: "babylonjs-scene-es6",
+        files: [
+            // Use non-minified sources for easier profiling:
+            // "./babylonjs/dist/bundle.es6.js",
+            "./babylonjs/dist/bundle.es6.min.js",
+            "./babylonjs/benchmark/scene.js",
+        ],
+        preload: {
+            PARTICLES_BLOB: "./babylonjs/data/particles.json",
+            PIRATE_FORT_BLOB: "./babylonjs/data/pirateFort.glb",
+            CANNON_BLOB: "./babylonjs/data/cannon.glb",
+        },
+        tags: ["Default", "js", "scene", "es6", "babylonjs"],
+        iterations: 5,
+    }),
     // WorkerTests
     new AsyncBenchmark({
         name: "bomb-workers",
@@ -2817,7 +2894,7 @@ let BENCHMARKS = [
     new WasmEMCCBenchmark({
         name: "8bitbench-wasm",
         files: [
-            "./polyfills/fast-text-encoding/1.0.3/text.js",
+            "./utils/polyfills/fast-text-encoding/1.0.3/text.js",
             "./8bitbench/build/rust/pkg/emu_bench.js",
             "./8bitbench/benchmark.js",
         ],

babylonjs/README.md

@@ -0,0 +1,34 @@
+# Babylon.js Benchmarks for JetStream
+
+This project contains two benchmarks for testing the performance of the Babylon.js 3D engine.
+
+## Build Instructions
+
+```bash
+# install required node packages.
+npm ci
+# build the workload, output is ./dist
+npm run build
+```
+
+## Workloads
+
+There are two distinct workloads in this benchmark suite:
+
+### 1. Startup Workload
+
+This benchmark measures the time it takes for the Babylon.js engine to initialize. It evaluates a large, bundled source file and measures the time to parse the code and execute a simple test. This workload is primarily focused on parse and startup time.
+
+To run this benchmark in node for testing:
+```bash
+npm run test:startup
+```
+
+### 2. Scene Workload
+
+This benchmark measures the rendering performance of a complex 3D scene. It loads 3D models (`.glb` files), animations, and particle systems, and then renders the scene for a number of frames. 
+
+To run this benchmark in node for testing:
+```bash
+npm run test:scene
+```

babylonjs/benchmark/scene-node.mjs

@@ -0,0 +1,25 @@
+import { runComplexScene } from "../src/babylon-js-benchmark.mjs";
+import { promises as fs } from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const fortPath = path.resolve(__dirname, "../data/pirateFort.glb");
+const cannonPath = path.resolve(__dirname, "../data/cannon.glb");
+const particlePath = path.resolve(__dirname, "../data/particles.json");
+
+async function main() {
+    try {
+    const fortBuffer = await fs.readFile(fortPath);
+    const cannonBuffer = await fs.readFile(cannonPath);
+    const particleData = JSON.parse(await fs.readFile(particlePath, "utf-8"))
+    const {classNames, cameraRotationLength} = await runComplexScene(fortBuffer, cannonBuffer, particleData, 1000);
+    } catch(e) {
+        console.error(e);
+        console.error(e.stack);
+    }
+}
+
+main();

babylonjs/benchmark/scene.js

@@ -0,0 +1,53 @@
+// console.log = () => {};
+
+globalThis.setTimeout = (callback, timeout) => callback();
+globalThis.requestAnimationFrame = (callback) => callback();
+
+// JetStream benchmark.
+class Benchmark {
+  iterationCount = 0;
+  preloaded = {
+    fortData: null,
+    cannonData: null,
+    particlesJson: null,
+  };
+
+  constructor(iterationCount) {
+    this.iterationCount = iterationCount;
+  }
+
+  async init() {
+    const [fort, cannon, particles] = await Promise.all([
+      JetStream.getBinary(JetStream.preload.PIRATE_FORT_BLOB),
+      JetStream.getBinary(JetStream.preload.CANNON_BLOB),
+      JetStream.getString(JetStream.preload.PARTICLES_BLOB),
+    ]);
+    this.preloaded.fortData = fort;
+    this.preloaded.cannonData = cannon;
+    this.preloaded.particlesJson = JSON.parse(particles);
+  }
+
+  async runIteration() {
+    const {classNames, cameraRotationLength} = await BabylonJSBenchmark.runComplexScene(
+      this.preloaded.fortData,
+      this.preloaded.cannonData,
+      this.preloaded.particlesJson,
+      100
+    );
+    const lastResult = {
+      classNames,
+      cameraRotationLength
+    };
+    this.validateIteration(lastResult);
+  }
+
+  validateIteration(lastResult) {
+    this.expect("this.lastResult.classNames.length", lastResult.classNames.length, 2135);
+    this.expect("this.lastResult.cameraRotationLength", lastResult.cameraRotationLength, 0);
+  }
+
+  expect(name, value, expected) {
+    if (value != expected)
+      throw new Error(`Expected ${name} to be ${expected}, but got ${value}`);
+  }
+}

babylonjs/benchmark/startup-node.mjs

@@ -0,0 +1,3 @@
+import { runTest } from "../src/babylon-js-benchmark.mjs";
+
+console.log(runTest());