libevent源码学习研究(libevent-0.1)

Posted MostHandsomeWang

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了libevent源码学习研究(libevent-0.1)相关的知识,希望对你有一定的参考价值。

<span style="font-family: Arial, Helvetica, sans-serif; background-color: rgb(255, 255, 255);">想学习研究libevent怎么设计的,学习它的思想,学习它的设计,奈何自己实力不够啊,于是另辟奇径,从最早的版本开始,一个版本一个版本的学习,不信吃不透它。</span>


struct event {
	TAILQ_ENTRY (event) ev_read_next;
	TAILQ_ENTRY (event) ev_write_next;
	TAILQ_ENTRY (event) ev_timeout_next;
	TAILQ_ENTRY (event) ev_add_next;

	int ev_fd;
	short ev_events;

	struct timeval ev_timeout;

	void (*ev_callback)(int, short, void *arg);
	void *ev_arg;

	int ev_flags;
};
以上为事件的结构体,libevent通过这个结构体管理事件

void event_init(void);
int event_dispatch(void);

int timeout_next(struct timeval *);
void timeout_process(void);
void event_set(struct event *, int, short, void (*)(int, short, void *), void *);
void event_add(struct event *, struct timeval *);
void event_del(struct event *);


int event_pending(struct event *, short, struct timeval *);
以上为libevent提供的接口,下面我们一个一个的详细分析他们

首先,事件初始化,初始化libevent


/*四个队列的头指针*/
TAILQ_HEAD (timeout_list, event) timequeue;		
TAILQ_HEAD (event_wlist, event) writequeue;
TAILQ_HEAD (event_rlist, event) readqueue;
TAILQ_HEAD (event_ilist, event) addqueue;

接着是libevent的核心循环函数

/*
	事件处理的主循环:int event_dispatch(void)
	功能描述:事件处理的主循环,循环监听,调用事件的回调函数处理
	函数实现:1.开始循环之前,先调用函数event_recalc()分配合适的fd_set
			  2.进入处理循环
				(1).遍历读事件队列和写事件队列,将描述符添加到fd_set中
				(2).调用timeout_next(),得到阻塞等待时间
				(3).调用select监听
				(4).遍历读写队列,看看有那个事件被触发,调用对应的回调函数,并将其从队列中移出
					如果没有被触发,它们将仍被保留在队列中,这个时候我们从它们中再次找到最大文件描述符
					并且,在处理期间,要将inloop标记置位,防止在读写队列期间,再将新的事件移入队列
				(5).处理完之后,遍历add队列,将add队列中的事件,对应投入读或者写队列中
				(6).根据新的最大描述符,调用event_recalc()重新分配fd_set空间
				(7).调用timeout_process()处理
				
*/
int
event_dispatch(void)
{
	struct timeval tv;
	struct event *ev, *old;
	int res, maxfd;

	/* Calculate the initial events that we are waiting for */
	//1.开始循环之前,重新计算分配描述符集合大小
	if (events_recalc(0) == -1)
		return (-1);

	while (1) {
		//将读写事件集全部清0,类似于FD_ZERO
		memset(event_readset, 0, event_fdsz);
		memset(event_writeset, 0, event_fdsz);
		
		//遍历写事件集合队列
		TAILQ_FOREACH(ev, &writequeue, ev_write_next)
				//将写事件集合中的描述符,添加道select监听的写数据集
				FD_SET(ev->ev_fd, event_writeset);
		//遍历读事件集合队列
		TAILQ_FOREACH(ev, &readqueue, ev_read_next)
				//遍历读事件集合队列,将事件描述符添加到select监听
				FD_SET(ev->ev_fd, event_readset);
		
		//时间设置
		timeout_next(&tv);

		if ((res = select(event_fds + 1, event_readset, 
				  event_writeset, NULL, &tv)) == -1) {
			if (errno != EINTR) {
				log_error("select");
				return (-1);
			}
			continue;
		}

		LOG_DBG((LOG_MISC, 80, __FUNCTION__": select reports %d",
			 res));
		
		maxfd = 0;
		event_inloop = 1;
		for (ev = TAILQ_FIRST(&readqueue); ev;) {
			//从读事件队头拿出读事件
			old = TAILQ_NEXT(ev, ev_read_next);
			if (FD_ISSET(ev->ev_fd, event_readset)) {
				//看看这个事件是否就绪
				event_del(ev);
				//从事件队列中删除事件
				(*ev->ev_callback)(ev->ev_fd, EV_READ,
						   ev->ev_arg);
					//调用事件注册的处理函数
			} else if (ev->ev_fd > maxfd)	//否则找最大描述符
				maxfd = ev->ev_fd;

			ev = old;
		}

		for (ev = TAILQ_FIRST(&writequeue); ev;) {
			old = TAILQ_NEXT(ev, ev_read_next);
			if (FD_ISSET(ev->ev_fd, event_writeset)) {
				event_del(ev);
				(*ev->ev_callback)(ev->ev_fd, EV_WRITE,
						   ev->ev_arg);
			} else if (ev->ev_fd > maxfd)
				maxfd = ev->ev_fd;

			ev = old;
		}
		event_inloop = 0;

		for (ev = TAILQ_FIRST(&addqueue); ev; 
		     ev = TAILQ_FIRST(&addqueue)) {
			TAILQ_REMOVE(&addqueue, ev, ev_add_next);
			ev->ev_flags &= ~EVLIST_ADD;
			
			event_add_post(ev);

			if (ev->ev_fd > maxfd)
				maxfd = ev->ev_fd;
		}

		if (events_recalc(maxfd) == -1)
			return (-1);

		timeout_process();
	}

	return (0);
}

