What is UnixBench?
UNIX bench is a benchmark suite for UNIX systems. The design goal of UNIX bench is to provide a set of basic indicators for UNIX like systems, so there are many projects to test the performance of the system. Each test has a score, and then there is a comprehensive score, which can be easily compared through the score.
UnixBench also contains some very simple 2D and 3D graphics tests.
UnixBench also supports multi CPU system testing. The default behavior is to test twice. The first time is a process test, and the second time is n tests. N is equal to the number of CPUs. This is designed to:
Test the single task performance of the system
Test the multitasking performance of the system
Test the parallel processing ability of the system
UNIX bench is a system based benchmarking tool, not just a CPU memory or disk testing tool. The test results depend not only on the hardware, but also on the system, development library, and even the compiler.
The test focuses on string processing without floating-point operations. This test is used to test linker compilation, code optimization, memory cache, waiting state, integer data type, etc. hardware and software design will greatly affect the test results.
This test item is used to test the efficiency and speed of floating-point operation. This test project includes several typical performance modules of scientific computing, including a large number of C language functions, sin cos sqrt exp and logs, as well as mathematical operations using integers and floating points. Contains array access, conditional branches, and procedure calls.
EXECL throughput (EXECL throughput, here EXECL is a very important function of UNIX like system, not EXECL of office software) test
This test tests the number of EXECL function calls per second. EXECL is a part of the exec function family, which uses new graphics processing to replace the current graphics processing. There are many commands that are very similar to the execve () function command on the front end.
File copy test
This test measures how file data is transferred from one file to another, using a large amount of cache. Including file read, write and copy tests. The test index is the number of characters rewritten, read and copied within a certain time (10 seconds by default).
Pipe throughput test
Pipe is a simple communication between processes. Pipeline throughput test is to test that a process writes 512 bits to a pipeline and reads them back in one second
Number. There is a gap between pipeline throughput test and actual programming.
Pipe based context switching test
This test measures the number of times two processes increase throughput through pipeline switching and integer multiples. Pipeline based context switching is very similar to real programs. The test program generates a sub thread of two-way pipeline communication.
Process creation test
This test measures the number of times a process can produce sub threads and exit immediately. The new process really creates process blocking and memory occupation, so the test program uses memory bandwidth directly. This test is used for a typical large number of operating system process creation operations.
Shell scripts test
Shell script test is used to measure the number of times a process can start and stop shell scripts in one minute. It usually tests the common copies of 1, 2, 3, 4 and 8 shell scripts. Shell scripts are a set of scripts that convert data files.
System call overhead test
This test measures the cost of entering and leaving the system kernel, for example, the cost of system calls. The program simply and repeatedly executes the getpid call (returns the process ID of the call). The indicator of consumption is the execution time of the call entering and leaving the kernel.
It is composed of “ubgears” program to test very coarse 2D and 3D graphics performance, especially the 3D test is very limited. The test results are closely related to the hardware and the appropriate driver of the system.
UNIX bench installation
The code is as follows:
tar xvfz unixbench-5.1.2.tar.gz
If you do not need to test the drawing, comment out this line of the makefile file
The code is as follows:
The code is as follows:
The code is as follows:
# # ## # # # # # # # ## # # # # #
# # # # # # ## ##### ##### # # # # ######
# # # # # # ## # # # # # # # # #
# # # ## # # # # # # # ## # # # #
#### # # # # # ##### ###### # # #### # #
Version 5.1.2 Based on the Byte Magazine Unix Benchmark
Multi-CPU version Version 5 revisions by Ian Smith,
Sunnyvale, CA, USA
December 22, 2007 johantheghost at yahoo period com
1 x Dhrystone 2 using register variables 1 2 3 4 5 6 7 8 9 10
1 x Double-Precision Whetstone 1 2 3 4 5 6 7 8 9 10
1 x Execl Throughput 1 2 3
1 x File Copy 1024 bufsize 2000 maxblocks 1 2 3
1 x File Copy 256 bufsize 500 maxblocks 1 2 3
1 x File Copy 4096 bufsize 8000 maxblocks 1 2 3
1 x Pipe Throughput 1 2 3 4 5 6 7 8 9 10
1 x Pipe-based Context Switching 1 2 3 4 5 6 7 8 9 10
1 x Process Creation 1 2 3
1 x System Call Overhead 1 2 3 4 5 6 7 8 9 10
1 x Shell Scripts (1 concurrent) 1 2 3
1 x Shell Scripts (8 concurrent) 1 2 3
BYTE UNIX Benchmarks (Version 5.1.2)
System: localhost.localdomain: GNU/Linux
OS: GNU/Linux — 3.10.0-123.8.1.el7.x86_64 — #1 SMP Mon Sep 22 19:06:58 UTC 2014
Machine: x86_64 (x86_64)
Language: en_US.utf8 (charmap=”UTF-8″, collate=”UTF-8″)
CPU 0: Intel(R) Xeon(R) CPU X5650 @ 2.67GHz (5331.8 bogomips)
x86-64, MMX, Physical Address Ext, SYSENTER/SYSEXIT, SYSCALL/SYSRET, Intel virtualization
08:24:54 up 1 day, 2:11, 1 user, load average: 0.00, 0.01, 0.05; runlevel 3
Benchmark Run: Wed Nov 12 2014 08:24:54 – 08:52:53
1 CPU in system; running 1 parallel copy of tests
Dhrystone 2 using register variables 28890881.0 lps (10.0 s, 7 samples)
Double-Precision Whetstone 3880.4 MWIPS (9.0 s, 7 samples)
Execl Throughput 4146.3 lps (30.0 s, 2 samples)
File Copy 1024 bufsize 2000 maxblocks 1051084.3 KBps (30.0 s, 2 samples)
File Copy 256 bufsize 500 maxblocks 286552.2 KBps (30.0 s, 2 samples)
File Copy 4096 bufsize 8000 maxblocks 2142638.4 KBps (30.0 s, 2 samples)
Pipe Throughput 1726807.0 lps (10.0 s, 7 samples)
Pipe-based Context Switching 322865.5 lps (10.0 s, 7 samples)
Process Creation 13662.4 lps (30.0 s, 2 samples)
Shell Scripts (1 concurrent) 5955.4 lpm (60.0 s, 2 samples)
Shell Scripts (8 concurrent) 713.1 lpm (60.0 s, 2 samples)
System Call Overhead 2138318.1 lps (10.0 s, 7 samples)
System Benchmarks Index Values BASELINE RESULT INDEX
Dhrystone 2 using register variables 116700.0 28890881.0 2475.7
Double-Precision Whetstone 55.0 3880.4 705.5
Execl Throughput 43.0 4146.3 964.2
File Copy 1024 bufsize 2000 maxblocks 3960.0 1051084.3 2654.3
File Copy 256 bufsize 500 maxblocks 1655.0 286552.2 1731.4
File Copy 4096 bufsize 8000 maxblocks 5800.0 2142638.4 3694.2
Pipe Throughput 12440.0 1726807.0 1388.1
Pipe-based Context Switching 4000.0 322865.5 807.2
Process Creation 126.0 13662.4 1084.3
Shell Scripts (1 concurrent) 42.4 5955.4 1404.6
Shell Scripts (8 concurrent) 6.0 713.1 1188.4
System Call Overhead 15000.0 2138318.1 1425.5
System Benchmarks Index Score 1444.7