Lucid Language Benchmark Suite¶

This suite empirically evaluates Lucid Native (AOT machine code compilation), CPython 3.14 (Python 3.14.4), and the Lucid Interpreted reference implementation. The benchmarks adapt canonical problems from the Computer Language Benchmarks Game (formerly Debian/Ubuntu Shootout) to measure execution speed, recursion overhead, mutable arrays, dense matrices, gravitational physics simulation, and tree allocation.

Executive Summary¶

• Lucid Native beats Python on 100% of benchmarks, with speedups ranging from 2.3x to 88.5x faster.
• Mathematical Equivalence: 100% exact numerical and output equivalence against CPython 3.14 across all benchmarks.
• Execution Model: Lucid compiles AOT to native machine code via GCC with unboxed primitive registers (int64_t, double, bool), eliminating Python bytecode interpretation loops and dynamic dictionary lookups.

Benchmark Results¶

Geometric Mean Speedup: 13.7x faster than Python 3.14 across the full benchmark suite.

Performance Analysis & Architectural Insights¶

1. Zero Stack-Frame Allocation Overhead¶

In recursive benchmarks such as fibonacci(28) (over 600,000 function calls), CPython creates dynamic PyFrameObject heap structures and Lucid's AST interpreter creates heap-allocated environment hash maps. In contrast, Lucid Native compiles directly to native hardware machine stack frames, keeping intermediate values in CPU registers (%rdi, %rax). This yields a 56x speedup over Python.

2. Unboxed Native Numeric Arithmetic¶

In math-intensive benchmarks (spectral_norm, mandelbrot, matmul), Python boxes every intermediate integer and floating-point value into a heap-allocated PyObject (PyLongObject, PyFloatObject). Lucid Native preserves unboxed 64-bit IEEE 754 doubles and 64-bit integers directly in AVX2/SSE SIMD vector registers, yielding 88x faster execution in spectral_norm and 31x faster in mandelbrot.

3. Fast Contiguous Arrays & Memory Layout¶

In quicksort, sieve, and fannkuch_redux, contiguous in-memory arrays allow single-cycle hardware dereferencing and branch prediction, eliminating Python's list pointer-indirection overhead.

Benchmark Descriptions¶

1. Fibonacci (fibonacci): Recursive calculation of $F_{28} = 317811$. Measures function call dispatch and hardware register preservation.
2. Sieve of Eratosthenes (sieve): Prime sieve calculation up to 100,000 using a mutable boolean array. Tests array index reads and in-place updates.
3. Matrix Multiplication (matmul): Dense $100 \times 100$ matrix product ($O(N^3)$ operations). Tests nested loop execution, 2D subscripting, and floating-point accumulation.
4. Quicksort (quicksort): In-place recursive partitioning of 10,000 pseudo-random numbers. Tests recursive sub-array mutations and element swaps.
5. Spectral Norm (spectral_norm): Computes the eigenvalue of an infinite matrix using the power method. Tests mathematical expression evaluation and vector transformations.
6. Mandelbrot (mandelbrot): Generates a $200 \times 200$ escape-time fractal point set. Tests intensive floating-point arithmetic and while loop branches.
7. Fannkuch-Redux (fannkuch_redux): Permutation generation of 7 elements and counting maximum prefix reversals. Tests list slicing, indexing, and array rotations.
8. N-Body Simulation (nbody): Symplectic numerical integration of 5 celestial bodies over 1,000 time steps. Tests double precision 3D vector physics and energy conservation.
9. Binary Trees (binary_trees): Allocates, traverses, and deallocates binary trees up to depth 10. Tests recursive class instantiation and pointer traversal.
10. FASTA (fasta): Generation of DNA sequences via a Linear Congruential Generator (LCG) and weighted nucleotide lookup. Tests class method calls and cumulative probability scanning.

How to Reproduce¶

# Build the release binary
cargo build --release

# Run the benchmark suite and generate report
python3 benchmarks/run_benchmarks.py