Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
78 changes: 60 additions & 18 deletions bootstrap/s2c-seed.c

Large diffs are not rendered by default.

98 changes: 89 additions & 9 deletions s2/mem.srs
Original file line number Diff line number Diff line change
Expand Up @@ -233,13 +233,20 @@ enum Mem.Mult:
case Mem.Many(why: Mem.Why)

enum Mem.Row:
case Mem.Row(line: I64, ctor: Sym.Sym, bytes: Coll.Option[I64], dies: Bool, m: Mem.Mult)
case Mem.Row(line: I64, f: Sym.Sym, ctor: Sym.Sym, bytes: Coll.Option[I64], dies: Bool, m: Mem.Mult)

// a handled region: the def f that handles it at line as x with handler h, its sites, the defs whose sites fill it (in
// order of first site), and the lines of its manual frees (x.free()); the drop op frees it at the end of its block when
// it is still live
enum Mem.Block:
case Mem.Block(line: I64, x: Sym.Sym, h: Sym.Sym, rows: Coll.List[Mem.Row])
case Mem.Block(line: I64, f: Sym.Sym, x: Sym.Sym, h: Sym.Sym, rows: Coll.List[Mem.Row], defs: Coll.List[Sym.Sym], frees: Coll.List[I64])

// a call x.free() in def f at line
enum Mem.FreeAt:
case Mem.FreeAt(f: Sym.Sym, line: I64, x: Sym.Sym)

enum Mem.Report:
case Mem.Ok(bs: Coll.List[Mem.Block], rs: Coll.List[Mem.Reuse], cs: Coll.List[Mem.Compact])
case Mem.Ok(bs: Coll.List[Mem.Block], pf: Coll.List[Mem.FreeAt], rs: Coll.List[Mem.Reuse], cs: Coll.List[Mem.Compact])
case Mem.RulesBad(rel: Sym.Sym)

// what the model says, by name or id
Expand Down Expand Up @@ -267,7 +274,9 @@ def Mem.report(ds: Coll.List[Ast.Decl], sb: Coll.List[Emit.SiteB]): Mem.Report =
val need = Mem.names(D.tuples(m, Mem.sSym(Mem.SNeed)), Coll.sEmpty())
val skip = Mem.names(D.tuples(m, Mem.sSym(Mem.SRunSink)), Mem.names(D.tuples(m, Mem.sSym(Mem.SSelf)), Mem.regionDefs(regions, 0, nr, Coll.sEmpty())))
val compact = Mem.pickCompacts(need, skip, Mem.names(D.tuples(m, Mem.sSym(Mem.SNewRet)), Coll.sEmpty()), fl, Coll.Nil)
Mem.Ok(Mem.blocks(md, cs, free, sites, ns, regions, Mem.byLine(Mem.regionKeys(regions, nr, Mem.liveOf(md), Coll.Nil)), Coll.Nil), Mem.byReuseLine(reuse), Mem.reachedOnly(compact, Mem.names(D.tuples(m, Mem.relSym(Mem.RReached)), Coll.sEmpty()), Coll.Nil))
val mf = Mem.manualFrees(fl, Coll.Nil)
val bs = Mem.blocks(md, cs, free, sites, ns, regions, mf, Mem.byLine(Mem.regionKeys(regions, nr, Mem.liveOf(md), Coll.Nil)), Coll.Nil)
Mem.Ok(bs, Mem.paramFrees(mf, bs, Coll.Nil), Mem.byReuseLine(reuse), Mem.reachedOnly(compact, Mem.names(D.tuples(m, Mem.relSym(Mem.RReached)), Coll.sEmpty()), Coll.Nil))
case D.Unsafe(rel) => Mem.RulesBad(rel)
case D.NegCycle(rel) => Mem.RulesBad(rel)

