I/O多路复用—epoll服务器

epoll是Linux内核为处理大批量文件描述符而作了改进的poll，是Linux下多路复用IO接口select/poll的增强版本，它能显著提高程序在大量并发连接中只有少量活跃的情况下的系统CPU利用率。另一点原因就是获取事件的时候，它无须遍历整个被侦听的描述符集，只要遍历那些被内核IO事件异步唤醒而加入Ready队列的描述符集合就行了。epoll除了提供select/poll那种IO事件的水平触发（Level Triggered）外，还提供了边缘触发（Edge Triggered），这就使得用户空间程序有可能缓存IO状态，减少epoll_wait/epoll_pwait的调用，提高应用程序效率。

使用：

LT（level triggered）是缺省的工作方式，并且同时支持block和no-block socket.在这种做法中，内核告诉你一个文件描述符是否就绪了，然后你可以对这个就绪的fd进行IO操作。如果你不作任何操作，内核还是会继续通知你的，所以，这种模式编程出错误可能性要小一点。传统的select/poll都是这种模型的代表。

ET （edge-triggered）是高速工作方式，只支持non-block socket。在这种模式下，当描述符从未就绪变为就绪时，内核通过epoll告诉你。然后它会假设你知道文件描述符已经就绪，并且不会再为那个文件描述符发送更多的就绪通知，直到你做了某些操作导致那个文件描述符不再为就绪状态了（比如，你在发送，接收或者接收请求，或者发送接收的数据少于一定量时导致了一个EWOULDBLOCK 错误）。但是请注意，如果一直不对这个fd作IO操作（从而导致它再次变成未就绪），内核不会发送更多的通知（only once），不过在TCP协议中，ET模式的加速效用仍需要更多的benchmark确认。

ET和LT的区别就在这里体现，LT事件不会丢弃，而是只要读buffer里面有数据可以让用户读，则不断的通知你。而ET则只在事件发生之时通知。可以简单理解为LT是水平触发，而ET则为边缘触发。LT模式只要有事件未处理就会触发，而ET则只在高低电平变换时（即状态从1到0或者0到1）触发。

epoll的相关系统调用
epoll只有epoll_create,epoll_ctl,epoll_wait 3个系统调用。
1. int epoll_create(int size);
创建⼀一个epoll的句柄。自从linux2.6.8之后，size参数是被忽略的。需要注意的是，当创建好epoll句柄后，它就是会占用一个fd值，在linux下如果查看/proc/进程id/fd/，是能够看到这个fd的，所以在使用完epoll后，必须调用close()关闭，否则可能导致fd被耗尽。
2. int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
epoll的事件注册函数，它不同于select()是在监听事件时告诉内核要监听什么类型的事件，而是在这里先注册要监听的事件类型。第一个参数是epoll_create()的返回值。第二个参数表示动作，用三个宏来表示：
EPOLL_CTL_ADD：注册新的fd到epfd中；

EPOLL_CTL_MOD：修改已经注册的fd的监听事件；

EPOLL_CTL_DEL：从epfd中删除一个fd；
第三个参数是需要监听的fd。
第四个参数是告诉内核需要监听什么事，struct epoll_event结构如下：

struct epoll_event
{
     _uint32_t events;   //epoll事件
     epoll_data_t data;  //用户数据
}

events可以是以下几个宏的集合：
EPOLLIN ：表示对应的文件描述符可以读（包括对端SOCKET正常关闭）；
EPOLLOUT：表示对应的文件描述符可以写；
EPOLLPRI：表示对应的文件描述符有紧急的数据可读（这里应该表示有带外数据到来）；
EPOLLERR：表示对应的文件描述符发生错误；
EPOLLHUP：表示对应的文件描述符被挂断；
EPOLLET： 将EPOLL设为边缘触发(Edge Triggered)模式，这是相对于水平触发(LevelTriggered)来说的。
EPOLLONESHOT：只监听一次事件，当监听完这次事件之后，如果还需要继续监听这个socket的话，需要再次把这个socket加入到EPOLL队列里
3. int epoll_wait(int epfd, struct epoll_event * events, int maxevents, int timeout);
收集在epoll监控的事件中已经发送的事件。参数events是分配好的epoll_event结构体数组，epoll将会把发生的事件赋值到events数组中（events不可以是空指针，内核只负责把数据复制到这个events数组中，不会去帮助我们在用户态中分配内存）。maxevents告之内核这个events有多大，这个 maxevents的值不能大于创建epoll_create()时的size，参数timeout是超时时间（毫秒，0会立即返回，-1将不确定，也有说法说是永久阻塞）。如果函数调用成功，返回对应I/O上已准备好的文件描述符数目，如返回0表示已超时。
简易的epoll服务器实现：

