Free linux benchmark suite software for linux

The Open CORBA Benchmarking Suite measures several basic performance aspects of various CORBA brokers.
The suite produces an XML output that can be submitted to a searchable database of broker performance data and browsed in a graphical form. The suite is portable to a number of platforms and brokers.
For C++ brokers
Enter the "C++" directory. Then enter the subdirectory of that directory that corresponds to the broker of your choice. Check the README file there for further instructions, usually you will use "make" to compile the benchmark.
For Java brokers
Enter the "Java" and then the "build" directory. Then enter the subdirectory of that directory that corresponds to the broker of your choice. Check the README file there for further instructions, usually you will use "ant" to compile the benchmark "ant run" to execute the benchmark.
Understanding results
The results do not get printed until the benchmark is finished, which can take from 2 to 4 hours depending on the platform. The best way to view the results is to capture them to a file and view them graphically at http://nenya.ms.mff.cuni.cz/~bench.
Enhancements:
- Support for system information on Linux 2.6 kernels.
- Slight extensions to the documentation.
- Support for some recent brokers on Solaris (VisiBroker 6.0, omniORB 4.0.5, JacORB 2.2.1).
- Support for some recent brokers on Linux (omniORB 4.0.5, JacORB 2.2.1, JDK 1.5.0, TAO 1.4.3).

The Bioinformatics Benchmark System is an attempt to build a reasonable testing framework, tests, and data, to enable end users and vendors to probe the performance of their systems.

What we are trying to do is to create a framework for testing, and a core set of tests that all may download and use to probe specific elements of systems performance.

Moreover, the source to these tests are available under GPL, and are hosted on Bioinformatics.org and Scalable Informatics LLC The idea is to enable end users, consumers, systems developers, and others to easily build and use meaningful tests for measurement and tuning reasons.

Joe Landman from Scalable Informatics LLC conceived the idea and wrote the original codes. We are looking for additional benchmark code suggestions, tests, data sets, etc.

Current baseline tests are several NCBI BLAST runs, several HMMer runs, and a variety of others. We plan to include ClustalW, X!Tandem, various chemistry, dynamics, and related tests, as well as several others.

Tests such as LINPACK or HPL simply do not provide meaningful performance indicators or predictive models for high performance informatics. Unfortunately, nor do a number of more recent and focused tests.

This is a problem as LINPACK and HPL specifically test the performance on various matrix operations, where you have effectively regular memory access patterns, and specific mathematical operations.

These codes are most useful for comparison to codes with heavy floating point operations, and interleaved memory traffic. These codes were not designed for comprehensive systems benchmarking, where disk I/O, memory latency, and other factors all contribute to the performance issues.

The best tests are the ones that are most similar to the codes you will run on the machine. The tests themselves should be reasonable approximations to a real execution of your code, using real data. You may need to pare it back in order to get realistic run times.

You should have a reasonable subset of data sizes. A single test does not tell you how your system scales, and one of the reasons for the existance of this test is specifically to allow you to test the performance while you increase various aspects of the workload.

You rarely get a quiescent system in a cluster, so we would recommend that you try to run in as realistic an operating environment as possible. A baseline in a quiescent system is fine, but it may set your expectations unreasonably.
top

Linux Commander is a powerful file manager for the X Window System.

It is partially modelled after Window Commander for Windows.

Cache::Benchmark is a Perl module that tests the quality and speed of a cache module to compare cachemodules and algorithms.

SYNOPSIS

use Cache::Benchmark();
use Cache::MemoryCache();
use Cache::SizeAwareMemoryCache();

my $cache_1 = new Cache::MemoryCache({
namespace => my,
default_expires_in => 1,
});
my $cache_2 = new Cache::SizeAwareMemoryCache({
namespace => my,
default_expires_in => 1,
max_size => 400,
});

my $test = new Cache::Benchmark();
$test->init( access_counter => 10_000 );

$test->run($cache_1);
print $test->get_printable_result();

$test->run($cache_2);
print $test->get_printable_result();

Interbench is benchmark application is designed to benchmark interactivity in Linux.
Interbench is designed to measure the effect of changes in Linux kernel design or system configuration changes such as I/O scheduler, cpu and filesystem changes and options. With careful benchmarking, different hardware can be compared.
What does it do?
It is designed to emulate the cpu scheduling behaviour of interactive tasks and measure their scheduling latency and jitter. It does this with the tasks on their own and then in the presence of various background loads, both with configurable nice levels and the benchmarked tasks can be real time.
How does it work?
First it benchmarks how best to reproduce a fixed percentage of cpu usage on the machine currently being used for the benchmark. It saves this to a file and then uses this for all subsequent runs to keep the emulation of cpu usage constant.
It runs a real time high priority timing thread that wakes up the thread or threads of the simulated interactive tasks and then measures the latency in the time taken to schedule. As there is no accurate timer driven scheduling in linux the timing thread sleeps as accurately as linux kernel supports, and latency is considered as the time from this sleep till the simulated task gets scheduled.
Each benchmarked simulation runs as a separate process with its own threads, and the background load (if any) also runs as a separate process.
Enhancements:
- This release adds options to select benchmarked loads, manpages, and documentation updates.

The benchmark program takes less than 10 minutes to run (on most machines) and compares the system it is run on to two benchmark systems (a Dell Pentium 90 with 256 KB cache running MSDOS and an AMD K6/233 with 512 KB cache running Linux).

The archive contains the complete source, documentation, and a binary (Linux elf). The source has been successfully compiled on various operating systems, including SunOS, DEC Unix 4.0, DEC OSF1, HP-UX, DEC Ultrix, MS-DOS, and of course Linux.

This release is based on the Unix port of beta release 2 of BYTE Magazines BYTEmark benchmark program (previously known as BYTEs Native Mode Benchmarks). The port to Linux/Unix was done by Uwe F. Mayer.

Additional changes to the code were made to make the code work with egcs compiler and to make the software packagable. This is a CPU benchmark providing indexes for integer, floating, and memory performance. It is single-threaded and is not designed to measure the performance gain on multi-processor machines.

Running a "make" will create the binary if all goes well. It is called "nbench" and performs a suite of 10 tests and compares the results to a Dell Pentium 90 with 16 MB RAM and 256 KB L2 cache running MSDOS and compiling with the Watcom 10.0 C/C++ compiler.

If you define -DLINUX during compilation (the default) then you also get a comparison to an AMD K6/233 with 32 MB RAM and 512 KB L2-cache running Linux 2.0.32 and using a binary which was compiled with GNU gcc version 2.7.2.3 and GNU libc-5.4.38.

The algorithms were not changed from the source which was obtained from the BYTE web site at http://www.byte.com/bmark/bmark.htm on December 14, 1996. However, the source was modified to better work with 64-bit machines (in particular the random number generator was modified to always work with 32 bit, no matter what kind of hardware you run it on).

Furthermore, for some of the algorithms additional resettings of the data was added to increase the consistency across different hardware. Some extra debugging code was added, which has no impact on normal runs.

In case there is uneven system load due to other processes while this benchmark suite executes, it might take longer to run than on an unloaded system.

This is because the benchmark does some statistical analysis to make sure that the reported results are statistically significant, and an increased variation in individual runs requires more runs to achieve the required statistical confidence.

This is a single-threaded benchmark and is not designed to measure the performance gain on multi-processor machines.

Linux DC++ is a project to port the DC++ direct connect client to Linux or any POSIX-compliant Unix.