Expand Down Expand Up @@ -335,22 +344,93 @@ def Mem.vals(xs: Coll.List[Coll.KV[I64]], acc: Coll.List[I64]): Coll.List[I64] =
val Coll.KV(_, v) = kv
Mem.vals(rest, Coll.Cons(v, acc))

def Mem.blocks(md: Mem.Model, cs: Coll.SMap[I64], free: Coll.List[Mem.Edge], ss: Coll.IMap[Mem.Site], ns: I64, rs: Coll.IMap[Mem.Region], ids: Coll.List[I64], acc: Coll.List[Mem.Block]): Coll.List[Mem.Block] = ids match
def Mem.blocks(md: Mem.Model, cs: Coll.SMap[I64], free: Coll.List[Mem.Edge], ss: Coll.IMap[Mem.Site], ns: I64, rs: Coll.IMap[Mem.Region], mf: Coll.List[Mem.FreeAt], ids: Coll.List[I64], acc: Coll.List[Mem.Block]): Coll.List[Mem.Block] = ids match
case Coll.Nil => Coll.rev(acc)
case Coll.Cons(r, rest) => Coll.lookup(rs, r) match
case Coll.Some(x) =>
val Mem.Region(_, line, nm, h) = x
val Mem.Region(f, line, nm, h) = x
val Mem.Model(_, _, byRegion, _, _, _) = md
val rows = Mem.rows(md, cs, free, ss, Mem.byLine(Mem.siteKeys(ss, ns, Mem.idsOf(byRegion, r), Coll.Nil)), Coll.Nil)
Mem.blocks(md, cs, free, ss, ns, rs, rest, Coll.Cons(Mem.Block(line, nm, h, rows), acc))
case Coll.None => Mem.blocks(md, cs, free, ss, ns, rs, rest, acc)
val b = Mem.Block(line, f, nm, h, rows, Mem.rowDefs(rows, Coll.sEmpty(), Coll.Nil), Mem.freeLines(mf, f, nm, line, Coll.Nil))
Mem.blocks(md, cs, free, ss, ns, rs, mf, rest, Coll.Cons(b, acc))
case Coll.None => Mem.blocks(md, cs, free, ss, ns, rs, mf, rest, acc)

// the defs of rows, each once, in order of first row
def Mem.rowDefs(rows: Coll.List[Mem.Row], seen: Coll.SMap[Bool], acc: Coll.List[Sym.Sym]): Coll.List[Sym.Sym] = rows match
case Coll.Nil => Coll.rev(acc)
case Coll.Cons(r, rest) =>
val Mem.Row(_, f, _, _, _, _) = r
if Mem.isIn(seen, f) then Mem.rowDefs(rest, seen, acc) else Mem.rowDefs(rest, Coll.sInsert(seen, f, true), Coll.Cons(f, acc))

// the lines of the calls x.free() in def f after the handle at line, in order
def Mem.freeLines(mf: Coll.List[Mem.FreeAt], f: Sym.Sym, x: Sym.Sym, line: I64, acc: Coll.List[I64]): Coll.List[I64] = mf match
case Coll.Nil => Coll.rev(acc)
case Coll.Cons(m, rest) =>
val Mem.FreeAt(g, l, y) = m
if l > line && Sym.eq(g, f) && Sym.eq(x, y) then Mem.freeLines(rest, f, x, line, Coll.Cons(l, acc)) else Mem.freeLines(rest, f, x, line, acc)

// the frees of no region its def handles: x is a {} Region param, so the free ends the region its caller passes
def Mem.paramFrees(mf: Coll.List[Mem.FreeAt], bs: Coll.List[Mem.Block], acc: Coll.List[Mem.FreeAt]): Coll.List[Mem.FreeAt] = mf match
case Coll.Nil => Coll.rev(acc)
case Coll.Cons(m, rest) => Mem.paramFrees(rest, bs, if Mem.freedIn(m, bs) then acc else Coll.Cons(m, acc))

