@tishlang/tish 1.13.2 → 2.0.0

package/crates/tish_vm/tests/concurrent_shared_state.rs

@@ -0,0 +1,140 @@
+//! Regression: concurrent HTTP handlers that mutate shared module-level state must not deadlock.
+//!
+//! ## What this guards
+//!
+//! Under `send-values` (forced on by the `http` feature), `serve(port, handler)` runs the handler
+//! closure — a `NativeFn` (`Arc<dyn Callable>`, `Send + Sync`) — **directly on each accept thread**
+//! (`tish_runtime::http::worker_loop_direct`). So N concurrent requests execute the SAME handler in
+//! parallel, all sharing the captured module scope through `Arc<Mutex>` (`VmRef`). A handler that
+//! mutates a module-level `let` (a request counter / cache / rate-limiter) therefore has many threads
+//! reading and writing the same scope cell at once.
+//!
+//! This test drives that exact path without a network: it pulls the handler `Value::Function` out of
+//! a freshly-run program and invokes it from many OS threads while they all read-modify-write a shared
+//! module-level `let`. It exists to catch a regression where the VM's variable-write path holds a
+//! scope guard across a re-acquisition of the same lock (which would deadlock concurrent writers and
+//! hang `serve`). The watchdog turns such a hang into a fast, explicit test failure instead of a
+//! stuck CI job.
+//!
+//! Note on coverage: macOS `SO_REUSEPORT` funnels HTTP accepts to a single worker thread, so a
+//! network-level test can't actually run two handlers concurrently on macOS. Calling the handler
+//! closure directly does — and OS thread scheduling + mutex semantics are platform-independent, so
+//! this reproduces the Linux multi-worker dispatch contention the bug was reported against.
+#![cfg(feature = "send-values")]
+
+use std::sync::atomic::{AtomicUsize, Ordering};
+use std::sync::Arc;
+use std::time::{Duration, Instant};
+use tishlang_bytecode::compile;
+use tishlang_core::{NativeFn, Value};
+use tishlang_vm::Vm;
+
+// `Value::Function` holds a `NativeFn` (= `Arc<dyn Callable>`, `Callable: Send + Sync` under
+// send-values); invoke a handler via the trait-object method `.call(args)`.
+type Handler = NativeFn;
+
+/// Compile + run `src`, then pull a function it stored in a global back out.
+fn export(vm: &Vm, name: &str) -> Handler {
+    match vm.get_global(name).unwrap_or_else(|| panic!("global `{name}` not found")) {
+        Value::Function(f) => f,
+        other => panic!("global `{name}` is not a function: {other:?}"),
+    }
+}
+
+fn read_num(obj: &Value, field: &str) -> f64 {
+    match obj {
+        Value::Object(o) => match o.borrow().strings.get(field) {
+            Some(Value::Number(n)) => *n,
+            other => panic!("stats.{field} is not a number: {other:?}"),
+        },
+        other => panic!("stats is not an object: {other:?}"),
+    }
+}
+
+#[test]
+fn concurrent_handlers_mutating_shared_module_state_do_not_deadlock() {
+    // `handler`/`stats` are bare top-level assignments (undeclared names) -> stored in globals, so
+    // the test can pull them out. Both functions close over the same module-level `let`s, exactly as
+    // a real `serve` handler closes over module state. `served` is monotonic (only incremented), so
+    // it gives a deterministic plausibility bound even though the read-modify-write is racy.
+    let src = r#"
+let active = 0
+let maxActive = 0
+let served = 0
+fn handleRequest(req) {
+    active = active + 1
+    served = served + 1
+    if (active > maxActive) { maxActive = active }
+    let i = 0
+    while (i < 2000) { i = i + 1 }   // brief CPU hold so handlers overlap
+    active = active - 1
+    return { status: 200, body: "ok" }
+}
+fn getStats() {
+    return { active: active, maxActive: maxActive, served: served }
+}
+handler = handleRequest
+stats = getStats
+"#;
+    let program = tishlang_parser::parse(src).expect("parse");
+    let chunk = compile(&program).expect("compile");
+    let mut vm = Vm::new();
+    vm.run(&chunk).expect("run top-level");
+    let handler = export(&vm, "handler");
+    let stats = export(&vm, "stats");
+
+    const THREADS: usize = 12;
+    const ITERS: usize = 100;
+    let total = THREADS * ITERS;
+
+    let done = Arc::new(AtomicUsize::new(0));
+    let start = Instant::now();
+    let mut handles = Vec::with_capacity(THREADS);
+    for t in 0..THREADS {
+        let h = handler.clone();
+        let done = Arc::clone(&done);
+        handles.push(std::thread::spawn(move || {
+            for i in 0..ITERS {
+                let resp = h.call(&[Value::Number((t * ITERS + i) as f64)]);
+                assert!(matches!(resp, Value::Object(_)), "handler must return a response object");
+                done.fetch_add(1, Ordering::Relaxed);
+            }
+        }));
+    }
+
+    // Watchdog: if concurrent writers deadlocked on the scope mutex, `done` stops advancing.
+    // Fail fast (and loudly) rather than hang the test runner.
+    let mut last = 0usize;
+    let mut last_change = Instant::now();
+    while done.load(Ordering::Relaxed) < total {
+        let cur = done.load(Ordering::Relaxed);
+        if cur != last {
+            last = cur;
+            last_change = Instant::now();
+        }
+        assert!(
+            last_change.elapsed() < Duration::from_secs(15),
+            "DEADLOCK regression: concurrent handlers stalled at {cur}/{total} (no progress for 15s)"
+        );
+        std::thread::sleep(Duration::from_millis(20));
+    }
+    for h in handles {
+        h.join().expect("a handler thread panicked");
+    }
+
+    // All calls returned without hanging. Read the shared counters back.
+    let s = stats.call(&[]);
+    let served = read_num(&s, "served");
+    let max_active = read_num(&s, "maxActive");
+    let active = read_num(&s, "active");
+    eprintln!(
+        "completed {total} concurrent calls / {THREADS} threads in {:?}; served={served}, maxActive={max_active}, active(final)={active}",
+        start.elapsed()
+    );
+
+    // `served` is monotonic, so it is deterministically in (0, total] regardless of lost updates.
+    assert!(served > 0.0 && served <= total as f64, "served={served} out of plausible range (0, {total}]");
+    // `maxActive` >= 2 proves at least two handlers were genuinely in-flight simultaneously, i.e. we
+    // actually exercised concurrent shared-state mutation (not an accidentally-serialized run).
+    assert!(max_active >= 2.0, "handlers never overlapped (maxActive={max_active}); test did not exercise concurrency");
+}

