8be7743b26
Implement clojure.core futures backed by Janet's ev/thread for genuine parallelism (CPU-bound work can use a second core, unlike cooperative go blocks): - future / future-call, deref + (deref f timeout-ms timeout-val), future?, future-done?, future-cancel, future-cancelled?; realized? on futures. - A worker OS thread computes and marshals back a [:ok v]/[:error e] result over a thread-chan; a parent-side collector fiber caches it and closes a broadcast latch so any number of deref-ers unpark. - Snapshot semantics: separate heaps mean the body + captured state are copied to the worker and only the result is copied back (mutating a captured atom does not propagate). Documented in README. - future-cancel can't interrupt a Janet OS thread, so it marks the future cancelled/done (deref throws, predicates flip) while the worker runs out. clojure-test-suite baseline 3915 -> 3913: implementing future unskips realized_qmark.cljc's (when-var-exists future ...) block, which depends on JVM Thread/sleep + real thread interruption jolt can't provide; deref then re-raises the unresolved-Thread/sleep error. Documented at the baseline. Spec: test/spec/futures-spec.janet (18 cases).
45 lines
2.6 KiB
Text
45 lines
2.6 KiB
Text
# Specification: clojure.core futures on Janet OS threads (ev/thread).
|
|
#
|
|
# A `future` runs its body on a *real* OS thread (ev/thread), so it can use a
|
|
# second core for CPU-bound work — unlike the cooperatively-scheduled go blocks.
|
|
# Because Janet threads have separate heaps, the body and its captured state are
|
|
# MARSHALLED (copied) to the worker thread and the result is marshalled back: a
|
|
# future sees a snapshot of captured state and communicates only via its return
|
|
# value (mutations to captured atoms do NOT propagate back). `deref`/`@` blocks
|
|
# (parks) until the worker finishes; the result is cached for later derefs.
|
|
(use ../support/harness)
|
|
|
|
(defspec "clojure.core / futures — deref"
|
|
["future + deref" "3" "(deref (future (+ 1 2)))"]
|
|
["@ reader macro derefs" "42" "@(future (* 6 7))"]
|
|
["future returns collection" "[2 3 4]" "(deref (future (mapv inc [1 2 3])))"]
|
|
["future returns a map" "{:a 1}" "(deref (future {:a 1}))"]
|
|
["deref is cached/idempotent" "[2 2]" "(let [f (future (+ 1 1))] [(deref f) (deref f)])"]
|
|
["timed deref of ready future" "42" "(let [f (future 42)] (deref f) (deref f 1000 :nope))"]
|
|
["body error re-raised on deref" :throws "(deref (future (throw \"boom\")))"])
|
|
|
|
(defspec "clojure.core / futures — predicates"
|
|
["future? true" "true" "(future? (future 1))"]
|
|
["future? false" "false" "(future? 42)"]
|
|
["future-done? after deref" "true" "(let [f (future 1)] (deref f) (future-done? f))"]
|
|
["realized? after deref" "true" "(let [f (future 1)] (deref f) (realized? f))"]
|
|
# Cancel marks the future done (the worker can't be interrupted, but the
|
|
# future object reflects the cancellation: deref raises, predicates flip).
|
|
["cancel an in-flight future returns true" "true"
|
|
"(let [f (future 1)] (future-cancel f))"]
|
|
["future-cancelled? after cancel" "true"
|
|
"(let [f (future 1)] (future-cancel f) (future-cancelled? f))"]
|
|
["future-done? after cancel" "true"
|
|
"(let [f (future 1)] (future-cancel f) (future-done? f))"]
|
|
["cancel an already-completed future returns false" "false"
|
|
"(let [f (future 1)] (deref f) (future-cancel f))"]
|
|
["future-cancelled? fresh is false" "false"
|
|
"(future-cancelled? (future 1))"])
|
|
|
|
(defspec "clojure.core / futures — snapshot (copy) semantics"
|
|
# The worker thread swaps its *copy* of the atom; the parent's atom is untouched.
|
|
["captured atom is snapshotted, not shared"
|
|
"0" "(let [a (atom 0)] (deref (future (swap! a inc))) @a)"]
|
|
# The future's own return value still reflects the swap on its copy.
|
|
["future sees its own mutation"
|
|
"1" "(let [a (atom 0)] (deref (future (swap! a inc))))"])
|