Skip to content

Commit 24424f7

Browse files
authored
atomics: ACell[A], an atomic word (I64, U64, Ptr) whose load, store, cas and fetchAdd are the C __atomic builtins with their memory order (acquire, release, acq_rel, seq_cst); each op is a request on the capability Atomic (handler Srs.Atomic), so plain code cannot touch an atomic word. Programs without ACell emit the same C; s2c self-compile instructions unchanged (5.0005 G). Tests prog/atomic, neg atom_list, atom_nocap, atom_noeffect; the gate checks every emitted call carries its own order (#103)
1 parent 6f63743 commit 24424f7

34 files changed

Lines changed: 291 additions & 53 deletions

‎CHANGELOG.md‎

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -4,6 +4,8 @@ Every change to srs that lands, newest first. A project that builds with srs (sn
44

55
## Unreleased
66

7+
- atomics: `ACell[A]` is an atomic word (A is I64, U64 or Ptr). `ACell.new(v)` makes one in the innermost Region; `ACell.load(c)`, `ACell.store(c, v)`, `ACell.cas(c, want, v)` (a Bool) and `ACell.fetchAdd(c, d)` (the word before the add) are the C `__atomic` builtins with their memory order: load acquire, store release, cas acq_rel (failure acquire), fetchAdd seq_cst. Each op is a request on the new capability `Atomic` (handler `Srs.Atomic`), so plain code cannot touch an atomic word (`error[unhandled-effect]`). A cell of a non-word type is `error[mismatch]`. Programs without ACell emit the same C as before; s2c compiling itself: 5.0005 G instructions, same as before. The `--mem` goldens list the new handler's var.
8+
79
- emit: the scratch copy-out searches the scratch's chunk table once per box (the copy function hands the chunk to `srs_ev_get` and `srs_ev_dup`; before, `srs_ev_in`, `srs_ev_get` and `srs_ev_put` each ran the binary search), and a pointer outside the span of the scratch's chunks is settled by two compares. s2c compiling itself: 6.15 -> 4.94 G instructions (-19.7%), user 1.7 -> 1.5 s, same peak, same program semantics (the emitted prims text changes: new seed).
810

911
- rt: a Console capture reuses the buffer of the last ended capture and returns its text as a tight copy; before, every capture kept its own fresh 4 KiB malloc block for the program's lifetime. s2c compiling itself (7,468 captures in `Mem.fresh`): page faults 8,617 -> 1,214 (-86%), peak RSS 417.5 -> 387.9 MB, same output. Test `tests/s2/prog/capture_many.srs`: 20,000 captures keep the peak flat (the old runtime grew it by 79 MB).

‎bootstrap/s2c-seed.c‎

Lines changed: 49 additions & 27 deletions
Large diffs are not rendered by default.

‎lib/prelude.srs‎

Lines changed: 8 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -663,3 +663,11 @@ handler Srs.FileOut for StoreOut:
663663
def init(path: Str): Ptr = rt_fout_new(path)
664664
def put(self: Ptr, s: Str): Unit = rt_out_str(self, s)
665665
def commit(self: Ptr): Unit = rt_out_commit(self)
666+
667+
// ACell[A] (s2/types.srs Ty.atomCall): ACell.load, store, cas and fetchAdd are requests on Atomic, so a fn that touches an
668+
// atomic word has Atomic in its row (or an {a: Atomic} binder) and main handles it; the ops are the __atomic builtins
669+
capability Atomic:
670+
def touch(): Unit
671+
672+
handler Srs.Atomic for Atomic:
673+
def touch(): Unit = ()

‎s2/cseal.srs‎

Lines changed: 5 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -52,6 +52,11 @@ def Cs.ex(e: El.Expr, sealed: Bool, open: Bool, acc: Cs.Acc): Cs.Acc = e match
5252
case El.CellPut(line, c, v, data) => Cs.put(Cs.ex(v, sealed, open, Cs.ex(c, sealed, open, acc)), sealed, data, line)
5353
case El.ArrPut(_, _, i, v) => Cs.ex(v, sealed, open, Cs.ex(i, sealed, open, acc))
5454
case El.Blit(_, _, at, s, m) => Cs.ex(m, sealed, open, Cs.ex(s, sealed, open, Cs.ex(at, sealed, open, acc)))
55+
// an atomic word holds a scalar (I64, U64, Ptr: Ty.atomNew), never region data, so its ops only walk their operands
56+
case El.AtomLoad(_, c) => Cs.ex(c, sealed, open, acc)
57+
case El.AtomStore(_, c, v) => Cs.ex(v, sealed, open, Cs.ex(c, sealed, open, acc))
58+
case El.AtomCas(_, c, w, v) => Cs.ex(v, sealed, open, Cs.ex(w, sealed, open, Cs.ex(c, sealed, open, acc)))
59+
case El.AtomAdd(_, c, d) => Cs.ex(d, sealed, open, Cs.ex(c, sealed, open, acc))
5560
case El.Int(_, _, _) => acc
5661
case El.Bool(_, _) => acc
5762
case El.Str(_, _) => acc

‎s2/eff.srs‎

Lines changed: 7 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -207,10 +207,14 @@ def Eff.isIn(m: Coll.SMap[Bool], x: Sym.Sym): Bool = Coll.sLookup(m, x) match
207207
case Coll.None => false
208208

209209
// A1: the builtins that allocate a new array (in the innermost Region, as a constructor)
210+
def Eff.isAtomOp(g: Sym.Sym): Bool =
211+
val s = Sym.str(g)
212+
Str.eq(s, "ACell.load") || Str.eq(s, "ACell.store") || Str.eq(s, "ACell.cas") || Str.eq(s, "ACell.fetchAdd")
213+
210214
def Eff.isArrayNew(ss: Eff.Syms, g: Sym.Sym): Bool =
211215
val Eff.Syms(_, _, _, _, _, ks, c) = ss
212216
val Names.Keys(_, f, t, _, _) = ks
213-
Sym.eq(g, f) || Sym.eq(g, t) || Sym.eq(g, c)
217+
Sym.eq(g, f) || Sym.eq(g, t) || Sym.eq(g, c) || Str.eq(Sym.str(g), "ACell.new")
214218

215219
def Eff.decls(cx: Eff.Cx, ds: Coll.List[Ast.Decl], w: Eff.W): Coll.List[D.Fact] = ds match
216220
case Coll.Nil =>
@@ -365,6 +369,8 @@ def Eff.expr(cx: Eff.Cx, at: Eff.At, e: Ast.Expr, w: Eff.W): Eff.W = e match
365369
// Cell.put(c, v) and Array.put(xs, i, v) write (A1, A1b): a request on Mut, so a fn that writes has Mut in its row
366370
else if Str.eq(Sym.str(g), "Cell.put") || Str.eq(Sym.str(g), "Array.put") || Str.eq(Sym.str(g), "Array.blit") then
367371
Eff.req(cx, at, Sym.of("Mut"), w1)
372+
// ACell.load, store, cas and fetchAdd request Atomic: plain code cannot touch an atomic word
373+
else if Eff.isAtomOp(g) then Eff.req(cx, at, Sym.of("Atomic"), w1)
368374
else Eff.opNeedsQ(cx, at, Eff.reqOf(ps, g), Eff.reqTo(cx, at, Eff.reqOf(ps, g), w1))
369375
// a trait method on {} evidence requests the capabilities the method declares (vic Q2); xs.at(i) on a local (an
370376
// array, A1) builds an Array.Index in the innermost Region

‎s2/elab.srs‎

Lines changed: 5 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -53,6 +53,11 @@ enum El.Expr:
5353
case El.CField(line: I64, c: El.Expr, name: Sym.Sym, field: Sym.Sym, ty: K.Term)
5454
// data: the element type is not a scalar (region data: Cseal checks where such a put runs)
5555
case El.CellPut(line: I64, c: El.Expr, v: El.Expr, data: Bool)
56+
// ACell[A]: new is a CellNew (one word); load/store/cas/fetchAdd are the __atomic builtins on that word (A a word type: I64, U64, Ptr)
57+
case El.AtomLoad(line: I64, c: El.Expr)
58+
case El.AtomStore(line: I64, c: El.Expr, v: El.Expr)
59+
case El.AtomCas(line: I64, c: El.Expr, want: El.Expr, v: El.Expr)
60+
case El.AtomAdd(line: I64, c: El.Expr, d: El.Expr)
5661
// A1b: Array.put(xs, i, v) writes one scalar slot of the local array xs, i proved in [0, n) (C xs[i] = v)
5762
case El.ArrPut(line: I64, xs: Sym.Sym, i: El.Expr, v: El.Expr)
5863
// Array.blit(xs, at, s, m): copies min(m, len s) bytes of s into the local Array[U8] xs from at, at and m proved in range (Ty.blit)

‎s2/emit.srs‎

Lines changed: 41 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -262,7 +262,7 @@ def Emit.ctype(cx: Emit.Cx, t: K.Term): Unit = t match
262262
else if Str.len(x) > 8 && Str.eq(Str.slice(x, 0, 8), "CStruct.") then Emit.cstructPtr(Str.slice(x, 8, Str.len(x)))
263263
else if Str.eq(x, "U64") then Console.print("uint64_t")
264264
// A1: Array[A](n) is one pointer to its elements (no header); Cell[A] a pointer to its word
265-
else if Str.eq(x, "Array") || Str.eq(x, "Cell") then Emit.arrayC(cx, args)
265+
else if Str.eq(x, "Array") || Str.eq(x, "Cell") || Str.eq(x, "ACell") then Emit.arrayC(cx, args)
266266
else if Emit.isProto(cx, n) then Console.print("srs_cap*")
267267
else Emit.nominalOf(cx, n) match
268268
case Coll.Some(b) => Emit.ctype(cx, b)
@@ -417,6 +417,34 @@ def Emit.ex(cx: Emit.Cx, fi: Emit.Fi, env: Emit.Env, pos: Emit.Pos, e: El.Expr):
417417
Console.print(") = (")
418418
Emit.ex(cx, fi, env, Emit.Inner, v)
419419
Console.print("), (int64_t)0)")
420+
// ACell[A]: the GCC/clang __atomic builtins on the cell's word, each with its memory order: load acquire, store
421+
// release, cas acq_rel (failure acquire), fetchAdd seq_cst (vic/notes/20261111T0600 B1: shared mutable state is only Atomic cells)
422+
case El.AtomLoad(_, c) =>
423+
Console.print("__atomic_load_n(")
424+
Emit.ex(cx, fi, env, Emit.Inner, c)
425+
Console.print(", __ATOMIC_ACQUIRE)")
426+
case El.AtomStore(_, c, v) =>
427+
Console.print("(__atomic_store_n(")
428+
Emit.ex(cx, fi, env, Emit.Inner, c)
429+
Console.print(", ")
430+
Emit.ex(cx, fi, env, Emit.Inner, v)
431+
Console.print(", __ATOMIC_RELEASE), (int64_t)0)")
432+
case El.AtomCas(_, c, w, v) =>
433+
Console.print("({ __typeof__(*")
434+
Emit.ex(cx, fi, env, Emit.Inner, c)
435+
Console.print(") ex_ = (")
436+
Emit.ex(cx, fi, env, Emit.Inner, w)
437+
Console.print("); __atomic_compare_exchange_n(")
438+
Emit.ex(cx, fi, env, Emit.Inner, c)
439+
Console.print(", &ex_, (")
440+
Emit.ex(cx, fi, env, Emit.Inner, v)
441+
Console.print("), 0, __ATOMIC_ACQ_REL, __ATOMIC_ACQUIRE); })")
442+
case El.AtomAdd(_, c, d) =>
443+
Console.print("__atomic_fetch_add(")
444+
Emit.ex(cx, fi, env, Emit.Inner, c)
445+
Console.print(", ")
446+
Emit.ex(cx, fi, env, Emit.Inner, d)
447+
Console.print(", __ATOMIC_SEQ_CST)")
420448
// A1b: the index is proved in range (Ty.arrPut): a plain store, no branch
421449
case El.ArrPut(_, x, i, v) =>
422450
Console.print("(")
@@ -1239,6 +1267,10 @@ def Emit.exTys(cx: Emit.Cx, fi: Emit.Fi, e: El.Expr, acc: Coll.List[K.Term]): Co
12391267
case El.CellPut(_, c, v, _) => Emit.exTys(cx, fi, v, Emit.exTys(cx, fi, c, acc))
12401268
case El.ArrPut(_, _, i, v) => Emit.exTys(cx, fi, v, Emit.exTys(cx, fi, i, acc))
12411269
case El.Blit(_, _, a, b, m) => Emit.exTys(cx, fi, m, Emit.exTys(cx, fi, b, Emit.exTys(cx, fi, a, acc)))
1270+
case El.AtomLoad(_, c) => Emit.exTys(cx, fi, c, acc)
1271+
case El.AtomStore(_, c, v) => Emit.exTys(cx, fi, v, Emit.exTys(cx, fi, c, acc))
1272+
case El.AtomCas(_, c, w, v) => Emit.exTys(cx, fi, v, Emit.exTys(cx, fi, w, Emit.exTys(cx, fi, c, acc)))
1273+
case El.AtomAdd(_, c, d) => Emit.exTys(cx, fi, d, Emit.exTys(cx, fi, c, acc))
12421274
case _ => acc
12431275

12441276
def Emit.exsTys(cx: Emit.Cx, fi: Emit.Fi, xs: Coll.List[El.Expr], acc: Coll.List[K.Term]): Coll.List[K.Term] = xs match
@@ -2849,6 +2881,10 @@ def Emit.seenE(cx: Emit.Cx, e: El.Expr, s: Emit.Seen): Emit.Seen = e match
28492881
case El.CellPut(_, c, v, _) => Emit.seenE(cx, v, Emit.seenE(cx, c, s))
28502882
case El.ArrPut(_, _, i, v) => Emit.seenE(cx, v, Emit.seenE(cx, i, s))
28512883
case El.Blit(_, _, a, b, m) => Emit.seenE(cx, m, Emit.seenE(cx, b, Emit.seenE(cx, a, s)))
2884+
case El.AtomLoad(_, c) => Emit.seenE(cx, c, s)
2885+
case El.AtomStore(_, c, v) => Emit.seenE(cx, v, Emit.seenE(cx, c, s))
2886+
case El.AtomCas(_, c, w, v) => Emit.seenE(cx, v, Emit.seenE(cx, w, Emit.seenE(cx, c, s)))
2887+
case El.AtomAdd(_, c, d) => Emit.seenE(cx, d, Emit.seenE(cx, c, s))
28522888
case _ => s
28532889

28542890
def Emit.seenEs(cx: Emit.Cx, xs: Coll.List[El.Expr], s: Emit.Seen): Emit.Seen = xs match
@@ -3011,6 +3047,10 @@ def Emit.dropE(m: Coll.SMap[El.Fn], xs: Coll.List[Sym.Sym], e: El.Expr): El.Expr
30113047
case El.CellPut(l, c, v, d) => El.CellPut(l, Emit.dropE(m, xs, c), Emit.dropE(m, xs, v), d)
30123048
case El.ArrPut(l, x, i, v) => El.ArrPut(l, x, Emit.dropE(m, xs, i), Emit.dropE(m, xs, v))
30133049
case El.Blit(l, x, a, b, k) => El.Blit(l, x, Emit.dropE(m, xs, a), Emit.dropE(m, xs, b), Emit.dropE(m, xs, k))
3050+
case El.AtomLoad(l, c) => El.AtomLoad(l, Emit.dropE(m, xs, c))
3051+
case El.AtomStore(l, c, v) => El.AtomStore(l, Emit.dropE(m, xs, c), Emit.dropE(m, xs, v))
3052+
case El.AtomCas(l, c, w, v) => El.AtomCas(l, Emit.dropE(m, xs, c), Emit.dropE(m, xs, w), Emit.dropE(m, xs, v))
3053+
case El.AtomAdd(l, c, d) => El.AtomAdd(l, Emit.dropE(m, xs, c), Emit.dropE(m, xs, d))
30143054
case _ => e
30153055

30163056
def Emit.dropEs(m: Coll.SMap[El.Fn], xs: Coll.List[Sym.Sym], es: Coll.List[El.Expr]): Coll.List[El.Expr] = es match

‎s2/flow.srs‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1045,7 +1045,7 @@ def Flow.request(st: Flow.St, p: I64, q: Coll.Option[Eff.Req], line: I64): Flow.
10451045
// keeps (the innermost Region at its handle site, recorded as the pseudo capability site.x): it lives there, so it cannot
10461046
// leave the block that closes that Region
10471047
def Flow.dataTy(es: Coll.List[Ast.Enum], tn: Sym.Sym): Bool =
1048-
Flow.isEnumName(es, tn) || Str.eq(Sym.str(tn), "Array") || Str.eq(Sym.str(tn), "Cell") || Str.eq(Sym.str(tn), "Str") || Str.eq(Sym.str(tn), "Ptr")
1048+
Flow.isEnumName(es, tn) || Str.eq(Sym.str(tn), "Array") || Str.eq(Sym.str(tn), "Cell") || Str.eq(Sym.str(tn), "ACell") || Str.eq(Sym.str(tn), "Str") || Str.eq(Sym.str(tn), "Ptr")
10491049

10501050
def Flow.siteSrc(cs: Coll.List[Flow.Cap], x: Sym.Sym, acc: Coll.List[Flow.Src]): Coll.List[Flow.Src] = Flow.capNamed(cs, Eff.dotted("site", x)) match
10511051
case Coll.None => acc

‎s2/mono.srs‎

Lines changed: 4 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -267,6 +267,10 @@ def Mono.calls(s: K.Subst, sub: Coll.List[Ty.Bind], e: El.Expr, acc: Coll.List[M
267267
case El.CellPut(_, c, v, _) => Mono.calls(s, sub, v, Mono.calls(s, sub, c, acc))
268268
case El.ArrPut(_, _, i, v) => Mono.calls(s, sub, v, Mono.calls(s, sub, i, acc))
269269
case El.Blit(_, _, a, b, m) => Mono.calls(s, sub, m, Mono.calls(s, sub, b, Mono.calls(s, sub, a, acc)))
270+
case El.AtomLoad(_, c) => Mono.calls(s, sub, c, acc)
271+
case El.AtomStore(_, c, v) => Mono.calls(s, sub, v, Mono.calls(s, sub, c, acc))
272+
case El.AtomCas(_, c, w, v) => Mono.calls(s, sub, v, Mono.calls(s, sub, w, Mono.calls(s, sub, c, acc)))
273+
case El.AtomAdd(_, c, d) => Mono.calls(s, sub, d, Mono.calls(s, sub, c, acc))
270274
case _ => acc
271275

272276
def Mono.callsAll(s: K.Subst, sub: Coll.List[Ty.Bind], xs: Coll.List[El.Expr], acc: Coll.List[Mono.Key]): Coll.List[Mono.Key] = xs match

‎s2/names.srs‎

Lines changed: 5 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -160,7 +160,11 @@ def Names.declare(st: Names.St, ns: Names.Ns, n: Sym.Sym, line: I64): Names.St =
160160
// the builtin types (parity D14): one declaration each, at line 0; A1 (vic/c/array-design.md): the type Array and its
161161
// builtin calls, typed by Ty.arrayCall
162162
def Names.builtins(st: Names.St): Names.St =
163-
Names.declare(Names.declare(Names.declare(Names.declare(Names.declare(Names.declare(Names.declare(Names.declare(Names.declare(Names.declare(Names.builtins7(st), Names.NType, Sym.of("Array"), 0), Names.NCall, Sym.of("Array.fill"), 0), Names.NType, Sym.of("Cell"), 0), Names.NCall, Sym.of("Cell.new"), 0), Names.NCall, Sym.of("Cell.get"), 0), Names.NCall, Sym.of("Cell.put"), 0), Names.NCall, Sym.of("Array.tabulate"), 0), Names.NCall, Sym.of("Array.slice"), 0), Names.NCall, Sym.of("Array.put"), 0), Names.NCall, Sym.of("Array.blit"), 0)
163+
Names.atoms(Names.declare(Names.declare(Names.declare(Names.declare(Names.declare(Names.declare(Names.declare(Names.declare(Names.declare(Names.declare(Names.builtins7(st), Names.NType, Sym.of("Array"), 0), Names.NCall, Sym.of("Array.fill"), 0), Names.NType, Sym.of("Cell"), 0), Names.NCall, Sym.of("Cell.new"), 0), Names.NCall, Sym.of("Cell.get"), 0), Names.NCall, Sym.of("Cell.put"), 0), Names.NCall, Sym.of("Array.tabulate"), 0), Names.NCall, Sym.of("Array.slice"), 0), Names.NCall, Sym.of("Array.put"), 0), Names.NCall, Sym.of("Array.blit"), 0))
164+
165+
// the Atom type and its builtin calls, typed by Ty.atomCall (a typed atomic word; every op but new requests Atomic)
166+
def Names.atoms(st: Names.St): Names.St =
167+
Names.declare(Names.declare(Names.declare(Names.declare(Names.declare(Names.declare(st, Names.NType, Sym.of("ACell"), 0), Names.NCall, Sym.of("ACell.new"), 0), Names.NCall, Sym.of("ACell.load"), 0), Names.NCall, Sym.of("ACell.store"), 0), Names.NCall, Sym.of("ACell.cas"), 0), Names.NCall, Sym.of("ACell.fetchAdd"), 0)
164168

165169
def Names.builtins7(st: Names.St): Names.St =
166170
Names.declare(Names.declare(Names.declare(Names.declare(Names.declare(Names.declare(Names.declare(Names.declare(Names.declare(Names.declare(Names.declare(Names.declare(st, Names.NType, Sym.of("I64"), 0), Names.NType, Sym.of("Bool"), 0), Names.NType, Sym.of("Unit"), 0), Names.NType, Sym.of("Str"), 0), Names.NType, Sym.of("Ptr"), 0), Names.NType, Sym.of("U32"), 0), Names.NType, Sym.of("U64"), 0), Names.NType, Sym.of("U8"), 0), Names.NType, Sym.of("I32"), 0), Names.NType, Sym.of("CStr"), 0), Names.NType, Sym.of("CArgv"), 0), Names.NType, Sym.of("F64"), 0)

0 commit comments

Comments
 (0)