PAPI  5.4.0.0
 All Data Structures Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
libasync.c File Reference
Include dependency graph for libasync.c:

Go to the source code of this file.

Data Structures

struct  cache_ent
 
struct  cache
 

Typedefs

typedef long long off64_t
 

Functions

void mbcopy (char *source, char *dest, size_t len)
 
struct cache_entalloc_cache ()
 
struct cache_entincache ()
 
void async_init ()
 
void end_async ()
 
int async_suspend ()
 
int async_read ()
 
void takeoff_cache ()
 
void del_cache ()
 
void async_release ()
 
void putoninuse ()
 
void takeoffinuse ()
 
struct cache_entallocate_write_buffer ()
 
size_t async_write ()
 
void async_wait_for_write ()
 
void async_put_on_write_queue ()
 
void async_write_finish ()
 
 exit (174)
 
bzerogc (struct cache)
 
 async_write_finish (gc)
 
 free ((void *) gc)
 
int async_suspend (struct cache_ent *ce)
 
 if ((ce=(struct cache_ent *) incache(gc, fd, offset, size)))
 
 if (ret!=0)
 
 if (stride==0)
 
 printf ("aio_error 2: ret %d %d\n", ret, errno)
 
 printf ("aio_return error2: fd %d offset %d buffer %lx size %d Opcode %d\n", first_ce->myaiocb.aio_fildes, first_ce->myaiocb.aio_offset,(long)(first_ce->myaiocb.aio_buf), first_ce->myaiocb.aio_nbytes, first_ce->myaiocb.aio_lio_opcode)
 
 if (retval > 0)
 
 takeoff_cache (gc, first_ce)
 
 return ((int) retval)
 
 exit (175)
 
 bzero (ce, sizeof(struct cache_ent))
 
 exit (176)
 
 return (ce)
 
 if (gc->head==0)
 
 while (move)
 
 return (0)
 
 if (move==ce)
 
 printf ("Internal Error in takeoff cache\n")
 
 if (!ce->direct)
 
 while (1)
 
 printf ("aio_error 4: ret %d %d\n", ret, errno)
 
 if (first_ce->oldbuf!=first_ce->myaiocb.aio_buf||first_ce->oldfd!=first_ce->myaiocb.aio_fildes||first_ce->oldsize!=first_ce->myaiocb.aio_nbytes)
 
 putoninuse (gc, first_ce)
 
 printf ("Takeoffinuse error\n")
 
 printf ("Error in take off inuse\n")
 
 free ((void *)(ce->real_address))
 
 free (ce)
 
 mbcopy (buffer,(char *)(ce->myaiocb.aio_buf),(size_t) size)
 
 async_put_on_write_queue (gc, ce)
 
 if (ret==-1)
 
 return ((ssize_t) size)
 
 if (fd==0LL)
 
 async_wait_for_write (gc)
 
 exit (179)
 
 if (!direct)
 
 exit (180)
 
 while ((ret=aio_error(&ce->myaiocb))==EINPROGRESS)
 

Variables

long long page_size
 
int one
 
char version [] = "Libasync Version $Revision$"
 
long long max_depth =sysconf(_SC_AIO_MAX)
 
int errno
 
void struct cache ** gc
 
int fd =(int)fd
 
int flag
 
char * ubuffer =(char *)0
 
off64_t offset
 
long long size
 
long long stride
 
off64_t max
 
long long depth
 
long long a_size
 
struct cache_entce =(struct cache_ent *)malloc((size_t)sizeof(struct cache_ent))
 
struct cache_entfirst_ce =0
 
long long i
 
ssize_t retval =0
 
ssize_t ret
 
long long start = 0
 
long long del_read =0
 
 a_offset =offset
 
 else
 
again __pad0__
 
out __pad1__
 
first_ce direct =0
 
long long op
 
long temp
 
ce myaiocb aio_fildes =(int)fd
 
ce myaiocb aio_offset =(off_t)offset
 
