Cpipe copies its standard input to its standard output while measuring the time
it takes to read an input buffer and write an output buffer. Statistics of
average throughput and the total amount of bytes copied are printed to the
standard error output.
This integer benchmark solves positions in the game of connect-4,
as played on a vertical 7x6 board. This takes about 10 minutes
on contemporary PCs.
Expedite is meant to be a detailed and comprehensive benchmark
suite for Evas.
Fio is an I/O testing tool that will spawn a number of threads or
processes doing a particular type of I/O action as specified by
the user. Fio can be driven by a 'job file' describing the I/O
load one wants to simulate.
forkbomb is tool for stress testing. It can create many processes
using fork(), bring up some zombies, allocate memory using
realloc() and accesses this memory. It has different switches for
fine-tuning operation. While classic fork() bomb is good only for
fun and QA release testing, running multiple memory-eaters can be
useful for determining maximum memory which can be given to
servers (bind or squid) without taking machine down. You can
test different operation systems with this tool and see how they
are handling the load.
Himeno Benchmark is made by HIMENO, Ryutaro,
for evaluation of performance of the calculation
of incompressible flow analysis. This program solves Poisson equation
by Jacobi's iterative method which have many loops.
HPL is a software package that solves a (random) dense linear system in double
precision (64 bits) arithmetic on distributed-memory computers. It can thus be
regarded as aportable as well as freely available implementation of the High
Performance Computing Linpack Benchmark.
The algorithm used by HPL can be summarized by the following keywords:
Two-dimensional block-cyclic data distribution - Right-looking variant of the
LU factorization with row partial pivoting featuring multiple look-ahead
depths - Recursive panel factorization with pivot search and column broadcast
combined - Various virtual panel broadcast topologies - bandwidth reducing
swap-broadcast algorithm - backward substitution with look-ahead of depth 1.
The HPL package provides a testing and timing program to quantify the accuracy
of the obtained solution as well as the time it took to compute it. The best
performance achievable by this software on your system depends on a large
variety of factors. Nonetheless, with some restrictive assumptions on the
interconnection network, the algorithm described here and its attached
implementation are scalable in the sense that their parallel efficiency is
maintained constant with respect to the per processor memory usage.
This benchmark application is designed to benchmark interactivity in Unix,
originally written by Con Kolivas et al. for Linux.
It is designed to measure the effect of changes in operating system kernel
design or system configuration changes such as CPU, I/O scheduler and file
system changes and options. With careful benchmarking, different hardware
can be compared.
The Benchmark::Forking module changes the behavior of the standard
Benchmark module, running each piece of code to be timed in a separate
forked process. Because each child exits after running its timing loop,
the computations it performs can't propogate back to affect subsequent
test cases.
This can make benchmark comparisons more accurate, because the
separate test cases are mostly isolated from side-effects caused by
the others. Benchmark scripts typically don't depend on those
side-effects, so in most cases you can simply use or require this
module at the top of your existing code without having to change
anything else.
The other benchmark modules provide excellent timing for specific
parts of your code. This module aims to allow you to easily time the
progression of your code.
The stopwatch analogy is that at some point you get a new stopwatch
and start timing. Then you note certain events using lap. Finally you
stop the watch and then print out a summary.
The summary shows all the events in order, what time they occurred at,
how long since the last lap and the percentage of the total time.
Hopefully this will give you a good idea of where your code is
spending most of its time.
The times are all wallclock times in fractional seconds.
That's it.