rellum.dev/benchmark
Benchmark
Rellum matches C++ on sequential native code and runs independent dataflow bindings in parallel automatically. No threads, locks, pragmas, or task annotations in the Rellum program.
| workload | recursive divide-and-conquer integer computation |
|---|---|
| problem size | 16,777,216 leaves |
| machine | Intel Core i7-11700F, 8 cores, 16 logical processors |
| compiler settings | C++: clang++ -O2. Rellum: opt -O2 + llc -O2. |
Results
| program | time | work items/sec | notes |
|---|---|---|---|
| C++ sequential | 59.9 ms | 560M | explicit recursive function, clang++ -O2 |
| Rellum sequential | 59.7 ms | 562M | same pure recursive function shape, native release build |
| C++ OpenMP recursive tasks | 38.3 ms | 877M | manual task tree with threshold and taskwait |
| C++ OpenMP 8 top-level tasks | 21.8 ms | 1.54B | manual split into eight explicit tasks |
| Rellum graph parallelism | 14.0 ms | 2.40B | eight independent graph bindings, parallelized by the compiler |
Rellum Parallel Version
chunk_size = 2097152
a = work(0, chunk_size)
b = work(chunk_size, chunk_size * 2)
c = work(chunk_size * 2, chunk_size * 3)
d = work(chunk_size * 3, chunk_size * 4)
e = work(chunk_size * 4, chunk_size * 5)
f = work(chunk_size * 5, chunk_size * 6)
g = work(chunk_size * 6, chunk_size * 7)
h = work(chunk_size * 7, chunk_size * 8)
result = a + b + c + d + e + f + g + hThe bindings a through h do not depend on each other. The compiler places them in the same graph layer and emits parallel dispatch for that layer.
What This Means
- Pure Rellum computation has no reactive runtime penalty in this benchmark.
- Parallelism comes from the dataflow graph, not from user-written thread code.
- The output is deterministic because later graph layers wait for earlier independent work to finish.
These are local best-of runs on one workstation. Benchmark numbers are hardware-sensitive; the source lives in the Rellum repository under benchmarks/language_speed.