From 4e0474d867bec44b483a1d8441e24a5417086f35 Mon Sep 17 00:00:00 2001 From: Marius S <39998+winding-lines@users.noreply.github.com> Date: Thu, 3 Sep 2026 05:56:35 -0700 Subject: [PATCH] The fix for the field deref, and the bug no origin can see MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit field_deref_after_last_use now runs the same shape twice: once with the raw untracked pointer field (-1, as before) and once with the cell behind an OwnedPointer, whose deref borrows the owner, so the struct stays alive through the read and prints 499500 with the drop last. The fix is a type, not a compiler change. plain_store_races is a new uncaught case of a different kind: a task that writes `sum` with a plain load and store. Every task holds mutable access to the same value and the origin only says how long it lives; a Sync-style trait is what would reject this, and Mojo has none. The load-store window is widened and the worker count fixed at 4 so the lost updates are certain rather than likely — ten runs, ten times True. `run` gains a num_workers passthrough for that. 8 passed, 0 failed. Co-Authored-By: Claude Fable 5 Claude-Session: https://claude.ai/code/session_015or6oTZmb7EQTXTbALbBXY --- .github/workflows/ci.yml | 2 +- README.md | 15 ++++++-- src/origins.mojo | 4 +-- .../uncaught/field_deref_after_last_use.mojo | 32 +++++++++++++++++ tests/uncaught/plain_store_races.mojo | 35 +++++++++++++++++++ 5 files changed, 83 insertions(+), 5 deletions(-) create mode 100644 tests/uncaught/plain_store_races.mojo diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index ebea563..0880674 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -32,7 +32,7 @@ jobs: pixi run run-post | tee post.txt grep -q 'sum: 499500' post.txt - # Deliberate misuse: four cases the compiler must reject, three it must + # Deliberate misuse: four cases the compiler must reject, four it must # still accept (and get wrong in the documented way). - name: Caught and uncaught run: pixi run check diff --git a/README.md b/README.md index 94eb6d5..377666f 100644 --- a/README.md +++ b/README.md @@ -53,7 +53,7 @@ which wrote the `threads-mojo = { git = …, rev = … }` line in ## What the compiler catches, and what it does not -`pixi run check` builds seven deliberately wrong programs under +`pixi run check` builds eight deliberately wrong programs under [`tests/`](tests/) and holds the compiler to a claim about each one. [`tests/caught/`](tests/caught/) must fail to compile, with the diagnostic the @@ -73,7 +73,8 @@ and then print the wrong answer the file predicts: | --- | --- | --- | | `untracked_ctx_drops_early` | the post's `Ctx` erases the origin; `totals` is destroyed at its last visible use, before any thread starts | `Totals dropped` printed first; sum `499499` (−1 + 499500, the tasks adding into the poisoned cell) | | `opaque_escapes_origin` | `share(totals).opaque()` outside `run` — the boundary of what origins cover | same | -| `field_deref_after_last_use` | `totals.cell[]` copies the pointer field, which is the struct's last use, and the deref reads a destroyed object | `-1`; the method read `totals.sum()` gives `499500` | +| `field_deref_after_last_use` | `totals.cell[]` copies the pointer field, which is the struct's last use, and the deref reads a destroyed object | `-1`; the method read `totals.sum()` gives `499500`, and so does the same field deref once the cell is an `OwnedPointer`, whose deref borrows the struct | +| `plain_store_races` | a task writes `sum` with a plain load and store instead of the atomic — every task holds `mut` access to the same value and nothing says the type is safe to share | lost updates, every run; not a lifetime bug but the one an origin cannot express | The uncaught set is the list a reviewer has to check by hand. If a newer compiler starts rejecting one, `check` fails on it — move the file to @@ -81,6 +82,16 @@ compiler starts rejecting one, `check` fails on it — move the file to those tests poisons the cell rather than freeing it, so the misuse stays a number that can be asserted instead of undefined behaviour. +Three of the four are lifetime bugs, and each has a fix that exists today: +keep the origin in the type (`origins.mojo`), keep the erasure inside `run`, +and own heap memory through a type whose deref borrows the owner +(`OwnedPointer`, `List`) rather than a raw untracked `Pointer`. The fourth is +a different kind: `Ctx` gives a thousand tasks mutable access to one value, +and only an atomic in the task keeps that honest. Rust would refuse the +aliased `&mut` and let the atomic through on the strength of `Sync`; Mojo has +no such trait yet, so the race is invisible to the compiler and lands in the +uncaught set with the others. + ## Comments The post has no comment box; this repo is where the code can be discussed. diff --git a/src/origins.mojo b/src/origins.mojo index ca13d7c..de6af36 100644 --- a/src/origins.mojo +++ b/src/origins.mojo @@ -65,13 +65,13 @@ def share[ def run[ T: AnyType, origin: MutOrigin, //, work: WorkFn -](n_tasks: Int, ctx: Ctx[T, origin]) raises: +](n_tasks: Int, ctx: Ctx[T, origin], num_workers: Int = 0) raises: """`parallel_for`, taking the tracked context rather than the pointer. `ctx` is alive for the whole call, so the state it points to is too. The erasure to `void *` happens here and nowhere else. """ - parallel_for[work](n_tasks, ctx.opaque()) + parallel_for[work](n_tasks, ctx.opaque(), num_workers) @fieldwise_init diff --git a/tests/uncaught/field_deref_after_last_use.mojo b/tests/uncaught/field_deref_after_last_use.mojo index bca7dd4..6aa2f3a 100644 --- a/tests/uncaught/field_deref_after_last_use.mojo +++ b/tests/uncaught/field_deref_after_last_use.mojo @@ -3,9 +3,16 @@ # copy and the deref, and the deref reads the poisoned cell. A method that # reads through `self` borrows the whole struct for the call and gets the # right number. +# +# The fix is a type, not a compiler change: `OwnedPointer.__getitem__` returns +# a ref whose origin is the pointer's own, so `owned.cell[]` borrows `owned` +# and it stays alive through the deref. Same shape, right answer, dropped last. # expect: via method: 499500 # expect: Totals dropped # expect: via field deref: -1 +# expect: via OwnedPointer field deref: 499500 +# expect: Owned dropped +from std.memory import OwnedPointer from std.memory.alloc import unsafe_alloc from origins import Ctx, run, share from threads import AtomicCounter, OpaquePtr @@ -33,13 +40,38 @@ struct Totals(Movable): self.cell[] = -1 +struct Owned(Movable): + """The same struct with the cell behind an `OwnedPointer`. + + Nothing to poison: the deref borrows `self`, so the drop cannot come + first, and the pointer frees its cell after this destructor runs. + """ + + var cell: OwnedPointer[Int64] + + def __init__(out self): + self.cell = OwnedPointer(Int64(0)) + + def __deinit__(deinit self): + print("Owned dropped") + + def task(i: Int, ptr: OpaquePtr) -> None: var t = Ctx[Totals].of(ptr) _ = AtomicCounter.at(Int(t[].cell)).fetch_add(Int64(i)) +def owned_task(i: Int, ptr: OpaquePtr) -> None: + var t = Ctx[Owned].of(ptr) + _ = AtomicCounter.at(Int(Pointer(to=t[].cell[]))).fetch_add(Int64(i)) + + def main() raises: var totals = Totals() run[task](1000, share(totals)) print("via method:", totals.sum()) print("via field deref:", totals.cell[]) + + var owned = Owned() + run[owned_task](1000, share(owned)) + print("via OwnedPointer field deref:", owned.cell[]) diff --git a/tests/uncaught/plain_store_races.mojo b/tests/uncaught/plain_store_races.mojo new file mode 100644 index 0000000..68e6441 --- /dev/null +++ b/tests/uncaught/plain_store_races.mojo @@ -0,0 +1,35 @@ +# Not a lifetime bug: a data race. `Ctx.__getitem__` hands every task a +# mutable ref to the same `Totals`, and nothing stops a task writing to +# `sum` with a plain load and store instead of the atomic. Rust rejects this +# before threads come into it — `&mut` aliased across closures is an +# exclusivity error, and the atomic works through `&AtomicI64` because that +# type is `Sync`. Mojo has no interior-mutability marker, so there is no way +# for `share` to demand one; the origin says only how long `totals` lives. +# +# The window between load and store is widened on purpose so that the lost +# updates are a certainty rather than a likelihood, and the worker count is +# fixed so a single-core runner cannot serialise the tasks by accident. +# expect: plain store, lost updates: True +from std.time import perf_counter_ns +from origins import Ctx, run, share +from threads import OpaquePtr + + +@fieldwise_init +struct Totals(Copyable, Movable): + var sum: Int64 + + +def task(i: Int, ptr: OpaquePtr) -> None: + var t = Ctx[Totals].of(ptr) + var seen = t[].sum + var t0 = perf_counter_ns() + while perf_counter_ns() - t0 < 20_000: + pass + t[].sum = seen + Int64(i) + + +def main() raises: + var totals = Totals(0) + run[task](1000, share(totals), num_workers=4) + print("plain store, lost updates:", totals.sum != 499500)