Linux - 异步IO（AIO）

1. POSIX异步IO(AIO)

BSD对不同的设备文件进行异步IO方法不一样, 如终端设备是产生SIGIO信号, 仅支持带外数据的设备才能产生SIGURG信号.
POSIX对不同类型文件进行异步IO提供一套一致的方法, SUSv4中, 这些接口被移到了基本部分中, 所以现在所有的平台都被要求支持这些接口.

1.1 AIO控制块

异步IO接口使用AIO控制块来描述IO操作.
AIO控制块由aiocb结构定义:

#include <aiocb.h>

struct aiocb {
   /* The order of these fields is implementation-dependent */

   int             aio_fildes;     /* File descriptor */
   off_t           aio_offset;     /* File offset */
   volatile void  *aio_buf;        /* Location of buffer */
   size_t          aio_nbytes;     /* Length of transfer */
   int             aio_reqprio;    /* Request priority */
   struct sigevent aio_sigevent;   /* Notification method */
   int             aio_lio_opcode; /* Operation to be performed;
                                      lio_listio() only */

   /* Various implementation-internal fields not shown */
};

字段说明
aio_fildes 表示已打开的文件描述符, 用于读/写;
aio_offset 读写操作从aio_offset指定的偏移量开始;
aio_buf 用于读写操作转存数据的缓冲区;
aio_nbytes 缓冲区aio_buf的大小;
aio_reqprio 应用程序使用该字段为异步IO请求提示顺序. 值必须介于0和sysconf(_SC_AIO_PRIO_DELTA_MAX)返回值之间. 文件同步操作忽略该字段;
aio_lio_opcode 应当进行的操作类型, 只能用于lio_listio (基于列表的异步IO), 值描述见lio_listio章节;
aio_sigevent 指明IO事件完成后, 如何通知应用程序.
sigevent结构:

union sigval {          /* Data passed with notification */
   int     sival_int;         /* Integer value */
   void   *sival_ptr;         /* Pointer value */
};

struct sigevent {
   int          sigev_notify; /* Notification method */
   int          sigev_signo;  /* Notification signal */
   union sigval sigev_value;  /* Data passed with
                                 notification */
   void       (*sigev_notify_function) (union sigval);
                    /* Function used for thread notification (SIGEV_THREAD) */
   void        *sigev_notify_attributes;
                    /* Attributes for notification thread (SIGEV_THREAD) */
   pid_t        sigev_notify_thread_id;
                    /* ID of thread to signal (SIGEV_THREAD_ID) */
};

sigevent字段说明:
-sigev_notify 通知类型, 其取值只能是这3个之一: SIGEV_NONE, SIGEV_SIGNAL, SIGEV_THREAD.
1)SIGEV_NONE 异步IO请求完成后, 不通知进程;
2)SIGEV_SIGNAL 异步IO请求完成后, 产生由sigev_signo字段指定的信号. 也就是说, 需要应用程序捕捉sigev_signo表示的信号, 并在信号处理程序中完成IO数据操作.
3)SIGEV_THREAD 异步IO请求完成时, 调用sigev_notify_function指定的函数, sigev_value作为唯一参数被传入. 除非sigev_notify_attributes字段被设定为pthread属性结构的地址, 且该结构指定了一个另外的线程属性, 否则该函数将在线程分离状态的一个单独的线程中执行.

1.2 aio_read & aio_write

使用异步IO前, 应先对AIO控制块(struct aiocb对象)进行初始化.

aio_read - 异步读, aio_write - 异步写:

#include <aio.h>

int aio_read(struct aiocb *aiocb);

int aio_write(struct aiocb *aiocb);

描述
将异步IO请求放入等待处理的队列中(函数提出请求, 由OS放入). 函数返回值与实际IO操作结果没有关系. IO操作等待时, 需确保AIO控制块和数据缓冲区保持稳定, 下面对应的内容也必须始终合法, 不能被释放, 也不能被复用, 除非IO操作完成.
aio_read是read的异步模拟, aio_write是write的异步模拟.