def Mem.freedIn(m: Mem.FreeAt, bs: Coll.List[Mem.Block]): Bool = bs match
case Coll.Nil => false
case Coll.Cons(b, rest) =>
val Mem.FreeAt(f, l, x) = m
val Mem.Block(line, g, y, _, _, _, _) = b
if l > line && Sym.eq(f, g) && Sym.eq(x, y) then true else Mem.freedIn(m, rest)

// every call x.free() in the bodies of fs, in program order
def Mem.manualFrees(fs: Coll.List[Ast.Fn], acc: Coll.List[Mem.FreeAt]): Coll.List[Mem.FreeAt] = fs match
case Coll.Nil => Coll.rev(acc)
case Coll.Cons(f, rest) =>
val Ast.Fn(_, n, _, _, _, _, body) = f
val acc2: Coll.List[Mem.FreeAt] = body match
case Ast.Def(_, e) => Mem.mfx(n, e, acc)
case Ast.Extern(_) => acc
Mem.manualFrees(rest, acc2)

def Mem.mfx(f: Sym.Sym, e: Ast.Expr, acc: Coll.List[Mem.FreeAt]): Coll.List[Mem.FreeAt] = e match
case Ast.Method(line, r, op, args) =>
val acc2 = if Str.eq(Sym.str(op), "free") then Coll.Cons(Mem.FreeAt(f, line, r), acc) else acc
Mem.mfxs(f, args, acc2)
case Ast.Call(_, _, _, _, args) => Mem.mfxs(f, args, acc)
case Ast.Resume(_, _, x) => Mem.mfx(f, x, acc)
case Ast.Bin(_, _, l, r) => Mem.mfx(f, r, Mem.mfx(f, l, acc))
case Ast.Un(_, _, x) => Mem.mfx(f, x, acc)
case Ast.If(_, c, t, x) => Mem.mfxs(f, Coll.Cons(c, Coll.Cons(t, Coll.Cons(x, Coll.Nil))), acc)
case Ast.Match(_, s, arms) => Mem.mfArms(f, arms, Mem.mfx(f, s, acc))
case Ast.Block(_, ss, last) => Mem.mfx(f, last, Mem.mfStmts(f, ss, acc))
case Ast.While(_, c, b) => Mem.mfx(f, b, Mem.mfx(f, c, acc))
case Ast.Assign(_, _, x) => Mem.mfx(f, x, acc)
case _ => acc

def Mem.mfxs(f: Sym.Sym, es: Coll.List[Ast.Expr], acc: Coll.List[Mem.FreeAt]): Coll.List[Mem.FreeAt] = es match
case Coll.Nil => acc
case Coll.Cons(e, rest) => Mem.mfxs(f, rest, Mem.mfx(f, e, acc))

def Mem.mfArms(f: Sym.Sym, arms: Coll.List[Ast.Arm], acc: Coll.List[Mem.FreeAt]): Coll.List[Mem.FreeAt] = arms match
case Coll.Nil => acc
case Coll.Cons(a, rest) =>
val Ast.Arm(_, _, b) = a
Mem.mfArms(f, rest, Mem.mfx(f, b, acc))

def Mem.mfStmts(f: Sym.Sym, ss: Coll.List[Ast.Stmt], acc: Coll.List[Mem.FreeAt]): Coll.List[Mem.FreeAt] = ss match
case Coll.Nil => acc
case Coll.Cons(s, rest) => s match
case Ast.Val(_, _, _, e) => Mem.mfStmts(f, rest, Mem.mfx(f, e, acc))
case Ast.Var(_, _, _, e) => Mem.mfStmts(f, rest, Mem.mfx(f, e, acc))
case Ast.Handle(_, _, _, args) => Mem.mfStmts(f, rest, Mem.mfxs(f, args, acc))
case Ast.Do(e) => Mem.mfStmts(f, rest, Mem.mfx(f, e, acc))
case Ast.Check(_, _, e) => Mem.mfStmts(f, rest, Mem.mfx(f, e, acc))

