perf: fast-path system_fs canonicalization and small file I/O

Author: Thanga-Ganapathy

Cargo.lock

@@ -26,7 +26,7 @@ cd "$(dirname "$0")"
 ESRUN="${ESRUN:-../target/release/esrun}"
 STARTUP_RUNS="${STARTUP_RUNS:-25}"
 WORKLOAD_RUNS="${WORKLOAD_RUNS:-5}"
-ALL_WORKLOADS="compute json jsonbig sha256 crypto url encoding base64 structured async timers streams fetch http fsread fswrite fsappend glob"
+ALL_WORKLOADS="compute json jsonbig sha256 crypto url encoding base64 structured async timers streams fetch http fsread_small fsread_large fswrite_small fswrite_large fsappend_small fsappend_large fsstat_small fsstat_large fsexists_small fsexists_large glob"
 WORKLOADS="${WORKLOADS:-$ALL_WORKLOADS}"
 BENCH_JSON="${BENCH_JSON:-}"
 FETCH_PORT=18923

bench/run.sh

@@ -0,0 +1,37 @@
+// File append benchmark: append 2 MB to a growing file in a loop. The
+// filesystem is not a shared Web API, so each runtime uses its own surface.
+(async () => {
+  const N = 20;
+  const data = "x".repeat(2097152);
+  const tmp = "bench_fsappend.bin";
+
+  let append, cleanup;
+  if (typeof Deno !== "undefined") {
+    const enc = new TextEncoder();
+    append = (p, d) => Deno.writeFile(p, enc.encode(d), { append: true });
+    cleanup = (p) => Deno.remove(p).catch(() => {});
+  } else if (typeof Bun !== "undefined") {
+    const { appendFile, unlink } = await import("node:fs/promises");
+    append = (p, d) => appendFile(p, d);
+    cleanup = (p) => unlink(p).catch(() => {});
+  } else if (typeof process !== "undefined" && process.versions && process.versions.node) {
+    const fsp = await import("node:fs/promises");
+    append = (p, d) => fsp.appendFile(p, d);
+    cleanup = (p) => fsp.unlink(p).catch(() => {});
+  } else {
+    const fs = await import("runtime:fs");
+    append = (p, d) => fs.write(p, d, { append: true });
+    cleanup = (p) => fs.remove(p).catch(() => {});
+  }
+
+  await cleanup(tmp); // start fresh
+  const run = async (n) => {
+    for (let i = 0; i < n; i++) await append(tmp, data);
+  };
+  await run(1); // untimed warmup
+  const t0 = performance.now();
+  await run(N);
+  const t1 = performance.now();
+  await cleanup(tmp);
+  console.log("RESULT_MS=" + (t1 - t0).toFixed(2));
+})();

bench/scripts/fsappend_large.js

@@ -0,0 +1,38 @@
+(async () => {
+  const N = 20;
+  const tmp = "bench_fsexists.bin";
+
+  let exists, write, cleanup;
+  if (typeof Deno !== "undefined") {
+    const enc = new TextEncoder();
+    write = (p, d) => Deno.writeFile(p, enc.encode(d));
+    exists = (p) => Deno.stat(p).then(()=>true).catch(()=>false);
+    cleanup = (p) => Deno.remove(p).catch(() => {});
+  } else if (typeof Bun !== "undefined") {
+    const { stat, unlink } = await import("node:fs/promises");
+    write = (p, d) => Bun.write(p, d);
+    exists = (p) => stat(p).then(()=>true).catch(()=>false);
+    cleanup = (p) => unlink(p).catch(() => {});
+  } else if (typeof process !== "undefined" && process.versions && process.versions.node) {
+    const fsp = await import("node:fs/promises");
+    write = (p, d) => fsp.writeFile(p, d);
+    exists = (p) => fsp.stat(p).then(()=>true).catch(()=>false);
+    cleanup = (p) => fsp.unlink(p).catch(() => {});
+  } else {
+    const fs = await import("runtime:fs");
+    write = (p, d) => fs.write(p, d);
+    exists = (p) => fs.exists(p);
+    cleanup = (p) => fs.remove(p).catch(() => {});
+  }
+
+  await write(tmp, "x".repeat(2097152));
+  const run = async (n) => {
+    for (let i = 0; i < n; i++) await exists(tmp);
+  };
+  await run(N / 10);
+  const t0 = performance.now();
+  await run(N);
+  const t1 = performance.now();
+  await cleanup(tmp);
+  console.log("RESULT_MS=" + (t1 - t0).toFixed(2));
+})();

