Linux中AIO设计框架

小咪咪 2023-02-28 05:43 23阅读 0赞

## 概述 ##

> aio异步读写是在Linux内核2.6之后才正式纳入其标准。之所以会增加此模块，是因为众所周知我们计算机CPU的执行速度远大于I/O读写的执行速度，如果我们用传统的阻塞式或非阻塞式来操作I/O的话，那么我们在同一个程序中(不用多线程或多进程)就不能同时操作俩个以上的文件I/O，每次只能对一个文件进行I/O操作，很明显这样效率很低下(因为CPU速度远大于I/O操作的速度，所以当执行I/O时，CPU其实还可以做更多的事)。因此就诞生了相对高效的异步I/O

## AIO编程方法 ##

> AIO 接口的 API 非常简单，但是它为数据传输提供了必需的功能，并给出了两个不同的通知模型。

### AIO对象 ###

*  struct aiocb

struct aiocb
    { 
      int aio_fildes;               // 文件描述符
      int aio_lio_opcode;           // 对于批量发起AIO时的设置（读/写）
      volatile void *aio_buf;       // 缓冲区
      size_t aio_nbytes;            // 缓冲区的大小
      struct sigevent aio_sigevent; // AIO的回调函数设置
      /* Internal fields */
      ...
    };
    AIO_READ  读
    AIO_WRITE 写

### aio\_read ###

*  aio\_read 函数请求对一个有效的文件描述符进行异步读操作。这个文件描述符可以表示一个文件、套接字甚至管道。aio\_read 函数的原型如下

int aio_read(struct aiocb *aiocbp);

*  aio\_read 函数在请求进行排队之后会立即返回。如果执行成功，返回值就为 0；如果出现错误，返回值就为 -1，并设置 errno 的值。

### aio\_error ###

*  aio\_error 函数被用来确定请求的状态。(状态：是否读/写完成)

int aio_error( struct aiocb *aiocbp );

*  返回值

> EINPROGRESS，说明请求尚未完成  
> ECANCELLED，说明请求被应用程序取消了  
> \-1，说明发生了错误，具体错误原因可以查阅 errno  
> 0 ,说明完成当前请求

### aio\_return ###

*  异步 I/O 和标准块 I/O 之间的另外一个区别是我们不能立即访问这个函数的返回状态，因为我们并没有阻塞在 read 调用上。在标准的 read 调用中，返回状态是在该函数返回时提供的。但是在异步 I/O 中，我们要使用 aio\_return 函数。这个函数的原型如下：

ssize_t aio_return( struct aiocb *aiocbp );

> 返回值大于0表示为读/写的字节数  
> 返回值小于0表示读/写错误

*  demo

#include<stdio.h>
    #include<sys/socket.h>
    #include<netinet/in.h>
    #include<arpa/inet.h>
    #include<assert.h>
    #include<unistd.h>
    #include<stdlib.h>
    #include<errno.h>
    #include<string.h>
    #include<sys/types.h>
    #include<fcntl.h>
    #include<aio.h>
    
    
    #define BUFFER_SIZE 1024
    
    int MAX_LIST = 2;
    
    int main(int argc,char **argv)
    { 
        //aio操作所需结构体
        struct aiocb rd;
    
        int fd,ret,couter;
    
        fd = open("test.txt",O_RDONLY);
        if(fd < 0)
        { 
            perror("test.txt");
        }
    
    
    
        //将rd结构体清空
        bzero(&rd,sizeof(rd));
    
    
        //为rd.aio_buf分配空间
        rd.aio_buf = malloc(BUFFER_SIZE + 1);
    
        //填充rd结构体
        rd.aio_fildes = fd;
        rd.aio_nbytes = BUFFER_SIZE;
        rd.aio_offset = 0;
    
        //进行异步读操作
        ret = aio_read(&rd);
        if(ret < 0)
        { 
            perror("aio_read");
            exit(1);
        }
    	//do other things
    	
        couter = 0;
    // 循环等待异步读操作结束
        while(aio_error(&rd) == EINPROGRESS)
        { 
           // printf("第%d次\n",++couter);
        }
    	
        //获取异步读返回值
        ret = aio_return(&rd);
    	
        printf("\n\n返回值为:%d\n",ret);
    	printf("%s\n",rd.aio_buf);
    	
    	free(rd.aio_buf);
    	close(fd);
        return 0;
    }

### aio\_write ###

*  aio\_write 函数用来请求一个异步写操作。其函数原型如下：

