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.
80 lines
2.6 KiB
Plaintext
80 lines
2.6 KiB
Plaintext
// Stream B1 (fibers) B1.5a — the M:1 cooperative fiber scheduler core, in pure
|
|
// sx over `swap_context` (proven in 1807-1809). `Scheduler` drives N fibers,
|
|
// each running a `body: Closure() -> void` on its own guarded `mmap` stack;
|
|
// fibers cooperate by calling `yield_now`, which round-robins control back
|
|
// through the scheduler loop.
|
|
//
|
|
// Round-robin demo: 3 fibers (A=0, B=1, C=2) each append their id to a shared
|
|
// sequence buffer, yielding between each of 3 rounds. Because the scheduler
|
|
// re-enqueues a yielding fiber at the TAIL (FIFO), the interleaving is the
|
|
// deterministic round-robin order:
|
|
//
|
|
// round 1: A B C (0 1 2)
|
|
// round 2: A B C (0 1 2)
|
|
// round 3: A B C (0 1 2)
|
|
//
|
|
// → sequence: 0 1 2 0 1 2 0 1 2
|
|
//
|
|
// Outputs flow OUT of each fiber through pointers captured in its closure (the
|
|
// shared `Shared` struct), since closure capture-by-value does not write back.
|
|
// Every fiber must reach `.done` (asserted via a per-fiber done flag).
|
|
//
|
|
// aarch64-macOS-pinned (the scheduler's asm + guard-page mmap constants are
|
|
// per-arch / Apple-specific): runs end-to-end on a matching host, ir-only on a
|
|
// mismatch.
|
|
#import "modules/std.sx";
|
|
sched :: #import "modules/std/sched.sx";
|
|
|
|
Shared :: struct {
|
|
seq: [16]i64; // appended interleaving sequence
|
|
n: i64; // count appended
|
|
done: [3]i64; // per-fiber done flag (set right before the body returns)
|
|
}
|
|
|
|
append :: (sh: *Shared, v: i64) {
|
|
sh.seq[sh.n] = v;
|
|
sh.n = sh.n + 1;
|
|
}
|
|
|
|
main :: () -> i64 {
|
|
sh : Shared = .{ n = 0 }; // seq[] + done[] zero-filled
|
|
|
|
s := sched.Scheduler.init();
|
|
ps := @s;
|
|
psh := @sh;
|
|
|
|
// Three DIFFERENT fiber bodies (distinct captured ids), interleaving via
|
|
// yield_now. Each appends its id once per round for 3 rounds.
|
|
spawn_worker :: (ps: *sched.Scheduler, psh: *Shared, my_id: i64) {
|
|
ps.spawn(() {
|
|
r := 0;
|
|
while r < 3 {
|
|
append(psh, my_id);
|
|
if r < 2 { ps.yield_now(); } // cooperate between rounds
|
|
r = r + 1;
|
|
}
|
|
psh.done[my_id] = 1;
|
|
});
|
|
}
|
|
|
|
spawn_worker(ps, psh, 0);
|
|
spawn_worker(ps, psh, 1);
|
|
spawn_worker(ps, psh, 2);
|
|
|
|
s.run();
|
|
|
|
// Ordering contract: round-robin FIFO interleaving.
|
|
print("sequence:");
|
|
i := 0;
|
|
while i < sh.n {
|
|
print(" {}", sh.seq[i]);
|
|
i = i + 1;
|
|
}
|
|
print("\n");
|
|
|
|
print("spawned: {}\n", s.n_spawned);
|
|
print("done: {} {} {}\n", sh.done[0], sh.done[1], sh.done[2]);
|
|
print("all done: {}\n", sh.done[0] + sh.done[1] + sh.done[2]);
|
|
return 0;
|
|
}
|