bench/scripts/fsappend.js bench/scripts/fsappend_small.jsbench/scripts/fsappend.js renamed to bench/scripts/fsappend_small.js

@@ -0,0 +1,38 @@
+(async () => {
+  const N = 5000;
+  const tmp = "bench_fsexists.bin";
+
+  let exists, write, cleanup;
+  if (typeof Deno !== "undefined") {
+    const enc = new TextEncoder();
+    write = (p, d) => Deno.writeFile(p, enc.encode(d));
+    exists = (p) => Deno.stat(p).then(()=>true).catch(()=>false);
+    cleanup = (p) => Deno.remove(p).catch(() => {});
+  } else if (typeof Bun !== "undefined") {
+    const { stat, unlink } = await import("node:fs/promises");
+    write = (p, d) => Bun.write(p, d);
+    exists = (p) => stat(p).then(()=>true).catch(()=>false);
+    cleanup = (p) => unlink(p).catch(() => {});
+  } else if (typeof process !== "undefined" && process.versions && process.versions.node) {
+    const fsp = await import("node:fs/promises");
+    write = (p, d) => fsp.writeFile(p, d);
+    exists = (p) => fsp.stat(p).then(()=>true).catch(()=>false);
+    cleanup = (p) => fsp.unlink(p).catch(() => {});
+  } else {
+    const fs = await import("runtime:fs");
+    write = (p, d) => fs.write(p, d);
+    exists = (p) => fs.exists(p);
+    cleanup = (p) => fs.remove(p).catch(() => {});
+  }
+
+  await write(tmp, "x".repeat(4096));
+  const run = async (n) => {
+    for (let i = 0; i < n; i++) await exists(tmp);
+  };
+  await run(N / 10);
+  const t0 = performance.now();
+  await run(N);
+  const t1 = performance.now();
+  await cleanup(tmp);
+  console.log("RESULT_MS=" + (t1 - t0).toFixed(2));
+})();

bench/scripts/fsexists_large.js

@@ -0,0 +1,41 @@
+// File read benchmark: read a 2 MB file in a loop (written once, untimed). The
+// filesystem is not a shared Web API, so each runtime uses its own surface.
+(async () => {
+  const N = 20;
+  const data = "x".repeat(2097152);
+  const tmp = "bench_fsread.bin";
+
+  let write, read, cleanup;
+  if (typeof Deno !== "undefined") {
+    const enc = new TextEncoder();
+    write = (p, d) => Deno.writeFile(p, enc.encode(d));
+    read = (p) => Deno.readFile(p);
+    cleanup = (p) => Deno.remove(p).catch(() => {});
+  } else if (typeof Bun !== "undefined") {
+    const { unlink } = await import("node:fs/promises");
+    write = (p, d) => Bun.write(p, d);
+    read = (p) => Bun.file(p).arrayBuffer();
+    cleanup = (p) => unlink(p).catch(() => {});
+  } else if (typeof process !== "undefined" && process.versions && process.versions.node) {
+    const fsp = await import("node:fs/promises");
+    write = (p, d) => fsp.writeFile(p, d);
+    read = (p) => fsp.readFile(p);
+    cleanup = (p) => fsp.unlink(p).catch(() => {});
+  } else {
+    const fs = await import("runtime:fs");
+    write = (p, d) => fs.write(p, d);
+    read = (p) => fs.file(p).arrayBuffer();
+    cleanup = (p) => fs.remove(p).catch(() => {});
+  }
+
+  await write(tmp, data); // setup, untimed
+  const run = async (n) => {
+    for (let i = 0; i < n; i++) await read(tmp);
+  };
+  await run(1); // untimed warmup
+  const t0 = performance.now();
+  await run(N);
+  const t1 = performance.now();
+  await cleanup(tmp);
+  console.log("RESULT_MS=" + (t1 - t0).toFixed(2));
+})();

