Asynchronous I/O & epoll

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/epoll.h>

#define MAX_EVENTS 10

int main(void) {
    int pipefd[2];
    if (pipe(pipefd) == -1) { perror("pipe"); return 1; }

    /* Write something into the pipe so one end becomes readable */
    write(pipefd[1], "hello", 5);

    /* Step 1: Create the epoll instance */
    int epfd = epoll_create1(0);
    if (epfd == -1) { perror("epoll_create1"); return 1; }

    /* Step 2: Register stdin (fd 0) for readability */
    struct epoll_event ev;
    ev.events  = EPOLLIN;
    ev.data.fd = STDIN_FILENO;
    epoll_ctl(epfd, EPOLL_CTL_ADD, STDIN_FILENO, &ev);

    /* Step 2b: Register the read end of the pipe */
    ev.events  = EPOLLIN;
    ev.data.fd = pipefd[0];
    epoll_ctl(epfd, EPOLL_CTL_ADD, pipefd[0], &ev);

    printf("Watching stdin (fd 0) and pipe read-end (fd %d)\n", pipefd[0]);
    printf("Type something, or just wait — the pipe event fires immediately.\n\n");

    /* Step 3: Event loop — timeout 3000 ms */
    struct epoll_event events[MAX_EVENTS];
    int nready = epoll_wait(epfd, events, MAX_EVENTS, 3000);

    if (nready == 0) {
        printf("Timeout — no events in 3 seconds.\n");
    } else {
        for (int i = 0; i < nready; i++) {
            int fd = events[i].data.fd;
            char buf[64] = {0};
            ssize_t n = read(fd, buf, sizeof(buf) - 1);
            if (fd == STDIN_FILENO)
                printf("stdin became ready: read %zd bytes: '%s'\n", n, buf);
            else
                printf("pipe became ready:  read %zd bytes: '%s'\n", n, buf);
        }
    }

    close(pipefd[0]);
    close(pipefd[1]);
    close(epfd);
    return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
#include <sys/epoll.h>

/* Helper: make any fd non-blocking */
static void set_nonblocking(int fd) {
    int flags = fcntl(fd, F_GETFL, 0);
    if (flags == -1) { perror("fcntl F_GETFL"); exit(1); }
    if (fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1) {
        perror("fcntl F_SETFL"); exit(1);
    }
}

#define MAX_EVENTS 16
#define BUF_SIZE   256

int main(void) {
    int pipefd[2];
    pipe(pipefd);

    /* Write a burst of data — more than one read() may be needed */
    for (int i = 0; i < 5; i++)
        write(pipefd[1], "COMP2017\n", 9);
    close(pipefd[1]);  /* signal EOF on writer side */

    /* Make read-end non-blocking */
    set_nonblocking(pipefd[0]);

    /* Set up epoll in EDGE-TRIGGERED mode (EPOLLET) */
    int epfd = epoll_create1(0);
    struct epoll_event ev;
    ev.events  = EPOLLIN | EPOLLET;   /* edge-triggered */
    ev.data.fd = pipefd[0];
    epoll_ctl(epfd, EPOLL_CTL_ADD, pipefd[0], &ev);

    printf("Edge-triggered epoll — must drain all data on each event:\n\n");

    struct epoll_event events[MAX_EVENTS];
    int nready = epoll_wait(epfd, events, MAX_EVENTS, 1000);

    for (int i = 0; i < nready; i++) {
        if (events[i].events & EPOLLIN) {
            /* With edge-triggered, drain the entire buffer in a loop */
            char buf[BUF_SIZE];
            while (1) {
                ssize_t n = read(events[i].data.fd, buf, sizeof(buf));
                if (n > 0) {
                    printf("Read %zd bytes: %.*s", n, (int)n, buf);
                } else if (n == 0) {
                    printf("\nEOF reached.\n");
                    break;
                } else {
                    /* n == -1 */
                    if (errno == EAGAIN || errno == EWOULDBLOCK) {
                        printf("\nEAGAIN — buffer drained, no more data right now.\n");
                        break;  /* done for this event */
                    }
                    perror("read");
                    break;
                }
            }
        }
    }

    close(pipefd[0]);
    close(epfd);
    return 0;
}

/* ================================================================
   SAME TASK: watch two pipes for readability.
   First implementation: select()   — O(N) rebuild every call
   Second implementation: epoll()   — O(1) ready-event lookup
   ================================================================ */

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/select.h>
#include <sys/epoll.h>

/* --- select() version --- */
void demo_select(int fd1, int fd2) {
    fd_set readfds;
    struct timeval tv = { .tv_sec = 2, .tv_usec = 0 };

    /* Must REBUILD the set before every call — O(N) overhead */
    FD_ZERO(&readfds);
    FD_SET(fd1, &readfds);
    FD_SET(fd2, &readfds);
    int maxfd = (fd1 > fd2 ? fd1 : fd2) + 1;

    int n = select(maxfd, &readfds, NULL, NULL, &tv);
    if (n <= 0) { printf("[select] timeout or error\n"); return; }

    /* Must CHECK every fd with FD_ISSET — iterates all up to maxfd */
    if (FD_ISSET(fd1, &readfds)) {
        char buf[32] = {0};
        read(fd1, buf, sizeof(buf)-1);
        printf("[select] fd1 ready: '%s'\n", buf);
    }
    if (FD_ISSET(fd2, &readfds)) {
        char buf[32] = {0};
        read(fd2, buf, sizeof(buf)-1);
        printf("[select] fd2 ready: '%s'\n", buf);
    }
}

/* --- epoll() version --- */
void demo_epoll(int fd1, int fd2) {
    int epfd = epoll_create1(0);
    struct epoll_event ev;

    /* Register ONCE — no rebuild needed on subsequent iterations */
    ev.events = EPOLLIN; ev.data.fd = fd1;
    epoll_ctl(epfd, EPOLL_CTL_ADD, fd1, &ev);
    ev.events = EPOLLIN; ev.data.fd = fd2;
    epoll_ctl(epfd, EPOLL_CTL_ADD, fd2, &ev);

    struct epoll_event events[10];
    /* epoll_wait returns ONLY ready fds — no need to check all */
    int nready = epoll_wait(epfd, events, 10, 2000);
    for (int i = 0; i < nready; i++) {
        char buf[32] = {0};
        read(events[i].data.fd, buf, sizeof(buf)-1);
        printf("[epoll]  fd%d ready: '%s'\n",
               events[i].data.fd == fd1 ? 1 : 2, buf);
    }
    close(epfd);
}

int main(void) {
    int p1[2], p2[2];
    pipe(p1); pipe(p2);
    write(p1[1], "alpha", 5);
    write(p2[1], "beta",  4);

    printf("=== select() ===\n");
    demo_select(p1[0], p2[0]);

    /* Refill pipes for epoll demo */
    write(p1[1], "alpha", 5);
    write(p2[1], "beta",  4);

    printf("\n=== epoll() ===\n");
    demo_epoll(p1[0], p2[0]);

    close(p1[0]); close(p1[1]);
    close(p2[0]); close(p2[1]);
    return 0;
}