def Mem.rows(md: Mem.Model, cs: Coll.SMap[I64], free: Coll.List[Mem.Edge], ss: Coll.IMap[Mem.Site], ids: Coll.List[I64], acc: Coll.List[Mem.Row]): Coll.List[Mem.Row] = ids match
case Coll.Nil => Coll.rev(acc)
case Coll.Cons(s, rest) => Coll.lookup(ss, s) match
case Coll.Some(x) =>
val Mem.Site(f, line, ctor, loop) = x
Mem.rows(md, cs, free, ss, rest, Coll.Cons(Mem.Row(line, ctor, Mem.bytesAt(md, line, ctor), Mem.dies(md, f, line, ctor), Mem.multOf(md, cs, free, f, loop)), acc))
Mem.rows(md, cs, free, ss, rest, Coll.Cons(Mem.Row(line, f, ctor, Mem.bytesAt(md, line, ctor), Mem.dies(md, f, line, ctor), Mem.multOf(md, cs, free, f, loop)), acc))
case Coll.None => Mem.rows(md, cs, free, ss, rest, acc)

// a site in a loop of its def, else its def's reason to be many: its own call sites, a call in a loop, or a caller
Expand Down
74 changes: 64 additions & 10 deletions s2c/main.srs
Original file line number Diff line number Diff line change
Expand Up @@ -404,18 +404,21 @@ enum S2c.Mode:
// --mem: each Region and the allocation sites that fill it, once or many (s2/mem.srs, vic/c/mem-design.md)
case S2c.MemAll

// --mem: one JSON object on one line (read it with jq). regions: each handled Region; sites:
// each allocation site of a region, with its bytes (null for an Array.fill), once or many and why, dies or escapes;
// total: the once sites and their bytes, the many sites, the sites that die; reuse: each match that can build its
// arm's box in the scrutinee's cell (M7a); compact: each def that can run in a scratch region and copy its result out
// (M6a)
// --mem: one JSON object on one line (read it with jq). regions: each handled Region, its def and the defs whose sites
// fill it; sites: each allocation site of a region, its def, its bytes (null for an Array.fill), once or many and why,
// dies or escapes; frees: each region's manual frees and its drop at block end; total: the once sites and their bytes,
// the many sites, the sites that die; reuse: each match that can build its arm's box in the scrutinee's cell (M7a);
// compact: each def that can run in a scratch region and copy its result out (M6a)
def S2c.mem(fs: Coll.List[S2c.File], r: Mem.Report): I64 = r match
case Mem.RulesBad(rel) => S2c.internal("mem", rel)
case Mem.Ok(bs, rs, cs) =>
case Mem.Ok(bs, pf, rs, cs) =>
Console.print("{\"regions\":[")
S2c.jRegions(fs, bs, 0)
Console.print("],\"sites\":[")
val S2c.MemCount(once, onceB, many, die, _) = S2c.jBlocks(fs, bs, 0, S2c.MemCount(0, 0, 0, 0, 0))
Console.print("],\"frees\":[")
S2c.jFrees(fs, bs, 0)
S2c.jParamFrees(fs, pf, Coll.length(bs) == 0)
Console.print("],\"total\":{\"once\":")
Console.printI64(once)
Console.print(",\"onceBytes\":")
Expand Down Expand Up @@ -492,35 +495,86 @@ def S2c.jSep(first: Bool): Unit = if first then () else Console.print(",")
def S2c.jRegions(fs: Coll.List[S2c.File], bs: Coll.List[Mem.Block], id: I64): Unit = bs match
case Coll.Nil => ()
case Coll.Cons(b, rest) =>
val Mem.Block(line, x, h, _) = b
val Mem.Block(line, f, x, h, _, defs, _) = b
S2c.jSep(id == 0)
Console.print("{\"id\":")
Console.printI64(id)
Console.print(",\"def\":")
S2c.jSym(f)
Console.print(",\"at\":")
S2c.jAt(fs, line)
Console.print(",\"var\":")
S2c.jSym(x)
Console.print(",\"handler\":")
S2c.jSym(h)
Console.print("}")
Console.print(",\"defs\":[")
S2c.jSyms(defs, true)
Console.print("]}")
S2c.jRegions(fs, rest, id + 1)

