UnixBench is an open-source tool licensed under GPLv2 that provides fundamental benchmarks for measuring the performance of Unix-like systems.
By running UnixBench, you can obtain essential performance metrics about your system, which can be used for comparison with other systems or as a reference to improve system performance. However, UnixBench is not a comprehensive performance evaluation tool; it offers only basic performance indicators. For a comprehensive assessment of system performance, it’s advisable to combine other tools and tests to gather more comprehensive insights.
|SOPHON SG2042 x1
|Number of cores:
|I:64KB and D:64KB
|64MB System Cache
|Micron 2RX8 32G 3200 RDIMM 4slot
This benchmark is used to measure and compare the performance of computers. The test focuses on string processing because it does not have floating-point arithmetic. It is influenced by a variety of factors, such as hardware and software design, compiler and linker options, code optimization, cache memory, wait state, and integer data types.
Measure the speed and efficiency of floating-point arithmetic. The test contains modules that represent a mix of operations commonly used in scientific applications. It uses many C functions, including floating-point and integer math operations such as sin, cos, sqrt, exp, and log, array access, conditional branching, and procedure calls. This test measures both integer and floating-point arithmetic.
This test measures the number of execl calls that can be executed per second. Execl is part of the exec function family that replaces the current process image with a new process image. It and many other similar commands are frontends to the execve() function。
File Copy Test：
This test measures the rate at which data is transferred from one file to another, using different buffer sizes. The File Read, Write, and Copy test captures the number of characters that can be written, read, and copied in a specified amount of time (10 seconds by default).。
Pipe throughput testing：
Pipes are the simplest form of communication between processes. Pipe throughput is the number of times a process can write 512 bytes per second to the pipe and read it back. Pipeline throughput testing has no real equivalent in real-world programming.
Pipe-based Context Switching tests：
This test measures the number of times two processes can increment integers through pipe exchange. The pipeline-based context switch test is more like a real application. The test program spawns a child process that talks through a two-way pipeline。
Process Creation tests：
This test measures the number of times a process can fork and reap a child process that exits immediately. Process creation refers to actually creating process control blocks and memory allocations for new processes, so memory bandwidth is directly involved. Typically, this benchmark is used to compare implementations of various operating system process creation calls.
Shell Scripts testing：
The Shell Script Test measures the number of times per minute a process can start and retract a set of one, two, four, and eight concurrent copies of shell scripts, which perform a series of transformations on data files.
System Call Overhead test:
Estimate the cost of entering and leaving the operating system kernel, that is, the overhead of performing system calls. It consists of a simple program repeatedly calling getpid (returning the process ID of the calling process) system call. The time required to make such calls is used to estimate the cost of entering and exiting the kernel.
2D and 3D graphics testing are provided; Currently, the 3D suite, in particular, is very limited and contains only “ubgears” programs. These tests are designed to provide an overview of the system’s 2D and 3D graphics performance. Of course, the reported performance depends not only on the hardware, but also on whether the system has the appropriate drivers.
Execute the command test:
According to the provided UnixBench benchmark results, system performance tests were performed in single-core and multi-core situations. In the single-core test, one CPU core was used for testing, while in the multi-core test, all 64 CPU cores were used for parallel testing.
On the whole, the multi-core test clearly shows the advantages of the parallel computing of the system, and the performance indicators have been greatly improved in all aspects. These test results help evaluate the performance of the system under different loads, and provide a reference for optimizing the system configuration and selecting the appropriate hardware. It should be noted that different application scenarios may have different performance requirements, so it is important to consider the indicators of all aspects.
Reprinted From: RISC-V public beta platform release · UnixBench complete testing