The following translations of this document are currently available:

Thanks to Vera Djuraskovic <veradjuraskovic@webhostinggeeks.com> for contributing a Serbo-Croatian translation of this document.

Current features allow to test the following system parameters:

The design is very simple. sysbench runs a specified number of threads and they all execute requests in parallel. The actual workload produced by requests depends on the specified test mode. You can limit either the total number of requests or the total time for the benchmark, or both.

Available test modes are implemented by compiled-in modules, and sysbench was designed to make adding new test modes an easy task. Each test mode may have additional (or workload-specific) options.

If you are building sysbench from a Bazaar repository rather than from a release tarball, you should run ./autogen.sh before building.

The following standart procedure will be sufficient to build sysbench in most cases:

	  ./configure
	  make
	  make install
	

The above procedure will try to compile sysbench with MySQL support by default. If you have MySQL headers and libraries in non-standard locations (and no mysql_config can be found in the PATH environmental variable), then you can specify them explicitly with --with-mysql-includes and --with-mysql-libs options to ./configure.

To compile sysbench without MySQL support, use --without-mysql. In this case all database-related test modes will be unavailable.

If you are running on a 64-bit platform, make sure to build a 64-bit binary by passing the proper target platform and compiler options to configure script. You can also consult the INSTALL file for generic installation instructions.

The general syntax for sysbench is as follows:

	  sysbench [common-options] --test=name [test-options] command
	

See Section 2, “General command line options” for a description of common options and documentation for particular test mode for a list of test-specific options.

Below is a brief description of available commands and their purpose:

Also you can use sysbench help to display the brief usage summary and the list of available test modes.

The table below lists the supported common options, their descriptions and default values:

Note that numerical values for all size options (like --thread-stack-size in this table) may be specified by appending the corresponding multiplicative suffix (K for kilobytes, M for megabytes, G for gigabytes and T for terabytes).

The cpu is one of the most simple benchmarks in sysbench. In this mode each request consists in calculation of prime numbers up to a value specified by the --cpu-max-primes option. All calculations are performed using 64-bit integers.

Each thread executes the requests concurrently until either the total number of requests or the total execution time exceed the limits specified with the common command line options.

Example:

	  sysbench --test=cpu --cpu-max-prime=20000 run
	

This test mode was written to benchmark scheduler performance, more specifically the cases when a scheduler has a large number of threads competing for some set of mutexes.

sysbench creates a specified number of threads and a specified number of mutexes. Then each thread starts running the requests consisting of locking the mutex, yielding the CPU, so the thread is placed in the run queue by the scheduler, then unlocking the mutex when the thread is rescheduled back to execution. For each request, the above actions are run several times in a loop, so the more iterations is performed, the more concurrency is placed on each mutex.

The following options are available in this test mode:

Example:

	  sysbench --num-threads=64 --test=threads --thread-yields=100 --thread-locks=2 run
	

This test mode was written to emulate a situation when all threads run concurrently most of the time, acquiring the mutex lock only for a short period of time (incrementing a global variable). So the purpose of this benchmarks is to examine the performance of mutex implementation.

The following options are available in this test mode:

	    $ sysbench --num-threads=16 --test=fileio --file-total-size=3G --file-test-mode=rndrw prepare
	    $ sysbench --num-threads=16 --test=fileio --file-total-size=3G --file-test-mode=rndrw run
	    $ sysbench --num-threads=16 --test=fileio --file-total-size=3G --file-test-mode=rndrw cleanup
	  

This test mode was written to benchmark a real database performance. At the prepare stage the following table is created in the specified database (sbtest by default):

	  CREATE TABLE `sbtest` (
	  `id` int(10) unsigned NOT NULL auto_increment,
	  `k` int(10) unsigned NOT NULL default '0',
	  `c` char(120) NOT NULL default '',
	  `pad` char(60) NOT NULL default '',
	  PRIMARY KEY  (`id`),
	  KEY `k` (`k`);
	

Then this table is filled with a specified number of rows.

The following execution modes are available at the run stage:

Below is a list of options available for the database test mode:

Also, each database driver may provide its own options. Currently only MySQL driver is available. Below is a list of MySQL-specific options:

Example usage:

	  $ sysbench --test=oltp --mysql-table-engine=myisam --oltp-table-size=1000000 --mysql-socket=/tmp/mysql.sock prepare
	  $ sysbench --num-threads=16 --max-requests=100000 --test=oltp --oltp-table-size=1000000 --mysql-socket=/tmp/mysql.sock --oltp-read-only=on run
	

The first command will create a MyISAM table 'sbtest' in a database 'sbtest' on a MySQL server using /tmp/mysql.sock socket, then fill this table with 1M records. The second command will run the actual benchmark with 16 client threads, limiting the total number of request by 100,000.