logo标签列表

epoll：当EPOLLONESHOT被指定时，水平触发和边缘触发的区别

linuxnetwork-programmingepoll
3
当指定EPOLLONESHOT时，级别触发和边缘触发模式有什么区别？这里已经有一个类似的问题here。"Crouching Kitten"的答案似乎不正确（另一个答案没有回答我的问题）。我尝试了以下步骤：服务器向客户端发送2个字节，而客户端在epoll_wait中等待；客户端从epoll_wait返回，然后读取1个字节；客户端重新启用事件（因为EPOLLONESHOT）；客户端再次调用epoll_wait。在这里，对于LT和ET两种情况，epoll_wait都不会等待，而是立即返回（与"Crouching Kitten"的答案相反）。客户端可以读取第二个字节。在指定EPOLLONESHOT时，LT和ET之间有区别吗？
如果您能够在上面发布您的代码，那将是非常好的。我相信您已经做了您所声称的事情，但这将使下一个遇到此问题的人受益。 - Shachar Shemesh
@ShacharShemesh：不幸的是，这段代码是较大框架的一部分。但是，我刚刚检查了内核源代码，并且据我所知，如果指定了EPOLLONESHOT，则LT和ET之间确实没有区别。我会等待一段时间，如果没有答案，我将回答自己的问题。 - geza
当你在写答案时被晚餐打断，就会发生这种情况。人们会在你不在的时候自己找到答案 :-) - Shachar Shemesh
3个回答
2
我认为最终答案是"没有区别"。
从代码来看，似乎fd在被单次触发禁用之前记住了最后设置的位。它记住了它是一次性触发，以及它是否是ET。
这是徒劳的，因为fd被禁用直到被修改，下一次调用EPOLL_CTL_MOD将擦除所有内容，并用新的MOD替换。
话虽如此，我不明白为什么有人想要同时使用EPOLLET和EPOLLONESHOT。对我来说，EPOLLET的整个意义在于，在某些编程模型（即微线程）下，它完美地遵循语义。这意味着我可以在最开始就将fd添加到epoll中，然后永远不必执行另一个与epoll相关的系统调用。

EPOLLONESHOT被用于那些想要严格控制fd何时被监视和何时不被监视的人。根据定义，这与EPOLLET的使用目的相反。我认为这两者在概念上是不兼容的。

你是什么意思？“这意味着我可以在最开始将fd添加到epoll中，然后再也不必执行另一个与epoll相关的系统调用。” 我认为epoll_wait仍然会被调用，不是吗？ - geza
另外还有一种组合似乎没有意义：ET+EXCLUSIVE。你对此有什么看法？ - geza
我对此没有太多经验。根据我的理解，EPOLLET 对于微线程非常有用，而独占和一次性则对于多线程非常有用。因此，在使用它们时，我认为没有任何固有的摩擦。 - Shachar Shemesh
关于你的第一个问题，我认为在评论中回答太长了。我知道我在这里是为了声望分数，但如果你问“何时使用EPOLLET有意义”，我保证会尽力回答 :-)（暗示） - Shachar Shemesh
@geza 请查看 https://stackoverflow.com/questions/46633433/what-is-the-use-case-for-epollet 获取你问题的答案。 - Shachar Shemesh
0
另一位海报说：“我不明白为什么有人想要同时使用 EPOLLET 和 EPOLLONESHOT 。” 实际上，根据 epoll（7），有一个使用案例：

即使在边缘触发的 epoll 中，也可能在接收到多个数据块时生成多个事件，因此呼叫者可以选择指定 EPOLLONESHOT 标志，告诉 epoll 在使用 epoll_wait（2）接收到事件后禁用相关联的文件描述符。

0
关键点在于EPOLL是否将EPOLLET | EPOLLONESHOT和EPOLLLT | EPOLLONESHOT的组合视为特殊情况。据我所知，不是这样的。EPOLL只会单独处理它们。对于EPOLLET和EPOLLLT，唯一的区别在于函数ep_send_events中，如果设置了EPOLLET，则该函数将调用list_add_tail将epitem添加到epoll_fd/eventepoll对象中的准备列表中。 对于EPOLLONESHOT，其作用是禁用fd。因此，我认为它们之间的区别在于ET和LT之间的区别。您可以使用以下代码检查结果。
// server.cc
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <assert.h>
#include <stdio.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <fcntl.h>
#include <stdlib.h>
#include <sys/epoll.h>
#include <pthread.h>

