使用异步 I/O 大大提高应用程序的性能

aio_read

aio_error

aio_return

aio_write

aio_suspend

aio_cancel

lio_listio

struct aiocb {

int aio_fildes;               // File Descriptor

int aio_lio_opcode;           // Valid only for lio_listio (r/w/nop)

volatile void *aio_buf;       // Data Buffer

size_t aio_nbytes;            // Number of Bytes in Data Buffer

struct sigevent aio_sigevent; // Notification Structure

/* Internal fields */

...

};

int aio_read
( struct aiocb *aiocbp );

#include <aio.h>

...

int fd, ret;

struct aiocb my_aiocb;

fd = open( "file.txt", O_RDONLY );

if (fd < 0) perror("open");

/* Zero out the aiocb structure (recommended) */

bzero( (char *)&my_aiocb, sizeof(struct aiocb) );

/* Allocate a data buffer for the aiocb request */

my_aiocb.aio_buf = malloc(BUFSIZE+1);

if (!my_aiocb.aio_buf) perror("malloc");

/* Initialize the necessary fields in the aiocb */

my_aiocb.aio_fildes = fd;

my_aiocb.aio_nbytes = BUFSIZE;

my_aiocb.aio_offset = 0;

ret = aio_read
( &my_aiocb );

if (ret < 0) perror("aio_read");

while ( aio_error
( &my_aiocb ) == EINPROGRESS ) ;

if ((ret = aio_return( &my_iocb )) > 0) {

/* got ret bytes on the read */

} else {

/* read failed, consult errno */

}

int aio_error
( struct aiocb *aiocbp );

ssize_t aio_return
( struct aiocb *aiocbp );

int aio_write
( struct aiocb *aiocbp );

int aio_suspend
( const struct aiocb *const cblist[],

int n, const struct timespec *timeout );

struct aioct *cblist[MAX_LIST]

/* Clear the list. */

bzero( (char *)cblist, sizeof(cblist) );

/* Load one or more references into the list */

cblist[0] = &my_aiocb;

ret = aio_read
( &my_aiocb );

ret = aio_suspend
( cblist, MAX_LIST, NULL );

int aio_cancel
( int fd, struct aiocb *aiocbp );

int lio_listio
( int mode, struct aiocb *list[], int nent,

struct sigevent *sig );

struct aiocb aiocb1, aiocb2;

struct aiocb *list[MAX_LIST];

...

/* Prepare the first aiocb */

aiocb1.aio_fildes = fd;

aiocb1.aio_buf = malloc( BUFSIZE+1 );

aiocb1.aio_nbytes = BUFSIZE;

aiocb1.aio_offset = next_offset;

aiocb1.aio_lio_opcode = LIO_READ;

...

bzero( (char *)list, sizeof(list) );

list[0] = &aiocb1;

list[1] = &aiocb2;

ret = lio_listio
( LIO_WAIT, list, MAX_LIST, NULL );

void setup_io( ... )

{

int fd;

struct sigaction sig_act;

struct aiocb my_aiocb;

...

/* Set up the signal handler */

sigemptyset(&sig_act.sa_mask);

sig_act.sa_flags = SA_SIGINFO;

sig_act.sa_sigaction = aio_completion_handler;

/* Set up the AIO request */

bzero( (char *)&my_aiocb, sizeof(struct aiocb) );

my_aiocb.aio_fildes = fd;

my_aiocb.aio_buf = malloc(BUF_SIZE+1);

my_aiocb.aio_nbytes = BUF_SIZE;

my_aiocb.aio_offset = next_offset;

/* Link the AIO request with the Signal Handler */

my_aiocb.aio_sigevent.sigev_notify = SIGEV_SIGNAL;

my_aiocb.aio_sigevent.sigev_signo = SIGIO;

my_aiocb.aio_sigevent.sigev_value.sival_ptr = &my_aiocb;

/* Map the Signal to the Signal Handler */

ret = sigaction( SIGIO, &sig_act, NULL );

...

ret = aio_read
( &my_aiocb );

}

void aio_completion_handler( int signo, siginfo_t *info, void *context )

{

struct aiocb *req;

/* Ensure it's our signal */

if (info->si_signo == SIGIO) {

req = (struct aiocb *)info->si_value.sival_ptr;

/* Did the request complete? */

if (aio_error
( req ) == 0) {

/* Request completed successfully, get the return status */

ret = aio_return
( req );

}

}

return;

}

void setup_io( ... )

{

int fd;

struct aiocb my_aiocb;

...

/* Set up the AIO request */

bzero( (char *)&my_aiocb, sizeof(struct aiocb) );

my_aiocb.aio_fildes = fd;

my_aiocb.aio_buf = malloc(BUF_SIZE+1);

my_aiocb.aio_nbytes = BUF_SIZE;

my_aiocb.aio_offset = next_offset;

/* Link the AIO request with a thread callback */

my_aiocb.aio_sigevent.sigev_notify = SIGEV_THREAD;

my_aiocb.aio_sigevent.notify_function = aio_completion_handler;

my_aiocb.aio_sigevent.notify_attributes = NULL;

my_aiocb.aio_sigevent.sigev_value.sival_ptr = &my_aiocb;

...

ret = aio_read
( &my_aiocb );

}

void aio_completion_handler( sigval_t sigval )

{

struct aiocb *req;

req = (struct aiocb *)sigval.sival_ptr;

/* Did the request complete? */

if (aio_error
( req ) == 0) {

/* Request completed successfully, get the return status */

ret = aio_return
( req );

}

return;

}