read(fd, buf, count);
write(fd, buf, n);

返回值
成功返回0; 失败-1

1.3 aio_fsync

aio_fsync - 异步文件同步:
强制所有(等待队中)等待的异步操作不等待, 而直接写入持久化的存储中(通常指磁盘, emmc等), 可以设置一个AIO控制块并调用aio_fsync.

#include <aio.h>

int aio_fsync(int ap, struct aiocb *aiocb);

描述
aiocb->aio_fildes字段(文件描述符)指定异步写操作被同步的文件.
如果op = O_DSYNC, 那么操作执行像调用fdatasync, 函数立即返回, 但IO操作完成前, 文件数据不会被持久化;
如果op = O_SYNC, 那么操作执行像调用fsync, 函数立即返回, 但IO操作完成前, 文件数据和属性不会被持久化;

sync, fsync, fdatasync, fflush是什么?
参考sync、fsync、fdatasync、fflush函数区别和使用举例 | CSDN

函数名称	作用描述
sync	将所有修改过的(内核)快缓存区排队进写队列, 然后返回, 并不等待实际写磁盘操作结束
fsync	只对由fd指定单一文件起作用, 并且等待磁盘操作结束, 然后返回
fdatasync	类似于fsync, 但只影响文件的数据部分, 不像fsync还会同步更新文件的属性
fflush	冲刷IO库缓存, 将库缓存内容写入内核缓冲区

1.4 aio_error

aio_error - 获取异步IO操作(异步读、写或同步)的完成状态

#include <aio.h>

int aio_error(const struct aiocb *aiocb);

描述
函数返回异步IO请求的错误状态, aiocb指向AIO控制块, 代表了异步IO请求信息.

返回值
0 异步操作成功, 需要调用aio_return 函数获取操作返回值;
-1 对aio_error调用失败, errno被设置;
EINPROGRESS 异步读、写或同步操作仍在等待;
其他值相关异步操作失败返回的错误码(errno);

1.5 aio_return

aio_error提到, 返回0时表示异步操作成功, 可以调用aio_return获取操作返回值.
aio_return - 获取异步IO操作返回值

int <aio.h>

int aio_return(const struct aiocb *aiocb);

描述
注意:

异步操作完成之前, 不要调用aio_return, 其行为是未定义的;
对每个异步操作调用一次aio_return, 因为一旦调用了, OS就能释放包含了IO操作返回值的记录;

返回值
失败返回-1, errno被设置; 成功时, 返回异步操作结果, 即返回(同步版本)read、write或fsync在被成功调用时可能返回的结果.

1.6 aio_suspend

aio_suspend - 等待异步IO操作完成, 或超时

#include <aio.h>

int aio_suspend(const struct aiocb *const list[], int nent, const strct timespec *timeout);

描述
执行IO操作时, 如果有其他事务处理而不想被IO操作阻塞, 可以使用异步IO. 如果事务执行完毕后, 还有异步操作尚未完成时, 可调用aio_suspend函数阻止进程, 直到操作完成.

参数
list 指向AIO控制块数组的指针
nent 表明数组的元素个数
timeout 超时时间

返回值
3种情况:

如果被一个信号中断, 返回-1, errno设置为EINTR;
如果没有任何IO操作完成, 阻塞时间超时, 返回-1, errno设置为EAGAIN;
如果有任何IO操作完成, 返回0; 如果所有的异步IO操作都已完成, aio_suspend将在不阻塞的情况下直接返回;

1.7 aio_cancel

aio_cancel - 取消未完成的异步IO请求

#include <aio.h>

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

描述
如果不想完成还在等待中的异步IO操作时, 可以调用aio_cancel尝试取消. 描述为尝试, 是因为系统无法保证一定能取消正在进行的任何操作.
如果异步IO操作成功取消, 相应AIO控制块调用aio_error将返回错误ECANCELED; 如果操作不能被取消, 那么相应的AIO控制块不会被修改

参数
fd 指定未完成的异步IO操作的文件描述符
aiocb 如果aiocb = NULL, 系统会尝试取消所有该文件上未完成的异步IO操作; 其他情况, 系统将尝试取消aiocb指向的单个AIO控制块描述的单个异步IO操作.

