Orkuncakilkaya
254097657e
Found by reading every builtin (Os.platform's 8 KB per call started it). Log builds its line only at or above the threshold and frees it; DateTime.format folds through + so its pieces go; Input.text encodes into one buffer; Path/Mime/Fs/Os free their temporaries on every path; string results of Text/Path/Mime/DateTime/Os dirs are fresh and Text frees a fresh argument. Reseeded. runtime_temps.ludic: 19.8 MB -> 0 over 20,000 rounds, 64 KB -> 0 over 200 of file work; clean under MallocScribble. string_temps still 0. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
102 lines
5 KiB
Text
102 lines
5 KiB
Text
# emit_log.ludic — the Log.* namespace: levelled, structured logging, the default
|
|
# way to answer "what is my game doing?" and "why did that break?" — better than
|
|
# scattered `print` calls. Lines go to standard error (so they never pollute a
|
|
# program's real stdout) with a level tag and optional structured key=value
|
|
# fields, gated by a runtime threshold so release builds can go quiet.
|
|
#
|
|
# Log.trace(msg, [k, v]...) most verbose level 0
|
|
# Log.debug(msg, [k, v]...) development detail level 1
|
|
# Log.info(msg, [k, v]...) normal operation level 2
|
|
# Log.warn(msg, [k, v]...) something looks wrong level 3
|
|
# Log.error(msg, [k, v]...) a failure level 4
|
|
# Log.set_level(n) show only level >= n (0 = all, the default)
|
|
# Log.level() the current threshold -> int
|
|
#
|
|
# Structured fields are optional trailing key/value pairs appended as ` key=value`;
|
|
# values may be strings, ints, or longs (numbers are formatted for you), so
|
|
# `Log.warn("missing texture", "path", p, "id", n)` is cheap to write and easy to
|
|
# grep. The level tag is chosen at compile time from the method name, so a
|
|
# disabled level costs only the threshold comparison at runtime.
|
|
#
|
|
# Determinism: logging writes to stderr and never touches the simulation, so it
|
|
# has no effect on gameplay or replays. This v1 ships the console (stderr) sink;
|
|
# file-with-rotation and in-engine overlay sinks are planned follow-ups.
|
|
|
|
function is_log_ns(meth: pointer) -> bool {
|
|
if (meth == "trace") or (meth == "debug") or (meth == "info") { return true }
|
|
if (meth == "warn") or (meth == "error") { return true }
|
|
if (meth == "set_level") or (meth == "level") { return true }
|
|
return false
|
|
}
|
|
|
|
# format any value as a string for a log field: a string passes through (fresh if it was), a long
|
|
# and an int are converted the same way the `string(...)` builtin does, into text freed once joined
|
|
function log_stringify(v: Val) -> Val {
|
|
if (llty(v.ty) == "ptr") {
|
|
let s = val(v.code, "string")
|
|
s.fresh = v.fresh
|
|
return s
|
|
}
|
|
if (llty(v.ty) == "i64") { g_uses_longstr = true; return fresh_val(emit_bind(`call ptr @lp_long_str(i64 {v.code})`), "string") }
|
|
g_uses_intstr = true
|
|
return fresh_val(emit_bind(`call ptr @lp_int_str(i32 {v.code})`), "string")
|
|
}
|
|
|
|
function emit_log_ns(meth: pointer, e: Node) -> Val {
|
|
g_uses_logrt = true
|
|
if (meth == "set_level") { # raise/lower the threshold
|
|
let n = emit_expr(e.kids[0])
|
|
emit(` store i32 {n.code}, ptr @L_log_level\n`)
|
|
return val("0", "void")
|
|
}
|
|
if (meth == "level") { # read the current threshold
|
|
return val(emit_bind("load i32, ptr @L_log_level"), "int")
|
|
}
|
|
# a level method: tag + numeric level chosen at compile time from the name.
|
|
var lvl = "2"; var pfx = "[INFO] "
|
|
if (meth == "trace") { lvl = "0"; pfx = "[TRACE] " }
|
|
if (meth == "debug") { lvl = "1"; pfx = "[DEBUG] " }
|
|
if (meth == "warn") { lvl = "3"; pfx = "[WARN] " }
|
|
if (meth == "error") { lvl = "4"; pfx = "[ERROR] " }
|
|
g_uses_str = true
|
|
# below the threshold nothing is built: the message and its fields are made, written and freed
|
|
# only for a line that is shown (every call once left its whole line behind, shown or not)
|
|
let cur = emit_bind("load i32, ptr @L_log_level")
|
|
let on = emit_bind(`icmp sge i32 {lvl}, {cur}`)
|
|
let lon = lbl("logon")
|
|
let lend = lbl("logend")
|
|
emit(` br i1 {on}, label %{lon}, label %{lend}\n`)
|
|
emit(`{lon}:\n`)
|
|
# line = "[LEVEL] " + msg, then " key=value" for each trailing pair
|
|
var line = val(emit_str_const(pfx), "string")
|
|
let msg = emit_expr(e.kids[0])
|
|
line = emit_str_op("+", line, log_stringify(msg))
|
|
var i = 1
|
|
while (i + 1) < len(e.kids) {
|
|
let k = emit_expr(e.kids[i])
|
|
let v = emit_expr(e.kids[i + 1])
|
|
line = emit_str_op("+", line, val(emit_str_const(" "), "string"))
|
|
line = emit_str_op("+", line, log_stringify(k))
|
|
line = emit_str_op("+", line, val(emit_str_const("="), "string"))
|
|
line = emit_str_op("+", line, log_stringify(v))
|
|
i += 2
|
|
}
|
|
emit(` call void @lp_log_emit(i32 {lvl}, ptr {line.code})\n`)
|
|
emit(` call void @free(ptr {line.code})\n`)
|
|
emit(` br label %{lend}\n`)
|
|
emit(`{lend}:\n`)
|
|
return val("0", "void")
|
|
}
|
|
|
|
# emit_log_prelude — the log level register and the console sink, emitted once per
|
|
# program that uses Log.* (g_uses_logrt). @lp_log_emit checks the threshold and,
|
|
# if the message is at or above it, writes the line + newline to stderr.
|
|
function emit_log_prelude() -> void {
|
|
emith("@L_log_level = global i32 0\n")
|
|
emith("@.log_nl = private unnamed_addr constant [2 x i8] c\"\\0A\\00\"\n")
|
|
emith("define void @lp_log_emit(i32 %lvl, ptr %s) {\n")
|
|
emith("entry:\n %th = load i32, ptr @L_log_level\n %skip = icmp slt i32 %lvl, %th\n br i1 %skip, label %done, label %go\n")
|
|
emith(`go:\n %e = {stdstream_rhs(2)}\n %n = call i64 @strlen(ptr %s)\n`)
|
|
emith(" %w = call i64 @fwrite(ptr %s, i64 1, i64 %n, ptr %e)\n %w2 = call i64 @fwrite(ptr @.log_nl, i64 1, i64 1, ptr %e)\n br label %done\n")
|
|
emith("done:\n ret void\n}\n")
|
|
}
|