在这个主循环函数中,它调用了
events_recalc()这个函数,那么这个函数是干嘛的呢?
<pre name="code" class="cpp">/*
	分配事件集fd_set大小的函数:int event_recalc(int max)
	功能描述:根据,最大事件描述符,分配对应大小的事件集,在unix中,fd_set是通过对应位表示事件描述符的,所以,事件集的大小要足够大
			  参数为最大描述符,根据所传入的参数,分配最大fd_set空间
			  如果,传入的参数为0,函数会自己遍历读写队列,找到最大描述符,分配fd_set空间
	
	函数实现:1.将传入的参数,赋值给存储最大描述符的全局变量event_fds
			  2.判断最大描述符是否为0,是就遍历读写队列,找到队列中最大的描述符
			  3.计算,表示最大描述符,所需要的fd_set字节数
			  4.全局变量event_fdsz存储当前fd_set的字节大小,将最新计算出的fd_set大小和event_fdsz进行比较
				如果,最新计算出的所需大小大于当前fd_set的大小,就重新分配读写集合的空间
				更新全局变量event_fds,event_fdsz,event_readset,event_writeset的值
 */
 
int
events_recalc(int max)
{
	//读写,描述符·集合
	fd_set *readset, *writeset;
	//描述事件的结构体
	struct event *ev;
	int fdsz;
	
	//最大文件描述符在描述符集合中
	event_fds = max;
	
	//如果最大传入描述符为0
	if (!event_fds) {
		//在写队列中遍历找最大描述符
		TAILQ_FOREACH(ev, &writequeue, ev_write_next)
			if (ev->ev_fd > event_fds)
				event_fds = ev->ev_fd;
		//再去遍历读队列
		TAILQ_FOREACH(ev, &readqueue, ev_read_next)
			if (ev->ev_fd > event_fds)
				event_fds = ev->ev_fd;
	//最后event_fds中是最大描述符
	}
	
	//得到fd_set占字节数
	fdsz = howmany(event_fds + 1, NFDBITS) * sizeof(fd_mask);
	if (fdsz > event_fdsz) {
		if ((readset = realloc(event_readset, fdsz)) == NULL) {
			log_error("malloc");
			return (-1);
		}

		if ((writeset = realloc(event_writeset, fdsz)) == NULL) {
			log_error("malloc");
			free(readset);
			return (-1);
		}

		memset(readset + event_fdsz, 0, fdsz - event_fdsz);
		memset(writeset + event_fdsz, 0, fdsz - event_fdsz);

		event_readset = readset;
		event_writeset = writeset;
		event_fdsz = fdsz;
	}

	return (0);
}
/*
初始化事件:void event_set(struct event *ev, int fd, short events,void (*callback)(int, short, void *), void *arg)
功能描述:设置所传入的事件结构体的属性,完成对事件的初始化
函数实现:1.设置事件的回调函数
 2.设置事件的参数ev_arg,它是回调函数的第三个参数
 3.设置事件的参数ev_fd,它是回调函数的第一个参数
 4.设置事件的参数ev_events,它是回调的第二个参数,也代表事件的类型(读、写、超时)
*/
void
event_set(struct event *ev, int fd, short events,
 void (*callback)(int, short, void *), void *arg)
{

ev->ev_callback = callback;
ev->ev_arg = arg;
ev->ev_fd = fd;
ev->ev_events = events;
ev->ev_flags = EVLIST_INIT;
}

 
/*
<span style="white-space:pre">	</span>将事件添加到对应的读或者写队列:void event_add(struct event*ev,struct timeval* tv)
<span style="white-space:pre">	</span>功能描述:将事件添加到对应的读写队列中
<span style="white-space:pre">	</span>函数实现:1.如果阻塞等待时间不为空
<span style="white-space:pre">				</span>(1).得到当前时间
<span style="white-space:pre">				</span>(2).将当前时间与阻塞时间相加得到超时时间
<span style="white-space:pre">				</span>(3).判断事件是否在超时队列中
<span style="white-space:pre">					</span>如果在超时队列中,将事件从队列中移出
<span style="white-space:pre">				</span>(4).在超时队列中寻找合适的位置(超时队列,将超时时间从小到大排列)
<span style="white-space:pre">					</span>如果找到合适的位置,将其插入到该位置
<span style="white-space:pre">					</span>如果没有找到,将其从队尾插入
<span style="white-space:pre">				</span>(5).将事件在超时队列的标记置位
<span style="white-space:pre">			</span>  2.如果事件正在处理中
<span style="white-space:pre">				</span>(1).通过检测标记位判断当前被插入的事件是否之前就已经在add队列中
<span style="white-space:pre">					</span>如果已经在队列中,直接返回
<span style="white-space:pre">					</span>如果没有,将其加入add队列中,并将其标记置位
<span style="white-space:pre">			</span>  3.否则
<span style="white-space:pre">				</span>(1).调用event_add_post()将其加入到对应的读写队列中
*/
void
event_add(struct event *ev, struct timeval *tv)
{
<span style="white-space:pre">	</span>LOG_DBG((LOG_MISC, 55,
<span style="white-space:pre">		</span> "event_add: event: %p, %s%s%scall %p",
<span style="white-space:pre">		</span> ev,
<span style="white-space:pre">		</span> ev->ev_events & EV_READ ? "EV_READ " : " ",
<span style="white-space:pre">		</span> ev->ev_events & EV_WRITE ? "EV_WRITE " : " ",
<span style="white-space:pre">		</span> tv ? "EV_TIMEOUT " : " ",
<span style="white-space:pre">		</span> ev->ev_callback));
<span style="white-space:pre">		</span> 
<span style="white-space:pre">	</span>//如果等待时间不为空
<span style="white-space:pre">	</span>if (tv != NULL) {
<span style="white-space:pre">		</span>struct timeval now;
<span style="white-space:pre">		</span>struct event *tmp;
<span style="white-space:pre">		</span>
<span style="white-space:pre">		</span>//1.得到当前时间
<span style="white-space:pre">		</span>gettimeofday(&now, NULL);
<span style="white-space:pre">		</span>//2.将当前时间与阻塞等待时间相加,得到超时时间
<span style="white-space:pre">		</span>timeradd(&now, tv, &ev->ev_timeout);


<span style="white-space:pre">		</span>LOG_DBG((LOG_MISC, 55,
<span style="white-space:pre">			</span> "event_add: timeout in %d seconds, call %p",
<span style="white-space:pre">			</span> tv->tv_sec, ev->ev_callback));
<span style="white-space:pre">		</span>//如果有超时队列标记(即之前在队列中存在)
<span style="white-space:pre">		</span>if (ev->ev_flags & EVLIST_TIMEOUT)
<span style="white-space:pre">		</span>//将事件从时间队列移出
<span style="white-space:pre">			</span>TAILQ_REMOVE(&timequeue, ev, ev_timeout_next);


<span style="white-space:pre">		</span>/* Insert in right temporal order */
<span style="white-space:pre">		</span>//再次将时间事件找到正确的队列位置插入
<span style="white-space:pre">		</span>for (tmp = TAILQ_FIRST(&timequeue); tmp;
<span style="white-space:pre">		</span>     tmp = TAILQ_NEXT(tmp, ev_timeout_next)) {
<span style="white-space:pre">		</span>     if (timercmp(&ev->ev_timeout, &tmp->ev_timeout, <=))
<span style="white-space:pre">			</span>     break;
<span style="white-space:pre">		</span>}


<span style="white-space:pre">		</span>if (tmp)
<span style="white-space:pre">			</span>TAILQ_INSERT_BEFORE(tmp, ev, ev_timeout_next);
<span style="white-space:pre">		</span>else
<span style="white-space:pre">			</span>TAILQ_INSERT_TAIL(&timequeue, ev, ev_timeout_next);
<span style="white-space:pre">		</span>//再将时间队列标记置位
<span style="white-space:pre">		</span>ev->ev_flags |= EVLIST_TIMEOUT;
<span style="white-space:pre">	</span>}
<span style="white-space:pre">	</span>
<span style="white-space:pre">	</span>//如果事件正在循环中,判断一下被插入的事件是否是从添加等待队列中取出来的,如果是,直接返回,不是,将它添加到等待队列返回
<span style="white-space:pre">	</span>if (event_inloop) {
<span style="white-space:pre">		</span>/* We are in the event loop right now, we have to
<span style="white-space:pre">		</span> * postpone the change until later.
<span style="white-space:pre">		</span> */
<span style="white-space:pre">		</span>if (ev->ev_flags & EVLIST_ADD)
<span style="white-space:pre">			</span>return;


<span style="white-space:pre">		</span>TAILQ_INSERT_TAIL(&addqueue, ev, ev_add_next);
<span style="white-space:pre">		</span>ev->ev_flags |= EVLIST_ADD;
<span style="white-space:pre">	</span>} else
<span style="white-space:pre">		</span>event_add_post(ev);
}
/*
<span style="white-space:pre">	</span>将事件添加到对应的读或者写队列
<span style="white-space:pre">	</span>功能描述:通过判断事件的ev_events标记将其放入对应的队列
<span style="white-space:pre">	</span>函数实现:1.判断事件是读事件,并且事件没有在read队列中,将其添加到读队列,读队列标记置位
<span style="white-space:pre">			</span>  2.判断事件是写事件,并且事件没有在write队列中,将其添加到写队列,写队列标记置位
*/
void
event_add_post(struct event *ev)
{
<span style="white-space:pre">	</span>//如果,事件是读事件,并且没有在读队列中,就添加到读队列
<span style="white-space:pre">	</span>if ((ev->ev_events & EV_READ) && !(ev->ev_flags & EVLIST_READ)) {
<span style="white-space:pre">		</span>TAILQ_INSERT_TAIL(&readqueue, ev, ev_read_next);
<span style="white-space:pre">		</span>
<span style="white-space:pre">		</span>ev->ev_flags |= EVLIST_READ;
<span style="white-space:pre">	</span>}
<span style="white-space:pre">	</span>//如果,事件为写事件,并且没有在写队列,就添加到写队列
<span style="white-space:pre">	</span>if ((ev->ev_events & EV_WRITE) && !(ev->ev_flags & EVLIST_WRITE)) {
<span style="white-space:pre">		</span>TAILQ_INSERT_TAIL(&writequeue, ev, ev_write_next);
<span style="white-space:pre">		</span>
<span style="white-space:pre">		</span>ev->ev_flags |= EVLIST_WRITE;
<span style="white-space:pre">	</span>}
}
/*
<span style="white-space:pre">	</span>删除事件
<span style="white-space:pre">	</span>功能描述:把事件从所在的队列中清除
<span style="white-space:pre">	</span>函数实现:1.判断事件在读或者写或者添加或者超时队列中,将其从对应队列中删除,将其flag位置0
*/
void
event_del(struct event *ev)
{
<span style="white-space:pre">	</span>LOG_DBG((LOG_MISC, 80, "event_del: %p, callback %p",
<span style="white-space:pre">		</span> ev, ev->ev_callback));


<span style="white-space:pre">	</span>if (ev->ev_flags & EVLIST_ADD) {
<span style="white-space:pre">		</span>TAILQ_REMOVE(&addqueue, ev, ev_add_next);


<span style="white-space:pre">		</span>ev->ev_flags &= ~EVLIST_ADD;
<span style="white-space:pre">	</span>}


<span style="white-space:pre">	</span>if (ev->ev_flags & EVLIST_TIMEOUT) {
<span style="white-space:pre">		</span>TAILQ_REMOVE(&timequeue, ev, ev_timeout_next);


<span style="white-space:pre">		</span>ev->ev_flags &= ~EVLIST_TIMEOUT;
<span style="white-space:pre">	</span>}


<span style="white-space:pre">	</span>if (ev->ev_flags & EVLIST_READ) {
<span style="white-space:pre">		</span>TAILQ_REMOVE(&readqueue, ev, ev_read_next);


<span style="white-space:pre">		</span>ev->ev_flags &= ~EVLIST_READ;
<span style="white-space:pre">	</span>}


<span style="white-space:pre">	</span>if (ev->ev_flags & EVLIST_WRITE) {
<span style="white-space:pre">		</span>TAILQ_REMOVE(&writequeue, ev, ev_write_next);


<span style="white-space:pre">		</span>ev->ev_flags &= ~EVLIST_WRITE;
<span style="white-space:pre">	</span>}
}