返回值
4个值之一:
AIO_ALLDONE 所有操作在尝试取消前, 已经完成;
AIO_CANCELED 所有要求的操作已被取消;
AIO_NOTCANCELED 至少有一个要求的操作没有被取消;
-1 对aio_cancel调用失败, 设置errno;

1.8 lio_listio

lio_listio - 初始化io请求列表

#include <aio.h>

int lio_listio(int mode, struct aiocb *const aiocb_list[], int nitems, struct sigevent *sevp);

描述
既能以同步方式使用, 也能以异步的方式使用. 函数提交一系列由一个AIO控制块列表描述的IO请求.
每个AIO控制块中, aio_lio_opcode字段指定了该操作是一个读操作(LIO_READ), 写操作(LIO_WRITE), 还是将忽略的空操作(LIO_NOP). 读操作, 会按照对应的AIO控制块被传给aio_read来处理; 写操作, 会被传给aio_write处理.

参数
mode 决定IO释放真的是异步的. 取值说明:

LIO_WAIT 调用块将等到所有操作完成, sevp参数将会被忽略;
LIO_NOWAIT IO请求入队后, 立即返回, 进程在所有IO操作完成后, 按sigev指定的, 被异步通知. 如果不想被通知, sigev可设置为NULL. 被sigev指定的异步通知, 是在每个AIO控制块本身的异步通知之外的.

aiocb_list 指向AIO控制块列表, 指定了要运行的IO操作.

nitems 指定了aiocb_list数组元素格式.

实现限制
实现一般会限制一些参数的实际取值
POSIX.1中异步IO运行时不变量的值

名称	描述	可接受的最小值
AIO_LISTIO_MAX	单个列表IO调用中的最大IO操作数	_POSIX_AOI_LISTIO_MAX
AIO_MAX	未完成的异步IO操作的最大数目	_POSIX_AIO_MAX
AIO_PRIO_DELTA_MAX	进程可以减少的异步IO优先级的最大值	0

2. AIO编程模型

1. 准备缓冲区 struct aiocb

2. 异步操作

异步读 aio_read

异步写aio_write

3. 检查是否操作完毕

aio_error 循环不断去检查

aio_suspend 阻塞式检查, 一般搭配 lio_listio 使用。

4. 得到数据 aio_return

2.1 异步读

#include <stdio.h>
#include <unistd.h>
#include <aio.h>
#include <string.h>
#include <stdlib.h>
#include <fcntl.h>

#define BUFF_SIZE  1024

int main()
{
	//1 准备缓冲区
	struct aiocb cb = {0};

	int fd = open("test.txt",O_RDONLY);
	if(-1 == fd) printf("打开文件失败:%m\n"),exit(-1);
	printf("打开文件成功!\n");
	//2 异步操作
	cb.aio_fildes = fd;//文件描述符号  
	cb.aio_buf = (void*)malloc(BUFF_SIZE+1);//开内存
	memset(cb.aio_buf,0,BUFF_SIZE+1);//清空  全部置零 
	cb.aio_nbytes = BUFF_SIZE;//数据大小   单位是字节
	cb.aio_offset = 0;//文件中的偏移量
	//bzero

	int r = aio_read(&cb);
	if(-1 == r) printf("异步读文件失败:%m\n"),close(fd),exit(-1);
	printf("异步读文件成功!\n");

	//3. 检查是否操作完毕
	int n = 0;
	while(0 != aio_error(&cb)) {//aio_error返回值为0  循环结束
		n++;
	}

	//4. 得到数据
	r = aio_return(&cb);
	if(r > 0){
		printf("拿到数据:r:%d n:%d >> %s\n",
		r,n,cb.aio_buf);
	}

	//5. 收尾
	free(cb.aio_buf);
	close(fd);
	return 0;
}

2.2 异步写

#include <stdio.h>
#include <unistd.h>
#include <aio.h>
#include <string.h>
#include <stdlib.h>
#include <fcntl.h>

