z_epoll.cpp

socket的事件分发模型

#include "skfwd.h"
#include "epoll.h"
#include <assert.h>

#define MAX_EPOLL_FD 10
struct epoll_info{
	struct epoll_event* pEvents;
	int* pSocks;
	size_t size;
	size_t count;
};

epoll_info g_epoll_info[MAX_EPOLL_FD];

static int ep_get_idx(int epfd, int fd)
{
	assert(epfd >= 0 && epfd < MAX_EPOLL_FD);
	epoll_info* p = &g_epoll_info[epfd];
	assert(p->pSocks);
	for(size_t i = 0 ; i < p->size ; ++i)
	{
		if (p->pSocks[i] == fd)
			return i;
	}
	return -1;
}

static int ep_fill_set(int epfd, fd_set& rset, fd_set& wset, fd_set& eset, fd_set*& pr, fd_set*& pw, fd_set*& pe)
{
	int maxfd = -1;
	assert(epfd >= 0 && epfd < MAX_EPOLL_FD);
	epoll_info* p = &g_epoll_info[epfd];

	pr = 0;
	pw = 0;
	pe = 0;
	FD_ZERO(&rset);
	FD_ZERO(&wset);
	FD_ZERO(&eset);
	
	for(size_t i = 0 ; i < p->count ; ++i)
	{
		int fd = p->pSocks[i];
		int events = p->pEvents[i].events;
		if (fd >= 0){
			if (events & EPOLLIN){
				FD_SET(fd, &rset);
				pr = &rset;
			}
			if (events & EPOLLOUT){
				FD_SET(fd, &wset);
				pw = &wset;
			}
			if (events & EPOLLERR){
				FD_SET(fd, &eset);
				pe = &eset;
			}
			if (fd > maxfd)
				maxfd = fd;
		}
	}	
	return maxfd;
}

static int ep_trans_events(int epfd, fd_set* pr, fd_set* pw, fd_set* pe, struct epoll_event* pEvents, int maxcnt)
{
	assert(epfd >= 0 && epfd < MAX_EPOLL_FD);
	epoll_info* p = &g_epoll_info[epfd];

	int ee_idx = 0;

	for(size_t i = 0 ; i < p->count ; ++i)
	{
		bool hasEvent = false;
		if (ee_idx >= maxcnt)
			break;
		pEvents[ee_idx] = p->pEvents[i];
		pEvents[ee_idx].events = 0;
		if (p->pSocks[i] >= 0){
			if (pr && FD_ISSET(p->pSocks[i], pr)){
				pEvents[ee_idx].events |= EPOLLIN;
				hasEvent = true;
			}
			if (pw && FD_ISSET(p->pSocks[i], pw)){
				pEvents[ee_idx].events |= EPOLLOUT;
				hasEvent = true;
			}
			if (pe && FD_ISSET(p->pSocks[i], pe)){
				pEvents[ee_idx].events |= EPOLLERR;
				hasEvent = true;
			}
		}
		if (hasEvent)
			++ee_idx;
	}
	return ee_idx;
}

int epoll_create(int size)
{
	epoll_info* p = 0;
	int idx;
	
	for(idx = 0 ; idx < MAX_EPOLL_FD ; ++idx)
	{
		if (!g_epoll_info[idx].pEvents){
			p = &g_epoll_info[idx];
			break;
		}
	}
	if (!p)
		return -1;
	p->size = size;
	p->count = 0;
	p->pSocks = new int[size];
	p->pEvents = new epoll_event[size];
	
	for(int i = 0 ; i < size ; ++i)
		p->pSocks[i] = -1;
	return idx;
}

int epoll_close(int epfd)
{
	assert(epfd >= 0 && epfd < MAX_EPOLL_FD);
	epoll_info* p = &g_epoll_info[epfd];
	delete[] p->pEvents;
	delete[] p->pSocks;
	p->pEvents = 0;
	p->pSocks = 0;
	p->count = 0;
	p->size = 0;
	return 0;
}

int epoll_ctl(int epfd, int op, int fd, struct epoll_event* pEvents)
{
	assert(epfd >= 0 && epfd < MAX_EPOLL_FD);
	epoll_info* p = &g_epoll_info[epfd];
	assert(p->pEvents);
	
	switch(op)
	{
	case EPOLL_CTL_ADD:
		{
			if (p->count >= p->size)
				return -1;
			assert(ep_get_idx(epfd, fd) < 0);

			p->pEvents[p->count] = *pEvents;
			p->pSocks[p->count] = fd;
			++p->count;
			return 0;
		}
		break;
	case EPOLL_CTL_DEL:
		{
			int idx = ep_get_idx(epfd, fd);
			if (idx < 0)
				return -1;
			if (idx < (int)p->count-1){	//不是最后一个
				p->pSocks[idx] = p->pSocks[p->count-1];
				p->pEvents[idx] = p->pEvents[p->count-1];
			}
			--p->count;
			return 0;
		}
		break;
	case EPOLL_CTL_MOD:
		{
			int idx = ep_get_idx(epfd, fd);
			if (idx < 0)
				return -1;
			p->pEvents[idx] = *pEvents;
		}
		break;
	default:
		return -1;
	}
	return 0;
}
		

int epoll_wait(int epfd, struct epoll_event* events, int maxevents, int timeout)
{
	timeval tv;
	tv.tv_sec = timeout/1000;
	tv.tv_usec = timeout%1000;
	
	fd_set rset, wset, eset;
	fd_set* pr, *pw, *pe;

	ep_fill_set(epfd, rset, wset, eset, pr, pw, pe);
	
	int ret = ::select(0, pr, pw, pe, timeout >= 0 ? &tv : 0);
	
	if (ret <= 0)
		return ret;
	return ep_trans_events(epfd, pr, pw, pe, events, maxevents);
}