Filesystems
comparison using iozone
Test bed:
Kernel: 2.6.11 with Alex Tomas' patches
RAM: 2 GB
Partition size: 68 GB (sdc1)
processor : 2
vendor_id : GenuineIntel
cpu family : 15
model : 2
model name : Intel(R) Xeon(TM) CPU 2.80GHz
cpu MHz : 2791.359
cache size : 512 KB
bogomips : 5505.02
# hdparm -t /dev/sdc1
/dev/sdc1:
Timing buffered disk reads: 202 MB in 3.02 seconds
= 66.90 MB/sec
IOZONE tests definition (from IOZONE documentation):
Backwards Read (bkwdread):
This test measures the performance of reading a file backwards. This
may seem like a strange way to read a file but in fact there are
applications that do this. MSC Nastran is an example of an application
that reads its files backwards. With MSC Nastran, these files are very
large (Gbytes to Tbytes in size). Although many operating systems have
special features that enable them to read a file forward more rapidly,
there are very few operating systems that detect and enhance the
performance of reading a file backwards.
Fread (fread):
This test measures the performance of reading a file using the library
function fread(). This is a library routine that performs buffered
& blocked read operations. The buffer is within the user s address
space. If an application were to read in very small size transfers then
the buffered & blocked I/O functionality of fread() can enhance the
performance of the application by reducing the number of actual
operating system calls and increasing the size of the transfers when
operating system calls are made.
Freread (freread):
This test is the same as fread above except that in this test the file
that is being read was read in the recent past. This should result in
higher performance as the operating system is likely to have the file
data in cache.
Frewrite (frewrite):
This test measures the performance of writing a file using the library
function fwrite(). This is a library routine that performs buffered
& blocked write operations. The buffer is within the user s address
space. If an application were to write in very small size transfers
then the buffered & blocked I/O functionality of fwrite() can
enhance the performance of the application by reducing the number of
actual operating system calls and increasing the size of the transfers
when operating system calls are made. This test is writing to an
existing file so the performance should be higher as there are no
metadata operations required.
Fwrite (fwrite):
This test measures the performance of writing a file using the library
function fwrite(). This is a library routine that performs buffered
write operations. The buffer is within the user s address space. If an
application were to write in very small size transfers then the
buffered & blocked I/O functionality of fwrite() can enhance the
performance of the application by reducing the number of actual
operating system calls and increasing the size of the transfers when
operating system calls are made. This test is writing a new file so
again the overhead of the metadata is included in the measurement.
Random Read (randread):
This test measures the performance of reading a file with accesses
being made to random locations within the file. The performance of a
system under this type of activity can be impacted by several factors
such as: Size of operating system s cache, number of disks, seek
latencies, and others.
Random Write
(randwrite):
This test measures the performance of writing a file with accesses
being made to random locations within the file. Again the performance
of a system under this type of activity can be impacted by several
factors such as: Size of operating system s cache, number of disks,
seek latencies, and others.
Read (read):
This test measures the performance of reading an existing file.
Record
Rewrite (recrewrite):
This test measures the performance of writing and re-writing a
particular spot within a file. This hot spot can have very interesting
behaviors. If the size of the spot is small enough to fit in the CPU
data cache then the performance is very high. If the size of the spot
is bigger than the CPU data cache but still fits in the TLB then one
gets a different level of performance. If the size of the spot is
larger than the CPU data cache and larger than the TLB but still fits
in the operating system cache then one gets another level of
performance, and if the size of the spot is bigger than the operating
system cache then one gets yet another level of performance.
Re-Read (reread):
This test measures the performance of reading a file that was recently
read. It is normal for the performance to be higher as the operating
system generally maintains a cache of the data for files that were
recently read. This cache can be used to satisfy reads and improves the
performance.
Re-write (rewrite):
This test measures the performance of writing a file that already
exists. When a file is written that already exists the work required is
less as the metadata already exists. It is normal for the rewrite
performance to be higher than the performance of writing a new file.
Strided
Read (strideread):
This test measures the performance of reading a file with a strided
access behavior. An example would be: Read at offset zero for a length
of 4 Kbytes, then seek 200 Kbytes, and then read for a length of 4
Kbytes, then seek 200 Kbytes and so on. Here the pattern is to read 4
Kbytes and then Seek 200 Kbytes and repeat the pattern. This again is a
typical application behavior for applications that have data structures
contained within a file and is accessing a particular region of the
data structure. Most operating systems do not detect this behavior or
implement any techniques to enhance the performance under this type of
access behavior. This access behavior can also sometimes produce
interesting performance anomalies. An example would be if the
application s stride causes a particular disk, in a striped file
system, to become the bottleneck.
Write (write):
This test measures the performance of writing a new file. When a new
file is written not only does the data need to be stored but also the
overhead information for keeping track of where the data is located on
the storage media. This overhead is called the metadata It
consists of the directory information, the space allocation and any
other data associated with a file that is not part of the data
contained in the file. It is normal for the initial write performance
to be lower than the performance of rewriting a file due to this
overhead information.