Orkuncakilkaya
7834b26ef8
Every pool thread runs the worker at once with the same states, so a mut state in a worker was a race nothing reported. check_worker_ref refuses a worker whose leading states include a mut one; threads.ludic's total moves into the words the worker is handed, under the mutex. The seeds are regenerated (ludic-dev reseed). ludic-dev test 305 passed, selfhost-test 33 passed. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
1.5 KiB
| id | name | category | kind | tokens | sig | tip | order | ns | member |
|---|---|---|---|---|---|---|---|---|---|
| job-parallel_for | Job.parallel_for | job | namespace-method | Job.parallel_for | Job.parallel_for(count, work, ctx) -> void | Run work(i, ctx) for every i in [0, count) across all cores; returns when every call is done. | 16 | Job | parallel_for |
Run work(i, ctx) for every i in [0, count) on real OS threads, and return when every call has
finished. The indices are split into chunks shared by a worker pool (one thread per core but one,
started on first use) and the calling thread, so each index runs exactly once, in no particular order.
work is a top-level function taking (i: int, ctx), named with fn; ctx is whatever it computes
on (words, bytes or a pointer). A worker computes on what it was handed and writes only its own
index's results: it must not spawn, despawn, push onto a list another thread can see, or use
Http or Audio. spawn and despawn on a worker stop the program with a located message. Shared
counters go through Sync.add, shared totals behind a Sync.mutex. A worker may take states, but
only to read them: every thread runs it at once, so a worker that takes one as mut is refused at
compile time (a result goes into ctx, a count through a Sync handle kept in the state).
program Squares {
function square(i: int, out: words) -> void { out[i] = i * i }
entry {
let sq = words(20000)
Job.parallel_for(20000, fn square, sq)
print(sq[141])
}
}