
louise
Clone avec HTTPS, un jeton personnel en mot de passe, ou avec SSH, une clé ajoutée dans vos paramètres.
ADR 0073: std/table, tables any actor reads without a message
Status: Proposed (2026-10-30, issue #407); needs engineering review (#44). It adds shared mutable state to a language whose state otherwise lives in actors, and a second way values become shared (ADR 0002).
Context
toki2 keeps one notebook actor per owner. Every read asks that actor: a page costs several message hops, and at an equal 2,500 req/s it measured p95 3.9 ms / p99 18.6 ms against 2.1 / 3.5 ms for a design that read one shared value. Erlang answers this read path with ETS (read_concurrency) and persistent_term: any process reads the latest value under a key with no message, while one process keeps it current.
Louise had no global or shared mutable storage: no registry, no table. It had the pieces: promotion of a value graph to atomic counts (send.rs, ADR 0002's "promoted to shared"), type-erased generic externs, and an interpreter that runs every actor on one thread.
Decision
pub opaque type Table<v>
pub fn new :: -> Table<v> / <proc>
pub fn get :: table: Table<v> key: String -> Option<v> / <proc>
pub fn put :: table: Table<v> key: String value: v -> () / <proc> where Send<v>
pub fn remove :: table: Table<v> key: String -> () / <proc>
- Values are shared, never copied.
putmakes the value shared withsend::share, a new entry point that promotes the whole graph even when the root's count is 1 (transferwould move a unique value, leaving a non-atomic count other threads would race on).getretains the stored value; every reader holds the same blocks. A value that cannot be shared panics in the writer, as a send does;where Send<v>makes that a compile error in typed code. - A reader can't race a reclaim. The map is 64 shards, each a read-write lock over the entries.
getretains the value before it releases the read lock;putandremoverelease what they replace only after releasing the write lock. A reader therefore always holds its own count before a writer can drop the map's. - Tables are immortal. A table is an id (an
Int), never freed, so no finalizer has to release Louise values (resource finalizers can't). Entries are released on replace and remove; what a program leaves in a table at exit is still alive then. - Effects: all four operations are
<proc>, and none ispure()in the extern table, so fusion never moves or drops a read. putconsumes its arguments (owned, in the extern table and the declaration).- Interpreter: a map in the interpreter's state; one thread runs every actor, so values are stored as they are;
putrefuses unsendable values likesend.
Consequences
- A read is a shard lookup and an atomic increment, from any actor, in parallel with other reads.
- Writers to one shard serialize; the 64 shards keep unrelated keys apart.
- Shared mutable state is visible to every actor holding the table. Programs keep one writer per key (an owning actor), as with
persistent_term; the table does not order concurrent writers. - Tests: the runtime's scenarios check exact counts (no live block left) for put, get, replace and remove, and
share's promotion and refusal;tests/run/table.lseruns on both backends (replace and remove while a reader keeps a value, two tables apart, 32 actors reading while one writes 2,000 times);tests/ui/table_send.lsechecks the compile-time refusal; the program is clean under AddressSanitizer and UBSan on 4 threads. - Counts are read atomically (2026-11-01). Tables are the first place many actors dup and drop the same shared value at once, and ThreadSanitizer found the fast paths' plain read of a count (
tl_dup,tl_drop,tl_is_unique,dup_value, the drop and send walks) racing with other threads' atomic updates. Every read that can see a shared block now goes throughtl_rc(louise_rt.h) orheap::rc, a relaxed atomic load, which is a plain load on x86-64 and aarch64; writes stay plain, as only a local count's one owner writes it. Under TSan the last release takes an acquire load in place of its fence, asArcdoes, since TSan does not model fences. Cost ontests/bench(instructions, one thread): +0.09% to +0.14% with thefastruntime, −0.05% to −0.30% withlto.scripts/tsan.shis clean,tests/run/table.lseincluded.