Могу порекомендовать следующее

достаточно простой код для оценки производительности дисков


/*
* Program to do disk reads for performance measurements
* Usage: pfread [-b bufsize] [-n nloops] [-m min] [-M max]
* [-S] [-w] [-v] [-s seed|=seq|file] file
* The three read modes are:
* -s seed --do random reads, seed the generator using seed
* -s =seq --do sequential reads
* -s file --read file to get buffer numbers to read
* The default is random reads with seed of 0.
*
* Sccsid: @(#) .../pfread/pfread.c 1.3 01/09/25
*/


#include <stdio.h>
#include <time.h>
#include <fcntl.h>


int bufsize = 2048; /* read buffer size */
long nloops = 1000; /* number of reads */
long min = 0; /* minimum buffer offset to read */
long max = 51200; /* maximum buffer offset to read */
char *file; /* file to read from */
int verbose; /* if set, print buffer numbers being read */
int sequential; /* if set, do sequential reads */
FILE *sfile; /* if set, file sfile to get buffer numbers */
int seed; /* otherwise use seed to do random reads */
int writing;
int osync = 0;

extern long atol();

void perror_exit(s)
char *s;
{
perror(s);
exit(2);
}

void usage()
{
fprintf(stderr,
"usage: pfread [-b bufsize] [-n nloops] [-m min] [-M max] [-S] [-v] [-s seed|=seq|file] file\n");
exit(1);
}

long scaled_atol(s)
char *s;
{
int sl;
long n;

n = atol(s);
sl = strlen(s);
if (sl)
switch (s[sl-1])
{
case 'b': n *= 512; break;
case 'k': n *= 1024; break;
}

return n;
}

void getargs(argc, argv)
char **argv;
{
extern char *optarg;
extern int optind;
int i;

while ((i = getopt(argc, argv, "b:n:m:M:wSvs:")) != -1)
{
switch (i)
{
case 'h':
case '?':
usage();
break;
case 'b':
bufsize = scaled_atol(optarg);
break;
case 'n':
nloops = atol(optarg);
break;
case 'm':
min = atol(optarg);
break;
case 'M':
max = atol(optarg);
break;
case 'v':
verbose = 1;
break;
case 'w':
writing = 1;
break;
case 'S':
osync = O_SYNC;
break;
case 's':
if (sequential || sfile)
usage();
if (strcmp(optarg, "=seq") == 0)
sequential = 1;
else if (sfile = fopen(optarg, "r"))
;
else
seed = atoi(optarg);
break;
}
}

if (optind != (argc-1))
usage();
file = argv[optind];
}

main(argc, argv)
char **argv;
{
long i, n;
int fd, oflag;
char *buf, *valloc();
time_t start_time, end_time, elapsed_time;

getargs(argc, argv);

oflag = writing ? O_WRONLY : O_RDONLY;
oflag |= osync;

if((fd = open(file, oflag)) < 0)
perror_exit("open");

if ((buf = valloc(bufsize)) == 0)
perror_exit("valloc");

if (!sequential && !sfile)
srand(seed);

n = min;
start_time = time(0);

if(writing)
for(i = 0; i < bufsize; ++i)
buf = 0xA5; /* leave evidence of destruction */

for (i = 0; i < nloops; i++)
{
int nread;

/*
* Do a read or write
*/
if (verbose)
printf("%ld\n", n);

if (lseek(fd, (long) n * bufsize, 0) < 0)
perror_exit("lseek");

if(writing)
nread = write(fd, buf, bufsize);
else
nread = read(fd, buf, bufsize);

if (nread < 0)
perror_exit(writing ? "write" : "read");
if (nread != bufsize)
perror_exit(writing ? "short write" : "short read");

/*
* Determine next buffer to read or write
*/
if (sequential)
{
n = (n+1) % max;
if (n == 0)
n = min;
}
else if (sfile)
{
if (fscanf(sfile, "%d\n", &n) != 1)
break;
}
else
{
n = rand() % max + min;
}
}
end_time = time(0);

elapsed_time = end_time - start_time;
printf("%s\t%d\t%d\t%d seconds\t%d KB/sec\n",
file, bufsize, nloops, elapsed_time,
(int)((double) (nloops * ( bufsize / 1024 )) /
(double) elapsed_time) );

return 0;
}