很幽默的讲解六种Socket IO模型(转)

本文简单介绍了当前Windows支持的各种Socket I/O模型，如果你发现其中存在什么错误请务必赐教。 一：select模型 二：WSAAsyncSelect模型 三：WSAEventSelect模型 四：Overlapped I/O 事件通知模型 五：Overlapped I/O 完成例程模型 六：IOCP模型 老陈有一个在外地工作的女儿，不能经常回来，老陈和她通过信件联系。他们的信会被邮递员投递到他们的信箱里。 这和Socket模型非常类似。下面我就以老陈接收信件为例讲解Socket I/O模型~~~ 一：select模型 老陈非常想看到女儿的信。以至于他每隔10分钟就下楼检查信箱，看是否有女儿的信~~~~~ 在这种情况下，"下楼检查信箱"然后回到楼上耽误了老陈太多的时间，以至于老陈无法做其他工作。 select模型和老陈的这种情况非常相似：周而复始地去检查......如果有数据......接收/发送....... 使用线程来select应该是通用的做法： procedure TListenThread.Execute; var addr : TSockAddrIn; fd_read : TFDSet; timeout : TTimeVal; ASock, MainSock : TSocket; len, i : Integer; begin MainSock := socket( AF_INET, SOCK_STREAM, IPPROTO_TCP ); addr.sin_family := AF_INET; addr.sin_port := htons(5678); addr.sin_addr.S_addr := htonl(INADDR_ANY); bind( MainSock, @addr, sizeof(addr) ); listen( MainSock, 5 ); while (not Terminated) do begin FD_ZERO( fd_read ); FD_SET( MainSock, fd_read ); timeout.tv_sec := 0; timeout.tv_usec := 500; if select( 0, @fd_read, nil, nil, @timeout ) > 0 then //至少有1个等待Accept的connection begin if FD_ISSET( MainSock, fd_read ) then begin for i:=0 to fd_read.fd_count-1 do //注意，fd_count <= 64，也就是说select只能同时管理最多64个连接 begin len := sizeof(addr); ASock := accept( MainSock, addr, len ); if ASock <> INVALID_SOCKET then ....//为ASock创建一个新的线程，在新的线程中再不停地select end;  end;  end;  end; //while (not self.Terminated) shutdown( MainSock, SD_BOTH ); closesocket( MainSock ); end; 二：WSAAsyncSelect模型 后来，老陈使用了微软公司的新式信箱。这种信箱非常先进，一旦信箱里有新的信件，盖茨就会给老陈打电话：喂，大爷，你有新的信件了！从此，老陈再也不必频繁上下楼检查信箱了，牙也不疼了，你瞅准了，蓝天......不是，微软~~~~~~~~ 微软提供的WSAAsyncSelect模型就是这个意思。 WSAAsyncSelect模型是Windows下最简单易用的一种Socket I/O模型。使用这种模型时，Windows会把网络事件以消息的形势通知应用程序。 首先定义一个消息标示常量： const WM_SOCKET = WM_USER + 55; 再在主Form的private域添加一个处理此消息的函数声明： private procedure WMSocket(var Msg: TMessage); message WM_SOCKET; 然后就可以使用WSAAsyncSelect了： var addr : TSockAddr; sock : TSocket; sock := socket( AF_INET, SOCK_STREAM, IPPROTO_TCP ); addr.sin_family := AF_INET; addr.sin_port := htons(5678); addr.sin_addr.S_addr := htonl(INADDR_ANY); bind( m_sock, @addr, sizeof(SOCKADDR) ); WSAAsyncSelect( m_sock, Handle, WM_SOCKET, FD_ACCEPT or FD_CLOSE ); listen( m_sock, 5 ); .... 应用程序可以对收到WM_SOCKET消息进行分析，判断是哪一个socket产生了网络事件以及事件类型： procedure TfmMain.WMSocket(var Msg: TMessage); var sock : TSocket; addr : TSockAddrIn; addrlen : Integer; buf : Array [0..4095] of Char; begin //Msg的WParam是产生了网络事件的socket句柄，LParam则包含了事件类型 case WSAGetSelectEvent( Msg.LParam ) of FD_ACCEPT : begin addrlen := sizeof(addr); sock := accept( Msg.WParam, addr, addrlen ); if sock <> INVALID_SOCKET then WSAAsyncSelect( sock, Handle, WM_SOCKET, FD_READ or FD_WRITE or FD_CLOSE ); end; FD_CLOSE : closesocket( Msg.WParam ); FD_READ : recv( Msg.WParam, buf[0], 4096, 0 ); FD_WRITE : ; end;  end; 三：WSAEventSelect模型 后来，微软的信箱非常畅销，购买微软信箱的人以百万计数......以至于盖茨每天24小时给客户打电话，累得腰酸背痛，喝蚁力神都不好使~~~~~~ 微软改进了他们的信箱：在客户的家中添加一个附加装置，这个装置会监视客户的信箱，每当新的信件来临，此装置会发出"新信件到达"声，提醒老陈去收信。盖茨终于可以睡觉了。 同样要使用线程： procedure TListenThread.Execute; var hEvent : WSAEvent; ret : Integer; ne : TWSANetworkEvents; sock : TSocket; adr : TSockAddrIn; sMsg : String; Index, EventTotal : DWORD; EventArray : Array [0..WSA_MAXIMUM_WAIT_EVENTS-1] of WSAEVENT; begin ...socket...bind... hEvent := WSACreateEvent(); WSAEventSelect( ListenSock, hEvent, FD_ACCEPT or FD_CLOSE ); ...listen... while ( not Terminated ) do begin Index := WSAWaitForMultipleEvents( EventTotal, @EventArray[0], FALSE, WSA_INFINITE, FALSE ); FillChar( ne, sizeof(ne), 0 ); WSAEnumNetworkEvents( SockArray[Index-WSA_WAIT_EVENT_0], EventArray[Index-WSA_WAIT_EVENT_0], @ne ); if ( ne.lNetworkEvents and FD_ACCEPT ) > 0 then begin if ne.iErrorCode[FD_ACCEPT_BIT] <> 0 then continue; ret := sizeof(adr); sock := accept( SockArray[Index-WSA_WAIT_EVENT_0], adr, ret ); if EventTotal > WSA_MAXIMUM_WAIT_EVENTS-1 then//这里WSA_MAXIMUM_WAIT_EVENTS同样是64 begin closesocket( sock ); continue; end; hEvent := WSACreateEvent(); WSAEventSelect( sock, hEvent, FD_READ or FD_WRITE or FD_CLOSE ); SockArray[EventTotal] := sock; EventArray[EventTotal] := hEvent; Inc( EventTotal ); end; if ( ne.lNetworkEvents and FD_READ ) > 0 then begin if ne.iErrorCode[FD_READ_BIT] <> 0 then continue; FillChar( RecvBuf[0], PACK_SIZE_RECEIVE, 0 ); ret := recv( SockArray[Index-WSA_WAIT_EVENT_0], RecvBuf[0], PACK_SIZE_RECEIVE, 0 ); ...... end; end; end; 分享到： 更多0

