libiop网络库数据结构和基础知识

最近朋友推荐,学习了libiop这个网络库,作者封装的很全面,代码很简洁

适合初学者学习基于事件驱动的网络io,先看看iop_def.h, 这里面定义了常用的数据结构

tag_iop_base_t 主要用于管理所有事件,每个事件是一个iop_t,

maxio表示最大的文件描述符,

free_list_head 表示可用的空闲列表头部id,一般用iops + free_list_head取出iop_t 的元素

同理free_list_tail,最后一个可用iop,

iop_op_t 是封装了几个函数指针的结构体,

包括网络模型的名字,事件的添加事件的删除事件的更改事件的派发

剩下的如注释所示

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
struct tag_iop_base_t
{
iop_t *iops; /*所有iop*/
int maxio; /*最大并发io数,包括定时器在内*/
int maxbuf; /*单个发送或接收缓存的最大值*/
int free_list_head; /*可用iop列表*/
int free_list_tail; /*最后一个可用iop*/
int io_list_head; /*已用io类型的iop列表*/
int timer_list_head; /*已用timer类型的iop列表*/
int connect_list_head; /*异步连接的iop列表*/
volatile int exit_flag; /*退出标志*/

int dispatch_interval; /*高度的间隔时间*/
iop_op_t op_imp; /*事件模型的内部实现*/
void *model_data; /*事件模型特定的数据*/

iop_time_t cur_time; /*当前调度时间*/
iop_time_t last_time; /*上次调度时间*/
iop_time_t last_keepalive_time; /*上次检查keepalive的时间*/

_list_node_t * tcp_protocol_list_head; /*use for advance tcp server model.*/
};

看一下iop_t结构体,id是从0开始到n的数,这个是在tag_iop_base_t 中初始化队列时做的,io_handle_t是这个结构存储的socket id, iop_type分三种0表示释放1表示io读写2表示定时器事件iop_event_cb表示事件回调函数指针,每一个iop_t绑定了不同的回调函数,

比如accept,比如read,比如write,但是这些回调函数要封装成iop_event_cb类型dbuf_t 是作者封装的一个管理发送和接受数据的结构

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
/*
*tag_iop_t:iop结构,每一个iop对象都会对应一个tag_iop_t结构
*/
struct tag_iop_t
{
int id; /*对应的id*/
io_handle_t handle; /*关联的句柄*/
int iop_type; /*对象类型:0:free,1:io,2:timer*/
int prev; /*上一个对象*/
int next; /*下一个对象*/
unsigned int events; /*关注的事件*/
int timeout; /*超时值*/
iop_event_cb evcb; /*事件回调*/
void *arg; /*用户指定的参数,由用户负责释放资源*/
void *sys_arg; /*系统指定的参数,系统自动释放资源*/
/*以下字段对定时器无用*/
dbuf_t *sbuf; /*发送缓存区*/
dbuf_t *rbuf; /*接收缓存区*/
iop_time_t last_dispatch_time; /*上次调度的时间*/
};

iop_event_cb 定义如下

/事件回调函数,返回-1代表要删除对象,返回0代表正常/
typedef int (*iop_event_cb)(iop_base_t *,int,unsigned int,void *);

dbuf_t结构如下

1
2
3
4
5
6
struct tag_dbuf
{
unsigned int capacity;
unsigned int size;
void *data;
};

至于dbuf_t如何开辟空间释放空间,读写偏移的都不做赘述,iop_base_t中iop_op_t 结构很重要,是事件调度的核心

结构如下

1
2
3
4
5
6
7
8
9
10
11
12
struct tag_iop_op_t
{
const char *name; //模型名称
void (*base_free)(iop_base_t *); //资源释放的接口
int (*base_dispatch)(iop_base_t *, int); //模型调度接口
//添加事件
int (*base_add)(iop_base_t *, int, io_handle_t, unsigned int);
//删除事件
int (*base_del)(iop_base_t *, int,io_handle_t);
//修改事件
int (*base_mod)(iop_base_t *, int, io_handle_t, unsigned int);
};

