Home /Modules/comparison/PERFORMANCE.ANALYSIS.001.md

PERFORMANCE.ANALYSIS.001.md

comparison/PERFORMANCE.ANALYSIS.001.md · 507 line(s) · markdown

SLeeLa Performance Assessment — Basic Data Types and RAM Access

Assessment ID: SCS-PERF-001 Edition: 1.0 Recorded: 2026-11-06 Repository: mearvk/SLeeLa · Branch: master Language baseline: SLeeLa Syntax 3.0 · C11 · C++17 · Java 21+ Status: CONFORMANCE RETRY IN PROGRESS — PARTIAL; no performance measurements available

1. Purpose

This assessment defines a reproducible comparison of computation speed and memory-access performance across:

  1. The Basic SLeeLa Native VM in impl/core.
  2. All ten Standard/think-tank VM generations, idea-vm-001 through idea-vm-010.
  3. All eleven runnable Premium VMs, SLVM/1 through SLVM/11.
  4. Native C11 and C++17 implementations.
  5. Java 21 or later on the JVM.

The purpose is to measure real execution, not infer speed from version number, feature count, source-code size, or architectural description. No performance values or rankings are asserted in this protocol. Results must be generated by the benchmark runners and retained with their environment metadata before conclusions are drawn.

2. Architecture and fair-comparison rules

2.1 Basic Native VM

The baseline is the Native VM implemented by impl/core, invoked through the repository's normal SLeeLa compiler/runtime path. It is the default SLeeLa execution engine.

2.2 Standard VMs: generations 1–10

The Standard progression is:

GenerationRegistry identityDocumented addition
1idea-vm-001Ground-floor configuration, report, status
2idea-vm-002Memory hardening
3idea-vm-003Typed results
4idea-vm-004Telemetry
5idea-vm-005Garbage-collection quality
6idea-vm-006Dispatch profiler
7idea-vm-007Capability enforcement
8idea-vm-008Platform parity
9idea-vm-009Audit trail
10idea-vm-010Consolidated runtime

Execution qualification: the repository's VM user guide currently identifies Standard generations 1–10 as a layered think-tank progression and explicitly says they are not yet bootable through the Premium-style sleela vm run command. They must therefore not be represented as ten independently executing instruction engines in this report.

The Standard generations remain in scope. Their assessment is divided into:

If a Standard layer has no independently callable operation or faithful native harness, record it as unavailable rather than inventing a measurement.

2.3 Premium VMs: generations 1–11

The Premium SLVM runners each link the shared Core archive and perform their own grade-specific admission/validation before running a compiled SLeeLa artifact. Their distinguishing feature validators are part of the measured architecture.

For every Premium generation, report two distinct timings:

  1. Steady-state workload: elapsed time to execute the same precompiled workload after the runner has started and admitted the VM.
  2. Cold invocation: process start, admission, artifact load, execution, and shutdown as one end-to-end interval.

The steady-state result is the primary computation comparison. Cold invocation is a separate operational metric. Do not attribute a difference in admission time to arithmetic throughput.

2.4 Native language comparators

ComparatorRequired language/runtime
CC11, optimized native build
C++C++17, optimized native build
JavaJava 21+; record exact JDK vendor and version

C and C++ are native baselines, not VM implementations. Java results include JVM/JIT behavior and must use warm-up and steady-state measurement. These results are comparative reference points, not proof that the languages have identical semantics or implementation strategies.

3. Basic data-type computation suite

Each implementation must run the same defined inputs, iteration counts, dependency patterns, and observable result checks. Inputs and outputs are fixed and included in the result record. Use integer-safe workloads with defined overflow behavior; do not rely on signed overflow in C or C++.

IDData type / operationPrimary measurement
DT-01Boolean operations and conditional selectionoperations/second
DT-028/16/32-bit integer arithmeticoperations/second
DT-0364-bit signed and unsigned integer arithmeticoperations/second
DT-04128-bit integer arithmetic where natively supportedoperations/second; support recorded
DT-05Single-precision floating-point arithmeticoperations/second
DT-06Double-precision floating-point arithmeticoperations/second
DT-07Integer comparisons, branches, and loopsiterations/second
DT-08Integer division and remainderoperations/second
DT-09Function calls and return-value handlingcalls/second
DT-10Mixed-type arithmetic/conversion where supportedoperations/second
DT-11Array element reads and writeselements/second
DT-12String construction, comparison, and traversaloperations/second or bytes/second, with exact semantics stated

