# SLeeLa runtime audit Revision 1.0, 2026-11-13. Scope: the execution core (`impl/core/sleela_core.{h,c}`), the collector (`runtime/garbage_collector.{h,c}`) and the interpreter's allocation, exception and thread paths. The contract is `impl/RUNTIME-SERVICES.md` and `lib/vm/RUNTIME-SERVICES.md`. This page records what was **run or read**, what was **fixed**, and what is **open**. A row without evidence says so. Tests: `bash impl/tests/runtime/pressure/run_pressure_tests.sh` (`make -C impl test-runtime-pressure`, part of `make test`). ## 1. Verified by test (impl/tests/runtime/pressure) | Area | What the test does | Result | |---|---|---| | Array churn | 20,000 short-lived arrays, with one 100-element array, one 30x30 grid and a 200-row jagged array held live | all contents intact after every collection | | Struct churn with live structs | 3,000 live structs, then 30,000 short-lived ones, then mixed array and struct churn | **failed before the fix**, passes now (see 2.1) | | `finally` that allocates | a method returns an array while its `finally` allocates 6,000 arrays; an exception path does the same | returned value intact (the saved return value is a rooted local) | | Bounded tables fail closed | hold 5,000 live arrays, then 5,000 live structs | a clear error naming the limit; the program does not continue | | Worker threads | two workers write disjoint arrays and allocate while the main thread allocates, repeated 5 times | deterministic result, no crash | ## 2. Fixed ### 2.1 Struct allocation did not retry after a full collection `OP_NEWARRAY` runs one complete root-aware collection and retries when the live-array table is full. `OP_NEWSTRUCT` and `OP_STRUCTUNPACK` did not, so a program holding a few thousand live objects failed with "store exhausted" while most of the table was garbage. Both now go through `struct_alloc_gc`, which does what `array_alloc_gc` does. A table whose slots are all reachable still fails. ### 2.2 Misleading allocation errors An array allocation that failed because the managed heap was full (default 1 GiB) said "negative or too-large size or store exhausted". The errors for arrays and structs now name the three real causes (size, memory, table) and give the limits: 4096 live arrays, 4096 live structs, 32 bytes per element, a 1 GiB managed heap unless `SLEELA_GC_LIMIT_BYTES` is set. ### 2.3 The build gate When the source tree does not match the trusted manifest, `make` stops with a hash mismatch (it was never silent). It now also says that nothing was rebuilt and that any existing `build/sleela` is the previous build. Earlier sessions ran tests against that stale binary without noticing; the message removes the trap. (A past claim that the failure was silent was wrong: output had been filtered.) ### 2.5 Negative array size Java throws `NegativeArraySizeException`; the VM ended the program. The converter wraps each non-constant size in `JavaChecks.size(n)` (`lib/java/JavaChecks.sleela`); `--unchecked-sizes` omits it. Test: `Bounds`. ### 2.6 Methods named like a built-in A Java method called `read`, `write`, `accept`, `lock`, `send`, `listen`, `join`, ... was taken for the SLeeLa built-in by an unqualified call ("read(handle) takes one argument"). The converter now qualifies such a call with its owner class (static) or `this.` (instance). The list is `sleelactl/convert/builtin_names.h`, taken from the compiler's call table. Not covered: a Java method named like a Munction verb (`connect`, `send`, `enable`, ...) called ON a receiver, which the compiler also treats as the verb on every receiver. ### 2.4 Stale documents `impl/RUNTIME-SERVICES.md` said no collector existed and that the ISA has 98 opcodes. Both are corrected. ### 2.7 Version statements (was finding 11) `working-binaries/` reported syntax 1.0 to 3.0 and the documents repeated that ceiling. The binaries report 1.0 to 3.1 (release 1.3.2-pro), and the documents that state the current range were brought to match. Test: `test-suites/regression/python/test_doc_versions.py` (group `integrity`) compares the release and range in the source and in the binary under test with those documents, so the next change of range names every document that lags. ## 3. Findings, not changed | # | Finding | Evidence | Why it matters | Suggested action | |---|---|---|---|---| | 1 | **Every array element is 32 bytes** (`sizeof(SLValue)` is 32 because the value union carries a 128-bit integer) | measured with a C probe; 20,000,000 `int` elements need 640 MB, so a second one exceeds the 1 GiB heap | Java `byte[]`, `int[]`, `char[]` cost 8 to 32 times more than on a JVM; large arrays fail early | typed array storage (a VM change); until then document the cost | | 2 | **Marking is quadratic in the object count**: `mark_internal` calls `live()`, a linear scan of every object, per mark; `push_unique` is linear too | read in `garbage_collector.c` (not profiled) | a full collection with N live objects does O(N squared) work; bounded today by the 4096 tables but grows with strings and externals | index objects by a flag or a hash; profile first | | 3 | **The memory manager appears not to see VM arrays**: after a program that allocated a 640 MB array, its exit banner still reports `allocs=0 frees=0 peak=0 bytes` | observed in the exit counters only; not confirmed with a mid-run reading | the 2 GiB "hard limit" is not what stops an array; the 1 GiB GC limit is | account for array storage, or document that the GC limit is the operative one | | 4 | **Catchable VM faults: partly in place.** Since 2026-11-13 (SLEELA.syntax 37.5, `lib/java/support/SLJavaFaults`) integer divide/modulo by zero, array index out of range and a failed checked cast are thrown inside a `try`. **Not covered:** null dereference, stack overflow, a negative array size (handled by the Java tier, 2.5 below), and every fault with no active handler (fatal, as an uncaught exception ends a Java program) | verified: `sleelactl/convert/tests/java/Bounds.java` (index reads, writes, compound stores, nested arrays) matches a JDK without any converter check | an earlier revision of this page listed this as wholly open; that was stale because the fix had landed the same day in another change and I had not re-read the spec | extend the fault kinds to null dereference (needs a typed null check at each dereference) | | 5 | **The unlocked array fast path depends on `workers_cached`**, refreshed at a safepoint and forced at `SPAWN` | read; the threaded test passes 5 of 5 | a stale zero while a worker exists would let reads and writes race | argue it formally or take the lock when any thread was ever spawned; add a randomized thread test | | 6 | **Unsynchronized shared updates lose writes** (two workers incrementing the same array: 399,956 of 400,000) | observed | the same as Java without `synchronized`; but the language has no atomic or monitor to fix it | document the guarantees: what `SPAWN`, `JOINALL`, locks and mailboxes order | | 7 | **Lock ordering is not audited**: the core has `global_mtx`, `array_mtx`, `struct_mtx`, `thr_mtx` and others | not read end to end | a path that takes two locks in opposite orders deadlocks | build the lock-order graph; add a test | | 8 | **Two string kinds** (plain UTF-8 and the VM-owned UTF-16 kind) | known | an unpaired surrogate or NUL is a runtime error for the plain kind only; each opcode that takes a string needs a stated rule for the other kind | a table of opcode by string kind | | 9 | **The verifier is a Python script** found by searching upward from the current directory | observed when `SLEELA_HOME` is unset | an installed runtime without the repository cannot run | decide whether verification is part of an installed runtime | | 10 | **Platform backends are only CI-covered where a workflow exists** (`native-portability`, `wifi-native`, `utf4088`, ...) | workflow list | Windows and macOS paths for sockets, terminal, threads | one table: backend by platform by workflow | ## 4. Decision recorded (2026-11-13) Catchable runtime faults for Java: the owner chose to **keep the rule** (Java improvements live in the Java tier, not in the compiler, VM or runtime) "for now". The VM mechanism of 37.5 is a generic fault hook, and the Java-specific exceptions are made by `SLJavaFaults` in `lib/java`, so the rule holds. The converter adds only what the hook does not cover: `JavaChecks.size` for a negative array size. Null dereference and stack overflow stay fatal and are listed as open in `lib/java/CONVERSION.PRINCIPLES.md`. ## 5. How to extend this audit Add a test under `impl/tests/runtime/pressure` that fails before a fix, fix the cause, move the row from section 3 to section 2. A finding stays in section 3 until a test proves it fixed.