def S2c.jSyms(xs: Coll.List[Sym.Sym], first: Bool): Unit = xs match
case Coll.Nil => ()
case Coll.Cons(x, rest) =>
S2c.jSep(first)
S2c.jSym(x)
S2c.jSyms(rest, false)

// each region's manual frees (x.free() at a line), then its drop at the end of its block, which frees it when it is
// still live
def S2c.jFrees(fs: Coll.List[S2c.File], bs: Coll.List[Mem.Block], id: I64): Unit = bs match
case Coll.Nil => ()
case Coll.Cons(b, rest) =>
val Mem.Block(_, _, _, _, _, _, frees) = b
S2c.jSep(id == 0)
S2c.jManual(fs, frees, id)
Console.print("{\"region\":")
Console.printI64(id)
Console.print(",\"kind\":\"auto\",\"when\":\"blockEnd\",\"ifLive\":true}")
S2c.jFrees(fs, rest, id + 1)

def S2c.jManual(fs: Coll.List[S2c.File], ls: Coll.List[I64], id: I64): Unit = ls match
case Coll.Nil => ()
case Coll.Cons(l, rest) =>
Console.print("{\"region\":")
Console.printI64(id)
Console.print(",\"kind\":\"manual\",\"at\":")
S2c.jAt(fs, l)
Console.print("},")
S2c.jManual(fs, rest, id)

// a manual free of a {} Region param: region null, the def and the param name (its caller passes the region)
def S2c.jParamFrees(fs: Coll.List[S2c.File], pf: Coll.List[Mem.FreeAt], first: Bool): Unit = pf match
case Coll.Nil => ()
case Coll.Cons(m, rest) =>
val Mem.FreeAt(f, l, x) = m
S2c.jSep(first)
Console.print("{\"region\":null,\"kind\":\"manual\",\"at\":")
S2c.jAt(fs, l)
Console.print(",\"def\":")
S2c.jSym(f)
Console.print(",\"param\":")
S2c.jSym(x)
Console.print("}")
S2c.jParamFrees(fs, rest, false)

def S2c.jBlocks(fs: Coll.List[S2c.File], bs: Coll.List[Mem.Block], region: I64, c: S2c.MemCount): S2c.MemCount = bs match
case Coll.Nil => c
case Coll.Cons(b, rest) =>
val Mem.Block(_, _, _, rows) = b
val Mem.Block(_, _, _, _, rows, _, _) = b
S2c.jBlocks(fs, rest, region + 1, S2c.jRows(fs, rows, region, c))