The suite must distinguish arithmetic throughput from dispatch overhead. Include both dependency-chain tests (each result depends on the previous result) and independent-operation batches (multiple independent values per iteration). This helps reveal latency versus throughput and reduces the risk that compiler/JIT optimization removes the work.

For floating point, report precision mode and validation tolerance. For 128-bit integers, record whether the implementation uses a native 128-bit representation, a library representation, or a narrower fallback. Do not compare unlike implementations without disclosing that distinction.

4. RAM and memory-access suite

RAM testing is separated into latency, bandwidth, cache behavior, and allocation/reclamation. A single generic “RAM speed” number is insufficient.

IDTestMeasurement
MEM-01Sequential readGiB/s
MEM-02Sequential writeGiB/s
MEM-03Read-modify-write streamGiB/s and operations/second
MEM-04Sequential copyGiB/s
MEM-05Random read, fixed working setns/access and accesses/second
MEM-06Dependent pointer chase over randomized permutationns/load; latency
MEM-07Random writens/store and operations/second
MEM-08Strided accessns/access and effective GiB/s
MEM-09Working-set sweeplatency/bandwidth by allocation size
MEM-10Allocation and releaseallocations/second and ns/allocation
MEM-11Array growth / appendns/element and total throughput
MEM-12GC allocation/reclamation pressure, where applicableallocation rate, pause time, reclaimed bytes

4.1 Working-set sizes

Use a documented geometric size sweep that includes small cache-resident sets and sets larger than the last-level cache and physical memory only where safely available. Suggested default sizes are 4 KiB, 32 KiB, 256 KiB, 2 MiB, 16 MiB, 64 MiB, and 256 MiB. The runner must detect available memory and cap the largest allocation conservatively; it must never intentionally exhaust the host.

Record actual allocation size, page size when available, and whether the test data fits in the relevant cache. Do not label a size “L1”, “L2”, “L3”, or “RAM” unless the host's cache topology supports that label.

4.2 Latency versus bandwidth

Report these as separate metrics. Never convert a bandwidth result into a latency claim.

5. Benchmark matrix

The target coverage is:

Target familyMembersComputationRAM accessStartup/admission
Basic Native VM1Full suiteFull suiteYes
Standard VMs1–10Layer operations only until bootableLayer operations only until bootablePer-layer init where callable
Premium SLVM1–11Full suiteFull suiteYes, separately
C111Full suiteFull suiteProcess launch separately
C++171Full suiteFull suiteProcess launch separately
Java 21+1Full suiteFull suiteJVM cold start separately

This is 23 primary target entries (1 Basic + 10 Standard + 11 Premium) plus three language comparators. Standard VM whole-program results are explicitly gated on bootability and cannot be silently counted as completed.

6. Execution protocol

  1. Record repository commit SHA, branch, dirty-tree state, compiler versions, JDK vendor/version, OS/kernel, CPU model, logical/physical core counts, RAM capacity, memory speed if available, cache sizes, and power mode.
  2. Use one physical host for a direct within-host comparison. Run a separate complete matrix for each additional OS/host; never compare numbers from unlike hardware as though the runtime caused the difference.
  3. Build native C and C++ with documented release optimization and warnings. Record the exact compiler command and flags. Build SLeeLa Core and every Premium runner from the same repository commit and compatible release configuration.
  4. Compile SLeeLa source once per workload to the same artifact format and use that artifact for the Basic VM and every Premium runner. Record compiler version, artifact hash, and compile time separately. Compilation time is not VM execution time.
  5. Compile Java comparators once. Warm up the JVM until the measured workload stabilizes or a declared warm-up ceiling is reached. Record warm-up iterations and JVM flags. Report cold JVM startup separately.
  6. Perform at least five measured repetitions after warm-up; use a longer run duration for short operations. Report median, minimum, maximum, and p95 where sample count permits. Include dispersion (standard deviation or median absolute deviation).
  7. Alternate or randomize target execution order to reduce thermal, frequency, and background-load bias. Record CPU governor/power plan and avoid concurrent benchmark workloads.
  8. Validate the final result/checksum of every workload. A run with a wrong result, missing workload, runtime error, or unsupported operation is not a performance result.
  9. Keep process startup, VM admission, artifact loading, steady-state execution, and shutdown as separate phases wherever instrumentation allows.
  10. Repeat the full suite on each target OS before making cross-platform claims. The initial reference run may use Ubuntu, but it must be labeled Linux-only until macOS and Windows runs complete.

