epoll 边缘触发模式的问题

cookis

1. 我将listen_fd 设置为nonblock 然后用EPOLLET + EPOLLIN 加入到epoll events中.
    当压力测试时(800个客户端), 一开始的时候接收连接有点儿迟钝, 但马上就好起来了. 总之. 效果不如水平触发的
    观察日志, 发现在接收 fd=319 后, 3秒钟后才接收到fd = 320, 多次测试后, 发现总是在三百多个连接后,出现3种钟的间隔.
2. 我要所有connection fd 设置为nonblock 然后用EPOLLET + EPOLLIN 加入到epoll events中.
    当压力测试时(800个客户端), 只检测到了556(总之是比800小)个关闭消息.

注: 采用单线程模型.

不知各位有没有遇到过同样的问题.

[ 本帖最后由 cookis 于 2008-11-4 18:07 编辑 ]

chenzhanyiczy

你是用一个client端模拟出800个连接过来？

cookis

原帖由 chenzhanyiczy 于 2008-11-4 20:37 发表
你是用一个client端模拟出800个连接过来？

对..

chenzhanyiczy

会不会client端实现有问题

cookis

原帖由 chenzhanyiczy 于 2008-11-5 12:56 发表
会不会client端实现有问题

不会..同样的客户端连接水平触发模式的epoll就没事

chenzhanyiczy

首先要清楚ET的概念

不知你的server端怎样实现的？

cookis

http://code.google.com/p/netdkit/

有时间帮我看一下.EpollProactor

chenzhanyiczy

希望能帮到你吧

cookis

1. 
   
2. 
   
3.     if (acceptor.open (local_addr) != 0)
   
4.     {
   
5.         std::cout << errno << std::endl;
   
6.         perror ("open");
   
7.         return 0;
   
8.     }
   
9.     NDK::set_non_block_mode (acceptor.handle ());
   
10.     int ep_fd = epoll_create (1000);
    
11.     struct epoll_event ep, evs[1000];
    
12.     ep.events  = EPOLLIN | EPOLLET;
    
13.     ep.data.fd = acceptor.handle ();
    
14.     epoll_ctl (ep_fd, EPOLL_CTL_ADD, acceptor.handle (), &ep);
    
15.     int close_count = 0;
    
16.     int connection_count = 0;
    
17.     char buff[4096] = {0};
    
18.     while (1)
    
19.     {
    
20.         int ret = epoll_wait (ep_fd, evs, 1000, -1);
    
21.         if (ret > 0)
    
22.         {
    
23.             for (int i = 0; i < ret; ++i)
    
24.             {
    
25.                 if (evs[i].data.fd == acceptor.handle ())
    
26.                 {
    
27.                     NDK_HANDLE new_handle = ::accept (evs[i].data.fd,
    
28.                             0,
    
29.                             0);
    
30.                     if (new_handle != -1)
    
31.                     {
    
32.                         ++connection_count;
    
33.                         fprintf (stderr, "new connection index = %d\n", connection_count);
    
34.                         NDK::set_non_block_mode (new_handle);
    
35.                         struct epoll_event eh;
    
36.                         eh.events  = EPOLLIN | EPOLLET;
    
37.                         eh.data.fd = new_handle;
    
38.                         epoll_ctl (ep_fd, EPOLL_CTL_ADD, eh.data.fd, &eh);
    
39.                     }
    
40.                 }else
    
41.                 {
    
42.                    int ret = NDK::recv (evs[i].data.fd, buff, sizeof (buff), 0);
    
43.                    if (ret == 0)
    
44.                    {
    
45.                        ++close_count;
    
46.                        fprintf (stderr, "peer close index = %d\n", close_count);
    
47.                        NDK::closesocket (evs[i].data.fd);
    
48.                        struct epoll_event eh;
    
49.                        eh.events  = EPOLLIN | EPOLLET;
    
50.                        eh.data.fd = evs[i].data.fd;
    
51.                        epoll_ctl (ep_fd, EPOLL_CTL_DEL, eh.data.fd, &eh);
    
52.                    }
    
53.                 }
    
54.             }
    
55.         }
    
56.     }
    
57.     NDK::closesocket (acceptor.handle ());
    
58.     return 0;
    
59. 
    

复制代码

我这样写了一个简单的..但发现在 close_count总是比new_connection少几个.

chenzhanyiczy

会不会有ret == -1的情况