#define BUFF_SIZE  1024

int main(){
	//1 准备缓冲区
	struct aiocb cb = {0};

	int fd = open("test2.txt",O_WRONLY | O_APPEND);
	if(-1 == fd) printf("打开文件失败:%m\n"),exit(-1);
	printf("打开文件成功!\n");
	//2 异步操作
	cb.aio_fildes = fd;//文件描述符号  
	cb.aio_buf = (void*)malloc(BUFF_SIZE+1);//开内存
	memset(cb.aio_buf,0,BUFF_SIZE+1);//清空  全部置零 
	strcpy(cb.aio_buf,"提前祝大家国庆节快乐，假期别忘记写代码");
	cb.aio_nbytes = strlen("提前祝大家国庆节快乐，假期别忘记写代码");//数据大小   单位是字节
	cb.aio_offset = 0;//文件中的偏移量
	//bzero
	int r = aio_write(&cb);
	if(-1 == r) printf("异步写文件失败:%m\n"),close(fd),exit(-1);
	printf("异步写文件成功!\n");

	//3. 检查是否操作完毕
	int n = 0;
	while(0 != aio_error(&cb)) {//aio_error返回值为0  循环结束
		n++;
	}

	//4. 得到数据
	r = aio_return(&cb);
	if(r > 0){
		printf("拿到数据:r:%d n:%d >> %s\n",
		r,n,cb.aio_buf);
	}

	//5. 收尾
	free(cb.aio_buf);
	close(fd);
	return 0;
}

2.3 lio_listio示例

#include <stdio.h>
#include <unistd.h>
#include <aio.h>
#include <string.h>
#include <stdlib.h>
#include <fcntl.h>

#define BUFF_SIZE  1024

#define LIO_LISTIO_NUM  2

int main(){
	//准备缓冲区
	struct aiocb rcb = {0};
	struct aiocb wcb = {0};

	//准备结构体指针数组
	struct aiocb* aiocb_list[LIO_LISTIO_NUM] = {0};

	int rfd = open("test.txt",O_RDONLY);
	if(-1 == rfd) printf("打开文件失败:%m\n"),exit(-1);
	printf("打开文件成功!\n");

	rcb.aio_fildes = rfd;//文件描述符号  
	rcb.aio_buf = (void*)malloc(BUFF_SIZE+1);//开内存
	memset(rcb.aio_buf,0,BUFF_SIZE+1);//清空  全部置零 
	rcb.aio_nbytes = BUFF_SIZE;//数据大小   单位是字节
	rcb.aio_offset = 0;//文件中的偏移量
	//bzero

	aiocb_list[0] = &rcb;//结构体地址放到结构体指针数组内

	int r = aio_read(&rcb);
	if(-1 == r) printf("异步读文件失败:%m\n"),close(rfd),exit(-1);
	printf("异步读文件成功!\n");


	int wfd = open("test2.txt",O_WRONLY | O_APPEND);
	if(-1 == wfd) printf("打开文件失败:%m\n"),exit(-1);
	printf("打开文件成功!\n");
	//2 异步操作
	wcb.aio_fildes = wfd;//文件描述符号  
	wcb.aio_buf = (void*)malloc(BUFF_SIZE+1);//开内存
	memset(wcb.aio_buf,0,BUFF_SIZE+1);//清空  全部置零 
	strcpy(wcb.aio_buf,"提前祝大家国庆节快乐，假期别忘记写代码");
	wcb.aio_nbytes = strlen("提前祝大家国庆节快乐，假期别忘记写代码");//数据大小   单位是字节
	wcb.aio_offset = 0;//文件中的偏移量

	aiocb_list[1] = &wcb;//结构体地址放到结构体指针数组内

	//bzero
	r = aio_write(&wcb);
	if(-1 == r) printf("异步写文件失败:%m\n"),close(wfd),exit(-1);
	printf("异步写文件成功!\n");

	//4 用 lio_listio来监视多个io操作
	//r = lio_listio(LIO_NOWAIT,aiocb_list,2,NULL);//不阻塞直接返回
	r = lio_listio(LIO_WAIT,aiocb_list,2,NULL);//阻塞
	printf("lio_listio完毕 r:%d\n",r);

	//5 得到数据
	r = aio_return(&rcb);
	if(r > 0){
		printf("拿到数据:r:%d  >> %s\n",
		r,rcb.aio_buf);
	}

	r = aio_return(&wcb);
	if(r > 0){
		printf("拿到数据:r:%d  >> %s\n",
		r,wcb.aio_buf);
	}

	free(wcb.aio_buf);
	free(rcb.aio_buf);
	close(rfd);
	close(wfd);


	return 0;
}