7. Measurement and reporting rules

7.1 Compiler/JIT and optimization controls

C/C++ builds must prevent dead-code elimination by validating a checksum observable outside the timed loop. Avoid undefined behavior and ensure allocation alignment is comparable. Record optimization flags, LTO state, target architecture flags, and allocator.

Java must record JDK and VM flags, warm-up policy, garbage collector, heap bounds, and whether compilation reached steady state. Report GC activity and pauses for memory-pressure workloads. A Java result before JIT warm-up must not be compared with a steady-state native result without an explicit cold-start label.

SLeeLa must use the same compiler/artifact and runtime build for the Basic and Premium comparisons. Do not include compilation in steady-state execution time. Record Core build flags and Premium admission checks.

8. Standard VM layer accounting

For each Standard generation, record the following where its source exposes a callable operation:

Use a paired baseline: run the same underlying operation with the layer disabled/absent and enabled/present, with identical inputs. Report incremental time and memory, not only total time. If a layer changes the semantics or amount of work, the pair is not directly comparable and must be described.

Until a supported executable Standard-VM route exists, report the whole-program execution field as NOT RUN — Standard generation not bootable through the documented runner. Do not claim that a source-level manifest or a selection record is an executing VM.

9. Results schema and artifacts

The benchmark implementation should write machine-readable JSON and a human-readable Markdown summary. Each result record should contain at least:

{
  "suite": "SCS-PERF-001",
  "repository_commit": "<commit-sha>",
  "target": "basic-native-vm",
  "target_version": "impl/core",
  "language": "SLeeLa",
  "workload": "DT-02",
  "status": "PASS",
  "host": {
    "os": "<os>",
    "cpu": "<cpu-model>",
    "logical_cores": 0,
    "ram_bytes": 0
  },
  "build": {
    "compiler": "<compiler-and-version>",
    "flags": "<exact-flags>",
    "artifact_sha256": "<hash-or-null>"
  },
  "measurement": {
    "warmups": 0,
    "repetitions": 5,
    "operation_count": 0,
    "elapsed_ns_median": 0,
    "elapsed_ns_min": 0,
    "elapsed_ns_max": 0,
    "throughput_per_second": 0,
    "checksum": "<validated-result>"
  }
}

Zeroes above are schema placeholders, not measurements. Unsupported/not-bootable results must use a status such as NOT_RUN and a reason; they must not be encoded as zero performance.

Recommended artifacts:

10. CI and execution policy

Correctness and performance must be separate CI concerns.

11. Current assessment state

AreaState
Basic Native VM target identifiedDefined
Standard VM generations 1–10 identifiedDefined; whole-program execution not currently documented as bootable
Premium SLVM generations 1–11 identifiedDefined; each uses shared Core plus generation-specific admission
C11 comparatorDefined
C++17 comparatorDefined
Java 21+ comparatorDefined
Basic data-type workload definitionsDefined
RAM latency/bandwidth workload definitionsDefined
Reproducible execution protocolDefined
Benchmark harness implementationPartial CI matrix runner exists; full performance harness not implemented
CI correctness checksPartial: Ubuntu/macOS language suites passed; Windows setup and VM matrix failed (details in §13)
Performance rankingNot established

13. CI execution record — run 42337765442

Workflow: Complete SLeeLa VM and Language Conformance Workflow file: .github/workflows/complete-vm-conformance.yml Commit tested: bd7eb049b6158bf129564aea43b58bfeeed993cd Run status: completed · Conclusion: failure Recorded by GitHub: 2026-11-07 (UTC)

This run was a correctness/build conformance attempt, not a performance benchmark. Its results must not be interpreted as execution-speed, RAM-bandwidth, or latency measurements.

13.1 Language comparator matrix

RunnerC11 / C++17 / Java 21+ jobOutcomeEvidence
Ubuntu latestCompletedPASSToolchain setup and shared comparison suites succeeded
macOS latestCompletedPASSJava 21 setup and shared comparison suites succeeded
Windows latestIncompleteFAIL — environment setupMSYS2 could not locate package mingw-w64-ucrt-x86_64-gcc-c++; language suites were skipped

The Ubuntu and macOS results establish that the configured comparison suites completed successfully on those hosted runners for this commit. They do not establish performance rankings, and they do not establish Windows compatibility.

13.2 Basic Native and Premium VM matrix

