virtual-machine 0.7.2 → 0.7.5

package/README.md

@@ -4,7 +4,7 @@ A complete RISC-V 64-bit (RV64GC) virtual machine implementation in Rust, capabl
 
 ## Features
 
-- **Core**: Full RV64GC instruction set implementation (IMAFDC + Zicsr + Zifencei).
+- **Core**: RV64GC instruction set implementation (IMAFDC + Zicsr + Zifencei). Integer, atomic and compressed instructions run in a superblock engine with a devirtualized memory fast path; F/D floating-point executes in the interpreter (NaN boxing, all rounding modes for conversions, fcsr flags). Misaligned scalar accesses to RAM are handled in hardware style (no trap).
 - **Memory**: Sv39 Virtual Memory Management Unit (MMU) with TLB.
 - **Peripherals**:
   - **UART**: 16550-compatible serial console.

package/build/{chunk-SWPU5PUE.mjs → chunk-QNHY4JET.mjs}

@@ -217,17 +217,17 @@ if (!("encodeInto" in cachedTextEncoder)) {
   };
 }
 var WASM_VECTOR_LEN = 0;
-function wasm_bindgen__convert__closures_____invoke__h4e3f98878f091896(arg0, arg1) {
-  wasm.wasm_bindgen__convert__closures_____invoke__h4e3f98878f091896(arg0, arg1);
+function wasm_bindgen__convert__closures_____invoke__h10fd13f77519f00f(arg0, arg1, arg2) {
+  wasm.wasm_bindgen__convert__closures_____invoke__h10fd13f77519f00f(arg0, arg1, arg2);
 }
-function wasm_bindgen__convert__closures_____invoke__h260170fb96639bcf(arg0, arg1, arg2) {
-  wasm.wasm_bindgen__convert__closures_____invoke__h260170fb96639bcf(arg0, arg1, arg2);
+function wasm_bindgen__convert__closures_____invoke__h3c19a701e2fb4946(arg0, arg1, arg2) {
+  wasm.wasm_bindgen__convert__closures_____invoke__h3c19a701e2fb4946(arg0, arg1, arg2);
 }
-function wasm_bindgen__convert__closures_____invoke__h658bde57dcf0e58b(arg0, arg1) {
-  wasm.wasm_bindgen__convert__closures_____invoke__h658bde57dcf0e58b(arg0, arg1);
+function wasm_bindgen__convert__closures_____invoke__h6ce8d92453d66e1b(arg0, arg1) {
+  wasm.wasm_bindgen__convert__closures_____invoke__h6ce8d92453d66e1b(arg0, arg1);
 }
-function wasm_bindgen__convert__closures_____invoke__h5006ec25729b138d(arg0, arg1, arg2) {
-  wasm.wasm_bindgen__convert__closures_____invoke__h5006ec25729b138d(arg0, arg1, arg2);
+function wasm_bindgen__convert__closures_____invoke__h1f45221b43ca80d0(arg0, arg1) {
+  wasm.wasm_bindgen__convert__closures_____invoke__h1f45221b43ca80d0(arg0, arg1);
 }
 var __wbindgen_enum_WorkerType = ["classic", "module"];
 var WasmVmFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
@@ -647,6 +647,16 @@ var WasmVm = class _WasmVm {
     const ret = wasm.wasmvm_get_gpu_dirty_rect(this.__wbg_ptr);
     return ret;
   }
+  /**
+   * Reset hart 0 to bare machine mode at the entry point.
+   *
+   * Benchmark workloads (see `bench_workload`) are M-mode programs; this
+   * undoes the S-mode boot setup that `new_with_harts` applies so they
+   * run exactly like under the native bench runner.
+   */
+  reset_machine_mode() {
+    wasm.wasmvm_reset_machine_mode(this.__wbg_ptr);
+  }
   /**
    * Check if cancellation has been requested.
    * @returns {boolean}
@@ -684,10 +694,14 @@ var WasmVm = class _WasmVm {
    * Get a direct zero-copy view into the framebuffer in SharedArrayBuffer.
    *
    * This eliminates all memory copies by creating a Uint8Array view directly
-   * into the SharedArrayBuffer at the framebuffer offset. The browser can
-   * pass this directly to WebGPU's writeTexture for zero-copy rendering.
+   * into guest memory at the framebuffer offset. The browser can pass this
+   * directly to WebGPU's writeTexture for zero-copy rendering.
    *
-   * Returns None if SharedArrayBuffer is not available (single-threaded mode).
+   * Works in both memory modes:
+   * - SMP (SharedArrayBuffer): stable view into the SAB.
+   * - Single-hart (linear memory): view into WASM linear memory. This view
+   *   is invalidated whenever WASM memory grows, so consume it immediately
+   *   and call this again each frame (do not cache it JS-side).
    * @returns {Uint8Array | undefined}
    */
   get_framebuffer_view() {
@@ -845,7 +859,11 @@ var WasmVm = class _WasmVm {
   }
   /**
    * Push an input byte to the UART.
-   * In SMP mode, this also writes to the shared input buffer so workers can receive it.
+   *
+   * In SMP mode there is a single shared input ring consumed by whichever
+   * hart runs the shell (the bus routes RBR/LSR reads of every hart,
+   * including hart 0, to the ring). Pushing to the local FIFO as well
+   * would duplicate the stream and leave stale bytes behind.
    * @param {number} byte
    */
   input(byte) {
@@ -860,10 +878,13 @@ var WasmVm = class _WasmVm {
     return ret !== 0;
   }
   /**
-   * Execute up to N instructions in a batch.
-   * Returns the number of instructions actually executed.
-   * This is more efficient than calling step() N times due to reduced
-   * JS-WASM boundary crossings.
+   * Execute up to N instructions by looping `step()`.
+   *
+   * DEPRECATED for hot paths: prefer `run_batch`, which hoists device
+   * polling and CLINT sync out of the instruction loop and returns early
+   * on WFI. `step_n` keeps the historical contract that a return value
+   * less than `count` means the VM halted (it never stops early on WFI),
+   * which existing consumers rely on for halt detection.
    * @param {number} count
    * @returns {number}
    */
@@ -871,6 +892,17 @@ var WasmVm = class _WasmVm {
     const ret = wasm.wasmvm_step_n(this.__wbg_ptr, count);
     return ret >>> 0;
   }
+  /**
+   * Total retired guest instructions on hart 0.
+   *
+   * Unlike step counts, this reflects real instructions (superblock
+   * execution retires many instructions per step). Use for MIPS metrics.
+   * @returns {number}
+   */
+  instret() {
+    const ret = wasm.wasmvm_instret(this.__wbg_ptr);
+    return ret;
+  }
   /**
    * Get the entry PC address for workers.
    * This is the address where secondary harts should start executing.
@@ -940,6 +972,25 @@ var WasmVm = class _WasmVm {
     const ret = wasm.wasmvm_num_harts(this.__wbg_ptr);
     return ret >>> 0;
   }
+  /**
+   * Execute up to N instructions in a batch with device polling, CLINT
+   * sync, and RTC updates hoisted to chunk boundaries.
+   *
+   * This is the fast path for hart 0: the inner loop is a tight
+   * `cpu.step()` with no per-instruction bookkeeping. Interrupt latency
+   * is bounded by IRQ_SYNC_INTERVAL (shared-CLINT sync) and the CPU's own
+   * internal 256-instruction interrupt poll.
+   *
+   * Returns the number of dispatcher steps executed (superblocks count as
+   * one step; use `instret()` for true instruction counts). Returns early
+   * on halt or WFI so the JS caller can pace execution.
+   * @param {number} max_steps
+   * @returns {number}
+   */
+  run_batch(max_steps) {
+    const ret = wasm.wasmvm_run_batch(this.__wbg_ptr, max_steps);
+    return ret >>> 0;
+  }
 };
 if (Symbol.dispose) WasmVm.prototype[Symbol.dispose] = WasmVm.prototype.free;
 var WorkerState = class {
@@ -1055,6 +1106,17 @@ var WorkerStepResult = Object.freeze({
   Wfi: 4,
   "4": "Wfi"
 });
+function bench_workload(name) {
+  const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+  const len0 = WASM_VECTOR_LEN;
+  const ret = wasm.bench_workload(ptr0, len0);
+  if (ret[3]) {
+    throw takeFromExternrefTable0(ret[2]);
+  }
+  var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+  wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+  return v2;
+}
 function worker_check_interrupts(hart_id, shared_mem) {
   const ret = wasm.worker_check_interrupts(hart_id, shared_mem);
   return BigInt.asUintN(64, ret);
@@ -1358,10 +1420,6 @@ function __wbg_get_imports() {
       return ret;
     }, arguments);
   };
-  imports.wbg.__wbg_new_with_shared_array_buffer_f801846979192910 = function(arg0, arg1, arg2) {
-    const ret = new DataView(arg0, arg1 >>> 0, arg2 >>> 0);
-    return ret;
-  };
   imports.wbg.__wbg_notify_65c8811cd7c0cdea = function() {
     return handleError(function(arg0, arg1, arg2) {
       const ret = Atomics.notify(arg0, arg1 >>> 0, arg2 >>> 0);
@@ -1530,24 +1588,28 @@ function __wbg_get_imports() {
     const ret = getStringFromWasm0(arg0, arg1);
     return ret;
   };
-  imports.wbg.__wbindgen_cast_808b97cce14173bb = function(arg0, arg1) {
-    const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen__closure__destroy__h16ea2e7332e3f0d8, wasm_bindgen__convert__closures_____invoke__h658bde57dcf0e58b);
+  imports.wbg.__wbindgen_cast_37ec172324e9c759 = function(arg0, arg1) {
+    const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen__closure__destroy__h1e8cf243a981f4cd, wasm_bindgen__convert__closures_____invoke__h1f45221b43ca80d0);
     return ret;
   };
-  imports.wbg.__wbindgen_cast_97885f52609c7a81 = function(arg0, arg1) {
-    const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen__closure__destroy__h16ea2e7332e3f0d8, wasm_bindgen__convert__closures_____invoke__h5006ec25729b138d);
+  imports.wbg.__wbindgen_cast_5d29676ef6c3e85f = function(arg0, arg1) {
+    const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen__closure__destroy__h1e8cf243a981f4cd, wasm_bindgen__convert__closures_____invoke__h3c19a701e2fb4946);
     return ret;
   };
-  imports.wbg.__wbindgen_cast_9d58885f229d7092 = function(arg0, arg1) {
-    const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen__closure__destroy__h612f8e24953b61d5, wasm_bindgen__convert__closures_____invoke__h260170fb96639bcf);
+  imports.wbg.__wbindgen_cast_5f9a13552260be22 = function(arg0, arg1) {
+    const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen__closure__destroy__h98fb6f0c0578da12, wasm_bindgen__convert__closures_____invoke__h10fd13f77519f00f);
     return ret;
   };
-  imports.wbg.__wbindgen_cast_d6cd19b81560fd6e = function(arg0) {
-    const ret = arg0;
+  imports.wbg.__wbindgen_cast_c6620a1285ea2988 = function(arg0, arg1) {
+    const ret = makeClosure(arg0, arg1, wasm.wasm_bindgen__closure__destroy__h1e8cf243a981f4cd, wasm_bindgen__convert__closures_____invoke__h6ce8d92453d66e1b);
     return ret;
   };
-  imports.wbg.__wbindgen_cast_e7df37cfbf20cf37 = function(arg0, arg1) {
-    const ret = makeClosure(arg0, arg1, wasm.wasm_bindgen__closure__destroy__h16ea2e7332e3f0d8, wasm_bindgen__convert__closures_____invoke__h4e3f98878f091896);
+  imports.wbg.__wbindgen_cast_cb9088102bce6b30 = function(arg0, arg1) {
+    const ret = getArrayU8FromWasm0(arg0, arg1);
+    return ret;
+  };
+  imports.wbg.__wbindgen_cast_d6cd19b81560fd6e = function(arg0) {
+    const ret = arg0;
     return ret;
   };
   imports.wbg.__wbindgen_init_externref_table = function() {
@@ -1609,6 +1671,7 @@ export {
   WasmVm,
   WorkerState,
   WorkerStepResult,
+  bench_workload,
   worker_check_interrupts,
   worker_entry,
   initSync,