int aio_write( struct aiocb *aiocbp );

*  aio\_write 函数会立即返回，说明请求已经进行排队（成功时返回值为 0，失败时返回值为 -1，并相应地设置 errno）。
 *  这与 read 系统调用类似，但是有一点不一样的行为需要注意。回想一下对于 read 调用来说，要使用的偏移量是非常重要的。然而，对于 write 来说，这个偏移量只有在没有设置 O\_APPEND 选项的文件上下文中才会非常重要。如果设置了 O\_APPEND，那么这个偏移量就会被忽略，数据都会被附加到文件的末尾。否则，aio\_offset 域就确定了数据在要写入的文件中的偏移量。
 *

#### demo ####

### aio\_suspend ###

*  aio\_suspend函数可以时当前进程挂起，直到有向其注册的异步事件完成为止
 *  阻塞
 *  当有AIO请求返程后，该函数返回

int aio_suspend(const struct aiocb *const cblist[],int n,const struct timespec *timeout);

*  > 第一个参数是个保存了aiocb块地址的数组，我们可以向其内添加想要等待阻塞的异步事件，第二个参数为向cblist注册的aiocb个数,第三个参数为等待阻塞的超时时间，NULL为无限等待

### demo ###

#include<stdio.h>
    #include<sys/socket.h>
    #include<netinet/in.h>
    #include<arpa/inet.h>
    #include<assert.h>
    #include<unistd.h>
    #include<stdlib.h>
    #include<errno.h>
    #include<string.h>
    #include<sys/types.h>
    #include<fcntl.h>
    #include<aio.h>
    
    
    #define BUFFER_SIZE 1024
    
    int MAX_LIST = 2;
    
    int main(int argc,char **argv)
    { 
        //aio操作所需结构体
        struct aiocb rd;
    
        int fd,ret,couter;
    
        //cblist链表
        struct aiocb *aiocb_list[2];
    
    
    
        fd = open("test.txt",O_RDONLY);
        if(fd < 0)
        { 
            perror("test.txt");
        }
    
    
    
        //将rd结构体清空
        bzero(&rd,sizeof(rd));
    
    
        //为rd.aio_buf分配空间
        rd.aio_buf = malloc(BUFFER_SIZE + 1);
    
        //填充rd结构体
        rd.aio_fildes = fd;
        rd.aio_nbytes =  BUFFER_SIZE;
        rd.aio_offset = 0;
    
        //将读fd的事件注册
        aiocb_list[0] = &rd;
    
        //进行异步读操作
        ret = aio_read(&rd);
        if(ret < 0)
        { 
            perror("aio_read");
            exit(1);
        }
    
        printf("我要开始等待异步读事件完成\n");
        //阻塞等待异步读事件完成
        ret = aio_suspend(aiocb_list,MAX_LIST,NULL);
    	
    	
        //获取异步读返回值
        ret = aio_return(&rd);
    
        printf("\n\n返回值为:%d\n",ret);
    
    
        return 0;
    }

### lio\_listio ###

> aio同时还为我们提供了一个可以发起多个或多种I/O请求的接口lio\_listio  
> 这个函数效率很高，因为我们只需一次系统调用(一次内核上下位切换)就可以完成大量的I/O操作

int lio_listio(int mode,struct aiocb *list[],int nent,struct sigevent *sig);

> 第一个参数mode可以有俩个实参，LIO\_WAIT和LIO\_NOWAIT，前一个会阻塞该调用直到所有I/O都完成为止，后一个则会挂入队列就返回

*  LIO\_WAIT 阻塞发起
 *  LIO\_NOWAIT 非阻塞发起

> 批量发起AIO的两种方法

*  阻塞等到所有发起的AIO全部完成后，才会返回
 *  发起后立即返回，通过绑定的信号来通知

### LIO\_WAIT demo ###