对我有用[0]  丢个板砖[0]  引用 |  举报 |  管理 回复次数：123

#1 得分：0 回复于： 2008-07-02 20:48:27 四：Overlapped I/O 事件通知模型 后 来，微软通过调查发现，老陈不喜欢上下楼收发信件，因为上下楼其实很浪费时间。于是微软再次改进他们的信箱。新式的信箱采用了更为先进的技术，只要用户告 诉微软自己的家在几楼几号，新式信箱会把信件直接传送到用户的家中，然后告诉用户，你的信件已经放到你的家中了！老陈很高兴，因为他不必再亲自收发信件 了！ Overlapped I/O 事件通知模型和WSAEventSelect模型在实现上非常相似，主要区别在"Overlapped"，Overlapped模型是让应用程序使用重叠数据结构(WSAOVERLAPPED)，一次投递一个或多个Winsock I/O请求。这些提交的请求完成后，应用程序会收到通知。什么意思呢？就是说，如果你想从socket上接收数据，只需要告诉系统，由系统为你接收数据，而你需要做的只是为系统提供一个缓冲区~~~~~ Listen线程和WSAEventSelect模型一模一样，Recv/Send线程则完全不同： procedure TOverlapThread.Execute; var dwTemp : DWORD; ret : Integer; Index : DWORD; begin ...... while ( not Terminated ) do begin Index := WSAWaitForMultipleEvents( FLinks.Count, @FLinks.Events[0], FALSE, RECV_TIME_OUT, FALSE ); Dec( Index, WSA_WAIT_EVENT_0 ); if Index > WSA_MAXIMUM_WAIT_EVENTS-1 then //超时或者其他错误 continue; WSAResetEvent( FLinks.Events[Index] ); WSAGetOverlappedResult( FLinks.Sockets[Index], FLinks.pOverlaps[Index], @dwTemp, FALSE, FLinks.pdwFlags[Index]^ ); if dwTemp = 0 then //连接已经关闭 begin ...... continue; end else begin fmMain.ListBox1.Items.Add( FLinks.pBufs[Index]^.buf ); end; //初始化缓冲区 FLinks.pdwFlags[Index]^ := 0; FillChar( FLinks.pOverlaps[Index]^, sizeof(WSAOVERLAPPED), 0 ); FLinks.pOverlaps[Index]^.hEvent := FLinks.Events[Index]; FillChar( FLinks.pBufs[Index]^.buf^, BUFFER_SIZE, 0 ); //递一个接收数据请求 WSARecv( FLinks.Sockets[Index], FLinks.pBufs[Index], 1, FLinks.pdwRecvd[Index]^, FLinks.pdwFlags[Index]^, FLinks.pOverlaps[Index], nil ); end; end; 五：Overlapped I/O 完成例程模型 老陈接收到新的信件后，一般的程序是：打开信封----掏出信纸----阅读信件----回复信件......为了进一步减轻用户负担，微软又开发了一种新的技术：用户只要告诉微软对信件的操作步骤，微软信箱将按照这些步骤去处理信件，不再需要用户亲自拆信/阅读/回复了！老陈终于过上了小资生活！ Overlapped I/O 完成例程要求用户提供一个回调函数，发生新的网络事件的时候系统将执行这个函数： procedure WorkerRoutine( const dwError, cbTransferred : DWORD; const lpOverlapped : LPWSAOVERLAPPED; const dwFlags : DWORD ); stdcall; 然后告诉系统用WorkerRoutine函数处理接收到的数据： WSARecv( m_socket, @FBuf, 1, dwTemp, dwFlag, @m_overlap, WorkerRoutine ); 然后......没有什么然后了，系统什么都给你做了！微软真实体贴！ while ( not Terminated ) do//这就是一个Recv/Send线程要做的事情......什么都不用做啊！！！ begin if SleepEx( RECV_TIME_OUT, True ) = WAIT_IO_COMPLETION then // begin ; end else begin continue; end; end; 六：IOCP模型 微软信箱似乎很完美，老陈也很满意。但是在一些大公司情况却完全不同！这些大公司有数以万计的信箱，每秒钟都有数以百计的信件需要处理，以至于微软信箱经常因超负荷运转而崩溃！需要重新启动！微软不得不使出杀手锏...... 微软给每个大公司派了一名名叫"Completion Port"的超级机器人，让这个机器人去处理那些信件！ "Windows NT小组注意到这些应用程序的性能没有预料的那么高。特别的，处理很多同时的客户请求意味着很多线程并发地运行在系统中。因为所有这些线程都是可运行的[没有被挂起和等待发生什么事]，Microsoft意识到NT内核花费了太多的时间来转换运行线程的上下文[Context]，线程就没有得到很多CPU时间来做它们的工作。大家可能也都感觉到并行模型的瓶颈在于它为每一个客户请求都创建了一个新线程。创建线程比起创建进程开销要小，但也远不是没有开销的。我们不妨设想一下：如果事先开好N个线程，让它们在那hold[堵塞]，然后可以将所有用户的请求都投递到一个消息队列中去。然后那N个线程逐一从消息队列中去取出消息并加以处理。就可以避免针对每一个用户请求都开线程。不仅减少了线程的资源，也提高了线程的利用率。理论上很不错，你想我等泛泛之辈都能想出来的问题，Microsoft又怎会没有考虑到呢?"-----摘自nonocast的《理解I/O Completion Port》 先看一下IOCP模型的实现： //创建一个完成端口 FCompletPort := CreateIoCompletionPort( INVALID_HANDLE_VALUE, 0,0,0 ); //接受远程连接，并把这个连接的socket句柄绑定到刚才创建的IOCP上 AConnect := accept( FListenSock, addr, len); CreateIoCompletionPort( AConnect, FCompletPort, nil, 0 ); //创建CPU数*2 + 2个线程 for i:=1 to si.dwNumberOfProcessors*2+2 do begin AThread := TRecvSendThread.Create( false ); AThread.CompletPort := FCompletPort;//告诉这个线程，你要去这个IOCP去访问数据 end; OK，就这么简单，我们要做的就是建立一个IOCP，把远程连接的socket句柄绑定到刚才创建的IOCP上，最后创建n个线程，并告诉这n个线程到这个IOCP上去访问数据就可以了。 再看一下TRecvSendThread线程都干些什么： procedure TRecvSendThread.Execute; var ...... begin while (not self.Terminated) do begin //查询IOCP状态（数据读写操作是否完成） GetQueuedCompletionStatus( CompletPort, BytesTransd, CompletKey, POVERLAPPED(pPerIoDat), TIME_OUT ); if BytesTransd <> 0 then ....;//数据读写操作完成 //再投递一个读数据请求 WSARecv( CompletKey, @(pPerIoDat^.BufData), 1, BytesRecv, Flags, @(pPerIoDat^.Overlap), nil ); end; end; 读写线程只是简单地检查IOCP是否完成了我们投递的读写操作，如果完成了则再投递一个新的读写请求。 应该注意到，我们创建的所有TRecvSendThread都在访问同一个IOCP（因为我们只创建了一个IOCP），并且我们没有使用临界区！难道不会产生冲突吗？不用考虑同步问题吗？ 呵呵，这正是IOCP的奥妙所在。IOCP不是一个普通的对象，不需要考虑线程安全问题。它会自动调配访问它的线程：如果某个socket上有一个线程A正在访问，那么线程B的访问请求会被分配到另外一个socket。这一切都是由系统自动调配的，我们无需过问。

