app/README.md

FOSSBench is ALPHA SOFTWARE, this means that scores reported from it should not be considered perfectly accurate. Across the machines we have tested (roughly 50 at the time of writing this) we have found it to be relatively accurate to what we would expect. This was more of a "for fun" project until someone confirms its validity on a larger scale.

fossbench

fossbench - open source CPU benchmark

Synopsis

make
./dist/fossbench-<os>-<arch> [--verbose] [--no-system-check] [--upload | --noupload]

Description

fossbench measures CPU and memory performance. Its source code and result database are public. Uploaded results provide the comparison data.

Version 0.2 adds a 32-bit integer test and a 12 MiB STREAM triad per thread. It keeps the old 64-bit test as the lower-weight wide integer test and changes the score weights. Version 0.1 and 0.2 scores are not comparable.

Systems

Architecture	Baseline
ARM64	ARMv8-A with NEON
x86-64	x86-64 with SSE2
x86 32-bit	original i386 ISA (scalar fallback)
PowerPC 32-bit, big-endian	scalar fallback with runtime-selected extensions
PowerPC 64-bit, big-endian	PowerPC 970 with AltiVec
PowerPC 32-bit, little-endian	scalar fallback with runtime-selected extensions
PowerPC 64-bit, little-endian	POWER8 with AltiVec/VSX

Linux, macOS, and Windows are supported. The Windows i386 release has a Windows XP (NT 5.1) compatibility baseline. Send a patch if a supported target fails.

Build

GNU Make, a C compiler, and the system math library are required. POSIX builds also require pthreads; Windows builds use native Win32 threads. Uploads use plain HTTP and require no TLS library.

Build for the current machine:

make

The output path is dist/fossbench-<os>-<arch>. Build and run it with:

make bench

The Makefile lists named build targets. Cross builds use standard GNU compiler names. Override them when needed:

make linux-arm64 CC_ARM64=aarch64-linux-gnu-gcc
make linux-ppc32be CC_PPC32BE=powerpc-linux-gnu-gcc
make linux-ppc64le CC_PPC64LE=powerpc64le-linux-gnu-gcc
make linux-ppc32le CC_PPC32LE=powerpc64le-linux-gnu-gcc
make windows-amd64 CC_WINDOWS_AMD64=x86_64-w64-mingw32-gcc

The macOS AMD64 target defaults to macOS 10.5. Set MACOS_AMD64_MIN to change the deployment target.

Run

Run the generated binary:

./dist/fossbench-linux-amd64

Options:

--verbose          print each workload
--no-system-check  skip the startup activity sample
--upload           upload without prompting
--noupload         do not prompt or upload

By default, fossbench samples system activity for ten seconds before a run. It reports background CPU use, available memory, process count, and the OS kernel or build. It does not collect process names or command lines.

Uploads are optional and anonymous. Every successful upload prints a claim code and link that can be used to attach the result to a fossbench.net account:

./dist/fossbench-linux-amd64 --upload

Set another server at compile time:

make CFLAGS='-O2 -Wall -Wextra -DFB_API_BASE_URL=\"http://bench.example.com\"'

Workloads

Workload	Measurement
Integer math	32-bit multiply, divide, shifts, and bit operations
Wide integer	64-bit multiply, divide, shifts, and bit operations
Floating point	scalar double-precision arithmetic
Prime numbers	sieve of Eratosthenes to 2,000,000
Extended instructions	128-bit integer and floating-point vector work
Compression	LZ77 match finding on a generated 4 MiB corpus
Encryption	ChaCha20 on a 1 MiB buffer
Physics	direct-sum gravity for 512 bodies
Sorting	in-place heapsort of one million 32-bit integers
Memory latency	dependent pointer chasing through a cycle larger than cache
Memory bandwidth	STREAM triad with a 12 MiB working set per thread

Scores

Each workload uses a fixed reference rate:

test score = 10000 * measured rate / reference rate

Single-core and multicore totals are weighted geometric means. Both use the same references and weights.

Workload	Weight
Integer math	10%
Wide integer	3%
Floating point	10%
Prime numbers	5%
Extended instructions	16%
Compression	12%
Encryption	8%
Physics	3%
Sorting	8%
Memory latency	10%
Memory bandwidth	15%

The benchmark profile is in src/app/benchmark.c. Changing its reference rates, weights, workload sizes, calibration time, or repeat count makes its scores incompatible with the default build.

Memory latency is shown in nanoseconds per access. Its score uses pointer-chase throughput. Memory placement and background system work affect the result.

Tests

Run the correctness suite:

make test

It checks kernels against C implementations, known answers, or invariants. It covers ChaCha20 RFC 8439, prime counts, sorting, physics momentum, pointer chasing, deterministic output, and concurrent execution. Failure returns a nonzero status.

Files

src/main.c                         option parsing and entry point
src/app/benchmark.c                workloads, timing, scoring, and run flow
src/app/benchmark.h                interface used by main.c
src/app/upload.c                   API payload and network transport
src/kernels/fossbench-arm64.S      ARM64 kernels
src/kernels/fossbench-amd64.S      x86-64 kernels
src/kernels/fossbench-i386.c       portable scalar i386 kernels
src/kernels/fossbench-ppc32be.S    32-bit big-endian PowerPC kernels
src/kernels/fossbench-ppc64be.S    64-bit big-endian PowerPC kernels
src/kernels/fossbench-ppc32le.S    32-bit little-endian PowerPC kernels
src/kernels/fossbench-ppc64le.S    64-bit little-endian PowerPC kernels
src/test_kernels.c                 kernel correctness suite