CheckOutcomeInterpretation
Integrity manifest generationPASSCheckout-specific manifest generated
Basic Native VM/compiler buildPASSBuild completed
Premium SLVM 1–11 buildsPASSAll eleven build targets completed
Basic Native VM output validationFAIL — runner parsingProgram emitted expected values 42, 15, and hello, followed by runtime/security diagnostics; runner treated the extra lines as unexpected output
Premium VM execution checksNOT RUNMatrix runner stopped at the Basic Native output assertion
Premium VM admission self-checksSKIPPEDDependent step did not execute
Standard VM Modium checksSKIPPEDDependent step did not execute
Standard VM inventoryPASS — 10/10 registeredRegistration only; no Standard VM execution is claimed

The Basic Native failure is presently a test-harness output-parsing defect, not evidence that the program produced incorrect workload values. The runner should validate the expected result lines while allowing or separately classifying known runtime, memory-manager, and security diagnostics. It should retain both the raw output and the parsed result.

The eleven Premium VM binaries were built, but this run provides no execution result for SLVM/1 through SLVM/11. Build success must not be reported as runtime conformance.

13.3 Required corrective actions

  1. Update comparison/tests/run_all_vm_matrix.py to parse the expected result lines without rejecting known diagnostic output. Preserve raw stdout/stderr and fail only on missing, malformed, or incorrect result values or a nonzero process exit.
  2. Correct the Windows MSYS2 package selection in the workflow. Confirm the package name against the selected UCRT64 repository and verify that both the C and C++ compilers are installed before running the comparison suites.
  3. Rerun the complete workflow after those corrections.
  4. Confirm all Premium VM execution checks and admission self-checks actually run and pass; do not infer their status from successful builds.
  5. Confirm the Standard VM registry/Modium checks run. Continue to mark Standard generations 1–10 as registered but not independently bootable unless an executable route is added and tested.
  6. Implement and run the separate controlled performance harness defined in this document. The conformance workflow does not produce the DT-* or MEM-* timing measurements specified in §§3–4.

13.4 Assessment after this CI run

The CI run provides partial correctness/build evidence: Ubuntu and macOS language comparator jobs passed, all Premium VM build targets compiled, and all ten Standard VM registrations were detected. Windows toolchain setup failed. The VM execution matrix did not complete because its Basic Native output parser rejected diagnostic lines after the expected values; consequently, no Premium VM execution result is available from this run.

Performance status remains NOT MEASURED. No throughput, startup, RAM bandwidth, memory latency, allocation-rate, or performance-ranking claim is supported by this CI run.

12. Repository references


Conclusion: SCS-PERF-001 establishes the scope and measurement standard for Basic SLeeLa, Standard generations 1–10, Premium generations 1–11, C11, C++17, and Java 21+. CI run 42337765442 completed with a failure and provides partial build/conformance evidence only; it does not contain measured performance results. Correct the VM output parser and Windows toolchain setup, rerun the matrix, and implement controlled DT-/MEM-suite benchmarking before publishing performance results. Do not promote unbootable Standard layers, unexecuted Premium VMs, or unmeasured targets to PASS.

14. Conformance retry and benchmark-readiness audit — 2026-11-06

Workflow: Complete SLeeLa VM and Language Conformance Action: Re-ran failed jobs using GitHub Actions' failed-job retry. Successful jobs were not rerun. Commit under test: bd7eb049b6158bf129564aea43b58bfeeed993cd Observation: the retry was still running when this record was written. The states below are a live snapshot, not a final workflow conclusion.

14.1 Retry status snapshot

JobRetry state observedConclusion at snapshot
C11 / C++17 / Java 21+ — UbuntuCompletedPASS
C11 / C++17 / Java 21+ — macOSCompletedPASS
C11 / C++17 / Java 21+ — WindowsCompletedFAIL — MSYS2 package unavailable
Basic Native VM + Premium SLVM 1–11Basic Native VM/compiler build in progress; later steps not startedPENDING

The retry confirms the Linux and macOS language-comparator correctness suites again. It does not yet resolve the Windows package-installation issue or establish the Basic/Premium VM execution outcome. The run must be inspected again after the remaining jobs finish; no final overall PASS is claimed here.

14.2 Benchmark implementation audit

The current workflow .github/workflows/complete-vm-conformance.yml performs toolchain installation, correctness-vector execution, VM builds, VM output validation, Premium admission self-checks, and Standard VM manifest checks. It does not execute a timed performance workload.

The inspected comparison runners are correctness-only:

A repository search for benchmark timing, pointer-chase, memory-bandwidth, and operations-per-second implementations found no executable performance harness in the comparison area. Accordingly, no speed or RAM figures can be reported from this CI run. This is an implementation gap, not a zero-speed result and not a failed performance result.

14.3 Measurements required before a performance claim

The next benchmark implementation must execute equivalent, checksum-validated workloads for the Basic Native VM, all eleven runnable Premium VMs, C11, C++17, and Java 21+. Standard generations 1–10 remain layer-accounting targets only until they have a supported bootable execution path.

Measurement groupRequired testsRequired output
Integer typesBoolean; 8/16/32/64-bit signed and unsigned arithmetic; 128-bit support where available; division/remainder; comparisonsns/op, ops/s, checksum, support/representation
Floating pointfloat32 and float64 arithmetic, conversions, comparisonsns/op, ops/s, precision mode, validation tolerance
Control flowdependent and independent loops, branches, function callsns/iteration, iterations/s, calls/s
Arrays and stringssequential/random element access, read/write, string traversal/comparison/constructionelements/s, bytes/s, checksum
Memory bandwidthsequential read, sequential write, copy, read-modify-writebytes/s and GiB/s, bytes transferred
Memory latencyrandomized dependent pointer chase, random read/write, strided accessns/access, accesses/s, stride and working-set size
Cache/working set4 KiB through safely capped large allocationslatency and bandwidth per allocation size; detected cache topology
Allocation/GCallocation/free, array growth, managed allocation and reclamationallocations/s, ns/allocation, peak bytes, GC pauses and reclaimed bytes
Startup and admissioncold process launch, VM admission, artifact load, shutdownseparate phase timings; not mixed with steady-state throughput

Every measured target must record the host CPU and architecture, OS/kernel, RAM capacity, available cache topology, compiler/JDK versions, exact optimization/runtime flags, allocator/GC, workload size, warm-up count, at least five measured repetitions, median/min/max and dispersion, raw samples, checksum, and artifact hash. Java requires warm-up and a separate cold-start measurement. C/C++ must avoid undefined behavior and dead-code elimination. SLeeLa Basic and Premium comparisons must use the same compiled workload artifact where the runtime interface permits it.

14.4 Current performance conclusion

No timing values, rankings, or ratios have been inferred from correctness results or build completion. The next CI change must add a dedicated benchmark workflow and executable benchmark harness; ordinary hosted-runner timings should be labeled informational unless run on controlled, repeatable hardware.

14.5 Retry update — Windows failure confirmed; workflow correction committed

The Windows job subsequently completed with the same setup failure. Its log confirms:

error: target not found: mingw-w64-ucrt-x86_64-gcc-c++

The language-comparison step was skipped, and no Windows comparison result artifacts were produced. This is an environment/package-selection failure, not a C11, C++17, or Java test failure.

A correction was committed to .github/workflows/complete-vm-conformance.yml at commit acf089533b6eeebaea0038ebd557c63ede5d6120: the nonexistent mingw-w64-ucrt-x86_64-gcc-c++ package was removed. The repository's separate Comparison Standards workflow already uses mingw-w64-ucrt-x86_64-gcc as the UCRT64 compiler package for both C and C++, and its Windows comparator job has previously passed. The corrected complete-conformance workflow still requires a fresh successful Windows run before Windows qualification can be claimed.

At the time of this update, the VM job for run 42337765442 remained in the Basic Native VM/compiler build step. Premium builds, VM execution, Premium self-checks, and Standard manifest checks had not yet been reported as completed. No outcome is inferred for those pending steps.

14.6 Completed VM retry — build success; output-validator defect isolated

Workflow: Complete SLeeLa VM and Language Conformance — prior retry VM job: 128300544777 Result: job failed at the VM matrix output-validation step, after all Premium VM builds had completed.

VM stageObserved resultInterpretation
Basic Native VM/compiler buildPASSBuild completed
Premium SLVM 1–11 buildsPASS — 11/11 builtEvery Premium build step completed
Standard VM inventoryPASS — 10/10 registeredInventory reported; execution remains gated
Basic Native VM workloadProgram values present: 42, 15, helloRuntime also emitted memory-manager/security diagnostics
VM matrix validatorFAIL — validator defectIt compared the final three combined-output lines, which were diagnostics rather than program values
Premium VM workload executionNOT RUNThe runner stopped at the Basic Native VM validation failure
Premium admission self-checksSKIPPEDEarlier step failed
Standard VM Modium manifest checkSKIPPEDEarlier step failed