关注CSDN论坛微博 送CSDN积分大礼包 对我有用[0]  丢个板砖[0]  引用 |  举报 |  管理

#2 得分：0 回复于： 2008-07-02 20:50:26 深入了解epoll 一、 介绍 Epoll是一种高效的管理socket的模型，相对于select和poll来说具有更高的效率和易用性。传统的select以及poll的效率会因为socket数量的线形递增而导致呈二次乃至三次方的下降，而epoll的性能不会随socket数量增加而下降。标准的linux-2.4.20内核不支持epoll，需要打patch。本文主要从linux-2.4.32和linux-2.6.10两个内核版本介绍epoll。 二、 Epoll的使用 epoll用到的所有函数都是在头文件sys/epoll.h中声明的，下面简要说明所用到的数据结构和函数： 所用到的数据结构 typedef union epoll_data {                 void *ptr;                 int fd;                 __uint32_t u32;                 __uint64_t u64;         } epoll_data_t;         struct epoll_event {                 __uint32_t events;      /* Epoll events */                 epoll_data_t data;      /* User data variable */         }; 结构体epoll_event 被用于注册所感兴趣的事件和回传所发生待处理的事件，其中epoll_data 联合体用来保存触发事件的某个文件描述符相关的数据，例如一个client连接到服务器，服务器通过调用accept函数可以得到于这个client对应的socket文件描述符，可以把这文件描述符赋给epoll_data的fd字段以便后面的读写操作在这个文件描述符上进行。epoll_event 结构体的events字段是表示感兴趣的事件和被触发的事件可能的取值为：EPOLLIN ：表示对应的文件描述符可以读； EPOLLOUT：表示对应的文件描述符可以写； EPOLLPRI：表示对应的文件描述符有紧急的数据可读 EPOLLERR：表示对应的文件描述符发生错误； EPOLLHUP：表示对应的文件描述符被挂断； EPOLLET：表示对应的文件描述符设定为edge模式； 所用到的函数： 1、epoll_create函数      函数声明：int epoll_create(int size)      该函数生成一个epoll专用的文件描述符，其中的参数是指定生成描述符的最大范围。在linux-2.4.32内核中根据size大小初始化哈希表的大小，在linux2.6.10内核中该参数无用，使用红黑树管理所有的文件描述符，而不是hash。 2、epoll_ctl函数      函数声明：int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event)      该函数用于控制某个文件描述符上的事件，可以注册事件，修改事件，删除事件。     参数：epfd：由 epoll_create 生成的epoll专用的文件描述符；                 op：要进行的操作例如注册事件，可能的取值 EPOLL_CTL_ADD 注册、 EPOLL_CTL_MOD 修改、 EPOLL_CTL_DEL 删除      fd：关联的文件描述符；      event：指向epoll_event的指针；     如果调用成功返回0,不成功返回-1 3、epoll_wait函数 函数声明:int epoll_wait(int epfd,struct epoll_event * events,int maxevents,int timeout) 该函数用于轮询I/O事件的发生； 参数： epfd:由epoll_create 生成的epoll专用的文件描述符； epoll_event:用于回传代处理事件的数组； maxevents:每次能处理的事件数； timeout:等待I/O事件发生的超时值（ms）；-1永不超时，直到有事件产生才触发，0立即返回。 返回发生事件数。-1有错误。 举一个简单的例子： int main() { //声明epoll_event结构体的变量,ev用于注册事件,数组用于回传要处理的事件 struct epoll_event ev,events[20]; epfd=epoll_create(10000); //创建epoll句柄 listenfd = socket(AF_INET, SOCK_STREAM, 0); //把socket设置为非阻塞方式 setnonblocking(listenfd); bzero(&serveraddr, sizeof (serveraddr)); serveraddr.sin_family = AF_INET; serveraddr.sin_addr.s_addr = INADDR_ANY; serveraddr.sin_port=htons(SERV_PORT); bind(listenfd,( struct sockaddr *)&serveraddr, sizeof (serveraddr)); listen(listenfd, 255); //设置与要处理的事件相关的文件描述符 ev.data.fd=listenfd; //设置要处理的事件类型 ev.events=EPOLLIN; //注册epoll事件 epoll_ctl(epfd,EPOLL_CTL_ADD,listenfd,&ev); for ( ; ; ) { //等待epoll事件的发生 nfds=epoll_wait(epfd,events,20,1000); //处理所发生的所有事件 for (i=0;i { if (events[i].data.fd==listenfd) { connfd = accept(listenfd,( struct sockaddr *)&clientaddr, &clilen); if (connfd<0) { perror ( "connfd<0" ); } setnonblocking(connfd); //设置用于读操作的文件描述符 ev.data.fd=connfd; //设置用于注测的读操作事件 ev.events=EPOLLIN|EPOLLET; //注册event epoll_ctl(epfd,EPOLL_CTL_ADD,connfd,&ev); } else if (events[i].events&EPOLLIN) { read_socket(events[i].data.fd); ev.data.fd=events[i].data.fd; ev.events=EPOLLIN|EPOLLOUT|EPOLLET; epoll_ctl(epfd,EPOLL_CTL_MOD,sockfd,&ev); } else if (events[i].events&EPOLLOUT) { write_socket(events[i].data.fd); ev.data.fd=events[i].data.fd; ev.events=EPOLLIN|EPOLLET; //ET模式 epoll_ctl(epfd,EPOLL_CTL_MOD,sockfd,&ev); } else { perror ( "other event" ); } } } } Epoll的ET模式与LT模式 ET（Edge Triggered）与LT（Level Triggered）的主要区别可以从下面的例子看出 eg： 1． 标示管道读者的文件句柄注册到epoll中； 2． 管道写者向管道中写入2KB的数据； 3． 调用epoll_wait可以获得管道读者为已就绪的文件句柄； 4． 管道读者读取1KB的数据 5． 一次epoll_wait调用完成 如果是ET模式，管道中剩余的1KB被挂起，再次调用epoll_wait，得不到管道读者的文件句柄，除非有新的数据写入管道。如果是LT模式，只要管道中有数据可读，每次调用epoll_wait都会触发。 另一点区别就是设为ET模式的文件句柄必须是非阻塞的。 三、 Epoll的实现 Epoll的源文件在/usr/src/linux/fs/eventpoll.c，在module_init时注册一个文件系统eventpoll_fs_type，对该文件系统提供两种操作poll和release，所以epoll_create返回的文件句柄可以被poll、select或者被其它epoll epoll_wait。对epoll的操作主要通过三个系统调用实现： 1． sys_epoll_create 2． sys_epoll_ctl 3． sys_epoll_wait 下面结合源码讲述这三个系统调用。 1.1 long sys_epoll_create (int size) 该系统调用主要分配文件句柄、inode以及file结构。在linux-2.4.32内核中，使用hash保存所有注册到该epoll的文件句柄，在该系统调用中根据size大小分配hash的大小。具体为不小于size，但小于2*size的2的某次方。最小为2的9次方（512），最大为2的17次方（128 x 1024）。在linux-2.6.10内核中，使用红黑树保存所有注册到该epoll的文件句柄，size参数未使用。 1.2 long sys_epoll_ctl(int epfd, int op, int fd, struct epoll_event *event) 1． 注册句柄 op = EPOLL_CTL_ADD 注册过程主要包括： A．将fd插入到hash（或rbtree）中，如果原来已经存在返回-EEXIST， B．给fd注册一个回调函数，该函数会在fd有事件时调用，在该函数中将fd加入到epoll的就绪队列中。 C．检查fd当前是否已经有期望的事件产生。如果有，将其加入到epoll的就绪队列中，唤醒epoll_wait。 2． 修改事件 op = EPOLL_CTL_MOD 修改事件只是将新的事件替换旧的事件，然后检查fd是否有期望的事件。如果有，将其加入到epoll的就绪队列中，唤醒epoll_wait。 3． 删除句柄 op = EPOLL_CTL_DEL 将fd从hash（rbtree）中清除。 1.3 long sys_epoll_wait(int epfd, struct epoll_event *events, int maxevents,int timeout) 如果epoll的就绪队列为空，并且timeout非0，挂起当前进程，引起CPU调度。 如果epoll的就绪队列不空，遍历就绪队列。对队列中的每一个节点，获取该文件已触发的事件，判断其中是否有我们期待的事件，如果有，将其对应的epoll_event结构copy到用户events。 revents = epi->file->f_op->poll(epi->file, NULL); epi->revents = revents & epi->event.events; if (epi->revents) { …… copy_to_user; …… } 需要注意的是，在LT模式下，把符合条件的事件copy到用户空间后，还会把对应的文件重新挂接到就绪队列。所以在LT模式下，如果一次epoll_wait某个socket没有read/write完所有数据，下次epoll_wait还会返回该socket句柄。 四、 使用epoll的注意事项 1. ET模式比LT模式高效，但比较难控制。 2. 如果某个句柄期待的事件不变，不需要EPOLL_CTL_MOD，但每次读写后将该句柄modify一次有助于提高稳定性，特别在ET模式。 3. socket关闭后最好将该句柄从epoll中delete（EPOLL_CTL_DEL），虽然epoll自身有处理，但会使epoll的hash的节点数增多，影响搜索hash的速度。