因为对应不同的平台,我们要应用不同的网络模型,比如epoll,select,iocp等等。

但是对于异步通信IO我们采取事件回调机制,也就是说提前绑定好读事件,写事件等,

在循环中调用base_dispatch函数指针,就可以实现对于不同模型的派发。

上面就是libiop模型的基本结构和框架

我们看下epoll模型的封装

tag_epoll_data 是封装的epoll基本结构,

这个结构存在iop_base_t的model_data里

1
2
3
4
5
struct tag_epoll_data {
struct epoll_event *events; //监听的epoll_events 队列
int nevents; //epoll_events 事件大小
int epfd; //epoll_create 产生的epoll表句柄
};

两个函数,iop_t应用层的读写宏

EV_TYPE_READEV_TYPE_WRITE
epoll的读写宏
EPOLLINEPOLLOUT互相转换

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
static uint32_t to_epoll_events(uint32_t what)
{
uint32_t events=0;
if(what & EV_TYPE_READ)
{
events = EPOLLIN;
}
if(what & EV_TYPE_WRITE)
{
events |= EPOLLOUT;
}
return events;
}

static uint32_t from_epoll_events(uint32_t events)
{
uint32_t what=0;
if(events & (EPOLLHUP|EPOLLERR))
{
what = EV_TYPE_READ | EV_TYPE_WRITE;
}
else
{
if(events & EPOLLIN){what |= EV_TYPE_READ;}
if(events & EPOLLOUT){what |= EV_TYPE_WRITE;}
}
return what;
}

初始化epoll结构和数据

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
int iop_init_epoll(void *iop_base, int maxev)
{
iop_base_t *base = (iop_base_t *)iop_base;
//iop_base 事 件 操作结构体

//iop_base_t中op_imp取出模型抽象的结构体
iop_op_t *iop_op = &(base->op_imp);
//开辟epoll_data空间
iop_epoll_data_t *iop_data = (iop_epoll_data_t *)(malloc(sizeof(iop_epoll_data_t)));
if(!iop_data)
{
return -1;
}
//监听的队列大小为maxev
iop_data->nevents = maxev;
//为epll_data里监听事件队列开辟连续空间
iop_data->events = (struct epoll_event *)(malloc(sizeof(struct epoll_event) * maxev));
if(!iop_data)
{
free(iop_data);
return -1;
}

//模型内部实现,不同模型不同的函数指针和名字
iop_op->name = "epoll";
iop_op->base_free = epoll_free;
iop_op->base_dispatch = epoll_dispatch;
iop_op->base_add = epoll_add;
iop_op->base_del = epoll_del;
iop_op->base_mod = epoll_mod;

//1024 is not the max events limit.
//创建epoll表句柄
int epfd = epoll_create(1024);
if(epfd < 0)
{
free(iop_data->events);
free(iop_data);
free(iop_op);
return -1;
}
iop_data->epfd = epfd;


//iop_epoll_data_t类型的数据存在base的model_data里
//方便回调
base->model_data = iop_data;

return 0;
}

对应的释放epoll开辟的空间和数据

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
//epoll 释放
static void epoll_free(iop_base_t *base)
{
//model_data里存放了epoll数据的指针
iop_epoll_data_t *iop_data = (iop_epoll_data_t *)(base->model_data);
if(!iop_data){return;}
//释放events队列
if(iop_data->events)
{
free(iop_data->events);
}
//关闭iop_data->epfd
if(iop_data->epfd >= 0)
{
close(iop_data->epfd);
}
free(iop_data);
base->model_data = (void *)0;
}

epoll 添加事件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
//epoll添加事件
//base 为iop_base回传指针
//id为iop的id
//io_handle_t 为socket
//events 为事件类型(EV_TYPE_READ或者EV_TYPE_WRITE)
static int epoll_add(iop_base_t *base, int id, io_handle_t handle, unsigned int events)
{
iop_epoll_data_t *iop_data = (iop_epoll_data_t *)(base->model_data);
struct epoll_event ev;
ev.data.u32 = id;
//转换为EPOLLIN或者EPOLLOUT
ev.events = to_epoll_events(events);
//iop_set_nonblock(handle);
return epoll_ctl(iop_data->epfd, EPOLL_CTL_ADD, (int)handle, &ev);
}

