kostya / benchmarks

Some benchmarks of different languages

MIT License

2.82k stars 255 forks source link

benchmarks languages

readme

Table of Content

Overview
- Measurements
Test Cases
- Brainfuck
- bench.b
- mandel.b
- Base64
- Json
- Matmul
- Primes
Tests Execution
Contribution

Overview

The benchmarks follow the criteria:

They are written as the average software developer would write them, i.e.
- The algorithms are implemented as cited in public sources;
- The libraries are used as described in the tutorials, documentation and examples;
- The used data structures are idiomatic.
The used algorithms are similar between the languages (as the reference implementations), variants are acceptable if the reference implementation exists.
All final binaries are releases (optimized for performance if possible) as debug performance may vary too much depending on the compiler.

My other benchmarks: jit-benchmarks, crystal-benchmarks-game

Measurements

The measured values are:

time spent for the benchmark execution (loading required data and code self-testing are not measured);
memory consumption of the benchmark process, reported as base + increase, where base is the RSS before the benchmark and increase is the peak increase of the RSS during the benchmark;
energy consumption of the CPU package during the benchmark: PP0 (cores) + PP1 (uncores like GPU) + DRAM. Currently, only Intel CPU are supported via the powercap interface.

All values are presented as: median_{±median absolute deviation}.

UPDATE: 2024-11-13

Test Cases

Brainfuck

Testing brainfuck implementations using two code samples (bench.b and mandel.b). Supports two mode:

Verbose (default). Prints the output immediately.
Quiet (if QUIET environment variable is set). Accumulates the output using Fletcher-16 checksum, and prints it out after the benchmark.

bench.b

Language	Time, s	Memory, MiB	Energy, J
Scala (Staged)	0.425_±0.017	208.26_±02.66 + 36.81_±04.81	27.57_±01.62
Racket (Staged)	0.885_±0.000	105.98_±00.09 + 0.00_±00.00	34.27_±00.03
Rust	1.012_±0.000	2.00_±00.00 + 0.00_±00.00	42.99_±00.30
C++/g++	1.095_±0.002	3.38_±00.00 + 0.00_±00.00	45.08_±00.23
C/gcc	1.111_±0.001	1.50_±00.00 + 0.00_±00.00	46.73_±00.25
D/gdc	1.118_±0.002	6.75_±00.00 + 0.00_±00.00	48.63_±00.23
C/clang	1.138_±0.001	1.38_±00.00 + 0.00_±00.00	48.14_±00.11
C++/clang++	1.166_±0.000	2.88_±00.00 + 0.00_±00.00	49.24_±01.17
D/ldc2	1.167_±0.001	3.12_±00.06 + 0.00_±00.00	49.12_±00.20
Nim/gcc	1.168_±0.001	1.94_±00.06 + 0.00_±00.00	48.20_±00.22
Java	1.188_±0.000	42.25_±00.11 + 0.81_±00.06	48.12_±00.33
V/gcc	1.198_±0.001	2.12_±00.00 + 0.00_±00.00	47.85_±00.12
Vala/gcc	1.210_±0.001	5.38_±00.06 + 0.00_±00.00	50.36_±00.52
Kotlin/JVM	1.227_±0.002	44.92_±00.09 + 0.88_±00.12	51.69_±00.13
Vala/clang	1.234_±0.000	5.31_±00.06 + 0.00_±00.00	52.04_±00.89
Go	1.247_±0.001	3.62_±00.06 + 0.00_±00.00	51.44_±00.38
Zig	1.266_±0.003	1.25_±00.00 + 0.00_±00.00	53.30_±01.05
Go/gccgo	1.288_±0.000	23.88_±00.12 + 0.00_±00.00	54.12_±00.51
C#/.NET Core	1.367_±0.001	32.38_±00.06 + 0.12_±00.00	58.25_±00.89
Julia	1.551_±0.014	248.75_±00.06 + 0.25_±00.00	66.53_±00.84
Nim/clang	1.582_±0.000	2.12_±00.00 + 0.00_±00.00	64.79_±00.92
F#/.NET Core	1.593_±0.002	37.49_±00.06 + 0.38_±00.12	68.98_±01.23
Crystal	1.635_±0.004	3.44_±00.06 + 0.00_±00.00	68.71_±00.54
OCaml	1.657_±0.003	3.25_±00.00 + 2.62_±00.00	76.47_±00.71
Chez Scheme	1.748_±0.002	25.12_±00.00 + 3.38_±00.00	73.58_±00.24
Racket	1.794_±0.027	93.84_±00.05 + 22.75_±00.19	73.46_±01.48
V/clang	1.891_±0.019	2.06_±00.06 + 0.00_±00.00	82.57_±01.03
C#/Mono	2.034_±0.001	25.84_±00.12 + 0.00_±00.00	86.11_±00.25
MLton	2.077_±0.011	1.75_±00.00 + 0.38_±00.00	86.06_±01.09
Scala	2.777_±0.005	62.17_±00.16 + 145.05_±00.32	122.07_±00.64
Node.js	3.150_±0.005	46.78_±00.00 + 6.12_±00.00	131.99_±01.28
Haskell (MArray)	3.236_±0.003	4.12_±00.00 + 4.12_±00.00	134.34_±00.29
D/dmd	3.328_±0.001	3.50_±00.00 + 0.00_±00.00	125.22_±00.34
Haskell (FP)	3.786_±0.003	4.25_±00.06 + 4.00_±00.00	160.86_±00.26
Ruby/truffleruby	4.669_±0.152	201.88_±00.69 + 814.31_±49.81	225.04_±10.28
Swift	5.593_±0.008	17.38_±00.00 + 0.00_±00.00	210.94_±02.31
Lua/luajit	5.687_±0.024	2.62_±00.00 + 0.00_±00.00	234.94_±01.49
Ruby/truffleruby (JVM)	5.884_±0.028	390.44_±02.98 + 468.57_±35.67	289.91_±02.92
Python/pypy	9.575_±0.073	60.50_±00.12 + 29.45_±00.01	426.59_±05.95
Idris	15.559_±0.040	20.63_±00.06 + 8.38_±00.00	700.59_±04.61
Elixir	20.530_±0.047	71.27_±00.45 + 0.00_±00.00	816.30_±01.74
Ruby (--jit)	31.953_±0.050	21.47_±00.07 + 4.88_±00.00	1320.18_±03.40
PHP	34.067_±0.088	18.88_±00.00 + 0.00_±00.00	1442.70_±16.86
Lua	37.027_±0.060	2.62_±00.00 + 0.00_±00.00	1523.51_±15.61
Python	54.076_±0.669	11.88_±00.00 + 0.00_±00.00	2418.75_±26.40
Ruby	71.836_±0.205	11.31_±00.06 + 0.00_±00.00	3123.03_±27.59
Ruby/jruby	79.903_±1.524	203.90_±02.51 + 222.73_±32.77	3573.69_±72.79
Tcl (FP)	193.372_±0.720	4.62_±00.12 + 0.00_±00.00	8541.35_±121.54
Perl	223.395_±1.420	7.06_±00.06 + 0.12_±00.00	9755.30_±45.94
Tcl (OOP)	382.403_±3.408	4.62_±00.12 + 0.12_±00.00	16926.54_±148.14