bench/scripts/fsexists_small.js

@@ -0,0 +1,38 @@
+(async () => {
+  const N = 20;
+  const tmp = "bench_fsstat.bin";
+
+  let stat, write, cleanup;
+  if (typeof Deno !== "undefined") {
+    const enc = new TextEncoder();
+    write = (p, d) => Deno.writeFile(p, enc.encode(d));
+    stat = (p) => Deno.stat(p);
+    cleanup = (p) => Deno.remove(p).catch(() => {});
+  } else if (typeof Bun !== "undefined") {
+    const { stat: statP, unlink } = await import("node:fs/promises");
+    write = (p, d) => Bun.write(p, d);
+    stat = (p) => statP(p);
+    cleanup = (p) => unlink(p).catch(() => {});
+  } else if (typeof process !== "undefined" && process.versions && process.versions.node) {
+    const fsp = await import("node:fs/promises");
+    write = (p, d) => fsp.writeFile(p, d);
+    stat = (p) => fsp.stat(p);
+    cleanup = (p) => fsp.unlink(p).catch(() => {});
+  } else {
+    const fs = await import("runtime:fs");
+    write = (p, d) => fs.write(p, d);
+    stat = (p) => fs.stat(p);
+    cleanup = (p) => fs.remove(p).catch(() => {});
+  }
+
+  await write(tmp, "x".repeat(2097152));
+  const run = async (n) => {
+    for (let i = 0; i < n; i++) await stat(tmp);
+  };
+  await run(N / 10);
+  const t0 = performance.now();
+  await run(N);
+  const t1 = performance.now();
+  await cleanup(tmp);
+  console.log("RESULT_MS=" + (t1 - t0).toFixed(2));
+})();

bench/scripts/fsread_large.js

@@ -0,0 +1,38 @@
+(async () => {
+  const N = 5000;
+  const tmp = "bench_fsstat.bin";
+
+  let stat, write, cleanup;
+  if (typeof Deno !== "undefined") {
+    const enc = new TextEncoder();
+    write = (p, d) => Deno.writeFile(p, enc.encode(d));
+    stat = (p) => Deno.stat(p);
+    cleanup = (p) => Deno.remove(p).catch(() => {});
+  } else if (typeof Bun !== "undefined") {
+    const { stat: statP, unlink } = await import("node:fs/promises");
+    write = (p, d) => Bun.write(p, d);
+    stat = (p) => statP(p);
+    cleanup = (p) => unlink(p).catch(() => {});
+  } else if (typeof process !== "undefined" && process.versions && process.versions.node) {
+    const fsp = await import("node:fs/promises");
+    write = (p, d) => fsp.writeFile(p, d);
+    stat = (p) => fsp.stat(p);
+    cleanup = (p) => fsp.unlink(p).catch(() => {});
+  } else {
+    const fs = await import("runtime:fs");
+    write = (p, d) => fs.write(p, d);
+    stat = (p) => fs.stat(p);
+    cleanup = (p) => fs.remove(p).catch(() => {});
+  }
+
+  await write(tmp, "x".repeat(4096));
+  const run = async (n) => {
+    for (let i = 0; i < n; i++) await stat(tmp);
+  };
+  await run(N / 10);
+  const t0 = performance.now();
+  await run(N);
+  const t1 = performance.now();
+  await cleanup(tmp);
+  console.log("RESULT_MS=" + (t1 - t0).toFixed(2));
+})();