package/crates/tish_wasm/src/lib.rs

@@ -379,10 +379,14 @@ fn main() {
         message: format!("Cannot write main.rs: {}", e),
     })?;
 
-    // Build - use explicit target-dir so we know where the artifact is
+    // Build into a SHARED target dir (one per host), not per-program. The wasi runtime + embedded
+    // VM then compile ONCE and are reused by every wasi build; only each program's tiny main is
+    // rebuilt. Without this each program left its own multi-GB `target/` and a full-suite sweep
+    // would fill the disk (same issue fixed for cranelift; see full-backend-parity-plan.md A3).
+    // cargo's target lock serializes concurrent builds safely.
     let cargo = std::env::var("CARGO").unwrap_or_else(|_| "cargo".to_string());
     let bin_name = format!("tish_wasi_{}", stem);
-    let target_dir = build_dir.join("target");
+    let target_dir = std::env::temp_dir().join("tishlang_wasi_target");
     let build_status = Command::new(&cargo)
         .current_dir(&build_dir)
         .env("CARGO_TARGET_DIR", &target_dir)

package/crates/tish_wasm_runtime/src/gpu.rs

@@ -10,7 +10,7 @@
 //!   command API is synchronous, so this covers it)
 //! - `js_new(ctorNameOrHandle, argsArray)`
 //! - `js_typeof(handle)` — debugging
-//! - `f32a(arr)` / `u16a(arr)` / `u8a(arr)` — tish `number[]` → real typed array
+//! - `f32a(arr)` / `u16a(arr)` / `u8a(arr)` / `u32a(arr)` — tish `number[]` → real typed array
 //! - `request_animation_frame(cb)` — drive a render loop
 //!
 //! GPU/JS objects (device, queue, context, buffers, pipelines, textures,
@@ -284,6 +284,21 @@ fn ffi_u8a() -> Value {
     })
 }
 