文思海辉第一届在线编程大赛 对我有用[0]  丢个板砖[0]  引用 |  举报 |  管理

#3 得分：0 回复于： 2008-07-02 20:52:12 Q：网络服务器的瓶颈在哪？ A：IO效率。 在大家苦苦的为在线人数的增长而导致的系统资源吃紧上的问题正在发愁的时候，Linux 2.6内核中提供的System Epoll为我们提供了一套完美的解决方案。传统的select以及poll的效率会因为在线人数的线形递增而导致呈二次乃至三次方的下降，这些直接导致了网络服务器可以支持的人数有了个比较明显的限制。 自从Linux提供了/dev/epoll的设备以及后来2.6内核中对/dev/epoll设备的访问的封装（System Epoll）之后，这种现象得到了大大的缓解，如果说几个月前，大家还对epoll不熟悉，那么现在来说的话，epoll的应用已经得到了大范围的普及。 那么究竟如何来使用epoll呢？其实非常简单。 通过在包含一个头文件#include 以及几个简单的API将可以大大的提高你的网络服务器的支持人数。 首先通过create_epoll(int maxfds)来创建一个epoll的句柄，其中maxfds为你epoll所支持的最大句柄数。这个函数会返回一个新的epoll句柄，之后的所有操作将通过这个句柄来进行操作。在用完之后，记得用close()来关闭这个创建出来的epoll句柄。 之后在你的网络主循环里面，每一帧的调用epoll_wait(int epfd, epoll_event events, int max events, int timeout)来查询所有的网络接口，看哪一个可以读，哪一个可以写了。基本的语法为： nfds = epoll_wait(kdpfd, events, maxevents, -1); 其中kdpfd为用epoll_create创建之后的句柄，events是一个epoll_event*的指针，当epoll_wait这个函数操作成功之后，epoll_events里面将储存所有的读写事件。max_events是当前需要监听的所有socket句柄数。最后一个timeout是 epoll_wait的超时，为0的时候表示马上返回，为-1的时候表示一直等下去，直到有事件范围，为任意正整数的时候表示等这么长的时间，如果一直没有事件，则范围。一般如果网络主循环是单独的线程的话，可以用-1来等，这样可以保证一些效率，如果是和主逻辑在同一个线程的话，则可以用0来保证主循环的效率。 epoll_wait范围之后应该是一个循环，遍利所有的事件： for (n = 0; n < nfds; ++n) { if (events[n].data.fd == listener) { //如果是主socket的事件的话，则表示有新连接进入了，进行新连接的处理。 client = accept(listener, ( struct sockaddr *) &local, &addrlen); if (client < 0){ perror ( "accept" ); continue ; } setnonblocking(client); // 将新连接置于非阻塞模式 ev.events = EPOLLIN | EPOLLET; // 并且将新连接也加入EPOLL的监听队列。 注意，这里的参数EPOLLIN | EPOLLET并没有设置对写socket的监听，如果有写操作的话，这个时候epoll是不会返回事件的，如果要对写操作也监听的话，应该是EPOLLIN | EPOLLOUT | EPOLLET ev.data.fd = client; if (epoll_ctl(kdpfd, EPOLL_CTL_ADD, client, &ev) < 0) { // 设置好event之后，将这个新的event通过epoll_ctl加入到epoll的监听队列里面，这里用EPOLL_CTL_ADD来加一个新的 epoll事件，通过EPOLL_CTL_DEL来减少一个epoll事件，通过EPOLL_CTL_MOD来改变一个事件的监听方式。 fprintf (stderr, "epoll set insertion error: fd=%d0, client); return -1; } } else // 如果不是主socket的事件的话，则代表是一个用户socket的事件，则来处理这个用户socket的事情，比如说read(fd,xxx)之类的，或者一些其他的处理。 do_use_fd(events[n].data.fd); } 对，epoll的操作就这么简单，总共不过4个API：epoll_create, epoll_ctl, epoll_wait和close。 如果您对epoll的效率还不太了解，请参考我之前关于网络游戏的网络编程等相关的文章。