2.4 aio_suspend示例

#include <stdio.h>
#include <unistd.h>
#include <aio.h>
#include <string.h>
#include <stdlib.h>
#include <fcntl.h>

#define BUFF_SIZE  1024

#define LIO_LISTIO_NUM  2

int main(){
	//准备缓冲区
	struct aiocb rcb = {0};
	struct aiocb wcb = {0};

	//准备结构体指针数组
	struct aiocb* aiocb_list[LIO_LISTIO_NUM] = {0};
	int rfd,r;
#if 1
	rfd = open("test.txt",O_RDONLY);
	if(-1 == rfd) printf("打开文件失败:%m\n"),exit(-1);
	printf("打开文件成功!\n");

	rcb.aio_fildes = rfd;//文件描述符号  
	rcb.aio_buf = (void*)malloc(BUFF_SIZE+1);//开内存
	memset(rcb.aio_buf,0,BUFF_SIZE+1);//清空  全部置零 
	rcb.aio_nbytes = BUFF_SIZE;//数据大小   单位是字节
	rcb.aio_offset = 0;//文件中的偏移量
	//bzero

	aiocb_list[0] = &rcb;//结构体地址放到结构体指针数组内

	r = aio_read(&rcb);
	if(-1 == r) printf("异步读文件失败:%m\n"),close(rfd),exit(-1);
	printf("异步读文件成功!\n");

#endif
	int wfd = open("test2.txt",O_WRONLY | O_APPEND);
	if(-1 == wfd) printf("打开文件失败:%m\n"),exit(-1);
	printf("打开文件成功!\n");
	//2 异步操作
	wcb.aio_fildes = wfd;//文件描述符号  
	wcb.aio_buf = (void*)malloc(BUFF_SIZE+1);//开内存
	memset(wcb.aio_buf,0,BUFF_SIZE+1);//清空  全部置零 
	strcpy(wcb.aio_buf,"提前祝大家国庆节快乐，假期别忘记写代码");
	wcb.aio_nbytes = strlen("提前祝大家国庆节快乐，假期别忘记写代码");//数据大小   单位是字节
	wcb.aio_offset = 0;//文件中的偏移量

	aiocb_list[0] = &wcb;//结构体地址放到结构体指针数组内

	//bzero
	r = aio_write(&wcb);
	if(-1 == r) printf("异步写文件失败:%m\n"),close(wfd),exit(-1);
	printf("异步写文件成功!\n");

	//4 用 aio_suspend 阻塞式等待
	r = aio_suspend(aiocb_list,2,NULL);
	printf("aio_suspend 阻塞式等待 完毕：r:%d\n",r);

	//5 得到数据
	r = aio_return(&rcb);
	if(r > 0){
		printf("拿到数据:r:%d  >> %s\n",
		r,rcb.aio_buf);
	}

	r = aio_return(&wcb);
	if(r > 0){
		printf("拿到数据:r:%d  >> %s\n",
		r,wcb.aio_buf);
	}

	free(wcb.aio_buf);
	free(rcb.aio_buf);
	close(rfd);
	close(wfd);


	return 0;
}

posted @ 2023-05-08 11:35 [BORUTO] 阅读(324) 评论(0) 收藏举报

刷新页面返回顶部

EKKO：

时间在溜，年龄在长，懂得多了，看得透了，快乐少了，焦虑多了，可能这就是长大的代价吧