+fn ffi_u32a() -> Value {
+    Value::native(|args: &[Value]| {
+        let arr = match args.first() {
+            Some(Value::Array(a)) => a.clone(),
+            _ => return Value::Null,
+        };
+        let b = arr.borrow();
+        let ta = js_sys::Uint32Array::new_with_length(b.len() as u32);
+        for (i, v) in b.iter().enumerate() {
+            ta.set_index(i as u32, v.as_number().unwrap_or(0.0) as u32);
+        }
+        wrap(ta.into())
+    })
+}
+
 // ---------------------------------------------------------------------------
 // requestAnimationFrame render loop
 // ---------------------------------------------------------------------------
@@ -362,6 +377,7 @@ fn install_ffi(vm: &mut Vm) {
     vm.set_global("f32a".into(), ffi_f32a());
     vm.set_global("u16a".into(), ffi_u16a());
     vm.set_global("u8a".into(), ffi_u8a());
+    vm.set_global("u32a".into(), ffi_u32a());
     vm.set_global("request_animation_frame".into(), ffi_request_animation_frame());
 }
 

package/crates/tishlang_cargo_bindgen/src/classify.rs

@@ -39,9 +39,7 @@ fn classify_tish_abi(item: &ItemFn) -> Option<SignatureClass> {
     if value_args != 1 || sig.inputs.len() != 1 {
         return None;
     }
-    let Some(ret_ty) = return_type_inner(&sig.output) else {
-        return None;
-    };
+    let ret_ty = return_type_inner(&sig.output)?;
     if !is_value_type(ret_ty) {
         return None;
     }

package/crates/tishlang_cargo_bindgen/src/lib.rs

@@ -121,7 +121,7 @@ fn generate_from_resolved(
 impl BindgenConfig {
     /// Write using [`generate_from_registry_dependency`].
     pub fn write_files(&self) -> io::Result<()> {
-        generate_from_registry_dependency(self).map_err(|e| io::Error::new(io::ErrorKind::Other, e))
+        generate_from_registry_dependency(self).map_err(io::Error::other)
     }
 }
 
@@ -199,7 +199,7 @@ fn render_generated_lib(
                 name = rust_fn
             ),
             SignatureClass::SerializeRefToResultString => format!(
-                "pub fn {name}(args: &[Value]) -> Value {{\n    let Some(v) = args.first() else {{ return Value::Null }};\n    match _tish_upstream::{name}(&tish_to_json(v)) {{\n        Ok(s) => Value::String(Arc::from(s)),\n        Err(_) => Value::Null,\n    }}\n}}\n\n",
+                "pub fn {name}(args: &[Value]) -> Value {{\n    let Some(v) = args.first() else {{ return Value::Null }};\n    match _tish_upstream::{name}(&tish_to_json(v)) {{\n        Ok(s) => Value::String(arcstr::ArcStr::from(s)),\n        Err(_) => Value::Null,\n    }}\n}}\n\n",
                 name = rust_fn
             ),
             SignatureClass::DeserializeStrToResult => format!(

package/crates/tishlang_cargo_bindgen/src/metadata.rs

@@ -79,7 +79,7 @@ edition = "2021"
         && !pkg
             .targets
             .iter()
-            .any(|t| t.kind.iter().any(|k| *k == TargetKind::Lib))
+            .any(|t| t.kind.contains(&TargetKind::Lib))
     {
         return Err(format!(
             "package `{}` has no src/ or lib target at {}",

package/justfile

@@ -258,6 +258,14 @@ perf-suite *ARGS:
 perf-suite-gen:
     ./scripts/generate_perf_ci_main.sh
 
+# HTTP throughput: tish vs Node, single vs multi-worker, plaintext + json (needs oha + jq)
+perf-http *ARGS:
+    ./scripts/run_http_perf.sh {{ARGS}}
+
+# Perf gauntlet: compute benchmarks vs Node, incl. known-fail targets to evolve past (needs node)
+perf-gauntlet *ARGS:
+    ./scripts/run_perf_gauntlet.sh {{ARGS}}
+
 # Show binary sizes for different builds
 sizes:
     @echo "Building secure binary..."

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tishlang/tish",
-  "version": "1.13.2",
+  "version": "2.0.0",
   "description": "Tish - minimal TS/JS-compatible language. Run, REPL, build to native or other targets.",
   "license": "PIF",
   "repository": {