959845bd30
The canonical sx block-body lambda is `(params) { stmts }` (and
`(params) -> Ret { stmts }`); the arrow form `=>` is for EXPRESSION bodies
(`(params) => expr`). The arrow-block hybrid `(params) => { .. }` was being
used in 33 files — convert all of them by dropping the `=>`. The two forms are
exactly equivalent (verified: identical IR and identical runtime values — the
block tail is the value with or without a `-> Ret`), so this is a pure source
cleanup: no `.ir` churn, and the only snapshot change is 0923's diagnostic
COLUMN (a negative narrowing test whose error span shifted by the removed `=> `).
Arrow EXPRESSION bodies (`=> expr`, `=> .{..}`, `=> [..]`) and `=>` inside
comments/strings were left untouched. Migrated across examples/concurrency,
examples/{closures,ffi-objc,generics,optionals,types}, issues/, and the stdlib
(io.sx, sched.sx). Suite 855/0.
65 lines
2.6 KiB
Plaintext
65 lines
2.6 KiB
Plaintext
// Stream B1 (fibers) B1.5a — fiber park/resume via `suspend_self` + `wake`,
|
|
// the off-queue half of the M:1 scheduler that FiberIo [B1.4] builds on.
|
|
//
|
|
// A running fiber that has nothing to do parks itself with `suspend_self`: it
|
|
// leaves the round-robin queue entirely (unlike `yield_now`, which re-enqueues)
|
|
// and only runs again when another fiber (or an I/O completion) calls `wake` on
|
|
// it. Here fiber A records 10, parks, and is resumed by fiber B to record 11:
|
|
//
|
|
// A: rec 10, suspend_self ──park──┐
|
|
// B: rec 20, wake(A), wake(A), rec 21
|
|
// A: ──resume──> rec 11
|
|
// → log: 10 20 21 11
|
|
//
|
|
// `wake` is GUARDED on `.suspended`: B's SECOND `wake(A)` is spurious (A is
|
|
// already re-queued by then). An unguarded enqueue would re-link an
|
|
// already-listed node and corrupt the FIFO (segfault); the guard makes a
|
|
// double/spurious/stale wake a safe no-op. `suspended-left: 0` confirms every
|
|
// park was balanced by a wake (an orphaned park would abort the scheduler).
|
|
//
|
|
// aarch64-macOS-pinned (the scheduler's per-arch asm + Apple mmap constants):
|
|
// runs end-to-end on a matching host, ir-only on a mismatch.
|
|
#import "modules/std.sx";
|
|
sched :: #import "modules/std/sched.sx";
|
|
|
|
// The shared state both fibers reach through (passed as `*Sh`). `parked` holds
|
|
// the fiber-A handle that B wakes — kept here (rather than a separate
|
|
// `**Fiber`) so the one `*Sh` carries everything the helper fns share.
|
|
Sh :: struct { log: [16]i64; n: i64; parked: *sched.Fiber; }
|
|
rec :: (sh: *Sh, v: i64) { sh.log[sh.n] = v; sh.n = sh.n + 1; }
|
|
|
|
main :: () -> i64 {
|
|
sh : Sh = ---; sh.n = 0; sh.parked = null;
|
|
s := sched.Scheduler.init();
|
|
ps := @s; psh := @sh;
|
|
|
|
// Fiber A: record 10, park, then (after wake) record 11. Store A's handle in
|
|
// the shared state so B can wake it.
|
|
mk_a :: (ps: *sched.Scheduler, psh: *Sh) {
|
|
psh.parked = ps.spawn(() {
|
|
rec(psh, 10);
|
|
ps.suspend_self();
|
|
rec(psh, 11);
|
|
});
|
|
}
|
|
// Fiber B: record 20, wake A (legit) + a spurious second wake (safe no-op),
|
|
// record 21.
|
|
mk_b :: (ps: *sched.Scheduler, psh: *Sh) {
|
|
ps.spawn(() {
|
|
rec(psh, 20);
|
|
ps.wake(psh.parked); // legitimate: A is parked
|
|
ps.wake(psh.parked); // spurious: A is now .ready/queued — must no-op
|
|
rec(psh, 21);
|
|
});
|
|
}
|
|
mk_a(ps, psh);
|
|
mk_b(ps, psh);
|
|
s.run();
|
|
|
|
print("log:");
|
|
i := 0; while i < sh.n { print(" {}", sh.log[i]); i = i + 1; }
|
|
print("\n");
|
|
print("suspended-left: {}\n", s.n_suspended);
|
|
return 0;
|
|
}
|