[TUP现场图文]《浪潮之巅》吴军即将开讲 对我有用[0]  丢个板砖[0]  引用 |  举报 |  管理

	#4 得分：10 回复于： 2008-07-02 21:00:53 恩 不错
	对我有用[0]  丢个板砖[0]  引用 |  举报 |  管理

#5 得分：0 回复于： 2008-07-02 21:01:49 Linux 2.6内核中提高网络I/O性能的新方法 1、为什么select是落后的？ 首先，在Linux内核中，select所用到的FD_SET是有限的，即内核中有个参数__FD_SETSIZE定义了每个FD_SET的句柄个数，在我用的2.6.15-25-386内核中，该值是1024，搜索内核源代码得到： include/linux/posix_types.h:#define __FD_SETSIZE         1024 也就是说，如果想要同时检测1025个句柄的可读状态是不可能用select实现的。或者同时检测1025个句柄的可写状态也是不可能的。 其次，内核中实现select是用轮询方法，即每次检测都会遍历所有FD_SET中的句柄，显然，select函数执行时间与FD_SET中的句柄个数有一个比例关系，即select要检测的句柄数越多就会越费时。 当然，在前文中我并没有提及poll方法，事实上用select的朋友一定也试过poll，我个人觉得select和poll大同小异，个人偏好于用select而已。 2、2.6内核中提高I/O性能的新方法epoll epoll是什么？按照man手册的说法：是为处理大批量句柄而作了改进的poll。要使用epoll只需要这三个系统调用：epoll_create(2)， epoll_ctl(2)， epoll_wait(2)。 当然，这不是2.6内核才有的，它是在2.5.44内核中被引进的(epoll(4) is a new API introduced in Linux kernel 2.5.44) epoll的优点 <1>支持一个进程打开大数目的socket描述符(FD) select 最不能忍受的是一个进程所打开的FD是有一定限制的，由FD_SETSIZE设置，默认值是2048。对于那些需要支持的上万连接数目的IM服务器来说显然太少了。这时候你一是可以选择修改这个宏然后重新编译内核，不过资料也同时指出这样会带来网络效率的下降，二是可以选择多进程的解决方案(传统的Apache方案)，不过虽然linux上面创建进程的代价比较小，但仍旧是不可忽视的，加上进程间数据同步远比不上线程间同步的高效，所以也不是一种完美的方案。不过 epoll则没有这个限制，它所支持的FD上限是最大可以打开文件的数目，这个数字一般远大于2048,举个例子,在1GB内存的机器上大约是10万左右，具体数目可以cat /proc/sys/fs/file-max察看,一般来说这个数目和系统内存关系很大。 <2>IO效率不随FD数目增加而线性下降 传统的select/poll另一个致命弱点就是当你拥有一个很大的socket集合，不过由于网络延时，任一时间只有部分的socket是"活跃"的，但是select/poll每次调用都会线性扫描全部的集合，导致效率呈现线性下降。但是epoll不存在这个问题，它只会对"活跃"的socket进行操作---这是因为在内核实现中epoll是根据每个fd上面的callback函数实现的。那么，只有"活跃"的socket才会主动的去调用 callback函数，其他idle状态socket则不会，在这点上，epoll实现了一个"伪"AIO，因为这时候推动力在os内核。在一些 benchmark中，如果所有的socket基本上都是活跃的---比如一个高速LAN环境，epoll并不比select/poll有什么效率，相反，如果过多使用epoll_ctl,效率相比还有稍微的下降。但是一旦使用idle connections模拟WAN环境,epoll的效率就远在select/poll之上了。 <3>使用mmap加速内核与用户空间的消息传递。 这点实际上涉及到epoll的具体实现了。无论是select,poll还是epoll都需要内核把FD消息通知给用户空间，如何避免不必要的内存拷贝就很重要，在这点上，epoll是通过内核于用户空间mmap同一块内存实现的。而如果你想我一样从2.5内核就关注epoll的话，一定不会忘记手工 mmap这一步的。 <4>内核微调 这一点其实不算epoll的优点了，而是整个linux平台的优点。也许你可以怀疑linux平台，但是你无法回避linux平台赋予你微调内核的能力。比如，内核TCP/IP协议栈使用内存池管理sk_buff结构，那么可以在运行时期动态调整这个内存pool(skb_head_pool)的大小--- 通过echo XXXX>/proc/sys/net/core/hot_list_length完成。再比如listen函数的第2个参数(TCP完成3次握手的数据包队列长度)，也可以根据你平台内存大小动态调整。更甚至在一个数据包面数目巨大但同时每个数据包本身大小却很小的特殊系统上尝试最新的NAPI网卡驱动架构。 epoll的使用 令人高兴的是，2.6内核的epoll比其2.5开发版本的/dev/epoll简洁了许多，所以，大部分情况下，强大的东西往往是简单的。唯一有点麻烦是epoll有2种工作方式:LT和ET。 LT(level triggered)是缺省的工作方式，并且同时支持block和no-block socket.在这种做法中，内核告诉你一个文件描述符是否就绪了，然后你可以对这个就绪的fd进行IO操作。如果你不作任何操作，内核还是会继续通知你的，所以，这种模式编程出错误可能性要小一点。传统的select/poll都是这种模型的代表． ET (edge-triggered)是高速工作方式，只支持no-block socket。在这种模式下，当描述符从未就绪变为就绪时，内核通过epoll告诉你。然后它会假设你知道文件描述符已经就绪，并且不会再为那个文件描述符发送更多的就绪通知，直到你做了某些操作导致那个文件描述符不再为就绪状态了(比如，你在发送，接收或者接收请求，或者发送接收的数据少于一定量时导致了一个EWOULDBLOCK 错误）。但是请注意，如果一直不对这个fd作IO操作(从而导致它再次变成未就绪)，内核不会发送更多的通知(only once),不过在TCP协议中，ET模式的加速效用仍需要更多的benchmark确认。 epoll只有epoll_create,epoll_ctl,epoll_wait 3个系统调用，具体用法请参考http://www.xmailserver.org/linux-patches/nio-improve.html ， 在http://www.kegel.com/rn/也有一个完整的例子，大家一看就知道如何使用了 Leader/follower模式线程pool实现，以及和epoll的配合