/*
<span style="white-space:pre">	</span>获得新的阻塞时间
<span style="white-space:pre">	</span>功能描述:获得新的阻塞时间
<span style="white-space:pre">	</span>函数实现:1.如果超时队列没有元素,返回默认超时时间
<span style="white-space:pre">			</span>  2.如果有事件
<span style="white-space:pre">				</span>(1).得到当前时间
<span style="white-space:pre">				</span>(2).和队头事件的超时时间比较,如果已经超时,说明出现问题,直接清空超时时间,不阻塞
<span style="white-space:pre">				</span>(3).没超时,就将剩余的阻塞时间计算出来,作为新的阻塞时间
*/
int
timeout_next(struct timeval *tv)
{
<span style="white-space:pre">	</span>//当前时间
<span style="white-space:pre">	</span>struct timeval now;
<span style="white-space:pre">	</span>//指向事件的指针
<span style="white-space:pre">	</span>struct event *ev;
<span style="white-space:pre">	</span>
<span style="white-space:pre">	</span>//定时器队头事件指针是否为空
<span style="white-space:pre">	</span>if ((ev = TAILQ_FIRST(&timequeue)) == NULL) {
<span style="white-space:pre">		</span>//清空时间
<span style="white-space:pre">		</span>timerclear(tv);
<span style="white-space:pre">		</span>//定时默认5,返回
<span style="white-space:pre">		</span>tv->tv_sec = TIMEOUT_DEFAULT;
<span style="white-space:pre">		</span>return (0);
<span style="white-space:pre">	</span>}
<span style="white-space:pre">	</span>
<span style="white-space:pre">	</span>
<span style="white-space:pre">	</span>//得到当前时间
<span style="white-space:pre">	</span>if (gettimeofday(&now, NULL) == -1)
<span style="white-space:pre">		</span>return (-1);
<span style="white-space:pre">	</span>
<span style="white-space:pre">	</span>//和定时器队头事件定义的超时时间比较
<span style="white-space:pre">	</span>if (timercmp(&ev->ev_timeout, &now, <=)) {
<span style="white-space:pre">		</span>//不超时,清空结构
<span style="white-space:pre">		</span>timerclear(tv);
<span style="white-space:pre">		</span>return (0);
<span style="white-space:pre">	</span>}
<span style="white-space:pre">	</span>//定时器事件超时出的时间,更新到tv中
<span style="white-space:pre">	</span>timersub(&ev->ev_timeout, &now, tv);


<span style="white-space:pre">	</span>LOG_DBG((LOG_MISC, 60, "timeout_next: in %d seconds", tv->tv_sec));
<span style="white-space:pre">	</span>return (0);
}


