lean4-htt/tests/bench
2020-08-26 11:34:43 +02:00
..
.gitignore
accumulate_profile.py
arith_eval.ml
binarytrees.ghc-6.hs
binarytrees.lean
binarytrees.lean.args
binarytrees.lean.expected.out
binarytrees.ocaml-2.ml
binarytrees.swift
compile.sh
const_fold.hs
const_fold.lean
const_fold.lean.args
const_fold.lean.expected.out
const_fold.ml
const_fold.sml
const_fold.swift
cross.nix chore: update cross benchsuite 2020-08-21 16:05:40 +02:00
cross.yaml chore: update cross benchsuite 2020-08-21 16:05:40 +02:00
deriv.hs
deriv.lean
deriv.lean.args
deriv.lean.expected.out
deriv.ml
deriv.sml
deriv.swift
disable-st.patch chore: update cross benches 2020-08-18 11:44:29 +02:00
ghc-gc.py
lean-gc.py
Makefile chore: update cross benchsuite 2020-08-21 16:05:40 +02:00
mlkit-gc.py
nixpkgs.nix chore: update cross benches 2020-08-18 11:44:29 +02:00
ocaml-gc.py
parser.lean chore: fix tests 2020-05-26 15:05:00 -07:00
perf.py
qsort.hs
qsort.lean
qsort.lean.args
qsort.lean.expected.out
qsort.ml
qsort.sml
qsort.swift
rbmap.hs
rbmap.lean
rbmap.lean.args
rbmap.lean.expected.out
rbmap.library.lean
rbmap.ml
rbmap.sml
rbmap.swift
rbmap2.lean
rbmap3.lean
rbmap4.lean
rbmap500k.lean
rbmap_checkpoint.hs
rbmap_checkpoint.lean
rbmap_checkpoint.lean.args
rbmap_checkpoint.lean.expected.out
rbmap_checkpoint.ml
rbmap_checkpoint.sml
rbmap_checkpoint.swift
rbmap_checkpoint2.lean
rbmap_checkpoint2.sml
rbmap_checkpoint_cpp_lean3.cpp
rbmap_checkpoint_cpp_std.cpp
rbmap_cpp_lean3.cpp
rbmap_cpp_std.cpp
README.md
report.py
run.sh
speedcenter.exec.velcom.yaml chore: remove hanging stdlib bench test from CI 2020-08-26 11:34:43 +02:00
speedcenter.exec.yaml chore: remove hanging stdlib bench test from CI 2020-08-26 11:34:43 +02:00
speedcenter.yaml
test_single.sh
unionfind.lean chore: { <source> with ... } syntax 2020-05-20 15:08:43 -07:00
unionfind.lean.args
unionfind.lean.expected.out
unionfind_clean.lean

Lean Benchmark Suites

This folder contains multiple small Lean programs for benchmarking used by two separate benchmark suites based on the temci benchmarking tool:

  • The light-weight "Speedcenter" suite benchmarks the current build of Lean. It can be used for quick comparisons on the cmdline and powers the Lean Speedcenter website.
  • The heavy-weight "Cross" suite benchmarks multiple Lean configurations and other functional compilers against each other and generates CSV and HTML reports from that. It was created for the paper "Counting Immutable Beans - Reference Counting Optimized for Purely Functional Programming" (IFL19).

Speedcenter Suite

Requirements:

  • A local Lean build in ../../build/release. Build at least the bin target.
  • temci. Using Nix, open a nix-shell in the project root directory to add a compatible version to your PATH. Alternatively, try pip3 install git+https://github.com/parttimenerd/temci.git.

To execute the suite and save the results in base.yaml, run (in this folder)

temci exec --config speedcenter.yaml --out base.yaml

Other interesting exec flags:

  • use --runs N to modify the default number of 10 runs per benchmark
  • use --included_blocks fast to excluded slow benchmarks like the stdlib benchmark. You can replace fast with any benchmark name or label in speedcenter.exec.yaml.

If you have multiple saved result files, you can compare them with

temci report --config speedcenter.yaml report1.yaml report2.yaml ...

Cross Suite

We recommend using Nix for building/obtaining all Lean variants and used compilers in a reproducible way. After installing Nix, running the benchmarks is as easy as

nix-shell cross.nix --pure --run make

This will record 50 runs for each benchmark configuration (this can be changed with runs in cross.yaml), generate results in report_lean.csv and report_cross.csv, and print them to stdout in a tabulated format. It will also generate HTML reports in report/ comparing the time-based benchmarks.

In order to reduce noise in the benchmarking data, you may instead want to try calling make inside a temci shell:

nix-shell cross.nix --pure --run "temci short shell --sudo --preset usable --cpuset_active make"

Using root powers, this will temporarily configure your machine similarly to the LLVM benchmarking recommendations and move all your other processes to a single CPU core.