怎么实现异步文件的读写啊？

pennyliang

Linux 中也有类似的功能，不过要用io_setup和io_submit来完成。
它们调用内核中的sys_io_setup和sys_io_submit工作。
下面是从网上找到的一个例子,试了一下,可以使用：

/************************************************************************/
/* Quellcode zum Buch                                                   */
/*                     Linux Treiber entwickeln                         */
/* (2. Auflage) erschienen im dpunkt.verlag                             */
/* Copyright (c) 2004, 2006 Juergen Quade und Eva-Katharina Kunst       */
/*                                                                      */
/* This program is free software; you can redistribute it and/or modify */
/* it under the terms of the GNU General Public License as published by */
/* the Free Software Foundation; either version 2 of the License, or    */
/* (at your option) any later version.                                  */
/*                                                                      */
/* This program is distributed in the hope that it will be useful,      */
/* but WITHOUT ANY WARRANTY; without even the implied warranty of       */
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the         */
/* GNU General Public License for more details.                         */
/*                                                                      */
/************************************************************************/
#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <libaio.h>

#define BUF_SIZE (64*1024)
static char *buf, *buf2;

int main( int argc, char **argv )
{
        io_context_t ctxp = NULL;
        struct iocb iocb, iocb2;
        struct iocb *iocbs[] = { &iocb, &iocb2 };
        struct io_event event[2];
        int fd1, fd2;
        struct timespec ts;
        int result;

        if( io_setup( 1024, &ctxp ) ) {
                perror( "io_setup" );
                return -1;
        }
        fd1 = open( "/tmp/foo", O_RDWR|O_DIRECT );
        //fd1 = open( "/tmp/aiodev", O_RDONLY );
        fd2 = open( "/tmp/too", O_RDWR|O_DIRECT );
        if( fd1<0 || fd2<0 ) {
                perror("open");
                return -2;
        }
        posix_memalign( (void**)&buf, 512, BUF_SIZE );
        posix_memalign( (void**)&buf2, 512, BUF_SIZE );
        io_prep_pread( &iocb,  fd1, buf, BUF_SIZE, 0 );
        io_prep_pread( &iocb2, fd2, buf2, BUF_SIZE, 0 );
        io_submit( ctxp, 2, iocbs );
        // ... do something else ...
        ts.tv_sec = 5;
        ts.tv_nsec= 0;
        result = io_getevents( ctxp, 2, 2, &event[0], &ts );
        printf("result= %d | result= %ld/%ld res2= %ld/%ld\n", result,
                event[0].res, event[0].res2,
                event[1].res, event[1].res2);
        //printf("Inhalt von buf: %s\n", buf ); // Test mit "asynctest"
        io_destroy( ctxp );
        return 0;
}

编译这个东西要有 libaio-dev, 编译时记得加 -laio (gcc aioappl.c -laio)
有一点值得注意的就是这种aio操作的前提是文件必须以O_DIRECT的方式
打开。
manpage: http://linux.die.net/man/2/io_setup

Thanks

leehq

看来还是要用aio，多谢各位大虾的指导！

[ 本帖最后由 leehq 于 2007-12-13 16:00 编辑 ]

todaygood

#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <libaio.h>




int  usage()
{
        printf ("read_aio  file.txt   buf_size  rn \n");
        return  0;
}



int main( int argc, char **argv )
{
        io_context_t ctxp = NULL;
        
        
        struct iocb *p_iocb;
      
        struct io_event  *p_event;
        int fd1;
        int buf_size;
        struct timespec ts;
        int  finished_rd=0;
        static int  sum_rd=0;
        unsigned long long  offset =0;
        int  rn;
        int i;
        
        char *pp_buf[10];
         
        if (argc < 4)
        {
                        usage();
                        return -1;
               
        }
        
        buf_size =atoi(argv[2]);
        rn =atoi(argv[3]);
        
        #define BUF_SIZE   buf_size
        
        
                p_iocb=malloc(  rn*sizeof (struct iocb));
            
            p_event=malloc(rn*sizeof(struct io_event));
         //    pp_buf =  malloc (rn* sizeof (void *));
             
            if (!p_iocb||  !p_event ||  !pp_buf)
                {
                        printf("malloc failed \n");
                        return -1;
            }
            
            
               
        if( io_setup( 1024, &ctxp ) ) {
               
                perror( "io_setup" );
                return -1;
        }
        fd1 = open( argv[1], O_RDWR|O_DIRECT );
        
        if (fd1<0)
        {
                        perror("open");
                        return  -2;
        }
      
        for(i=0;i<rn; i++)      
          posix_memalign((void**)&(pp_buf), 512, BUF_SIZE );
      
      
        
         
      
        
        for (i=0; i<rn; i++)
        {
                        io_prep_pread(&p_iocb,  fd1, pp_buf, BUF_SIZE, offset );
                        p_iocb.data= pp_buf;
                          offset += BUF_SIZE;
                          
                          
        }
              io_submit( ctxp, rn, (struct iocb**)&p_iocb  );
      
        
       while (sum_rd <rn)
        {
        
                        ts.tv_sec = 5;
                        ts.tv_nsec= 0;
                        
                        
                        finished_rd = io_getevents( ctxp, 1, rn, p_event, &ts );
                        sum_rd +=finished_rd;
                        for (i=0;i<finished_rd ; i++)
                        {
                        
                                                 printf("finished_rd= %d\nres= %ld/%ld\n", finished_rd,
                                                                p_event.res, p_event.res2);
                               //  printf("read  buf: %s\n", p_event.data );
                                                //   printf("pp_buf : %s\n",   pp_buf);
                                               
                                               
                                                printf("-------------------\n");
                        }
                        
                      printf("+\n");
        
      }
      
      
      
      
        io_destroy( ctxp );
        
        
          for(i=0;i<rn; i++)
             free(pp_buf);
        
        
        return 0;
}


执行时
[root@linux-58 public]# gcc -g -o read_aio  read_aio.c -laio
[root@linux-58 public]# ./read_aio aio.c 512 5
finished_rd= 1
res= 512/0
-------------------
+
过5秒
打印
+
一直打印
+


怎么回事？ 怎么只有一个读操作完成?


程序的问题在哪里？