The captured Basic Native VM output contains the three expected program values, followed by legitimate memory-manager statistics and security verification messages. This is not evidence of a VM computation failure. The original runner's lines[-3:] comparison incorrectly treated the final diagnostics as the program result.

Correction committed: comparison/tests/run_all_vm_matrix.py now separates a small, explicit set of known runtime/security diagnostic prefixes from program output, requires the remaining output to match the expected values exactly, and retains recognized diagnostics in the JSON result for audit. It does not silently discard arbitrary output.

Commit: c9753ee51de4e2b9a00cc7dd058b11d915f94ede.

14.7 Windows workflow repair — committed, fresh run required

The complete-conformance workflow's Windows setup now:

Workflow repair commit: d04cfb44e72c14f00f5f545787fe784f34ea778f.

The previous Windows failure belongs to the old workflow revision and therefore does not test this correction. A new run on the corrected commit is required before marking Windows PASS. The new workflow and validator commits are on master; their fresh Actions results must be reviewed before claiming either correction has passed.

14.8 Current measured-performance status

The conformance workflow still has no timed benchmark harness. The VM retry produced build and correctness evidence only. It did not measure arithmetic throughput, data-type latency, memory bandwidth, random RAM-access latency, cache behavior, allocation rate, or GC pause time. All such performance values remain NOT MEASURED. The VM build successes must not be converted into performance claims.

15. Arithmetic speed series — SCS-PERF-ARITH-001

The first executable arithmetic-throughput batch has been added to the comparison workflow.

15.1 Operation and type coverage

Each workload measures the four operators independently: addition (+), subtraction (-), multiplication (*), and division (/). Every case executes 2,000,000 operations per measured sample over a deterministic 4,096-element operand set. Operands are constrained to small, nonzero values so that signed overflow and division by zero are avoided and the same vector can be used across integer widths.

TypeC11C++17Java 21+Representation note
signed 8-bitYesYesYesExact-width C/C++; Java byte arithmetic with narrowing
unsigned 8-bitYesYesYesJava masked emulation
signed 16-bitYesYesYesExact-width C/C++; Java short arithmetic with narrowing
unsigned 16-bitYesYesYesJava masked emulation
signed 32-bitYesYesYesExact-width C/C++; Java int
unsigned 32-bitYesYesYesJava masked emulation
signed 64-bitYesYesYesExact-width C/C++; Java long
unsigned 64-bitYesYesYesJava unsigned division helper; same small positive test domain
signed 128-bitWhere compiler supports __int128Where compiler supports __int128Not primitiveExtension; not a three-way primitive comparison
float32YesYesYesNative float operations
float64YesYesYesNative double operations
BooleanN/AN/AN/AExcluded from arithmetic operators; logical/conditional tests belong in a separate suite

The C and C++ implementations share the same C-compatible workload source, compiled independently in C11 and C++17 modes. The Java implementation uses its own implementation and preserves the fixed-width masks for unsigned narrow types. A cross-language checksum check qualifies that the shared input cases produced matching results before timing rows are accepted.

15.2 Timing protocol

15.3 Scope boundary

This batch measures native C11, C++17, and Java 21+ arithmetic. It does not yet measure SLeeLa VM arithmetic. SLeeLa's core runtime currently exposes int (64-bit), double, and boolean as primitive VM value tags; width-family annotations and the 128-bit path require separate runtime qualification before they can be claimed as equivalent native primitive cases. The Basic Native VM and Premium SLVM 1–11 must receive the same SLeeLa workload through an internal monotonic timer or another measurement boundary that excludes compiler, process-start, and admission costs. Until that is implemented, SLeeLa VM arithmetic speed remains NOT MEASURED.

15.4 Executed reference run

A local reference execution was completed and recorded in Arithmetic Speed Series — Iteration 001. It passed 40/40 shared C11/C++17/Java checksum cases and four additional signed-128-bit cases in C/C++. Five measured samples were collected per case. The full median table and host/toolchain metadata are in that report.

This is a single Linux container reference run (AMD EPYC 9V74 allocation, 3 logical CPUs), not a controlled release benchmark. It establishes that the harness executes and validates its shared vectors; it does not establish a universal performance ranking. The separate GitHub Actions arithmetic job is still pending and will retain its own run-specific JSON artifact.

The SLeeLa Basic Native and Premium VM timing series remains NOT MEASURED. The report explicitly separates this from the native-language reference run.