#include<stdio.h>
    #include<sys/socket.h>
    #include<netinet/in.h>
    #include<arpa/inet.h>
    #include<assert.h>
    #include<unistd.h>
    #include<stdlib.h>
    #include<errno.h>
    #include<string.h>
    #include<sys/types.h>
    #include<fcntl.h>
    #include<aio.h>
    
    #define BUFFER_SIZE 1025
    
    int MAX_LIST = 2;
    
    
    int main(int argc,char **argv)
    { 
        struct aiocb *listio[2];
        struct aiocb rd,wr;
        int fd,ret;
    
        //异步读事件
        fd = open("test1.txt",O_RDONLY);
        if(fd < 0)
        { 
            perror("test1.txt");
        }
    
        bzero(&rd,sizeof(rd));
    
        rd.aio_buf = (char *)malloc(BUFFER_SIZE);
        if(rd.aio_buf == NULL)
        { 
            perror("aio_buf");
        }
    
        rd.aio_fildes = fd;
        rd.aio_nbytes = 1024;
        rd.aio_offset = 0;
        rd.aio_lio_opcode = LIO_READ;   ///lio操作类型为异步读
    
        //将异步读事件添加到list中
        listio[0] = &rd;
    
    
        //异步些事件
        fd = open("test2.txt",O_WRONLY | O_APPEND);
        if(fd < 0)
        { 
            perror("test2.txt");
        }
    
        bzero(&wr,sizeof(wr));
    
        wr.aio_buf = (char *)malloc(BUFFER_SIZE);
        if(wr.aio_buf == NULL)
        { 
            perror("aio_buf");
        }
    
        wr.aio_fildes = fd;
        wr.aio_nbytes = 1024;
    
        wr.aio_lio_opcode = LIO_WRITE;   ///lio操作类型为异步写
    
        //将异步写事件添加到list中
        listio[1] = &wr;
    
        //使用lio_listio发起一系列请求
        ret = lio_listio(LIO_WAIT,listio,MAX_LIST,NULL);
    
        //当异步读写都完成时获取他们的返回值
    
        ret = aio_return(&rd);
        printf("\n读返回值:%d",ret);
    
        ret = aio_return(&wr);
        printf("\n写返回值:%d",ret);
    
    
    
        return 0;
    }

#### LIO\_NOWAIT ####

> 当我们的异步I/O操作完成之时，我们可以通过信号通知我们的进程也可用回调函数来进行异步通知，接下来我会为大家主要介绍以下回调函数来进行异步通知

struct sigevent { 
        int           sigev_notify;            //通知类型
        int           sigev_signo;            //信号的值
        union sigval  sigev_value;             //回调函数中的参数
        void         (*sigev_notify_function)(union sigval); //回调函数 
        pthread_attr_t *sigev_notify_attributes;  //通知属性
    };

union sigval
    { 
        int sival_int;
        void *sival_ptr;
    };

##### demo #####

#include<stdio.h>
    #include<sys/socket.h>
    #include<netinet/in.h>
    #include<arpa/inet.h>
    #include<assert.h>
    #include<unistd.h>
    #include<stdlib.h>
    #include<errno.h>
    #include<string.h>
    #include<sys/types.h>
    #include<fcntl.h>
    #include<aio.h>
    #include<unistd.h>
    
    #define BUFFER_SIZE 1025
    
    
    void aio_completion_handler(sigval_t sigval)
    { 
        //用来获取读aiocb结构的指针
        struct aiocb *prd;
        int ret;
    
        prd = (struct aiocb *)sigval.sival_ptr;
    
        printf("hello\n");
    
        //判断请求是否成功
        if(aio_error(prd) == 0)
        { 
            //获取返回值
            ret = aio_return(prd);
            printf("读返回值为:%d\n",ret);
        }
    }
    
    int main(int argc,char **argv)
    { 
        int fd,ret;
        struct aiocb rd;
    
        fd = open("test.txt",O_RDONLY);
        if(fd < 0)
        { 
            perror("test.txt");
        }
    
    
    
        //填充aiocb的基本内容
        bzero(&rd,sizeof(rd));
    
        rd.aio_fildes = fd;
        rd.aio_buf = (char *)malloc(sizeof(BUFFER_SIZE + 1));
        rd.aio_nbytes = BUFFER_SIZE;
        rd.aio_offset = 0;
    
        //填充aiocb中有关回调通知的结构体sigevent
        rd.aio_sigevent.sigev_notify = SIGEV_THREAD;//使用线程回调通知
        rd.aio_sigevent.sigev_notify_function = aio_completion_handler;//设置回调函数
        rd.aio_sigevent.sigev_notify_attributes = NULL;//使用默认属性
        rd.aio_sigevent.sigev_value.sival_ptr = &rd;//在aiocb控制块中加入自己的引用
    
        //异步读取文件
        ret = aio_read(&rd);
        if(ret < 0)
        { 
            perror("aio_read");
        }
    
        printf("异步读以开始\n");
        sleep(1);
        printf("异步读结束\n");
    
    
    
        return 0;
    }