Provided by: sysbench_0.4.12-1.1ubuntu1_amd64 bug


       sysbench - A modular, cross-platform and multi-threaded benchmark tool.


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

       sysbench [{-h | --help} | {-v | --version}]


       SysBench is a modular, cross-platform and multi-threaded benchmark tool for evaluating OS
       parameters that are important for a system running a database under intensive load.

       The idea of this benchmark suite is to quickly get an impression about system performance
       without setting up complex database benchmarks or even without installing a database at

       Current features allow to test the following system parameters:

       •   file I/O performance

       •   scheduler performance

       •   memory allocation and transfer speed

       •   POSIX threads implementation performance

       •   database server performance

       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.


           The total number of worker threads to create (defaut: 1)

           Limit for total number of requests. 0 means unlimited (defaut: 10000)

           Limit for total execution time in seconds. 0 (defaut: 0)

           Size of stack for each thread (defaut: 32K)

           Specifies if random numbers generator should be initialized from timer before the test
           start (defaut: off)

           Name of the test mode to run Required

           Print more debug info (default: off)

           Perform validation of test results where possible (default: off)

           Print help on general syntax or on a test mode specified with --test, and exit

           Show version of program.

           SysBench measures execution times for all processed requests to display statistical
           information like minimal, average and maximum execution time. For most benchmarks it
           is also useful to know a request execution time value matching some percentile (e.g.
           95% percentile means we should drop 5% of the most long requests and choose the
           maximal value from the remaining ones).

           This option allows to specify a percentile rank of query execution times to count
           (default: 95)

           Dump current results periodically (default: off - see also the section called “Batch

           Delay between batch dumps in secods (default: 300 - see also the section called “Batch

       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).

   Batch mode
       In some cases it is useful to have not only the final benchmarks statistics, but also
       periodical dumps of current stats to see how they change over the test run. For this
       purpose SysBench has a batch execution mode which is turned on by the --batch option. You
       may specify the delay in seconds between the consequent dumps with the --batch-delay


                 sysbench --batch --batch-delay=5 --test=threads run

       This will run SysBench in a threads test mode, with the current values of minimum,
       average, maximum and percentile for request execution times printed every 5 seconds.

   Test modes
       This section gives a detailed description for each test mode available in SysBench.

           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.


               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

           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:

               Number of lock/yield/unlock loops to execute per each request (default: 1000)

               Number of mutexes to create (default: 8)


               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:

               Number of mutexes. The actual mutex to lock is chosen randomly before each lock
               (default: 4096)

               Possible values: global, local. Specifies whether each thread will use a globally
               allocated memory block, or a local one. (default: global)

               Total size of data to transfer (default: 100G)

               Type of memory operations. Possible values: read, write

           This test mode can be used to produce various kinds of file I/O workloads. At the
           prepare stage SysBench creates a specified number of files with a specified total
           size, then at the run stage, each thread performs specified I/O operations on this set
           of files.

           When the global --validate option is used with the fileio test mode, SysBench performs
           checksums validation on all data read from the disk. On each write operation the block
           is filled with random values, then the checksum is calculated and stored in the block
           along with the offset of this block within a file. On each read operation the block is
           validated by comparing the stored offset with the real offset, and the stored checksum
           with the real calculated checksum.

           The following I/O operations are supported:

               sequential write

               sequential rewrite

               sequential read

               random read

               random write

               combined random read/write

           Also, the following file access modes can be specified, if the underlying platform
           supports them:

           Asynchronous I/O mode
               At the moment only Linux AIO implementation is supported. When running in
               asynchronous mode, SysBench queues a specified number of I/O requests using Linux
               AIO API, then waits for at least one of submitted requests to complete. After that
               a new series of I/O requests is submitted.

           Slow mmap() mode
               In this mode SysBench will use mmap'ed I/O. However, a separate mmap will be used
               for each I/O request due to the limitation of 32-bit architectures (we cannot
               mmap() the whole file, as its size migth possibly exceed the maximum of 2 GB of
               the process address space).

           Fast mmap() mode
               On 64-bit architectures it is possible to mmap() the whole file into the process
               address space, avoiding the limitation of 2 GB on 32-bit platforms.

           Using fdatasync() instead of fsync()
               Flush only data buffers, but not the metadata.

           Additional flags to open(2)
               SysBench can use additional flags to open(2), such as O_SYNC, O_DSYNC and

           Below is a list of test-specific option for the fileio mode:

               Number of files to create (default: 128)

               Block size to use in all I/O operations (default: 16K)

               Total size of files (default: 2G)

               Type of workload to produce. Possible values: seqwr, seqrewr, seqrd, rndrd, rndwr,
               rndwr (see above) required

               I/O mode. Possible values: sync, async, fastmmap, slowmmap (only if supported by
               the platform, see above). (default: sync)

               Number of asynchronous operations to queue per thread (only for
               --file-io-mode=async, see above) (default: 128)

               Additional flags to use with open(2)

               Do fsync() after this number of requests (default: 0 - don't use fsync())

               Do fsync() after each write operationi (default: no)

               Do fsync() at the end of the test (default: yes)

               Which method to use for synchronization. Possible values: fsync, fdatasync
               (default: fsync)

               Merge at most this number of I/O requests if possible (default: 0 - don't merge)

               reads/writes ration for combined random read/write test (default: 1.5)

           Usage example:

                        $ 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

           In the above example the first command creates 128 files with the total size of 3 GB
           in the current directory, the second command runs the actual benchmark and displays
           the results upon completion, and the third one removes the files used for the test.

           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:

               In this mode each thread runs simple queries of the following form:

                    SELECT c FROM sbtest WHERE id=N

               where N takes a random value in range 1..<table size>

           Advanced transactional
               Each thread performs transactions on the test table. If the test table and
               database support transactions (e.g. InnoDB engine in MySQL), then BEGIN/COMMIT
               statements will be used to start/stop a transaction. Otherwise, SysBench will use
               LOCK TABLES/UNLOCK TABLES statements (e.g. for MyISAM engine in MySQL). If some
               rows are deleted in a transaction, the same rows will be inserted within the same
               transaction, so this test mode does not destruct any data in the test table and
               can be run multiple times on the same table.

               Depending on the command line options, each transaction may contain the following

               •   Point queries:

                       SELECT c FROM sbtest WHERE id=N

               •   Range queries:

                       SELECT c FROM sbtest WHERE id BETWEEN N AND M

               •   Range SUM() queries:

                       SELECT SUM(K) FROM sbtest WHERE id BETWEEN N and M

               •   Range ORDER BY queries:

                       SELECT c FROM sbtest WHERE id between N and M ORDER BY c

               •   Range DISTINCT queries:

                       SELECT DISTINCT c FROM sbtest WHERE id BETWEEN N and M ORDER BY c

               •   UPDATEs on index column:

                       UPDATE sbtest SET k=k+1 WHERE id=N

               •   UPDATEs on non-index column:

                       UPDATE sbtest SET c=N WHERE id=M

               •   DELETE queries:

                       DELETE FROM sbtest WHERE id=N

               •   INSERT queries:

                       INSERT INTO sbtest VALUES (...)

               This mode is similar to Simple, but you can also choose the query to run. Note
               that unlike the Advanced transactional mode, this one does not preserve the test
               table between requests, so you should recreate it with the appropriate
               cleanup/prepare commands between consecutive benchmarks.

               Below is a list of possible queries:

               •   Point queries:

                       SELECT pad FROM sbtest WHERE id=N

               •   UPDATEs on index column:

                       UPDATE sbtest SET k=k+1 WHERE id=N

               •   UPDATEs on non-index column:

                       UPDATE sbtest SET c=N WHERE id=M

               •   DELETE queries:

                       DELETE FROM sbtest WHERE id=N

                   The generated row IDs are unique over each test run, so no row is deleted

               •   INSERT queries:

                       INSERT INTO sbtest (k, c, pad) VALUES(N, M, S)

               Execution mode (see above). Possible values: simpe (simple), complex (advanced
               transactional) and nontrx (non-transactional) (default: complex)

               Read-only mode. No UPDATE, DELETE or INSERT queries will be performed. (default:

               Range size for range queries (default: 100)

               Number of point select queries in a single transaction (default: 10)

               Number of simple range queries in a single transaction (default: 1)

               Number of SUM range queries in a single transaction (default: 1)

               Number of ORDER range queries in a single transaction (default: 1)

               Number of DISTINCT range queries in a single transaction (default: 1)

               Number of index UPDATE queries in a single transaction (default: 1)

               Number of non-index UPDATE queries in a single transaction (default: 1)

               Type of queries for non-transactional execution mode (see above). Possible values:
               select, update_key, update_nokey, insert, delete. (default: select)

               Time in microseconds to sleep after each connection to database (default: 10000)

               Minimum time in microseconds to sleep after each request (default: 0)

               Maximum time in microseconds to sleep after each request (default: 0)

               Name of the test table (default: sbtest)

               Number of rows in the test table (default: 10000)

               Distribution of random numbers. Possible values: uniform (uniform distribution),
               gauss (gaussian distribution) and special. (default: special)

               With special distribution a specified percent of numbers is generated in a
               specified percent of cases (see options below).

               Percentage of values to be treated as 'special' (for special distribution)
               (default: 1)

               Percentage of cases when 'special' values are generated (for special distribution)
               (default: 75)

               If the database driver supports Prepared Statements API, SysBench will use
               server-side prepared statements for all queries where possible. Otherwise,
               client-side (or emulated) prepared statements will be used. This option allows to
               force using emulation even when PS API is available. Possible values: disable,
               auto. (default: auto)

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

               MySQL server host. (default: localhost)

               Starting from version 0.4.5 you may specify a list of hosts separated by commas.
               In this case SysBench will distribute connections between specified MySQL hosts on
               a round-robin basis. Note that all connection ports and passwords must be the same
               on all hosts. Also, databases and tables must be prepared explicitely on each host
               before executing the benchmark.

               MySQL server port (in case TCP/IP connection should be used) (default: 3306)

               Unix socket file to communicate with the MySQL server

               MySQL user (default: user)

               MySQL password

               MySQL database name. Note SysBench will not automatically create this database.
               You should create it manually and grant the appropriate privileges to a user which
               will be used to access the test table. (default: sbtest)

               Type of the test table. Possible values: myisam, innodb, heap, ndbcluster, bdb,
               maria, falcon, pbxt (default: innodb)

               Use SSL connections. (default: no)

               MAX_ROWS option for MyISAM tables (required for big tables) (default: 1000000)

               Additional options passed to CREATE TABLE.

           Example usage:

                          $ sysbench --test=oltp --mysql-table-type=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 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.


       Alexey Kopytov <>


       Copyright © 2004-2008 MySQL AB

       This manual page was rewritten for the Debian system (and may be used by others) from the
       manual.xml of the original package.

       Permission is granted to copy, distribute and/or modify this document under the terms of
       the GNU General Public License, Version 2 or (at your option) any later version published
       by the Free Software Foundation.

       On Debian systems, the complete text of the GNU General Public License can be found in