Operating System 02 - IO复用

int select(int n, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);

fd_set fd_in, fd_out;
struct timeval tv;

// reset sets
FD_ZERO(&fd_in);
FD_ZERO(&fd_out);

// monitor sock1 for input events
FD_SET(sock1, &fd_in);

// monitor sock2 for output events
FD_SET(sock2, &fd_out);

// find out which socket has the largest numeric value as select requires it
int largest_sock = sock1 > sock2 ? sock1 : sock2;

// wait up to 10 seconds
tv.tv_sec = 10;
tv.tv_usec = 0;

// call the select
int ret = select(largest_sock + 1, &fd_in, &fd_out, NULL, &tv);

// check if select actually succeed
if(ret == -1) {
    // report error and abort
} else if(ret == 0) {
    // timeout, no event detected
} else {
    if(FD_ISSET(sock1, &fd_in)) {
        // input event on sock1
    }
    if(FD_ISSET(sock2, &fd_out)) {
        // output event on sock2
    }
}

int poll(struct pollfd *fds, unsigned int nfds, int timeout);

struct pollfd {
    int fd;
    // 监视的请求事件
    short events;
    // 已发生的事件
    short revents;
}

struct poolfd fds[2];

// monitor sock1 for input
fds[0].fd = sock1;
fds[0].events = POLLIN;

// monitor sock2 for output
fds[1].fd = sock2;
fds[1].events = POLLOUT;

// wait 10 seconds
int res = poll(&fds, 2, 10000);

// check if poll actually succed
if(res == -1) {
    // report error and abort
} else if (res == 0) {
    // timeout, no event detected
} else {
    // if we detect the event, zero it out so we can reuse the strutcure
    if(fds[0].revents & POLLIN) {
        fds[0].revents = 0;
        // input event on sock1
    }
    if(fds[1].revents & POLLOUT) {
        fds[1].revents = 0;
        // output event on sock2
    }
}

int epoll_create(int size);
int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
int epoll_wait(int epfd, struct epoll_event * events, int maxevents, int timeout);

// create the epoll descriptor, only one is needed per app, and is used to monitor all sockets
// the fuction argument is ignored(it was not before, but now it is), so put your favorite number here
int pollingfd = epoll_create(0xCAFE);

if(pollingfd < 0) {
    // report error
} 

// initialize the epoll structure in case more members are added in future
struct epoll_event ev = {0};

// associate the connection class instance with the event, you can associate anything
// you want, epoll dose not use the information. we store a connection class pointer, pConnection1
ev.data.ptr = pConnection1

// monitor for input, and do not automatically rearm the descriptor after the event
ev.events = EPOLLIN | EPOLLONESHOT;

// add the descriptor into the monitoring list, we can do it even if another thread is
// waiting in epoll_wait - the descriptor will be properly added
if(epoll_ctl(epollfd, EPOLL_CTL_ADD, pConnection1->getSocket(), &ev) != 0) {
    // report error
}

// wait for up to 20 events(assuming we have added maybe 200 sockets before that it may happen)
struct epoll_event prevents[20];

// wait for up to 10 secounds, and retrieve less than 20 epoll_event and store them into epoll_event array
int ret = epoll_wait(pollingfd, prevents, 20, 10000);

// check if epoll actually succeed
if(ret == -1) {
    // report error and abort
} else if(ret == 0) {
    // timeout, no event detected
} else {
    for(int i = 0; i < ret; i++) {
        if(prevents[i].events & EPOLLIN) {
            // get back our connection pointer
            Connection* c = (Connection*) prevents[i].data.ptr;
            c->handleReadEvent();
        }
    }
}