Bonnie++ Sample Results
First Page
Bonnie++ Sequence Report
This is a Sample Page. The links below do not work, and are provided for illustration only
End of first page
We run Bonnie four times. The first run is the 'base' run with no options.
The second run is done in blocking mode, using the fsync() call after each
write to simulate mail/db server performance.
The third and fourth passes use the -n option to increase the number of files
accessed
Results from base run
Version @version@ ------Sequential Output------ --Sequential Input- --Random-
-Per Chr- --Block-- -Rewrite- -Per Chr- --Block-- --Seeks--
Machine Size K/sec %CP K/sec %CP K/sec %CP K/sec %CP K/sec %CP /sec %CP
stp2-001.pdx.osd 2G 10846 98 56304 43 16170 19 10071 82 44446 18 504.8 2
stp2-001.pdx.osd 2G 10641 97 55830 38 16610 20 10016 82 45483 18 501.4 2
stp2-001.pdx.osd 2G 10681 97 56914 39 17310 20 10037 82 44899 18 507.0 2
------Sequential Create------ --------Random Create--------
-Create-- --Read--- -Delete-- -Create-- --Read--- -Delete--
files:max:min /sec %CP /sec %CP /sec %CP /sec %CP /sec %CP /sec %CP
stp2-001.pdx.osd 16 890 99 +++++ +++ 31419 97 910 99 +++++ +++ 4797 100
stp2-001.pdx.osd 16 993 99 +++++ +++ 32111 99 1002 99 +++++ +++ 4884 99
stp2-001.pdx.osd 16 995 99 +++++ +++ 31554 96 1098 100 +++++ +++ 5381 99
Some intrepretation from the documentation:
- A note on blocking writes
I have recently added a -b option to cause a fsync() after every
write (and a fsync() of the directory after file create or delete). This is
what you probably want to do if testing performance of mail or database
servers as they like to sync everything. The default is to allow write-back
caching in the OS which is what you want if testing performance for copying
files, compiling, etc.
- Waiting for semaphores
There is often a need to test multiple types of IO at the same time. This is
most important for testing RAID arrays where you will almost never see full
performance with only one process active. Bonnie++ 2.0 will address this
issue, but there is also a need for more flexibility than the ability to
create multiple files in the same directory and fork processes to access
them (which is what version 2.0 will do). There is also need to perform tests
such as determining whether access to an NFS server will load the system and
slow down access to a local hard drive.
Christian Kagerhuber contributed the initial code to do semaphores so that
several copies of Bonnie++ can be run in a synchronised fashion. This means
you can have 8 copies of Bonnie++ doing per-char reads to test out your 8CPU
system!
- Summary of tests
The first 6 tests are from the original Bonnie: Specifically, these are the
types of filesystem activity that have been observed to be bottlenecks in
I/O-intensive applications, in particular the text database work done in
connection with the New Oxford English Dictionary Project at the University
of Waterloo.
It initially performs a series of tests on a file (or files) of known size.
By default, that size is 200 Mb (but that's not enough - see below). For
each test, Bonnie reports the number of Kilo-bytes processed per elapsed
second, and the % CPU usage (sum of user and system). If a size >1G is
specified then we will use a number of files of size 1G or less. This way
we can use a 32bit program to test machines with 8G of RAM! NB I have not
yet tested more than 2100M of file storage. If you test with larger storage
then this please send me the results.
The next 6 tests involve file create/stat/unlink to simulate some operations
that are common bottlenecks on large Squid and INN servers, and machines with
tens of thousands of mail files in /var/spool/mail.
In each case, an attempt is made to keep optimizers from noticing it's
all bogus. The idea is to make sure that these are real transfers to/from
user space to the physical disk.
- Test Details
- The file IO tests are:
- Sequential Output
- Per-Character. The file is written using the putc() stdio macro.
The loop that does the writing should be small enough to fit into any
reasonable I-cache. The CPU overhead here is that required to do the
stdio code plus the OS file space allocation.
- Block. The file is created using write(2). The CPU overhead
should be just the OS file space allocation.
- Rewrite. Each BUFSIZ of the file is read with read(2), dirtied, and
rewritten with write(2), requiring an lseek(2). Since no space
allocation is done, and the I/O is well-localized, this should test the
effectiveness of the filesystem cache and the speed of data transfer.
- Sequential Input
- Per-Character. The file is read using the getc() stdio macro. Once
again, the inner loop is small. This should exercise only stdio and
sequential input.
- Block. The file is read using read(2). This should be a very pure
test of sequential input performance.
- Random Seeks
This test runs SeekProcCount processes (default 3) in parallel, doing a total of
8000 lseek()s to locations in the file specified by random() in bsd systems,
drand48() on sysV systems. In each case, the block is read with read(2).
In 10% of cases, it is dirtied and written back with write(2).
The idea behind the SeekProcCount processes is to make sure there's always
a seek queued up.
AXIOM: For any unix filesystem, the effective number of lseek(2) calls
per second declines asymptotically to near 30, once the effect of
caching is defeated.
One thing to note about this is that the number of disks in a RAID set
increases the number of seeks. For read using RAID-1 (mirroring) will
double the number of seeks. For write using RAID-0 will multiply the number
of writes by the number of disks in the RAID-0 set (provided that enough
seek processes exist).
The size of the file has a strong nonlinear effect on the results of
this test. Many Unix systems that have the memory available will make
aggressive efforts to cache the whole thing, and report random I/O rates
in the thousands per second, which is ridiculous. As an extreme
example, an IBM RISC 6000 with 64 Mb of memory reported 3,722 per second
on a 50 Mb file. Some have argued that bypassing the cache is artificial
since the cache is just doing what it's designed to. True, but in any
application that requires rapid random access to file(s) significantly
larger than main memory which is running on a system which is doing
significant other work, the caches will inevitably max out. There is
a hard limit hiding behind the cache which has been observed by the
author to be of significant import in many situations - what we are trying
to do here is measure that number.
-
The file creation tests use file names with 7 digits numbers and a random
number (from 0 to 12) of random alpha-numeric characters.
For the sequential tests the random characters in the file name follow the
number. For the random tests the random characters are first.
The sequential tests involve creating the files in numeric order, then
stat()ing them in readdir() order (IE the order they are stored in the
directory which is very likely to be the same order as which they were
created), and deleting them in the same order.
For the random tests we create the files in an order that will appear
random to the file system (the last 7 characters are in numeric order on
the files). Then we stat() random files (NB this will return very good
results on file systems with sorted directories because not every file
will be stat()ed and the cache will be more effective). After that we
delete all the files in random order.
If a maximum size greater than 0 is specified then when each file is created
it will have a random amount of data written to it. Then when the file is
stat()ed it's data will be read.
- COPYRIGHT NOTICE
(tbray@textuality.com), 1990.
(russell@coker.com.au) 1999.
I have updated the program, added support for >2G on 32bit machines, and
tests for file creation.
Licensed under the GPL version 2.0.
-
DISCLAIMER
This program is provided AS IS with no warranty of any kind, and
The author makes no representation with respect to the adequacy of this
program for any particular purpose or with respect to its adequacy to
produce any particular result, and
The authors shall not be liable for loss or damage arising out of
the use of this program regardless of how sustained, and
In no event shall the author be liable for special, direct, indirect
or consequential damage, loss, costs or fees or expenses of any
nature or kind.
NB The results of running this program on live server machines can include
extremely bad performance of server processes, and excessive consumption of
disk space and/or Inodes which may cause the machine to cease performing it's
designated tasks. Also the benchmark results are likely to be bad.
Do not run this program on live production machines.