def S2c.jRows(fs: Coll.List[S2c.File], rows: Coll.List[Mem.Row], region: I64, c: S2c.MemCount): S2c.MemCount = rows match
case Coll.Nil => c
case Coll.Cons(r, rest) =>
val Mem.Row(line, ctor, bytes, dies, m) = r
val Mem.Row(line, f, ctor, bytes, dies, m) = r
val S2c.MemCount(once, onceB, many, die, site) = c
S2c.jSep(site == 0)
Console.print("{\"id\":")
Console.printI64(site)
Console.print(",\"region\":")
Console.printI64(region)
Console.print(",\"def\":")
S2c.jSym(f)
Console.print(",\"at\":")
S2c.jAt(fs, line)
Console.print(",\"ctor\":")
Expand Down
2 changes: 1 addition & 1 deletion tests/s2/mem/bytes.out
Original file line number Diff line number Diff line change
@@ -1 +1 @@
{"regions":[{"id":0,"at":"tests/s2/mem/bytes.srs:15","var":"r","handler":"Srs.Arena"}],"sites":[{"id":0,"region":0,"at":"tests/s2/mem/bytes.srs:8","ctor":"MG","bytes":24,"fate":"escapes","mult":"many","why":{"kind":"sites","def":"MG.wrap","n":2}},{"id":1,"region":0,"at":"tests/s2/mem/bytes.srs:18","ctor":"MS","bytes":32,"fate":"dies","mult":"once"}],"total":{"once":1,"onceBytes":32,"many":1,"dies":1},"reuse":[],"compact":[]}
{"regions":[{"id":0,"def":"main","at":"tests/s2/mem/bytes.srs:15","var":"r","handler":"Srs.Arena","defs":["MG.wrap","main"]}],"sites":[{"id":0,"region":0,"def":"MG.wrap","at":"tests/s2/mem/bytes.srs:8","ctor":"MG","bytes":24,"fate":"escapes","mult":"many","why":{"kind":"sites","def":"MG.wrap","n":2}},{"id":1,"region":0,"def":"main","at":"tests/s2/mem/bytes.srs:18","ctor":"MS","bytes":32,"fate":"dies","mult":"once"}],"frees":[{"region":0,"kind":"auto","when":"blockEnd","ifLive":true}],"total":{"once":1,"onceBytes":32,"many":1,"dies":1},"reuse":[],"compact":[]}
2 changes: 1 addition & 1 deletion tests/s2/mem/compact.out
Original file line number Diff line number Diff line change
@@ -1 +1 @@
{"regions":[{"id":0,"at":"tests/s2/mem/compact.srs:35","var":"r","handler":"Srs.Arena"}],"sites":[{"id":0,"region":0,"at":"tests/s2/mem/compact.srs:11","ctor":"CC","bytes":24,"fate":"escapes","mult":"many","why":{"kind":"sites","def":"CL.build","n":6}},{"id":1,"region":0,"at":"tests/s2/mem/compact.srs:20","ctor":"CS","bytes":16,"fate":"escapes","mult":"once"},{"id":2,"region":0,"at":"tests/s2/mem/compact.srs:30","ctor":"CS","bytes":16,"fate":"escapes","mult":"once"},{"id":3,"region":0,"at":"tests/s2/mem/compact.srs:38","ctor":"Array.fill","bytes":null,"fate":"escapes","mult":"once"},{"id":4,"region":0,"at":"tests/s2/mem/compact.srs:38","ctor":"CS","bytes":16,"fate":"escapes","mult":"once"},{"id":5,"region":0,"at":"tests/s2/mem/compact.srs:39","ctor":"CS","bytes":16,"fate":"dies","mult":"once"},{"id":6,"region":0,"at":"tests/s2/mem/compact.srs:44","ctor":"Array.fill","bytes":null,"fate":"escapes","mult":"once"},{"id":7,"region":0,"at":"tests/s2/mem/compact.srs:44","ctor":"CS","bytes":16,"fate":"escapes","mult":"once"},{"id":8,"region":0,"at":"tests/s2/mem/compact.srs:46","ctor":"CS","bytes":16,"fate":"escapes","mult":"once"},{"id":9,"region":0,"at":"tests/s2/mem/compact.srs:47","ctor":"CS","bytes":16,"fate":"escapes","mult":"once"},{"id":10,"region":0,"at":"tests/s2/mem/compact.srs:49","ctor":"CS","bytes":16,"fate":"escapes","mult":"once"},{"id":11,"region":0,"at":"tests/s2/mem/compact.srs:52","ctor":"CS","bytes":16,"fate":"escapes","mult":"once"}],"total":{"once":11,"onceBytes":144,"many":1,"dies":1},"reuse":[],"compact":[{"at":"tests/s2/mem/compact.srs:20","def":"C.summary"},{"at":"tests/s2/mem/compact.srs:52","def":"C.deep"}]}
{"regions":[{"id":0,"def":"main","at":"tests/s2/mem/compact.srs:35","var":"r","handler":"Srs.Arena","defs":["CL.build","C.summary","C.store","main","C.sink","C.small","C.deep"]}],"sites":[{"id":0,"region":0,"def":"CL.build","at":"tests/s2/mem/compact.srs:11","ctor":"CC","bytes":24,"fate":"escapes","mult":"many","why":{"kind":"sites","def":"CL.build","n":6}},{"id":1,"region":0,"def":"C.summary","at":"tests/s2/mem/compact.srs:20","ctor":"CS","bytes":16,"fate":"escapes","mult":"once"},{"id":2,"region":0,"def":"C.store","at":"tests/s2/mem/compact.srs:30","ctor":"CS","bytes":16,"fate":"escapes","mult":"once"},{"id":3,"region":0,"def":"main","at":"tests/s2/mem/compact.srs:38","ctor":"Array.fill","bytes":null,"fate":"escapes","mult":"once"},{"id":4,"region":0,"def":"main","at":"tests/s2/mem/compact.srs:38","ctor":"CS","bytes":16,"fate":"escapes","mult":"once"},{"id":5,"region":0,"def":"main","at":"tests/s2/mem/compact.srs:39","ctor":"CS","bytes":16,"fate":"dies","mult":"once"},{"id":6,"region":0,"def":"C.sink","at":"tests/s2/mem/compact.srs:44","ctor":"Array.fill","bytes":null,"fate":"escapes","mult":"once"},{"id":7,"region":0,"def":"C.sink","at":"tests/s2/mem/compact.srs:44","ctor":"CS","bytes":16,"fate":"escapes","mult":"once"},{"id":8,"region":0,"def":"C.sink","at":"tests/s2/mem/compact.srs:46","ctor":"CS","bytes":16,"fate":"escapes","mult":"once"},{"id":9,"region":0,"def":"C.sink","at":"tests/s2/mem/compact.srs:47","ctor":"CS","bytes":16,"fate":"escapes","mult":"once"},{"id":10,"region":0,"def":"C.small","at":"tests/s2/mem/compact.srs:49","ctor":"CS","bytes":16,"fate":"escapes","mult":"once"},{"id":11,"region":0,"def":"C.deep","at":"tests/s2/mem/compact.srs:52","ctor":"CS","bytes":16,"fate":"escapes","mult":"once"}],"frees":[{"region":0,"kind":"auto","when":"blockEnd","ifLive":true}],"total":{"once":11,"onceBytes":144,"many":1,"dies":1},"reuse":[],"compact":[{"at":"tests/s2/mem/compact.srs:20","def":"C.summary"},{"at":"tests/s2/mem/compact.srs:52","def":"C.deep"}]}
2 changes: 1 addition & 1 deletion tests/s2/mem/cycle.out
Original file line number Diff line number Diff line change
@@ -1 +1 @@
{"regions":[{"id":0,"at":"tests/s2/mem/cycle.srs:14","var":"r","handler":"Srs.Arena"}],"sites":[{"id":0,"region":0,"at":"tests/s2/mem/cycle.srs:10","ctor":"MT","bytes":16,"fate":"dies","mult":"many","why":{"kind":"via","def":"MT.a"}}],"total":{"once":0,"onceBytes":0,"many":1,"dies":1},"reuse":[],"compact":[]}
{"regions":[{"id":0,"def":"main","at":"tests/s2/mem/cycle.srs:14","var":"r","handler":"Srs.Arena","defs":["MT.b"]}],"sites":[{"id":0,"region":0,"def":"MT.b","at":"tests/s2/mem/cycle.srs:10","ctor":"MT","bytes":16,"fate":"dies","mult":"many","why":{"kind":"via","def":"MT.a"}}],"frees":[{"region":0,"kind":"auto","when":"blockEnd","ifLive":true}],"total":{"once":0,"onceBytes":0,"many":1,"dies":1},"reuse":[],"compact":[]}
Loading
Loading