mandel.b

Mandel in Brainfuck

Language	Time, s	Memory, MiB	Energy, J
Scala (Staged)	7.751_±0.157	211.17_±04.45 + 132.95_±12.75	465.58_±11.30
C++/g++	10.076_±0.018	3.50_±00.00 + 0.62_±00.00	416.16_±01.64
C#/.NET Core	11.991_±0.035	32.56_±00.06 + 1.38_±00.00	481.39_±02.69
Java	12.441_±0.041	42.18_±00.16 + 2.18_±00.07	500.84_±03.37
C/gcc	12.597_±0.005	1.62_±00.00 + 0.25_±00.00	509.44_±01.23
C++/clang++	12.910_±0.015	3.00_±00.00 + 0.62_±00.00	534.77_±00.89
Kotlin/JVM	13.168_±0.070	44.94_±00.06 + 1.94_±00.27	551.88_±02.60
C/clang	13.205_±0.013	1.62_±00.00 + 0.25_±00.00	581.89_±04.42
Zig	13.314_±0.028	1.38_±00.06 + 1.00_±00.00	558.65_±04.76
F#/.NET Core	13.335_±0.024	37.61_±00.06 + 2.12_±00.12	534.94_±02.52
Go	14.113_±0.014	3.62_±00.06 + 0.00_±00.00	568.61_±02.43
Rust	14.242_±0.020	1.88_±00.00 + 0.25_±00.00	569.99_±01.08
D/ldc2	14.272_±0.019	3.25_±00.06 + 0.75_±00.00	584.52_±03.64
V/gcc	14.333_±0.038	2.12_±00.06 + 1.00_±00.00	560.92_±03.16
Vala/gcc	14.436_±0.031	5.38_±00.00 + 0.62_±00.00	572.24_±04.78
Racket (Staged)	14.758_±0.159	105.70_±00.14 + 71.38_±01.87	584.52_±06.50
Vala/clang	14.781_±0.010	5.38_±00.12 + 0.62_±00.00	593.05_±01.04
Crystal	14.942_±0.019	3.50_±00.00 + 0.25_±00.00	631.98_±02.50
Nim/gcc	15.017_±0.014	2.06_±00.06 + 1.50_±00.00	608.83_±01.49
D/gdc	15.433_±0.016	6.75_±00.00 + 0.88_±00.00	642.43_±03.76
Scala	16.477_±0.112	62.29_±00.09 + 144.88_±00.19	717.49_±03.80
Nim/clang	17.695_±0.052	2.38_±00.12 + 1.50_±00.00	719.34_±09.74
Swift	18.038_±0.044	17.62_±00.12 + 0.12_±00.00	740.60_±03.26
V/clang	18.356_±0.084	2.12_±00.06 + 1.00_±00.00	806.70_±06.57
Go/gccgo	18.686_±0.314	24.06_±00.06 + 0.00_±00.00	773.76_±12.67
OCaml	24.514_±0.018	4.38_±00.00 + 3.12_±00.00	1178.94_±06.82
Julia	30.494_±0.068	248.88_±00.00 + 0.25_±00.00	1291.74_±10.50
C#/Mono	31.075_±0.053	25.81_±00.15 + 0.75_±00.00	1320.05_±03.33
Chez Scheme	31.201_±0.191	25.45_±00.00 + 3.12_±00.00	1372.33_±16.13
Lua/luajit	31.900_±0.061	2.50_±00.06 + 0.25_±00.00	1318.65_±02.87
MLton	33.684_±0.058	1.75_±00.00 + 4.27_±00.00	1527.54_±10.09
Node.js	34.372_±0.081	46.80_±00.00 + 8.62_±00.12	1380.19_±03.68
Haskell (MArray)	35.178_±0.039	4.00_±00.06 + 5.12_±00.00	1431.66_±08.02
Racket	35.789_±0.831	93.83_±00.07 + 23.62_±00.12	1591.23_±45.98
D/dmd	37.954_±0.004	3.38_±00.06 + 0.88_±00.00	1390.20_±05.03
Python/pypy	41.239_±0.111	60.38_±00.12 + 30.13_±00.05	1834.39_±16.72
Ruby/truffleruby	48.778_±0.439	201.31_±00.94 + 734.44_±18.06	2375.16_±22.12
Ruby/truffleruby (JVM)	50.823_±2.734	393.21_±05.77 + 405.25_±32.51	2255.45_±41.59
Idris	66.743_±0.120	21.82_±00.00 + 9.25_±00.00	2977.76_±12.58
Haskell (FP)	78.765_±0.269	4.00_±00.00 + 76.00_±00.00	3323.00_±06.05

