8bacb2b01c
A cancelled async worker now abandons its body at its next suspend instead
of running to completion.
- Cancel-flag back-ref (D4): SpawnOpts.cancel_flag (core.sx) + Fiber.cancel_flag
(sched.sx), set from opts.cancel_flag in Scheduler.spawn_raw; async passes
xx @f.canceled (the Future.canceled Atomic(bool) erased to *void).
- Delivery: Scheduler.suspend_raw consults fiber_canceled(self.current) PRE-park
(raise without parking — no deadlock if cancel landed before the worker ran)
and POST-resume (cancel landed while parked), raising error.Canceled.
cancel(f) flips the sticky flag, marks .canceled, and wakes the worker.
- async worker is failable Closure() -> ($R, !); the completion closure
f.value = worker() catch {…} marks .canceled/.failed and wakes the awaiter,
so post-suspend side effects never run. New failable io.sleep(ms) is the
cancellation point.
- Compiler: a -> ! fn whose only error source is try-ing a protocol method
(io.suspend_raw) was wrongly flagged 'declared ! but never errors';
collectErrorSites now marks a try of a non-identifier callee as a dynamic
(opaque) error source, suppressing the warning.
- Two UAFs found by adversarial review and fixed: (1) cancel-before-park
orphaned io.sleep's armed timer — suspend_raw's pre-park raise now evicts the
current fiber's timer/waiter first; (2) cancel(f) could wake a reaped worker —
now only wakes when was_pending.
Migrated 1805/1806/1824 to failable workers. Lock: example 1825 (seq: 1 -99,
post-suspend line never runs); byte-identical on aarch64-macOS + aarch64-linux.
.ir churn is the SpawnOpts layout change (type-table string renumbering).
43 lines
1.9 KiB
Plaintext
43 lines
1.9 KiB
Plaintext
// Stream B2 — `async`/`await` (the io.sx ergonomic layer) running COLORBLIND over
|
|
// the fiber `Io` scheduler. The SAME `context.io.async(worker)` that runs inline
|
|
// under the blocking `CBlockingIo` (1805) here spawns the worker as a real fiber
|
|
// and returns a PENDING `*Future`; `await` suspends the calling fiber until the
|
|
// worker completes. No bespoke `go`/`wait` — this is the unified async stack
|
|
// (io.sx async over the `Io` protocol), reaching the fiber scheduler purely
|
|
// through `context.io`.
|
|
//
|
|
// The completion log makes the deferral visible: the coordinator records 1,2
|
|
// BEFORE either worker runs (async only SPAWNS them), then `await` parks it while
|
|
// the workers run (10,20), then it resumes and sums (123). Deterministic.
|
|
//
|
|
// aarch64-pinned (the scheduler's per-arch asm): runs end-to-end on a matching
|
|
// host (macOS + linux), ir-only on a mismatch.
|
|
#import "modules/std.sx";
|
|
sched :: #import "modules/std/sched.sx";
|
|
|
|
Log :: struct { seq: [8]i64; n: i64; }
|
|
rec :: (l: *Log, v: i64) { l.seq[l.n] = v; l.n = l.n + 1; }
|
|
|
|
main :: () -> i64 {
|
|
lg : Log = ---; lg.n = 0;
|
|
s := sched.Scheduler.init();
|
|
ps := @s; pl := @lg;
|
|
push .{ io = xx s } {
|
|
ps.spawn(() => {
|
|
rec(pl, 1); // coordinator starts
|
|
a := context.io.async(() -> (i64, !) => { rec(pl, 10); 100 }); // worker A — deferred
|
|
b := context.io.async(() -> (i64, !) => { rec(pl, 20); 23 }); // worker B — deferred
|
|
rec(pl, 2); // both spawned, neither has run
|
|
va := a.await() or { -1 }; // park; A runs, wakes us
|
|
vb := b.await() or { -1 };
|
|
rec(pl, va + vb); // 123
|
|
});
|
|
ps.run();
|
|
}
|
|
print("sequence:");
|
|
i := 0;
|
|
while i < lg.n { print(" {}", lg.seq[i]); i = i + 1; }
|
|
print("\n");
|
|
return 0;
|
|
}
|