/**
* @file
*
* @brief Test Program for Evaluating NFS Read Throughput
* @ingroup libfs
*
* This test code allows for evaluating NFS read performance
* under various scenarios:
* - synchronous reads with various buffer sizes (select
* 'num_readers' == 0, see below).
* - pseudo 'read-ahead' using multiple threads that issue
* NFS reads from the same file (but from different offsets)
* in parallel.
* Rationale: each NFS read request is synchronous, i.e., the
* caller sends a request to the server and waits for the
* reply to come back. Performance enhancement can be expected
* by requesting multiple blocks in parallel rather than
* sequentially.
*
* rtems_interval
* nfsTestRead(char *file_name, int chunk_size, int num_readers);
*
* 1) creates 'num_readers' threads, each opening 'file_name' for
* reading on a separate file descriptor.
* 2) creates message queues for communicating with reader threads
*
* 3) read file using nfsTestReadBigbuf() until EOF is reached
*
* 4) releases resources.
*
* RETURNS: Time elapsed during step 3 in ms. This is measured
* using the system clock so make sure the test file
* is big enough.
*
* nfsTestReadBigbuf() synchronously reads a block of
* 'num_readers * chunk_size' (which may be bigger than
* the UDP limit of 8k) using 'num_reader' threads to
* retrieve the various pieces of the big block in parallel.
* This speeds up things since several RPC calls can
* be in the works at once.
*
* NOTES:
* - if 'num_readers' == 0 this corresponds to an 'ordinary'
* NFS read. 'num_readers' == 1 schedules a single reader
* thread (== ordinary NFS read + message passing overhead).
* - no actual processing on the data is done; they are simply
* thrown away. A real, performance-critical application could
* pipeline 'reader' and 'cruncher' threads.
* - read is not completely asynchronous; synchronization is still
* performed at 'big block' boundaries (num_readers * chunk_size).
*/
/*
* Author: Till Straumann <strauman@slac.stanford.edu>, 2006
*
* Authorship
* ----------
* This software (NFS-2 client implementation for RTEMS) was created by
* Till Straumann <strauman@slac.stanford.edu>, 2002-2007,
* Stanford Linear Accelerator Center, Stanford University.
*
* Acknowledgement of sponsorship
* ------------------------------
* The NFS-2 client implementation for RTEMS was produced by
* the Stanford Linear Accelerator Center, Stanford University,
* under Contract DE-AC03-76SFO0515 with the Department of Energy.
*
* Government disclaimer of liability
* ----------------------------------
* Neither the United States nor the United States Department of Energy,
* nor any of their employees, makes any warranty, express or implied, or
* assumes any legal liability or responsibility for the accuracy,
* completeness, or usefulness of any data, apparatus, product, or process
* disclosed, or represents that its use would not infringe privately owned
* rights.
*
* Stanford disclaimer of liability
* --------------------------------
* Stanford University makes no representations or warranties, express or
* implied, nor assumes any liability for the use of this software.
*
* Stanford disclaimer of copyright
* --------------------------------
* Stanford University, owner of the copyright, hereby disclaims its
* copyright and all other rights in this software. Hence, anyone may
* freely use it for any purpose without restriction.
*
* Maintenance of notices
* ----------------------
* In the interest of clarity regarding the origin and status of this
* SLAC software, this and all the preceding Stanford University notices
* are to remain affixed to any copy or derivative of this software made
* or distributed by the recipient and are to be affixed to any copy of
* software made or distributed by the recipient that contains a copy or
* derivative of this software.
*
* ------------------ SLAC Software Notices, Set 4 OTT.002a, 2004 FEB 03
*/
#if HAVE_CONFIG_H
#include "config.h"
#endif
#include <rtems.h>
#include <rtems/error.h>
#include <fcntl.h>
#include <stdlib.h>
#include <stdio.h>
unsigned nfsTestReaderPri = 80;
struct nfsTestReq_ {
unsigned offset; /* file offset */
int size; /* IN: block size to read (must be < 8192), OUT: bytes actually read */
void *buf; /* data buffer address */
};
/* Queue for sending requests to parallel reader tasks */
rtems_id nfsTestRQ = 0;
/* Queue to pickup replies from parallel reader tasks */
rtems_id nfsTestAQ = 0;
/* Reader task; opens its own file descriptor
* and works on requests:
* - obtain request from request queue.
* - lseek to the requested file offset
* - NFS read into buffer
* - queue reply.
*
* Note that this implementation is very simple
* - no full error checking.
* - file is opened/closed by thread
* it's main purpose is running quick tests.
*/
static rtems_task
nfsTestReader(rtems_task_argument arg)
{
int fd = open((char*)arg,O_RDONLY);
unsigned long s;
struct nfsTestReq_ r;
rtems_status_code sc;
if ( fd < 0 ) {
perror("nfsReader: opening file");
goto cleanup;
}
do {
s = sizeof(r);
sc = rtems_message_queue_receive(nfsTestRQ, &r, &s, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if ( RTEMS_SUCCESSFUL != sc ) {
rtems_error(sc, "(Error) reading from message queue");
goto cleanup;
}
if ( !r.buf ) {
/* They send a NULL buffer as a shutdown request */
break;
}
#ifdef DEBUG
printf("Reader: reading offset %u, size %i to %p ... ",
r.offset, r.size, r.buf);
#endif
/* seek to requested offset */
lseek(fd, r.offset, SEEK_SET);
r.size = read(fd, r.buf, r.size);
#ifdef DEBUG
printf("got %i\n",r.size);
#endif
rtems_message_queue_send(nfsTestAQ, &r, sizeof(r));
} while (1) ;
cleanup:
if ( fd >= 0 )
close(fd);
rtems_task_delete(RTEMS_SELF);
}
/* helper to create and start a reader task */
static rtems_id
taskSpawn(char *filenm, int inst)
{
rtems_status_code sc;
rtems_id tid;
sc = rtems_task_create(
rtems_build_name('n','t','t','0'+inst),
nfsTestReaderPri,
1400,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&tid);
if ( RTEMS_SUCCESSFUL != sc ) {
rtems_error(sc,"(Error) Creating nfs reader task %i",inst);
return 0;
}
sc = rtems_task_start(tid, nfsTestReader, (rtems_task_argument)filenm);
if ( RTEMS_SUCCESSFUL != sc ) {
rtems_error(sc,"(Error) Staritng nfs reader task %i",inst);
rtems_task_delete(tid);
return 0;
}
return tid;
}
/*
* Read nrd*sz bytes into 'buf' from file offset 'off'
* using 'nrd' parallel reader tasks to do the job.
* This helper routine schedules 'nrd' requests to
* the reader tasks and waits for all requests to
* finish.
*
* RETURNS: number of bytes read or -1 (error).
*
* CAVEATS:
* - assumes read requests always return 'sz' bytes
* unless the end of file is reached.
* THIS ASSUMPTION SHOULD NOT BE MADE WHEN WRITING
* ANY 'REAL' CODE.
*/
static int
nfsTestReadBigbuf(char *buf, int off, int sz, int nrd)
{
int i,rval=0;
struct nfsTestReq_ r;
r.buf = buf;
r.size = sz;
r.offset = off;
/* send out parallel requests */
for (i=0; i<nrd; i++) {
rtems_message_queue_send(nfsTestRQ, &r, sizeof(r));
r.offset += sz;
r.buf += sz;
}
/* wait for answers */
for (i=0; i<nrd; i++) {
unsigned long s = sizeof(r);
rtems_message_queue_receive(nfsTestAQ, &r, &s, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if ( r.size < 0 ) {
fprintf(stderr,"A reader failed\n");
rval = -1;
} else {
/* FIXME sanity checks:
* - catch case where any-but-last read returns < sz
*/
if ( rval >= 0 ) {
rval += r.size;
}
}
}
return rval;
}
/* Main test routine
*
* Read file 'fname' usint 'nrd' parallel reader tasks,
* each operating on chunks of 'sz' bytes.
*
* RETURNS: time elapsed in milliseconds. This is measured
* using the system clock. Hence, for the result
* to be meaningful, the file must be big enough.
*
*/
rtems_interval
nfsTestRead(char *fnam, int sz, int nrd)
{
int i;
unsigned off;
rtems_interval now=-1, then, tickspsec;
rtems_status_code sc;
int fd=-1;
char *buf=0;
if ( nrd < 0 )
nrd = 0;
if ( sz < 0 || sz > 8192 ) {
fprintf(stderr,"\n");
return -1;
}
nfsTestRQ = nfsTestAQ = 0;
/* Allocate buffer */
if ( ! (buf=malloc(sz*(nrd ? nrd : 1))) ) {
perror("allocating buffer");
goto cleanup;
}
/* Don't bother proceeding if we can't open the file for reading */
if ( (fd=open(fnam,O_RDONLY)) < 0 ) {
perror("opening file");
goto cleanup;
}
if ( nrd ) {
close(fd); fd = -1;
}
/* Create request queue */
if ( nrd ) {
sc = rtems_message_queue_create(
rtems_build_name('n','t','r','q'),
nrd,
sizeof(struct nfsTestReq_),
RTEMS_DEFAULT_ATTRIBUTES,
& nfsTestRQ );
if ( RTEMS_SUCCESSFUL != sc ) {
rtems_error(sc, "(Error) creating request queue");
nfsTestRQ = 0;
goto cleanup;
}
/* Spawn reader tasks */
for ( i=0; i<nrd; i++ ) {
if ( ! taskSpawn(fnam, i) )
goto cleanup;
}
/* Create reply queue */
sc = rtems_message_queue_create(
rtems_build_name('n','t','a','q'),
nrd,
sizeof(struct nfsTestReq_),
RTEMS_DEFAULT_ATTRIBUTES,
& nfsTestAQ );
if ( RTEMS_SUCCESSFUL != sc ) {
rtems_error(sc, "(Error) creating reply queue");
nfsTestAQ = 0;
goto cleanup;
}
}
/* Timed main loop */
then = rtems_clock_get_ticks_since_boot();
if ( nrd ) {
off = 0;
while ((i = nfsTestReadBigbuf(buf, off, sz, nrd)) > 0 ) {
#ifdef DEBUG
printf("bigbuf got %i\n", i);
#endif
off += i;
}
} else {
while ( (i = read(fd, buf, sz)) > 0 )
/* nothing else to do */;
if ( i < 0 ) {
perror("reading");
goto cleanup;
}
}
now = rtems_clock_get_ticks_since_boot();
now = (now-then)*1000;
ticksspec = rtems_clock_get_ticks_per_second();
now /= tickspsec; /* time in ms */
cleanup:
if ( fd >= 0 )
close(fd);
if ( nfsTestRQ ) {
/* request tasks to shutdown by sending NULL buf request */
struct nfsTestReq_ r;
r.buf = 0;
for ( i=0; i<nrd; i++ ) {
rtems_message_queue_send( nfsTestRQ, &r, sizeof(r) );
}
/* cheat: instead of proper synchronization with shutdown we simply
* delay for a second...
*/
rtems_task_wake_after( tickspsec );
rtems_message_queue_delete( nfsTestRQ );
}
if ( nfsTestAQ )
rtems_message_queue_delete( nfsTestAQ );
free(buf);
return now;
}