Base64

Testing base64 encoding/decoding of the large blob into the newly allocated buffers.

Language	Time, s	Memory, MiB	Energy, J
C/clang (aklomp)	0.095_±0.001	2.12_±00.00 + 0.00_±00.00	4.50_±00.05
C/gcc (aklomp)	0.097_±0.000	2.12_±00.00 + 0.00_±00.00	4.56_±00.02
PHP	0.105_±0.000	19.25_±00.00 + 0.00_±00.00	4.93_±00.03
Go (base64x)	0.275_±0.002	6.62_±00.06 + 0.00_±00.00	13.00_±00.06
Node.js	0.663_±0.004	45.19_±00.02 + 40.96_±00.16	29.74_±00.50
Zig	0.703_±0.000	1.75_±00.00 + 0.12_±00.00	26.41_±00.10
Rust	0.875_±0.000	2.38_±00.00 + 0.12_±00.00	36.15_±00.19
C/clang	0.918_±0.000	2.00_±00.00 + 0.12_±00.00	33.80_±00.13
Nim/clang	0.944_±0.002	2.81_±00.06 + 4.94_±00.06	37.54_±00.31
Crystal	1.039_±0.001	3.88_±00.00 + 1.00_±00.00	42.82_±00.44
C/gcc	1.106_±0.001	1.88_±00.00 + 0.12_±00.00	40.27_±00.33
D/ldc2	1.179_±0.001	3.75_±00.00 + 3.38_±00.00	48.73_±00.37
Nim/gcc	1.347_±0.001	2.62_±00.00 + 4.62_±00.00	54.54_±00.35
Java	1.433_±0.002	43.05_±00.10 + 215.12_±03.94	59.06_±00.69
Ruby (--jit)	1.503_±0.002	15.09_±00.06 + 72.88_±00.38	58.96_±00.26
Scala	1.531_±0.002	59.09_±00.11 + 265.94_±05.44	65.30_±00.39
Kotlin/JVM	1.567_±0.003	45.92_±00.12 + 263.50_±05.75	67.15_±00.22
V/gcc	1.630_±0.001	2.62_±00.00 + 2379.12_±01.50	59.57_±00.39
Vala/gcc	1.645_±0.001	5.75_±00.00 + 0.12_±00.00	63.19_±00.43
Vala/clang	1.645_±0.001	5.81_±00.06 + 0.12_±00.00	63.50_±01.04
Go	1.659_±0.005	4.25_±00.00 + 0.00_±00.00	68.14_±00.65
C++/clang++ (libcrypto)	1.705_±0.003	6.06_±00.06 + 0.11_±00.00	68.13_±00.60
C++/g++ (libcrypto)	1.706_±0.004	6.50_±00.00 + 0.12_±00.00	68.03_±00.51
Ruby	1.738_±0.002	11.75_±00.06 + 39.74_±00.39	68.37_±00.46
Perl (MIME::Base64)	2.000_±0.003	14.94_±00.06 + 0.00_±00.00	80.98_±00.50
C#/.NET Core	2.494_±0.039	33.85_±00.03 + 17.63_±01.91	97.82_±01.66
F#/.NET Core	2.580_±0.027	38.48_±00.01 + 19.97_±01.83	98.40_±01.39
Tcl	2.753_±0.005	5.12_±00.00 + 0.12_±00.00	114.23_±00.59
Python	2.872_±0.001	11.62_±00.00 + 0.12_±00.00	112.57_±00.90
Julia	2.983_±0.002	263.48_±00.11 + 28.98_±00.08	120.37_±00.91
Go/gccgo	3.020_±0.005	25.00_±00.12 + 0.00_±00.00	142.55_±00.34
V/clang	3.248_±0.001	2.75_±00.00 + 2388.56_±00.50	119.99_±00.66
Python/pypy	3.249_±0.009	60.25_±00.12 + 31.31_±00.05	143.38_±01.06
Ruby/truffleruby (JVM)	3.443_±0.007	389.16_±05.72 + 294.50_±17.44	173.84_±01.07
Racket	3.903_±0.006	93.95_±00.11 + 25.88_±00.12	155.48_±00.43
D/gdc	3.920_±0.001	7.06_±00.06 + 3.75_±00.06	162.11_±01.78
D/dmd	4.020_±0.002	3.62_±00.00 + 3.38_±00.00	164.62_±00.95
C#/Mono	4.800_±0.010	26.58_±00.20 + 18.86_±00.03	198.99_±01.14
Ruby/jruby	6.210_±0.070	196.29_±01.99 + 144.32_±10.97	273.42_±04.78
Ruby/truffleruby	8.259_±0.038	200.88_±00.50 + 542.00_±02.56	399.78_±03.55
Perl (MIME::Base64::Perl)	10.394_±0.088	16.25_±00.06 + 0.21_±00.03	457.56_±03.07

