add zig bench

Author: elringus

samples/bench/bench.mjs

@@ -3,6 +3,7 @@ import { init as initDotNet } from "./dotnet/init.mjs";
 import { init as initDotNetLLVM } from "./dotnet-llvm/init.mjs";
 import { init as initGo } from "./go/init.mjs";
 import { init as initRust } from "./rust/init.mjs";
+import { init as initZig } from "./zig/init.mjs";
 import * as fixtures from "./fixtures.mjs";
 
 /**
@@ -15,6 +16,8 @@ import * as fixtures from "./fixtures.mjs";
 const lang = process.argv[2];
 const baseline = new Map;
 
+if (!lang || lang.toLowerCase() === "zig")
+    await run("Zig", await initZig());
 if (!lang || lang.toLowerCase() === "rust")
     await run("Rust", await initRust());
 if (!lang || lang.toLowerCase() === "llvm")

samples/bench/zig/.gitignore

@@ -0,0 +1,2 @@
+.zig-cache
+zit-out

samples/bench/zig/build.zig

@@ -0,0 +1,24 @@
+const std = @import("std");
+
+pub fn build(b: *std.Build) void {
+    const lib = b.addExecutable(.{
+        .name = "zig",
+        .root_source_file = b.path("main.zig"),
+        .target = b.resolveTargetQuery(.{
+            .cpu_arch = .wasm32,
+            .os_tag = .freestanding,
+            .cpu_features_add = std.Target.wasm.featureSet(&.{
+                .simd128,
+                .relaxed_simd,
+                .tail_call,
+            }),
+        }),
+        .use_llvm = true,
+        .use_lld = true,
+        .optimize = b.standardOptimizeOption(.{}),
+    });
+    lib.entry = .disabled;
+    lib.rdynamic = true;
+    lib.want_lto = true;
+    b.installArtifact(lib);
+}

samples/bench/zig/init.mjs

@@ -0,0 +1,44 @@
+import { getNumber, getStruct } from "../fixtures.mjs";
+import fs from "fs/promises";
+
+/** @returns {Promise<import("../bench.mjs").Exports>} */
+export async function init() {
+    const source = await fs.readFile("./zig/zig-out/bin/zig.wasm");
+    const { instance: { exports } } = await WebAssembly.instantiate(source, {
+        x: {
+            getNumber,
+            getStruct: () => toCString(JSON.stringify(getStruct())),
+        }
+    });
+    memory = exports.memory, cached = new Uint8Array(memory.buffer);
+
+    return {
+        echoNumber: exports.echoNumber,
+        echoStruct: () => JSON.parse(fromCString(exports.echoStruct())),
+        fi: exports.fi
+    };
+}
+
+let memory, cached;
+const encoder = new TextEncoder("utf-8");
+const decoder = new TextDecoder("utf-8");
+
+function toCString(str) {
+    const memory = getMemoryCached();
+    const { written } = encoder.encodeInto(str, memory);
+    memory[written] = 0; // appending null terminator
+    return 0; // naive: always writing to the start of the wasm memory
+}
+
+function fromCString(ptr) {
+    const memory = getMemoryCached();
+    let len = 0;
+    while (memory[ptr + len] !== 0) len++;
+    const bytes = memory.subarray(ptr, ptr + len);
+    return decoder.decode(bytes);
+}
+
+function getMemoryCached() {
+    if (cached.buffer.byteLength === memory.buffer.byteLength) return cached;
+    return cached = new Uint8Array(memory.buffer);
+}

samples/bench/zig/main.zig

@@ -0,0 +1,33 @@
+const std = @import("std");
+
+var arena = std.heap.ArenaAllocator.init(std.heap.wasm_allocator);
+const ally = arena.allocator();
+
+pub const Data = struct {
+    info: []const u8,
+    ok: bool,
+    revision: i32,
+    messages: []const []const u8,
+};
+
+extern "x" fn getNumber() i32;
+extern "x" fn getStruct() [*:0]const u8;
+
+export fn echoNumber() i32 {
+    return getNumber();
+}
+
+export fn echoStruct() [*:0]const u8 {
+    _ = arena.reset(.retain_capacity);
+    const input = std.mem.span(getStruct());
+    const parsed = std.json.parseFromSlice(Data, ally, input, .{}) catch unreachable;
+    var output = std.ArrayList(u8).init(ally);
+    std.json.stringify(parsed.value, .{}, output.writer()) catch unreachable;
+    output.append(0) catch unreachable; // append null terminator
+    return @ptrCast(output.items);
+}
+
+export fn fi(n: i32) i32 {
+    if (n <= 1) return n;
+    return fi(n - 1) + fi(n - 2);
+}