#include<stdio.h>
#include<stdlib.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<sys/epoll.h>
#include<string.h>
#include<arpa/inet.h>

static void usage(const char *proc)
{
	printf("Usage :%s [local_ip] [local_port]\n",proc);
}


typedef struct fd_buf{
	int fd;
	char buf[1024];
}fd_buf_t,*fd_buf_p;

static void *alloc_fd_buf(int fd)
{
	fd_buf_p tmp=(fd_buf_p)malloc(sizeof(fd_buf_t));
	if(!tmp){
		perror("malloc");
		return NULL;
	}
	tmp->fd=fd;
	return tmp;
}

int startup(const char *_ip,int _port)
{
	int sock=socket(AF_INET,SOCK_STREAM,0);
	if(sock<0){
		perror("socket");
		exit(2);
	}

	int opt=1;
	setsockopt(sock,SOL_SOCKET,SO_REUSEADDR,&opt,sizeof(opt));
	struct sockaddr_in local;
	local.sin_family=AF_INET;
	local.sin_port=htons(_port);
	local.sin_addr.s_addr=inet_addr(_ip);

	if(bind(sock,(struct sockaddr*)&local,sizeof(local))<0){
		perror("bind");
		exit(3);
	}

	if(listen(sock,10)<0){
		perror("listen");
		exit(4);
	}

	return sock;
}


int main(int argc,char *argv[])
{
	if(argc!=3){
		usage(argv[0]);
		return 1;
	}
	int listen_sock=startup(argv[1],atoi(argv[2]));
	int epollfd=epoll_create(256);
	if(epollfd<0){
		perror("epoll_create");
		close(listen_sock);
		return 5;
	}
	struct epoll_event ev;
	ev.events = EPOLLIN;
	ev.data.ptr=alloc_fd_buf(listen_sock);
	epoll_ctl(epollfd,EPOLL_CTL_ADD,listen_sock,&ev);

	int nums=0;
	struct epoll_event evs[64];
	int timeout=-1;
	while(1){
		switch((nums=epoll_wait(epollfd,evs,64,timeout))){
			case -1:
				perror("epoll_wait");
				break;
			case 0:
				printf("timeout");
				break;
			default:
				{
					int i=0;
					for(;i<nums;i++)
					{
						fd_buf_p fp=(fd_buf_p)evs[i].data.ptr;
						if(fp->fd==listen_sock&&\
								(evs[i].events & EPOLLIN))
						{
							struct sockaddr_in client;
							socklen_t len=sizeof(client);
							int new_sock=accept(listen_sock,\
									(struct sockaddr*)&client,&len);
							if(new_sock<0)
							{
								perror("accept");
								continue;
							}
							printf("get a new client!\n");
							ev.events=EPOLLIN;
							ev.data.ptr=alloc_fd_buf(new_sock);
							epoll_ctl(epollfd,EPOLL_CTL_ADD,\
									new_sock,&ev);
						}
						else if(fp->fd!=listen_sock)
						{
							if(evs[i].events & EPOLLIN)
							{
								ssize_t s=read(fp->fd,fp->buf,\
										sizeof(fp->buf));
								if(s>0)
								{
									fp->buf[s]=0;
									printf("client say# %s\n",fp->buf);
									ev.events=EPOLLOUT;
									ev.data.ptr=fp;
									epoll_ctl(epollfd,EPOLL_CTL_MOD,\
											fp->fd,&ev);
								}
								else if(s<=0)
								{
									close(fp->fd);
									epoll_ctl(epollfd,EPOLL_CTL_DEL,\
											fp->fd,NULL);
									free(fp);
								}
								else{}
							}
							else if(evs[i].events & EPOLLOUT)
							{
								const char *msg="HTTP/1.0 200 OK\r\n\r\n<html><h1>hello epoll!</h1></html>";
								write(fp->fd,msg,strlen(msg));
								close(fp->fd);
								epoll_ctl(epollfd,EPOLL_CTL_DEL,\
										fp->fd,NULL);
								free(fp);
							}
							else{}
						}
						else{}
					}
				}
				break;
		}
	}
	
	return 0;
}