Json

Testing parsing and simple calculating of values from a big JSON file.

Few notes:

gason mutates input strings;
simdjson requires input strings with batch of trailing zeros: a special zero padding for SIMD instructions;
DAW JSON Link "NoCheck" skips some JSON structure correctness checks;
DAW JSON Link, gason, default (not "Precise") RapidJSON, and D implementations except Mir-based have some inaccuracies in number parsing:

Language	Time, s	Memory, MiB	Energy, J
C++/clang++ (simdjson On-Demand)	0.061_±0.000	112.88_±00.00 + 59.75_±00.00	2.55_±00.01
C++/g++ (simdjson On-Demand)	0.061_±0.000	113.50_±00.00 + 59.75_±00.00	2.56_±00.01
C++/clang++ (DAW JSON Link NoCheck)	0.071_±0.000	112.71_±00.00 + 0.00_±00.00	2.95_±00.03
C++/g++ (DAW JSON Link NoCheck)	0.083_±0.000	113.21_±00.00 + 0.00_±00.00	3.39_±00.02
C++/clang++ (DAW JSON Link)	0.092_±0.000	112.77_±00.06 + 0.00_±00.00	3.84_±00.03
C++/g++ (DAW JSON Link)	0.092_±0.000	113.33_±00.01 + 0.00_±00.00	3.78_±00.04
C++/clang++ (simdjson DOM)	0.103_±0.001	112.81_±00.06 + 174.75_±00.81	4.67_±00.06
C++/g++ (simdjson DOM)	0.105_±0.001	113.38_±00.00 + 172.62_±00.31	4.82_±00.05
Rust (Serde Custom)	0.107_±0.000	111.62_±00.00 + 0.00_±00.00	4.54_±00.03
Rust (Serde Typed)	0.112_±0.000	111.62_±00.00 + 12.12_±00.00	4.73_±00.07
C++/g++ (gason)	0.127_±0.000	113.21_±00.00 + 96.75_±00.00	5.11_±00.06
D/ldc2 (Mir Asdf DOM)	0.132_±0.000	112.88_±00.00 + 61.25_±00.00	5.41_±00.05
C++/clang++ (gason)	0.134_±0.000	112.70_±00.06 + 96.75_±00.00	5.32_±00.03
C++/g++ (RapidJSON)	0.144_±0.002	113.34_±00.06 + 125.54_±01.73	6.15_±00.12
Scala (jsoniter-scala)	0.153_±0.001	279.53_±00.11 + 26.48_±00.73	8.43_±00.17
Go (rjson custom)	0.194_±0.000	113.94_±00.06 + 0.00_±00.00	7.52_±00.02
C++/clang++ (RapidJSON)	0.195_±0.001	112.83_±00.00 + 128.62_±00.00	8.20_±00.03
C++/g++ (RapidJSON Precise)	0.202_±0.001	113.34_±00.00 + 128.75_±00.00	8.61_±00.08
Go (Sonic)	0.204_±0.002	123.62_±00.06 + 0.00_±00.00	8.87_±00.07
D/ldc2 (Mir Amazon's Ion DOM)	0.220_±0.001	112.88_±00.00 + 80.75_±00.00	9.32_±00.03
Go (rjson)	0.221_±0.000	114.00_±00.00 + 0.00_±00.00	8.58_±00.04
Zig	0.225_±0.000	111.12_±00.00 + 39.25_±00.00	9.76_±00.13
Go (goccy/go-json)	0.260_±0.001	114.44_±00.06 + 0.00_±00.00	10.41_±00.16
C++/clang++ (RapidJSON Precise)	0.262_±0.001	112.71_±00.00 + 128.75_±00.00	11.06_±00.14
C++/g++ (RapidJSON SAX)	0.351_±0.001	113.21_±00.00 + 0.00_±00.00	15.53_±00.10
C/clang (yajl)	0.362_±0.001	111.31_±00.06 + 0.00_±00.00	15.71_±00.27
C/gcc (yajl)	0.365_±0.000	111.31_±00.06 + 0.00_±00.00	15.77_±00.10
C++/g++ (Boost.JSON)	0.365_±0.001	113.60_±00.00 + 307.75_±00.00	15.48_±00.06
C++/clang++ (Boost.JSON)	0.375_±0.002	112.96_±00.12 + 307.75_±00.00	16.06_±00.10
Nim/clang (jsony)	0.382_±0.001	112.06_±00.06 + 154.12_±00.00	16.10_±00.29
Nim/gcc (jsony)	0.408_±0.001	111.62_±00.00 + 156.19_±01.75	17.33_±00.14
C++/clang++ (RapidJSON SAX)	0.417_±0.001	195.08_±00.00 + 0.00_±00.00	17.70_±00.04
C++/g++ (RapidJSON SAX Precise)	0.427_±0.000	113.34_±00.00 + 0.12_±00.00	19.06_±00.18
Node.js	0.437_±0.001	155.54_±00.06 + 201.31_±03.75	21.57_±00.11
C++/clang++ (RapidJSON SAX Precise)	0.514_±0.000	195.08_±00.00 + 0.12_±00.00	22.66_±00.11
Go (jsoniter)	0.542_±0.001	114.25_±00.12 + 0.00_±00.00	22.00_±00.31
C#/.NET Core (System.Text.Json)	0.549_±0.002	490.00_±00.08 + 140.62_±00.19	24.45_±00.29
Rust (Serde Untyped)	0.558_±0.001	111.75_±00.00 + 839.88_±00.00	23.69_±00.30
Java (DSL-JSON)	0.571_±0.004	267.72_±00.12 + 288.95_±01.92	30.06_±00.56
Python/pypy	0.614_±0.000	280.79_±00.01 + 125.21_±00.00	26.83_±00.15
V/clang	0.634_±0.001	111.75_±00.12 + 496.00_±00.00	26.49_±00.14
V/gcc	0.634_±0.000	111.81_±00.06 + 496.00_±00.00	26.77_±00.27
Crystal (Pull)	0.634_±0.002	113.44_±00.06 + 18.12_±00.00	27.95_±00.31
Crystal (Schema)	0.647_±0.001	113.38_±00.00 + 50.75_±00.00	28.21_±00.09
Nim/gcc (Packedjson)	0.673_±0.001	112.00_±00.00 + 294.19_±00.06	28.78_±00.44
Nim/clang (Packedjson)	0.675_±0.001	112.38_±00.12 + 294.25_±00.00	29.45_±00.42
CPython (UltraJSON)	0.720_±0.002	123.90_±00.00 + 476.31_±00.88	28.65_±00.08
Perl (Cpanel::JSON::XS)	0.772_±0.006	125.44_±00.06 + 402.88_±00.00	32.07_±00.29
PHP	0.805_±0.002	128.44_±00.06 + 517.88_±00.00	34.83_±00.19
Go	0.825_±0.001	114.00_±00.00 + 0.00_±00.00	34.28_±00.40
Python	0.895_±0.004	121.73_±00.06 + 325.88_±00.00	37.83_±00.56
Crystal	0.947_±0.008	113.50_±00.00 + 392.12_±00.00	41.02_±00.80
Nim/gcc	1.023_±0.002	112.06_±00.06 + 1001.25_±00.00	42.77_±00.18
C#/.NET Core	1.064_±0.004	496.26_±00.18 + 273.00_±00.12	50.88_±00.49
Nim/clang	1.091_±0.002	112.38_±00.00 + 999.00_±00.00	45.69_±00.46
Clojure	1.141_±0.022	411.01_±04.96 + 545.75_±15.06	60.70_±00.83
C++/g++ (json-c)	1.203_±0.002	113.35_±00.00 + 1215.88_±00.00	50.53_±00.81
C++/clang++ (Nlohmann)	1.205_±0.001	112.89_±00.06 + 359.88_±00.00	50.78_±00.19
C++/clang++ (json-c)	1.205_±0.005	112.91_±00.06 + 1215.88_±00.00	50.10_±00.29
Go/gccgo	1.227_±0.002	139.38_±00.06 + 0.00_±00.00	50.43_±00.12
C++/g++ (Nlohmann)	1.274_±0.002	113.40_±00.06 + 447.88_±00.00	53.66_±00.57
Ruby (--jit)	1.330_±0.017	127.03_±00.43 + 213.50_±00.62	56.45_±00.76
Ruby	1.360_±0.004	121.25_±00.00 + 212.75_±00.00	57.49_±00.53
F#/.NET Core (System.Text.Json)	1.498_±0.006	498.96_±00.06 + 231.38_±04.12	68.65_±00.71
D/ldc2	1.742_±0.002	113.25_±00.00 + 708.38_±00.06	73.21_±00.37
Ruby (YAJL)	1.745_±0.005	121.38_±00.12 + 219.06_±00.06	73.96_±00.69
C#/Mono	1.789_±0.010	253.37_±00.07 + 31.54_±00.03	77.28_±00.84
C3	1.962_±0.004	111.88_±00.00 + 795.88_±00.00	81.93_±00.35
Haskell	2.008_±0.005	115.88_±00.00 + 723.56_±00.19	86.20_±00.70
C++/g++ (Boost.PropertyTree)	2.515_±0.009	113.40_±00.06 + 1439.88_±00.00	107.37_±01.05
Rust (jq)	2.597_±0.006	113.50_±00.06 + 903.47_±01.19	108.44_±00.97
C++/clang++ (Boost.PropertyTree)	2.625_±0.007	195.14_±00.06 + 1232.62_±00.00	112.22_±00.99
Odin	2.824_±0.003	111.44_±00.06 + 20.00_±00.00	117.93_±00.75
Ruby/jruby	2.869_±0.026	469.56_±03.09 + 890.16_±23.07	146.96_±02.03
Vala/gcc	3.089_±0.009	115.31_±00.06 + 980.00_±00.00	131.83_±00.56
Vala/clang	3.094_±0.006	115.38_±00.00 + 980.00_±00.00	132.11_±00.59
D/dmd	3.101_±0.003	113.38_±00.00 + 708.56_±00.06	133.40_±01.11
D/gdc	3.493_±0.022	116.62_±00.06 + 708.75_±00.00	148.35_±00.78
Racket	3.819_±0.025	320.69_±00.42 + 225.56_±00.12	159.99_±01.22
Perl (JSON::Tiny)	9.297_±0.067	126.00_±00.00 + 528.69_±00.01	409.51_±01.80
Ruby/truffleruby (JVM)	10.154_±0.186	483.81_±04.05 + 2243.44_±141.72	637.52_±13.44
Ruby/truffleruby	10.192_±0.089	398.88_±02.12 + 1932.31_±17.38	586.73_±04.37

Matmul

Testing allocating and multiplying matrices.

Language	Time, s	Memory, MiB	Energy, J
D/ldc2 (lubeck)	0.042_±0.001	16.19_±02.25 + 48.19_±02.31	4.17_±00.04
Python (NumPy)	0.066_±0.001	39.59_±02.13 + 52.95_±02.12	5.61_±00.04
Nim/gcc (Arraymancer)	0.073_±0.002	10.69_±03.00 + 53.19_±03.06	5.81_±00.10
Java (ND4J)	0.082_±0.001	117.87_±01.02 + 92.62_±00.00	6.38_±00.11
Rust (ndarray)	0.091_±0.001	2.50_±00.00 + 68.48_±00.00	6.18_±00.06
Nim/clang (Arraymancer)	0.112_±0.027	20.44_±02.25 + 44.06_±02.25	7.99_±01.36
Julia (threads: 2)	0.119_±0.000	263.91_±00.08 + 57.19_±00.06	6.62_±00.02
C++/g++ (Eigen)	0.147_±0.000	4.21_±00.00 + 85.54_±00.00	7.23_±00.09
C++/clang++ (Eigen)	0.147_±0.000	4.75_±00.00 + 85.42_±00.00	7.31_±00.03
Julia (threads: 1)	0.170_±0.000	263.98_±00.07 + 56.62_±00.00	7.95_±00.04
V/clang (VSL + CBLAS)	0.274_±0.003	14.31_±02.00 + 44.88_±01.88	19.26_±00.20
V/clang (VSL)	0.274_±0.004	14.38_±02.75 + 44.69_±02.69	18.94_±00.23
V/gcc (VSL + CBLAS)	0.469_±0.006	12.94_±02.44 + 46.31_±02.38	35.29_±00.27
V/gcc (VSL)	0.484_±0.002	13.25_±02.44 + 45.94_±02.25	32.84_±00.15
Julia (no BLAS)	1.110_±0.018	263.50_±00.00 + 51.88_±00.00	48.27_±00.89
D/gdc	1.504_±0.000	7.12_±00.06 + 4.00_±00.00	56.83_±00.29
D/ldc2	1.723_±0.002	3.62_±00.06 + 70.38_±00.00	64.10_±00.41
D/dmd	1.881_±0.002	3.44_±00.06 + 70.38_±00.00	71.95_±00.51
C/gcc	3.034_±0.000	2.00_±00.00 + 68.38_±00.00	112.68_±00.46
V/gcc	3.036_±0.000	2.50_±00.00 + 68.75_±00.00	113.43_±00.28
Vala/clang	3.061_±0.001	5.66_±00.03 + 68.38_±00.00	107.97_±01.66
Rust	3.064_±0.001	2.25_±00.00 + 68.50_±00.00	107.36_±01.14
V/clang	3.064_±0.001	2.88_±00.00 + 68.75_±00.00	106.71_±00.68
C/clang	3.066_±0.000	2.00_±00.00 + 68.38_±00.00	105.48_±00.31
Zig	3.068_±0.002	1.75_±00.00 + 68.62_±00.00	109.29_±00.23
Nim/gcc	3.094_±0.002	2.50_±00.00 + 57.88_±00.00	115.51_±00.14
Java	3.107_±0.006	43.27_±00.10 + 78.61_±00.08	123.58_±00.40
Swift	3.117_±0.001	8.31_±00.06 + 68.62_±00.00	112.98_±00.66
Nim/clang	3.121_±0.001	2.88_±00.12 + 57.88_±00.00	108.74_±00.94
Vala/gcc	3.130_±0.001	5.53_±00.03 + 68.50_±00.00	115.26_±00.63
Go	3.153_±0.000	4.00_±00.12 + 0.00_±00.00	114.91_±00.69
Crystal	3.154_±0.001	4.00_±00.06 + 59.50_±00.00	113.86_±01.39
Go/gccgo	3.160_±0.000	24.38_±00.06 + 0.00_±00.00	112.72_±00.89
Kotlin/JVM	3.197_±0.002	43.74_±00.09 + 78.32_±00.17	124.82_±00.65
Node.js	3.201_±0.001	54.88_±00.13 + 70.75_±00.12	125.28_±00.24
Python/pypy	3.263_±0.002	61.00_±00.00 + 68.75_±00.12	136.35_±00.22
Scala	3.295_±0.004	61.33_±00.10 + 150.06_±00.06	121.09_±00.77
C#/.NET Core	4.890_±0.001	34.75_±00.07 + 68.88_±00.00	199.16_±01.76
C#/Mono	7.394_±0.002	26.13_±00.15 + 69.62_±00.00	307.51_±01.02
Ruby/truffleruby	23.778_±0.432	323.12_±01.06 + 495.12_±08.81	822.87_±11.67
Ruby/truffleruby (JVM)	24.266_±0.702	460.01_±13.73 + 344.48_±85.17	849.21_±19.35
Python	131.064_±0.887	11.94_±00.06 + 68.62_±00.00	6080.98_±50.15
Perl	149.885_±1.491	8.75_±00.12 + 379.62_±00.00	6523.98_±63.31
Ruby (--jit)	153.769_±0.077	21.87_±00.03 + 68.44_±00.06	6836.84_±17.55
Tcl	205.038_±0.931	7.50_±00.00 + 400.25_±00.00	9334.51_±36.78
Ruby	213.180_±0.222	11.62_±00.00 + 69.25_±00.00	9606.45_±45.45
Ruby/jruby	378.246_±8.095	269.65_±12.79 + 1169.97_±99.95	15729.25_±399.84

Primes

Testing:

generating primes using the optimized sieve of Atkin;
prefix search for their decimal numbers using Trie data structure.

Notes:

All languages but V and Python use unordered hashmaps (V and Python don't provide those out of box, and their hashmaps use keys in the insertion order);
The results are always sorted (could be unstable or stable though).

Language	Time, s	Memory, MiB	Energy, J
Zig	0.060_±0.000	1.50_±00.00 + 47.88_±00.25	2.52_±00.02
C++/g++	0.064_±0.001	3.62_±00.12 + 85.86_±00.56	2.50_±00.02
Go	0.072_±0.001	3.56_±00.06 + 0.00_±00.00	3.13_±00.06
C++/clang++	0.075_±0.000	3.12_±00.12 + 64.66_±00.12	2.85_±00.03
V/clang	0.100_±0.000	2.25_±00.00 + 200.38_±00.94	4.15_±00.03
Rust	0.103_±0.000	2.00_±00.00 + 72.98_±00.00	4.05_±00.06
V/gcc	0.105_±0.001	2.12_±00.00 + 215.81_±02.50	4.36_±00.05
Java	0.136_±0.003	41.95_±00.12 + 126.09_±05.43	7.73_±00.17
Crystal	0.142_±0.000	3.44_±00.06 + 89.06_±00.62	5.77_±00.06
Scala	0.193_±0.002	63.27_±00.10 + 147.50_±04.91	11.42_±00.09
Node.js	0.195_±0.000	44.05_±00.00 + 147.14_±00.26	10.22_±00.04
Nim/gcc	0.290_±0.002	1.75_±00.00 + 596.00_±04.81	11.18_±00.16
Nim/clang	0.291_±0.001	2.12_±00.00 + 585.56_±03.38	11.34_±00.10
Lua/luajit	0.305_±0.001	2.56_±00.06 + 157.53_±00.65	12.31_±00.03
Julia	0.419_±0.002	263.62_±00.00 + 216.46_±02.14	15.98_±00.08
Python/pypy	0.636_±0.003	60.00_±00.12 + 248.82_±00.07	26.09_±00.26
Racket	0.751_±0.001	111.73_±00.41 + 246.77_±00.46	29.66_±00.18
Ruby/truffleruby	0.895_±0.009	201.19_±02.19 + 649.06_±40.88	60.60_±00.54
Ruby (--jit)	1.214_±0.003	23.14_±00.06 + 163.74_±00.49	49.45_±00.50
Lua	1.218_±0.004	2.50_±00.00 + 283.91_±00.62	49.71_±00.55
Ruby/truffleruby (JVM)	1.305_±0.052	393.06_±03.76 + 462.28_±33.59	84.79_±03.35
Ruby	1.964_±0.007	11.38_±00.06 + 172.75_±00.31	82.09_±00.37
Ruby/jruby	2.245_±0.083	200.22_±01.74 + 552.07_±44.14	120.12_±05.85
Python	2.275_±0.007	11.62_±00.00 + 172.88_±00.69	98.93_±01.08

Tests Execution

Environment

CPU: Intel(R) Xeon(R) E-2324G

Base Docker image: Debian GNU/Linux trixie/sid

Language	Version
.NET Core	8.0.403
C#/.NET Core	4.11.0-3.24468.6 (b4e5d1dd)
C#/Mono	6.12.0.200
C3	0.6.4
Chez Scheme	10.0.0
Clojure	"1.12.0"
Crystal	1.14.0
D/dmd	v2.109.1
D/gdc	14.2.0
D/ldc2	1.39.0
Elixir	1.14.0
F#/.NET Core	12.8.401.0 for F# 8.0
Go	go1.23.2
Go/gccgo	14.2.0
Haskell	9.8.2
Idris 2	0.6.0
Java	23.0.1
Julia	v"1.11.1"
Kotlin	2.0.21
Lua	5.4.6
Lua/luajit	2.1.1723681758
MLton	20210117
Nim	2.2.0
Node.js	v23.1.0
OCaml	5.2.0
Odin	dev-2024-11-nightly
PHP	8.2.24
Perl	v5.40.0
Python	3.12.6
Python/pypy	7.3.17-final0 for Python 3.10.14
Racket	"8.14"
Ruby	3.3.5p100
Ruby/jruby	9.4.8.0
Ruby/truffleruby	24.1.1
Rust	1.82.0
Scala	3.5.2
Swift	6.0.2
Tcl	8.6
V	0.4.8 2ab1523
Vala	0.56.17
Zig	0.13.0
clang/clang++	19.1.2 (1)
gcc/g++	14.2.0

Using Docker

Build the image:

$ docker build docker/ -t benchmarks

Run the image:

$ docker run -it --rm -v $(pwd):/src benchmarks <cmd>

where <cmd> is:

versions (print installed language versions);
shell (start the shell);
brainfuck bench (build and run Brainfuck bench.b benchmarks);
brainfuck mandel (build and run Brainfuck mandel.b benchmarks);
base64 (build and run Base64 benchmarks);
json (build and run Json benchmarks);
matmul (build and run Matmul benchmarks);
primes (build and run Primes benchmarks);

Please note that the actual measurements provided in the project are taken semi-manually (via shell) as the full update takes days and could have occassional issues in Docker.

There is a ./run.sh that could be used to simplify Docker usage:

./run.sh build (build the image);
./run.sh make versions (run the image with the versions command);
sudo ./run.sh shell (run the image with the `shell' command, sudo is required to read energy levels).

Manual Execution

Makefiles contain recipes for building and executing tests with the proper dependencies. Please use make run (and make run2 where applicable). The measurements are taken using analyze.rb script:

$ cd <test suite>
$ ../analyze.rb make run
$ ../analyze.rb make run[<single test>]

Please note that the measurements could take hours. It uses 10 iterations by default, but it could be changed using ATTEMPTS environment variable:

$ ATTEMPTS=1 ../analyze.rb make run

Prerequisites

Please use Dockerfile as a reference regarding which packages and tools are required.

For all (optional):

Powercap for reading energy counters in Linux (Debian package powercap-utils).

For Python:

NumPy for matmul tests (Debian package python3-numpy).
UltraJSON for JSON tests (Debian package python3-ujson).

For C++:

Boost for JSON tests (Debian package libboost-dev).
JSON-C for JSON tests (Debian package libjson-c-dev).

For Rust:

libjq for jq test (Debian packages libjq-dev, libonig-dev and environment variable JQ_LIB_DIR=/usr/lib/x86_64-linux-gnu/).

For Java, Scala:

Coursier for downloading Maven artifacts.

For Haskell:

network for TCP connectivity between the tests and the test runner.
raw-strings-qq for raw string literals used in tests.

For Perl:

cpanminus for installing modules from CPAN (Debian package cpanminus).

For Vala:

JSON-GLib for JSON tests (Debian package libjson-glib-dev).

Contribution

Please follow the criteria specified in the overview. Besides that please ensure that the communication protocol between a test and the test runner is satisfied:

The test runner listens on localhost:9001;
All messages are sent using TCP sockets closed immediately after the message has been sent;
There are two messages sent from a test (it establishes the measurement boundary):
1. The beginning message having the format name of the test/tprocess ID (the process ID is used to measure the memory consumption). Please note that the name of the test couldn't use Tab character as it's a delimiter;
2. The end message with any content (mostly it's "stop" for consistency).
The test runner could be unavailable (if the test is launched as is) and the test should gracefully handle it.

Makefile guide

Binary executables

If the test is compiled into a single binary, then two sections of the Makefile require changes:

append a new target (the final binary location) into executables variable;
append the proper target rule.

Compiled artifacts

If the test is compiled, but can't be executed directly as a binary, then three sections of the Makefile require changes:

append a new target (the final artifact location) into artifacts variable;
append the proper target rule to compile the test;
append run[<target_artifact>] rule to run the test.

Scripting language

If the test doesn't require compilation, then two sections of the Makefile requires changes:

append run[<script_file>] into all_runners variable;
append run[<script_file>] rule to run the test.

README update

TOC is regenerated using git-markdown-toc:

./run.sh toc