epoll删除事件

1
2
3
4
5
6
7
8
9
10
11
12
13
//epoll删除事件
//base 为iop_base回传指针
//id为iop的id
//io_handle_t 为socket
static int epoll_del(iop_base_t *base, int id,io_handle_t handle)
{
iop_epoll_data_t *iop_data = (iop_epoll_data_t *)(base->model_data);
struct epoll_event ev;
ev.data.u32 = id;
ev.events = 0;
//ev回传进去,删除epoll_events中socket为handle的注册事件
return epoll_ctl(iop_data->epfd, EPOLL_CTL_DEL, (int)handle, &ev);
}

epoll事件更改

1
2
3
4
5
6
7
8
9
//epoll 模式更改(读写更改)
static int epoll_mod(iop_base_t *base, int id, io_handle_t handle, unsigned int events)
{
iop_epoll_data_t *iop_data = (iop_epoll_data_t *)(base->model_data);
struct epoll_event ev;
ev.data.u32 = id;
ev.events = to_epoll_events(events);
return epoll_ctl(iop_data->epfd, EPOLL_CTL_MOD, (int)handle, &ev);
}

epoll事件派发

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
//epoll 事件派发
static int epoll_dispatch(iop_base_t * base, int timeout)
{
int i;
int id = 0;
iop_t *iop = NULL;
//iop_base中取出模型数据
iop_epoll_data_t *iop_data = (iop_epoll_data_t *)(base->model_data);
int n = 0;
do{
n = epoll_wait(iop_data->epfd, iop_data->events, iop_data->nevents, timeout);
}while((n < 0) && (errno == EINTR));
base->cur_time = time(NULL);
for(i = 0; i < n; i++)
{
//取出iop的id
id = (int)((iop_data->events)[i].data.u32);
if(id >= 0 && id < base->maxio)
{
iop = (base->iops)+id;
//这个宏是调用绑定在iop的事件回调函数(accept,read,write等)
IOP_CB(base,iop,from_epoll_events(iop_data->events[i].events));
}
}
return n;
}

以上就是libiop事件驱动的核心结构和设计,做个简单的总结,如果我们要设计一个多路复用的事件驱动

基本结构是这样的

//eventEle是应用层管理的最小单元

int (*WRAFuc )(eventLoop* eventLoopP, int id, int mask, ...);

//mask为应用层自己定义的读写标记

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
struct eventEle

{

int socket; //关联的socket

WRAFuc mPfunc; //读写接受等功能回调的函数

//读写缓冲区可自己封装

char readBuf[]; //读缓冲区

char writeBuff[]; //写缓冲区

};

//事件轮询的基本结构

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
struct eventLoop

{

eventEle * eventList;

int maxfd;

int lastActiveTime;

iop_op_t op_imp; /*事件模型的内部实现*/

void * model_data; /*void 指针指向开辟的不同模型的数据*/

};

不同模型的操作进行封装成一个结构体,

结构体里面有添加,删除,更改,派发,释放的函数指针

1
2
3
4
5
6
7
8
9
10
11
12
struct tag_iop_op_t
{
const char *name; //模型名称
void (*base_free)(iop_base_t *); //资源释放的接口
int (*base_dispatch)(iop_base_t *, int); //模型调度接口
//添加事件
int (*base_add)(iop_base_t *, int, io_handle_t, unsigned int);
//删除事件
int (*base_del)(iop_base_t *, int,io_handle_t);
//修改事件
int (*base_mod)(iop_base_t *, int, io_handle_t, unsigned int);
};

这就是设计一个基本的事件驱动网络库的基本思路,

源代码下载地址:http://download.csdn.net/detail/secondtonone1/9517689