/*
<span style="white-space:pre">	</span>超时后的处理
<span style="white-space:pre">	</span>功能描述:将超时队列中所有超时的事件从队列中移出,并且执行其对应的回调
<span style="white-space:pre">	</span>函数实现:1.获得当前时间
<span style="white-space:pre">			</span>  2.只要超时队列不为空,进入到队列中
<span style="white-space:pre">				</span>(1).从队头获得的超时时间比当前时间大,说明整个队列中都没有超时,跳出循环
<span style="white-space:pre">				</span>(2).否则,将队头从队列中移出,将队头事件的超时队列标记位置0,调用对应的超时回调处理,继续循环
*/
void
timeout_process(void)
{
<span style="white-space:pre">	</span>struct timeval now;
<span style="white-space:pre">	</span>struct event *ev;


<span style="white-space:pre">	</span>gettimeofday(&now, NULL);


<span style="white-space:pre">	</span>while ((ev = TAILQ_FIRST(&timequeue)) != NULL) {
<span style="white-space:pre">		</span>if (timercmp(&ev->ev_timeout, &now, >))
<span style="white-space:pre">			</span>break;


<span style="white-space:pre">		</span>TAILQ_REMOVE(&timequeue, ev, ev_timeout_next);
<span style="white-space:pre">		</span>ev->ev_flags &= ~EVLIST_TIMEOUT;


<span style="white-space:pre">		</span>LOG_DBG((LOG_MISC, 60, "timeout_process: call %p",
<span style="white-space:pre">			</span> ev->ev_callback));
<span style="white-space:pre">		</span>(*ev->ev_callback)(ev->ev_fd, EV_TIMEOUT, ev->ev_arg);
<span style="white-space:pre">	</span>}
}

以上是关于libevent源码学习研究(libevent-0.1)的主要内容,如果未能解决你的问题,请参考以下文章

Libevent 2.0.22 项目编译问题(OSX)

如何使用 Visual Studio 2008 构建 libevent 2.0.10 版

workerman运行环境的libevent怎么安装

libevent源码剖析

libevent 源码学习二 —— reactor 模式

libev个人问题解惑