#define MAX_EVENT_NUMBER 1024

int setnonblocking(int fd)
{
    int old_option = fcntl(fd, F_GETFL);
    int new_option = old_option | O_NONBLOCK;
    fcntl(fd, F_SETFL, new_option);
    return old_option;
}

void addfd(int epollfd, int fd, bool oneshot)
{
    epoll_event event;
    event.data.fd = fd;
    event.events = EPOLLIN | EPOLLET;
    if(oneshot)
        event.events |= EPOLLONESHOT;
    epoll_ctl(epollfd, EPOLL_CTL_ADD, fd, &event);
    setnonblocking(fd);
}
// reset the fd with EPOLLONESHOT
void reset_oneshot(int epollfd, int fd)
{
    epoll_event event;
    event.data.fd = fd;
    event.events = EPOLLIN | EPOLLET | EPOLLONESHOT;
    epoll_ctl(epollfd, EPOLL_CTL_MOD, fd, &event);
}

int main(int argc, char** argv)
{
    if(argc <= 2)
    {
        printf("usage: %s ip_address port_number\n", basename(argv[0]));
        return 1;
    }
    const char* ip = argv[1];
    int port = atoi(argv[2]);

    int ret = 0;
    struct sockaddr_in address;
    bzero(&address, sizeof(address));
    address.sin_family = AF_INET;
    inet_pton(AF_INET, ip, &address.sin_addr);
    address.sin_port = htons(port);

    int listenfd = socket(PF_INET, SOCK_STREAM, 0);
    assert(listenfd >= 0);
    ret = bind(listenfd, (struct sockaddr*)&address, sizeof(address));
    assert(ret != -1);

    ret = listen(listenfd, 5);
    assert(ret != -1);

    epoll_event events[MAX_EVENT_NUMBER];
    int epollfd = epoll_create(5);
    addfd(epollfd, listenfd, false);
    while(1)
    {
        printf("next loop: -----------------------------");
        int ret = epoll_wait(epollfd, events, MAX_EVENT_NUMBER, -1);
        if(ret < 0)
        {
            printf("epoll failure\n");
            break;
        }
        for(int i = 0; i < ret; i++)
        {
            int sockfd = events[i].data.fd;
            if(sockfd == listenfd)
            {
                printf("into listenfd part\n");
                struct sockaddr_in client_address;
                socklen_t client_addrlength = sizeof(client_address);
                int connfd = accept(listenfd, (struct sockaddr*)&client_address,
                     &client_addrlength);
                printf("receive connfd: %d\n", connfd);
                addfd(epollfd, connfd, true);
                // reset_oneshot(epollfd, listenfd);
            }
            else if(events[i].events & EPOLLIN)
            {
                printf("into linkedfd part\n");
                printf("start new thread to receive data on fd: %d\n", sockfd);
                char buf[2];
                memset(buf, '\0', 2);
                // just read one byte, and reset the fd with EPOLLONESHOT, check whether still EPOLLIN event
                int ret = recv(sockfd, buf, 2 - 1, 0);

                if(ret == 0)
                {
                    close(sockfd);
                    printf("foreigner closed the connection\n");
                    break;
                }
                else if(ret < 0)
                {
                    if(errno == EAGAIN)
                    {
                        printf("wait to the client send the new data, check the oneshot memchnism\n");
                        sleep(10);
                        reset_oneshot(epollfd, sockfd);
                        printf("read later\n");
                        break;
                    }
                }
                else {
                    printf("receive the content: %s\n", buf);
                    reset_oneshot(epollfd, sockfd);
                    printf("reset the oneshot successfully\n");
                }
            }
            else 
                printf("something unknown happend\n");
        }
        sleep(1);
    }
    close(listenfd);
    return 0;
}

客户端是

from socket import *
import sys
import time

long_string = b"this is a long content which need two time to fetch"

def sendOneTimeThenSleepAndClose(ip, port):
    s = socket(AF_INET, SOCK_STREAM);
    a = s.connect((ip, int(port)));
    print("connect success: {}".format(a));
    data = s.send(b"this is test");
    print("send successfuly");
    time.sleep(50);
    s.close();
sendOneTimeThenSleepAndClose('127.0.0.1', 9999)
网页内容由stack overflow 提供, 点击上面的
可以查看英文原文，
原文链接