对我有用[0]  丢个板砖[0]  引用 |  举报 |  管理

#6 得分：0 回复于： 2008-07-02 21:03:47 在Linux上开发网络服务器的一些相关细节:poll与epoll 　　随着2.6内核对epoll的完全支持，网络上很多的文章和示例代码都提供了这样一个信息：使用epoll代替传统的 poll能给网络服务应用带来性能上的提升。但大多文章里关于性能提升的原因解释的较少，这里我将试分析一下内核（2.6.21.1）代码中poll与 epoll的工作原理，然后再通过一些测试数据来对比具体效果。 POLL： 先说poll，poll或select为大部分Unix/Linux程序员所熟悉，这俩个东西原理类似，性能上也不存在明显差异，但select对所监控的文件描述符数量有限制，所以这里选用poll做说明。 poll是一个系统调用，其内核入口函数为sys_poll，sys_poll几乎不做任何处理直接调用do_sys_poll，do_sys_poll的执行过程可以分为三个部分： 1，将用户传入的pollfd数组拷贝到内核空间，因为拷贝操作和数组长度相关，时间上这是一个O（n）操作，这一步的代码在do_sys_poll中包括从函数开始到调用do_poll前的部分。 2，查询每个文件描述符对应设备的状态，如果该设备尚未就绪，则在该设备的等待队列中加入一项并继续查询下一设备的状态。查询完所有设备后如果没有一个设备就绪，这时则需要挂起当前进程等待，直到设备就绪或者超时，挂起操作是通过调用schedule_timeout执行的。设备就绪后进程被通知继续运行，这时再次遍历所有设备，以查找就绪设备。这一步因为两次遍历所有设备，时间复杂度也是O（n），这里面不包括等待时间。相关代码在do_poll函数中。 3，将获得的数据传送到用户空间并执行释放内存和剥离等待队列等善后工作，向用户空间拷贝数据与剥离等待队列等操作的的时间复杂度同样是O（n），具体代码包括do_sys_poll函数中调用do_poll后到结束的部分。 EPOLL： 接下来分析epoll，与poll/select不同，epoll不再是一个单独的系统调用，而是由epoll_create/epoll_ctl/epoll_wait三个系统调用组成，后面将会看到这样做的好处。 先来看sys_epoll_create(epoll_create对应的内核函数），这个函数主要是做一些准备工作，比如创建数据结构，初始化数据并最终返回一个文件描述符（表示新创建的虚拟epoll文件），这个操作可以认为是一个固定时间的操作。 epoll是做为一个虚拟文件系统来实现的，这样做至少有以下两个好处： 1，可以在内核里维护一些信息，这些信息在多次epoll_wait间是保持的，比如所有受监控的文件描述符。 2， epoll本身也可以被poll/epoll; 具体epoll的虚拟文件系统的实现和性能分析无关，不再赘述。 在sys_epoll_create中还能看到一个细节，就是epoll_create的参数size在现阶段是没有意义的，只要大于零就行。 接着是sys_epoll_ctl(epoll_ctl对应的内核函数），需要明确的是每次调用sys_epoll_ctl只处理一个文件描述符，这里主要描述当op为EPOLL_CTL_ADD时的执行过程，sys_epoll_ctl做一些安全性检查后进入ep_insert，ep_insert里将 ep_poll_callback做为回掉函数加入设备的等待队列（假定这时设备尚未就绪），由于每次poll_ctl只操作一个文件描述符，因此也可以认为这是一个O(1)操作 ep_poll_callback函数很关键，它在所等待的设备就绪后被系统回掉，执行两个操作： 1，将就绪设备加入就绪队列，这一步避免了像poll那样在设备就绪后再次轮询所有设备找就绪者，降低了时间复杂度，由O（n）到O（1）; 2，唤醒虚拟的epoll文件; 最后是sys_epoll_wait，这里实际执行操作的是ep_poll函数。该函数等待将进程自身插入虚拟epoll文件的等待队列，直到被唤醒（见上面ep_poll_callback函数描述），最后执行ep_events_transfer将结果拷贝到用户空间。由于只拷贝就绪设备信息，所以这里的拷贝是一个O(1）操作。 还有一个让人关心的问题就是epoll对EPOLLET的处理，即边沿触发的处理，粗略看代码就是把一部分水平触发模式下内核做的工作交给用户来处理，直觉上不会对性能有太大影响，感兴趣的朋友欢迎讨论。 POLL/EPOLL对比： 表面上poll的过程可以看作是由一次epoll_create/若干次epoll_ctl/一次epoll_wait/一次close等系统调用构成，实际上epoll将poll分成若干部分实现的原因正是因为服务器软件中使用poll的特点（比如Web服务器）： 1，需要同时poll大量文件描述符; 2，每次poll完成后就绪的文件描述符只占所有被poll的描述符的很少一部分。 3，前后多次poll调用对文件描述符数组（ufds）的修改只是很小; 传统的poll函数相当于每次调用都重起炉灶，从用户空间完整读入ufds，完成后再次完全拷贝到用户空间，另外每次poll都需要对所有设备做至少做一次加入和删除等待队列操作，这些都是低效的原因。 epoll将以上情况都细化考虑，不需要每次都完整读入输出ufds，只需使用epoll_ctl调整其中一小部分，不需要每次epoll_wait都执行一次加入删除等待队列操作，另外改进后的机制使的不必在某个设备就绪后搜索整个设备数组进行查找，这些都能提高效率。另外最明显的一点，从用户的使用来说，使用epoll不必每次都轮询所有返回结果已找出其中的就绪部分，O（n）变O（1），对性能也提高不少。 此外这里还发现一点，是不是将epoll_ctl改成一次可以处理多个fd（像semctl那样）会提高些许性能呢？特别是在假设系统调用比较耗时的基础上。不过关于系统调用的耗时问题还会在以后分析。 POLL/EPOLL测试数据对比： 测试的环境：我写了三段代码来分别模拟服务器，活动的客户端，僵死的客户端，服务器运行于一个自编译的标准2.6.11内核系统上，硬件为 PIII933，两个客户端各自运行在另外的PC上，这两台PC比服务器的硬件性能要好，主要是保证能轻易让服务器满载，三台机器间使用一个100M交换机连接。 服务器接受并poll所有连接，如果有request到达则回复一个response，然后继续poll。 活动的客户端（Active Client）模拟若干并发的活动连接，这些连接不间断的发送请求接受回复。 僵死的客户端（zombie）模拟一些只连接但不发送请求的客户端，其目的只是占用服务器的poll描述符资源。 测试过程：保持10个并发活动连接，不断的调整僵并发连接数，记录在不同比例下使用poll与epoll的性能差别。僵死并发连接数根据比例分别是：0，10，20，40，80，160，320，640，1280，2560，5120，10240。 下图中横轴表示僵死并发连接与活动并发连接之比，纵轴表示完成40000次请求回复所花费的时间，以秒为单位。红色线条表示poll数据，绿色表示 epoll数据。可以看出，poll在所监控的文件描述符数量增加时，其耗时呈线性增长，而epoll则维持了一个平稳的状态，几乎不受描述符个数影响。 在监控的所有客户端都是活动时，poll的效率会略高于epoll（主要在原点附近，即僵死并发连接为0时，图上不易看出来），究竟epoll实现比poll复杂，监控少量描述符并非它的长处。