ce real_address = (char *)malloc((size_t)(size+page_size))
 
ce myaiocb aio_buf =(volatile void *)temp
 
ce myaiocb aio_reqprio =0
 
ce myaiocb aio_nbytes =(size_t)size
 
ce myaiocb aio_sigevent sigev_notify =SIGEV_NONE
 
ce myaiocb aio_lio_opcode =(int)op
 
ce forward =0
 
ce back =gc->tail
 
gc tail = ce
 
gc head =ce
 
gc count
 
 move =gc->head
 
long long found
 
again __pad2__
 
first_ce oldfd =first_ce->myaiocb.aio_fildes
 
first_ce oldsize =first_ce->myaiocb.aio_nbytes
 
out __pad3__
 
struct cache_ententry
 
gc inuse_head =entry
 
char * buffer
 
again __pad4__
 
long long w_depth
 
char * free_addr
 
gc w_tail = ce
 
gc w_head =ce
 
gc w_count
 
 return
 
again __pad5__
 

Typedef Documentation

typedef long long off64_t

Definition at line 139 of file libasync.c.

Function Documentation

struct cache_ent* alloc_cache ( )

Here is the caller graph for this function:

struct cache_ent* allocate_write_buffer ( )
void async_init ( )

Definition at line 19044 of file iozone.c.

19045 {
19046  printf("Your system does not support async I/O\n");
19047  exit(172);
19048 }
#define printf
Definition: papi_test.h:125
void exit()

Here is the call graph for this function:

void async_put_on_write_queue ( )
async_put_on_write_queue ( gc  ,
ce   
)
int async_read ( )

Definition at line 19026 of file iozone.c.

19027 {
19028  printf("Your system does not support async I/O\n");
19029  exit(169);
19030 }
#define printf
Definition: papi_test.h:125
void exit()

Here is the call graph for this function:

void async_release ( )

Definition at line 19056 of file iozone.c.

19057 {
19058  printf("Your system does not support async I/O\n");
19059  exit(173);
19060 }
#define printf
Definition: papi_test.h:125
void exit()

Here is the call graph for this function:

int async_suspend ( )

Here is the caller graph for this function:

int async_suspend ( struct cache_ent ce)

Definition at line 271 of file libasync.c.

272 {
273 #ifdef _LARGEFILE64_SOURCE
274 #ifdef __LP64__
275  const struct aiocb * const cblist[1] = {&ce->myaiocb};
276 #else
277  const struct aiocb64 * const cblist[1] = {&ce->myaiocb64};
278 #endif
279 #else
280  const struct aiocb * const cblist[1] = {&ce->myaiocb};
281 #endif
282 
283 #ifdef _LARGEFILE64_SOURCE
284 #ifdef __LP64__
285  return aio_suspend(cblist, 1, NULL);
286 #else
287  return aio_suspend64(cblist, 1, NULL);
288 #endif
289 #else
290  return aio_suspend(cblist, 1, NULL);
291 #endif
292 }
struct aiocb myaiocb
Definition: libasync.c:155
void async_wait_for_write ( )

Here is the caller graph for this function:

async_wait_for_write ( gc  )
size_t async_write ( )

Definition at line 19038 of file iozone.c.

19039 {
19040  printf("Your system does not support async I/O\n");
19041  exit(171);
19042 }
#define printf
Definition: papi_test.h:125
void exit()

Here is the call graph for this function:

void async_write_finish ( )
async_write_finish ( gc  )
bzero ( ce  ,
sizeof(struct cache_ent  
)
void del_cache ( )
void end_async ( )
exit ( 174  )
exit ( 175  )
exit ( 176  )
exit ( 179  )
exit ( 180  )
free ( (void *)  gc)
free ( (void *)(ce->real_address )
free ( ce  )
bzero* gc ( struct cache  )
if ( (ce=(struct cache_ent *) incache(gc, fd, offset, size))  )

Definition at line 348 of file libasync.c.

349  {
350 #ifdef _LARGEFILE64_SOURCE
351 #ifdef __LP64__
352  while((ret=aio_error(&ce->myaiocb))== EINPROGRESS)
353  {
354  async_suspend(ce);
355  }
356 #else
357  while((ret=aio_error64(&ce->myaiocb64))== EINPROGRESS)
358  {
359  async_suspend(ce);
360  }
361 #endif
362 #else
363  while((ret=aio_error(&ce->myaiocb))== EINPROGRESS)
364  {
365  async_suspend(ce);
366  }
367 #endif
368  if(ret)
369  {
370  printf("aio_error 1: ret %d %d\n",ret,errno);
371  }
372 #ifdef _LARGEFILE64_SOURCE
373 #ifdef __LP64__
374  retval=aio_return(&ce->myaiocb);
375 #else
376 #if defined(__CrayX1__)
377  retval=aio_return64((aiocb64_t *)&ce->myaiocb64);
378 #else
379  retval=aio_return64((struct aiocb64 *)&ce->myaiocb64);
380 #endif
381 
382 #endif
383 #else
384  retval=aio_return(&ce->myaiocb);
385 #endif
386  if(retval > 0)
387  {
388 #ifdef _LARGEFILE64_SOURCE
389 #ifdef __LP64__
390  mbcopy((char *)ce->myaiocb.aio_buf,(char *)ubuffer,(size_t)retval);
391 #else
392  mbcopy((char *)ce->myaiocb64.aio_buf,(char *)ubuffer,(size_t)retval);
393 #endif
394 #else
395  mbcopy((char *)ce->myaiocb.aio_buf,(char *)ubuffer,(size_t)retval);
396 #endif
397  }
398 #ifdef _LARGEFILE64_SOURCE
399 #ifdef __LP64__
400  if(retval < ce->myaiocb.aio_nbytes)
401 #else
402  if(retval < ce->myaiocb64.aio_nbytes)
403 #endif
404 #else
405  if(retval < ce->myaiocb.aio_nbytes)
406 #endif
407  {
408  printf("aio_return error1: ret %d %d\n",retval,errno);
409 #ifdef _LARGEFILE64_SOURCE
410 #ifdef __LP64__
411  printf("aio_return error1: fd %d offset %ld buffer %lx size %d Opcode %d\n",
412  ce->myaiocb.aio_fildes,
413  ce->myaiocb.aio_offset,
414  (long)(ce->myaiocb.aio_buf),
415  ce->myaiocb.aio_nbytes,
416  ce->myaiocb.aio_lio_opcode
417 #else
418  printf("aio_return error1: fd %d offset %lld buffer %lx size %d Opcode %d\n",
419  ce->myaiocb64.aio_fildes,
420  ce->myaiocb64.aio_offset,
421  (long)(ce->myaiocb64.aio_buf),
422  ce->myaiocb64.aio_nbytes,
423  ce->myaiocb64.aio_lio_opcode
424 #endif
425 #else
426  printf("aio_return error1: fd %d offset %d buffer %lx size %d Opcode %d\n",
427  ce->myaiocb.aio_fildes,
428  ce->myaiocb.aio_offset,
429  (long)(ce->myaiocb.aio_buf),
430  ce->myaiocb.aio_nbytes,
431  ce->myaiocb.aio_lio_opcode
432 #endif
433  );
434  }
435  ce->direct=0;
437  }else
int errno
char * ubuffer
Definition: libasync.c:327
#define printf
Definition: papi_test.h:125
long long ret
Definition: iozone.c:1346
long long direct
Definition: libasync.c:167
void mbcopy(char *source, char *dest, size_t len)
Definition: libasync.c:1597
long long * gc
Definition: iozone.c:12357
void takeoff_cache()
struct aiocb myaiocb
Definition: libasync.c:155
ssize_t retval
Definition: libasync.c:338
struct cache_ent * ce
Definition: libasync.c:336
int async_suspend()

Here is the call graph for this function:

if ( ret!  = 0)

Definition at line 455 of file libasync.c.

456  {
457  if(errno==EAGAIN)
458  goto again;
459  else
460  printf("error returned from aio_read(). Ret %d errno %d\n",ret,errno);
461  }
int errno
#define printf
Definition: papi_test.h:125
long long ret
Definition: iozone.c:1346
if ( stride  = =0)

Definition at line 463 of file libasync.c.

476  {
477  r_offset=a_offset+((i+1)*(stride*a_size));
478  if(r_offset<0)
479  continue;
480  if(r_offset+size > max)
481  continue;
482  if((ce=incache(gc,fd,r_offset,a_size)))
483  continue;
484  ce=alloc_cache(gc,fd,r_offset,a_size,(long long)LIO_READ);
485 #ifdef _LARGEFILE64_SOURCE
486 #ifdef __LP64__
487  ret=aio_read(&ce->myaiocb);
488 #else
489  ret=aio_read64(&ce->myaiocb64);
490 #endif
491 #else
492  ret=aio_read(&ce->myaiocb);
493 #endif
494  if(ret!=0)
495  {
497  break;
498  }
499  }
off64_t max
Definition: libasync.c:331
struct cache_ent * alloc_cache()
long long stride
Definition: iozone.c:1532
int fd
Definition: iozone.c:1291
struct cache_ent * incache()
long long a_size
Definition: libasync.c:333
long long ret
Definition: iozone.c:1346
int i
Definition: fileop.c:140
char *long long size
Definition: iozone.c:12023
a_offset
Definition: libasync.c:343
long long * gc
Definition: iozone.c:12357
void takeoff_cache()
struct aiocb myaiocb
Definition: libasync.c:155
struct cache_ent * ce
Definition: libasync.c:336

Here is the call graph for this function:

if ( retval  ,
 
)

Definition at line 569 of file libasync.c.

570  {
571 #ifdef _LARGEFILE64_SOURCE
572 #ifdef __LP64__
573  mbcopy((char *)first_ce->myaiocb.aio_buf,(char *)ubuffer,(size_t)retval);
574 #else
575  mbcopy((char *)first_ce->myaiocb64.aio_buf,(char *)ubuffer,(size_t)retval);
576 #endif
577 #else
578  mbcopy((char *)first_ce->myaiocb.aio_buf,(char *)ubuffer,(size_t)retval);
579 #endif
580  }
char * ubuffer
Definition: libasync.c:327
struct cache_ent * first_ce
Definition: libasync.c:336
void mbcopy(char *source, char *dest, size_t len)
Definition: libasync.c:1597
struct aiocb myaiocb
Definition: libasync.c:155
ssize_t retval
Definition: libasync.c:338

Here is the call graph for this function:

if ( gc->  head = =0)

Definition at line 685 of file libasync.c.

686  {
687  return(0);
688  }
if ( move  = =ce)

Definition at line 739 of file libasync.c.

740  {
741 
742  gc->head=ce->forward;
743  if(gc->head)
744  gc->head->back=0;
745  else
746  gc->tail = 0;
747  if(!ce->direct)
748  {
749  free((void *)(ce->real_address));
750  free((void *)ce);
751  }
752  gc->count--;
753  return;
754  }
long long direct
Definition: libasync.c:167
free(dummyfile[xx])
long long * gc
Definition: iozone.c:12357
struct cache_ent * forward
Definition: libasync.c:165
char * real_address
Definition: libasync.c:169
struct cache_ent * ce
Definition: libasync.c:336

Here is the call graph for this function:

if ( !ce->  direct)
Initial value:
{
printf("aio_return error: %d\n",errno)
int errno
#define printf
Definition: papi_test.h:125

Definition at line 781 of file libasync.c.

782  {
783  free((void *)(ce->real_address));
784  free((void *)ce);
785  }
free(dummyfile[xx])
char * real_address
Definition: libasync.c:169
struct cache_ent * ce
Definition: libasync.c:336

Here is the call graph for this function:

Definition at line 1086 of file libasync.c.

1101  {
1102  printf("aio_return error5: ret %d %d\n",retval,errno);
1103 #ifdef _LARGEFILE64_SOURCE
1104 #ifdef __LP64__
1105  printf("aio_return error5: fd %d offset %lld buffer %lx size %d Opcode %d\n",
1106  first_ce->myaiocb.aio_fildes,
1107  first_ce->myaiocb.aio_offset,
1108  (long)(first_ce->myaiocb.aio_buf),
1109  first_ce->myaiocb.aio_nbytes,
1110  first_ce->myaiocb.aio_lio_opcode
1111 #else
1112  printf("aio_return error5: fd %d offset %lld buffer %lx size %d Opcode %d\n",
1113  first_ce->myaiocb64.aio_fildes,
1114  first_ce->myaiocb64.aio_offset,
1115  (long)(first_ce->myaiocb64.aio_buf),
1116  first_ce->myaiocb64.aio_nbytes,
1117  first_ce->myaiocb64.aio_lio_opcode
1118 #endif
1119 #else
1120  printf("aio_return error5: fd %d offset %ld buffer %lx size %d Opcode %d\n",
1121  first_ce->myaiocb.aio_fildes,
1122  first_ce->myaiocb.aio_offset,
1123  (long)(first_ce->myaiocb.aio_buf),
1124  first_ce->myaiocb.aio_nbytes,
1125  first_ce->myaiocb.aio_lio_opcode
1126 #endif
1127  );
1128  }
int errno
#define printf
Definition: papi_test.h:125
struct cache_ent * first_ce
Definition: libasync.c:336
struct aiocb myaiocb
Definition: libasync.c:155
ssize_t retval
Definition: libasync.c:338
if ( ret  = =-1)

Definition at line 1246 of file libasync.c.

1247  {
1248  if(errno==EAGAIN)
1249  {
1251  goto again;
1252  }
1253  if(errno==0)
1254  {
1255  /* Compensate for bug in async library */
1257  goto again;
1258  }
1259  else
1260  {
1261  printf("Error in aio_write: ret %d errno %d count %lld\n",ret,errno,gc->w_count);
1262  /*
1263  printf("aio_write_no_copy: fd %d buffer %x offset %lld size %d\n",
1264  ce->myaiocb64.aio_fildes,
1265  ce->myaiocb64.aio_buf,
1266  ce->myaiocb64.aio_offset,
1267  ce->myaiocb64.aio_nbytes);
1268  */
1269  exit(177);
1270  }
1271  }
int errno
#define printf
Definition: papi_test.h:125
long long ret
Definition: iozone.c:1346
long long * gc
Definition: iozone.c:12357
void async_wait_for_write()
void exit()

Here is the call graph for this function:

if ( fd  = =0LL)

Definition at line 1292 of file libasync.c.

1293  {
1294  printf("Setting up write buffer insane\n");
1295  exit(178);
1296  }
#define printf
Definition: papi_test.h:125
void exit()

Here is the call graph for this function:

if ( direct)

Definition at line 1342 of file libasync.c.

1343  {
1344  ce->real_address = (char *)malloc((size_t)(size+page_size));
1346  temp = (temp+page_size) & ~(page_size-1);
1347  ce->myaiocb.aio_buf=(volatile void *)temp;
1348  }
long long page_size
Definition: iozone.c:428
char *long long size
Definition: iozone.c:12023
long long
Definition: iozone.c:19827
int temp
Definition: iozone.c:22158
struct aiocb myaiocb
Definition: libasync.c:155
char * real_address
Definition: libasync.c:169
struct cache_ent * ce
Definition: libasync.c:336
struct cache_ent* incache ( )

Here is the caller graph for this function:

void mbcopy ( char *  source,
char *  dest,
size_t  len 
)

Definition at line 1597 of file libasync.c.

1600 {
1601  int i;
1602  for(i=0;i<len;i++)
1603  *dest++=*source++;
1604 }
int i
Definition: fileop.c:140

Here is the caller graph for this function:

mbcopy ( buffer  ,
(char *)(ce->myaiocb.aio_buf ,
(size_t)  size 
)
printf ( "aio_error 2: ret %d %d\n ,
ret  ,
errno   
)
printf ( "aio_return error2: fd %d offset %d buffer %lx size %d Opcode %d\n ,
first_ce->myaiocb.  aio_fildes,
first_ce->myaiocb.  aio_offset,
(long)(first_ce->myaiocb.aio_buf ,
first_ce->myaiocb.  aio_nbytes,
first_ce->myaiocb.  aio_lio_opcode 
)
printf ( "Internal Error in takeoff cache\n )
printf ( "aio_error 4: ret %d %d\n ,
ret  ,
errno   
)
printf ( "Takeoffinuse error\n )
printf ( "Error in take off inuse\n )
void putoninuse ( )
putoninuse ( gc  ,
first_ce   
)
return ( (int retval)
return ( ce  )
return ( )
return ( (ssize_t)  size)
void takeoff_cache ( )

Here is the caller graph for this function:

takeoff_cache ( gc  ,
first_ce   
)
void takeoffinuse ( )
while ( move  )

Definition at line 713 of file libasync.c.

714  {
715  if((move->fd == fd) && (move->myaiocb.aio_offset==(off_t)offset) &&
716  ((size_t)size==move->myaiocb.aio_nbytes))
717  {
718  return(move);
719  }
720  move=move->forward;
721  }
off64_t offset
Definition: iozone.c:1279
int fd
Definition: iozone.c:1291
char *long long size
Definition: iozone.c:12023
move
Definition: libasync.c:689
while ( )

Definition at line 802 of file libasync.c.

803  {
804  ce=gc->head;
805  if(ce==0)
806  return;
807 #ifdef _LARGEFILE64_SOURCE
808 #ifdef __LP64__
809  while((ret = aio_cancel(0,&ce->myaiocb))==AIO_NOTCANCELED)
810 #else
811  while((ret = aio_cancel64(0,&ce->myaiocb64))==AIO_NOTCANCELED)
812 #endif
813 #else
814  while((ret = aio_cancel(0,&ce->myaiocb))==AIO_NOTCANCELED)
815 #endif
816  ;
817 
818 #ifdef _LARGEFILE64_SOURCE
819 #ifdef __LP64__
820  ret = aio_return(&ce->myaiocb);
821 #else
822  ret = aio_return64(&ce->myaiocb64);
823 #endif
824 #else
825  ret = aio_return(&ce->myaiocb);
826 #endif
827  ce->direct=0;
828  takeoff_cache(gc,ce); /* remove from cache */
829  }
long long ret
Definition: iozone.c:1346
long long direct
Definition: libasync.c:167
long long * gc
Definition: iozone.c:12357
void takeoff_cache()
struct aiocb myaiocb
Definition: libasync.c:155
struct cache_ent * ce
Definition: libasync.c:336

Here is the call graph for this function:

while ( (ret=aio_error(&ce->myaiocb))  = = EINPROGRESS)

Definition at line 1453 of file libasync.c.

1454  {
1455  async_suspend(ce);
1456  }
struct cache_ent * ce
Definition: libasync.c:336
int async_suspend()

Here is the call graph for this function:

Variable Documentation

again __pad0__

Definition at line 453 of file libasync.c.

out __pad1__

Definition at line 518 of file libasync.c.

again __pad2__

Definition at line 989 of file libasync.c.

out __pad3__

Definition at line 1066 of file libasync.c.

again __pad4__

Definition at line 1244 of file libasync.c.

again __pad5__

Definition at line 1549 of file libasync.c.

a_offset =offset

Definition at line 343 of file libasync.c.

long long a_size
Initial value:
{
off64_t a_offset,r_offset
a_offset
Definition: libasync.c:343
long long off64_t
Definition: iozone.c:357

Definition at line 333 of file libasync.c.

ce myaiocb aio_buf =(volatile void *)temp

Definition at line 636 of file libasync.c.

ce myaiocb aio_fildes =(int)fd

Definition at line 631 of file libasync.c.

ce myaiocb aio_lio_opcode =(int)op

Definition at line 660 of file libasync.c.

ce myaiocb aio_nbytes =(size_t)size

Definition at line 658 of file libasync.c.

ce myaiocb aio_offset =(off_t)offset

Definition at line 632 of file libasync.c.

ce myaiocb aio_reqprio =0

Definition at line 657 of file libasync.c.

ce back =gc->tail

Definition at line 664 of file libasync.c.

char* buffer

Definition at line 1212 of file libasync.c.

struct cache_ent * ce =(struct cache_ent *)malloc((size_t)sizeof(struct cache_ent))

Definition at line 336 of file libasync.c.

gc count

Definition at line 670 of file libasync.c.

long long del_read =0

Definition at line 341 of file libasync.c.

long long depth

Definition at line 332 of file libasync.c.

ce direct =0

Definition at line 581 of file libasync.c.

else
Initial value:
{
void del_cache()
long long * gc
Definition: iozone.c:12357

Definition at line 438 of file libasync.c.

struct cache_ent* entry

Definition at line 1170 of file libasync.c.

int errno
long long fd =(int)fd

Definition at line 229 of file libasync.c.

struct cache_ent * first_ce =0

Definition at line 336 of file libasync.c.

int flag

Definition at line 230 of file libasync.c.

ce forward =0

Definition at line 663 of file libasync.c.

found
Initial value:
{
struct cache_ent *move
move
Definition: libasync.c:689

Definition at line 735 of file libasync.c.

char* free_addr

Definition at line 1288 of file libasync.c.

size_t struct cache* gc
Initial value:
{
printf("Malloc failed\n")
#define printf
Definition: papi_test.h:125

Definition at line 228 of file libasync.c.

gc head =ce

Definition at line 669 of file libasync.c.

Definition at line 337 of file libasync.c.

gc inuse_head =entry

Definition at line 1176 of file libasync.c.

off64_t max

Definition at line 331 of file libasync.c.

max_depth =sysconf(_SC_AIO_MAX)

Definition at line 192 of file libasync.c.

move =gc->head

Definition at line 689 of file libasync.c.

off64_t offset

Definition at line 328 of file libasync.c.

Definition at line 990 of file libasync.c.

Definition at line 991 of file libasync.c.

int one
long long op

Definition at line 600 of file libasync.c.

long long page_size

Definition at line 428 of file iozone.c.

ce real_address = (char *)malloc((size_t)(size+page_size))

Definition at line 633 of file libasync.c.

size_t ret
Initial value:
{
struct cache_ent *ce
struct cache_ent * ce
Definition: libasync.c:336

Definition at line 339 of file libasync.c.

return

Definition at line 1399 of file libasync.c.

size_t retval =0

Definition at line 338 of file libasync.c.

ce myaiocb aio_sigevent sigev_notify =SIGEV_NONE

Definition at line 659 of file libasync.c.

long long size

Definition at line 329 of file libasync.c.

long long start = 0

Definition at line 340 of file libasync.c.

long long stride

Definition at line 330 of file libasync.c.

gc tail = ce

Definition at line 667 of file libasync.c.

long temp
Initial value:
{
struct cache_ent *ce
struct cache_ent * ce
Definition: libasync.c:336

Definition at line 602 of file libasync.c.

else * ubuffer =(char *)0

Definition at line 327 of file libasync.c.

char version[] = "Libasync Version $Revision$"

Definition at line 153 of file libasync.c.

gc w_count

Definition at line 1398 of file libasync.c.

long long w_depth

Definition at line 1286 of file libasync.c.

gc w_head =ce

Definition at line 1397 of file libasync.c.

gc w_tail = ce

Definition at line 1395 of file libasync.c.