SLeeLa Computational Standards
Edition 1.4 | Baseline: SLeeLa Syntax 3.0 | Status: baseline and edge batches passed; arithmetic VM qualification pending CI
Purpose
This directory establishes a common computational vocabulary and repeatable comparison method for SLeeLa, Java/JVM, native C, and native C++. It supports language design, compiler qualification, runtime engineering, interoperability, and performance research.
Documents
- Computational Standards
- Type and Value Mapping
- Memory and Execution Models
- ABI and Interoperability
- Conformance Matrix
- Common Test Vectors
- Running PASS Record 001 — Java/JVM, Native C/C++, and SLeeLa VM
- Numeric and Unicode Edge Vectors
- Running PASS Record 002 — Numeric and Unicode edge-vector iteration
- Array, Bounds, and String Vectors
- Arithmetic Speed Series — Iteration 001 (C11/C++17/Java)\n12. SLeeLa VM Arithmetic Speed — Iteration 001
Architectural principle
One computational specification, multiple implementation environments.
SLeeLa supplies language semantics, compiler, VM, and artifact model. Java supplies Java language and JVM behavior. C and C++ supply native language implementations and platform ABI integration. SLeeLa's own native implementation may use C/C++, but that does not make SLeeLa source semantics identical to either language.
Execution model
SLeeLa source -> Sleelvac -> SLeeLa IR/artifact -> SLeeLa VM Java source -> javac -> class files -> JVM C/C++ source -> native compiler -> object/executable -> processor/OS
Java process delegation, JNI, and an embedded JVM are distinct arrangements. The repository's documented default Java path is external process delegation, not an embedded JVM.
Normative hierarchy
- Applicable SLeeLa syntax specification and version gates.
- SLeeLa VM, artifact, and ABI specifications.
- Java Language Specification and Java Virtual Machine Specification.
- Applicable ISO C and ISO C++ standards.
- Target platform ABI and operating-system contracts.
- This directory's cross-environment comparison and test guidance.
This directory does not override upstream standards.
Evidence vocabulary
Normative, Implemented, Tested, Qualified, Planned, Not applicable, and Unknown have distinct meanings. A source file existing is not proof that a runtime capability works. Every qualification claim must identify its feature, toolchain, platform, test command, and retained result.
Version policy
Record SLeeLa syntax, compiler version, VM artifact ABI, Java/JDK release, C/C++ language modes, compiler versions, target architecture, OS, and optimization settings. Syntax version, VM generation, artifact format, and ABI version are separate numbers.
Qualification levels
SCS-0 Described; SCS-1 Compiles; SCS-2 Executes; SCS-3 Semantic tests pass; SCS-4 ABI/interoperability tests pass; SCS-5 Platform-qualified. A level applies to a feature and toolchain, not to a whole language by implication.
Executable baseline
The initial executable baseline is in tests/:
- tests/native/common_vectors.c: C11 arithmetic, bounded loop, and ASCII output.
- tests/native/common_vectors.cpp: C++17 equivalents.
- tests/java/CommonVectors.java: Java equivalents.
- tests/sleela/common_vectors.sleela: SLeeLa Syntax 3.0 VM equivalents.
- tests/run_native_java.py: compiles and runs C, C++, and Java, then compares their output to the shared expected vector.
- tests/check_sleela_output.py: verifies the final program-output lines separately from SLeeLa runtime diagnostics.
- tests/run_edge_vectors.py: runs fixed-width integer and UTF-8/code-point vectors in C11, C++17, and Java.
- tests/run_array_string_vectors.py: runs checked array access and strict UTF-8 vectors in C11, C++17, and Java.
Run the native/Java parity checks locally with Python 3, a C11 compiler, a C++17 compiler, and JDK 21 (or a compatible JDK):
python3 comparison/tests/run_native_java.py
GitHub Actions workflow: Comparison Standards Conformance. It runs native/Java parity on Ubuntu, macOS, and Windows, and builds/runs the SLeeLa VM vector on Ubuntu. Each job retains its result/output artifact.
Current result: baseline runs 42331591283, 42331589662, and 42331561514 completed successfully. Numeric/Unicode edge run 42332366905 also passed all four jobs. Its Ubuntu, macOS, and Windows jobs each passed seven edge assertions in C11, C++17, and Java 21+; the SLeeLa Syntax 3.0 VM baseline job passed on Ubuntu. The first run 42331126707 exposed a Windows Java launcher issue and a too-strict SLeeLa stdout comparison; both were corrected and verified in the successful reruns.
See RUNNING.PASS.JAVA.001.md for the detailed evidence ledger, platform results, corrective engineering record, artifact names, graphs, and remaining qualification limits.
The first baseline exercises arithmetic, loop accumulation, and ASCII output. Iteration 002 adds signed 32-bit boundaries, defined unsigned wrap, signed division/remainder, UTF-8 byte length, and Unicode code-point counting for C/C++/Java. See RUNNING.PASS.JAVA.002.md: the updated edge-vector workflow completed successfully on all three native/Java platforms. SLeeLa VM coverage for those added edge cases remains unqualified until equivalent VM vectors are implemented and run. It does not yet qualify integer overflow, floating-point edge cases, Unicode indexing, memory ownership, C ABI interoperability, Java process delegation, JNI, concurrency, or performance. Those remain unassessed until executable tests and retained CI results exist.
Iteration 003 — array and string semantics
The next batch is implemented in ARRAY-STRING-BOUNDS-VECTORS.md, with C11, C++17, and Java implementations under tests/. It is wired into the cross-platform workflow and retains comparison-array-string-results.json per OS. The batch remains pending until a completed CI run verifies all ten assertions on Ubuntu, macOS, and Windows. SLeeLa VM parity for these array/string cases is not yet claimed.
Iteration 004 — SLeeLa VM arithmetic throughput
The in-VM arithmetic workload and runner are now committed under tests/sleela/arithmetic_speed.sleela and tests/run_sleela_vm_arithmetic_speed.py. The workflow runs the workload after building the Basic Native VM and Premium SLVM 1–11. It times int and double addition, subtraction, multiplication, and division using timeMonotonicNanos(); startup, build, VM selection, and Premium admission are outside the measured interval. Five samples are collected for each operation on each of the twelve targets. The report and retained CI artifact are pending the first completed execution; no timings are claimed yet. See SLeeLa VM Arithmetic Speed — Iteration 001.