What is this useful for?

Imagine you are interested in buying/upgrading some SoC/NAS/Barebone/HTPC/Mini PC and you don't know which option would be the more suitable based on your requirements. This table seeks helping you decide on this topic. If you own/ed some listed machine, maybe you can make a better decission at the time of acquiring a new one by comparing test results.

Want to contribute?

1. Download Unixbench from here. You can also use this direct link to the file or this local copy (may be outdated).
2. Extract files and run:
./Run -c `cat /proc/cpuinfo | grep processor | wc -l` (this is the fast way; otherwise just launch ./Run)
3. Wait for the script to end and output result. Take a coffe meanwhile :)
4. Once finished, send me an e-mail (to jors*at*enchufado*dot*com) with the following:
• Hardware brand/model (the output of dmidecode would be great!). Specify also brand and model of HDD/SDD.
• Product URL (if any).
• Operating System and version.
• Full Unixbench results.

Notes

• On systems with multiple cores, the results published will be the 'full core' ones.
• On DIY systems (the ones assembled by the user), the "Hardware" field will show the CPU, RAM, Motherboard and storage used.
• Ideally, tests should be done with no extra/production load other than the one generated by the benchmark.

Test summary

Dhrystone (Dhry.)

Focuses on string handling, as there are no floating point operations. It is heavily influenced by hardware and software design, compiler and linker options, code optimization, cache memory, wait states, and integer data types.

Whetstone (D-P Whet.)

Measures the speed and efficiency of floating-point operations. This test contains several modules that are meant to represent a mix of operations typically performed in scientific applications. A wide variety of C functions including sin, cos, sqrt, exp, and log are used as well as integer and floating-point math operations, array accesses, conditional branches, and procedure calls. This test measure both integer and floating-point arithmetic.

Execl Throughput (Execl thr.)

Measures the number of execl calls that can be performed per second. Execl is part of the exec family of functions that replaces the current process image with a new process image. It and many other similar commands are front ends for the function execve().

File Copy (FC1024 2000 maxblck, FC256 500 maxblck, FC4096 8000 maxblck)

Measures the rate at which data can be transferred from one file to another, using various buffer sizes. The file read, write and copy tests capture the number of characters that can be written, read and copied in a specified time (default is 10 seconds).

Pipe Throughput (Pipe thr.)

A pipe is the simplest form of communication between processes. Pipe throughtput is the number of times (per second) a process can write 512 bytes to a pipe and read them back. The pipe throughput test has no real counterpart in real-world programming.

Pipe-based Context Switching (Pipe based C/S)

Measures the number of times two processes can exchange an increasing integer through a pipe. The pipe-based context switching test is more like a real-world application. The test program spawns a child process with which it carries on a bi-directional pipe conversation.

Process Creationi (Ps creat.)

Measures the number of times a process can fork and reap a child that immediately exits. Process creation refers to actually creating process control blocks and memory allocations for new processes, so this applies directly to memory bandwidth. Typically, this benchmark would be used to compare various implementations of operating system process creation calls.

Shell Scripts (Shell 1conc., Shell 8conc.)

Measures the number of times per minute a process can start and reap a set of one, two, four and eight concurrent copies of a shell scripts where the shell script applies a series of transofrmation to a data file.

System Call Overhead (S/C Ovrhd.)

Estimates the cost of entering and leaving the operating system kernel, i.e. the overhead for performing a system call. It consists of a simple program repeatedly calling the getpid (which returns the process id of the calling process) system call. The time to execute such calls is used to estimate the cost of entering and exiting the kernel.