C언어에서 epoll과 select: 효율적인 I/O 다중화 비교와 구현

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

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

int main() {
    fd_set readfds;
    FD_ZERO(&readfds);
    FD_SET(STDIN_FILENO, &readfds);

    printf("Press any key: \n");
    if (select(STDIN_FILENO + 1, &readfds, NULL, NULL, NULL) > 0) {
        if (FD_ISSET(STDIN_FILENO, &readfds)) {
            char buf[100];
            read(STDIN_FILENO, buf, sizeof(buf));
            printf("You entered: %s", buf);
        }
    }
    return 0;
}

   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);

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

int main() {
    int epfd = epoll_create(1);
    if (epfd == -1) {
        perror("epoll_create");
        return -1;
    }

    struct epoll_event event;
    event.events = EPOLLIN;
    event.data.fd = STDIN_FILENO;

    if (epoll_ctl(epfd, EPOLL_CTL_ADD, STDIN_FILENO, &event) == -1) {
        perror("epoll_ctl");
        return -1;
    }

    printf("Press any key:\n");
    struct epoll_event events[1];
    int n = epoll_wait(epfd, events, 1, -1);
    if (n > 0) {
        if (events[0].data.fd == STDIN_FILENO) {
            char buf[100];
            read(STDIN_FILENO, buf, sizeof(buf));
            printf("You entered: %s", buf);
        }
    }

    close(epfd);
    return 0;
}

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

#define MAX_EVENTS 10
#define PORT 8080
#define BUFFER_SIZE 1024

int main() {
    int server_fd, new_socket, epfd;
    struct sockaddr_in address;
    struct epoll_event ev, events[MAX_EVENTS];
    char buffer[BUFFER_SIZE];

    // Create a socket
    if ((server_fd = socket(AF_INET, SOCK_STREAM, 0)) == 0) {
        perror("socket failed");
        exit(EXIT_FAILURE);
    }

    // Bind the socket to the port
    address.sin_family = AF_INET;
    address.sin_addr.s_addr = INADDR_ANY;
    address.sin_port = htons(PORT);
    if (bind(server_fd, (struct sockaddr *)&address, sizeof(address)) < 0) {
        perror("bind failed");
        close(server_fd);
        exit(EXIT_FAILURE);
    }

    // Listen for connections
    if (listen(server_fd, 10) < 0) {
        perror("listen failed");
        close(server_fd);
        exit(EXIT_FAILURE);
    }

    // Create an epoll instance
    epfd = epoll_create1(0);
    if (epfd == -1) {
        perror("epoll_create1 failed");
        close(server_fd);
        exit(EXIT_FAILURE);
    }

    // Add the server socket to the epoll instance
    ev.events = EPOLLIN; // Monitor incoming connections
    ev.data.fd = server_fd;
    if (epoll_ctl(epfd, EPOLL_CTL_ADD, server_fd, &ev) == -1) {
        perror("epoll_ctl: server_fd");
        close(server_fd);
        close(epfd);
        exit(EXIT_FAILURE);
    }

    printf("Server is listening on port %d...\n", PORT);

    while (1) {
        int nfds = epoll_wait(epfd, events, MAX_EVENTS, -1);
        if (nfds == -1) {
            perror("epoll_wait");
            break;
        }

        for (int i = 0; i < nfds; i++) {
            if (events[i].data.fd == server_fd) {
                // Accept a new connection
                new_socket = accept(server_fd, NULL, NULL);
                if (new_socket == -1) {
                    perror("accept");
                    continue;
                }
                printf("New connection accepted: %d\n", new_socket);

                // Add the new socket to epoll instance
                ev.events = EPOLLIN | EPOLLET; // Enable edge-triggered mode
                ev.data.fd = new_socket;
                if (epoll_ctl(epfd, EPOLL_CTL_ADD, new_socket, &ev) == -1) {
                    perror("epoll_ctl: new_socket");
                    close(new_socket);
                }
            } else {
                // Handle data from a client
                int client_fd = events[i].data.fd;
                memset(buffer, 0, BUFFER_SIZE);
                int bytes_read = read(client_fd, buffer, BUFFER_SIZE);
                if (bytes_read <= 0) {
                    // Connection closed or error
                    if (bytes_read == 0) {
                        printf("Client disconnected: %d\n", client_fd);
                    } else {
                        perror("read");
                    }
                    close(client_fd);
                    epoll_ctl(epfd, EPOLL_CTL_DEL, client_fd, NULL);
                } else {
                    // Echo the data back to the client
                    printf("Received: %s", buffer);
                    write(client_fd, buffer, bytes_read);
                }
            }
        }
    }

    close(server_fd);
    close(epfd);
    return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/select.h>

#define PORT 8080
#define BUFFER_SIZE 1024
#define MAX_CLIENTS 30

int main() {
    int server_fd, client_fd, max_sd, activity, sd, new_socket;
    int client_sockets[MAX_CLIENTS] = {0};
    struct sockaddr_in address;
    fd_set readfds;
    char buffer[BUFFER_SIZE];

    // Create server socket
    if ((server_fd = socket(AF_INET, SOCK_STREAM, 0)) == 0) {
        perror("socket failed");
        exit(EXIT_FAILURE);
    }

    // Configure server address
    address.sin_family = AF_INET;
    address.sin_addr.s_addr = INADDR_ANY;
    address.sin_port = htons(PORT);

    // Bind the socket to the address
    if (bind(server_fd, (struct sockaddr *)&address, sizeof(address)) < 0) {
        perror("bind failed");
        close(server_fd);
        exit(EXIT_FAILURE);
    }

    // Listen for incoming connections
    if (listen(server_fd, 10) < 0) {
        perror("listen failed");
        close(server_fd);
        exit(EXIT_FAILURE);
    }

    printf("Server is listening on port %d...\n", PORT);

    while (1) {
        // Clear and set the file descriptor set
        FD_ZERO(&readfds);
        FD_SET(server_fd, &readfds);
        max_sd = server_fd;

        // Add client sockets to the set
        for (int i = 0; i < MAX_CLIENTS; i++) {
            sd = client_sockets[i];
            if (sd > 0) {
                FD_SET(sd, &readfds);
            }
            if (sd > max_sd) {
                max_sd = sd;
            }
        }

        // Wait for activity on any of the sockets
        activity = select(max_sd + 1, &readfds, NULL, NULL, NULL);
        if (activity < 0) {
            perror("select error");
            continue;
        }

        // Handle new connections
        if (FD_ISSET(server_fd, &readfds)) {
            new_socket = accept(server_fd, NULL, NULL);
            if (new_socket < 0) {
                perror("accept");
                continue;
            }

            printf("New connection: %d\n", new_socket);

            // Add new socket to the client sockets array
            for (int i = 0; i < MAX_CLIENTS; i++) {
                if (client_sockets[i] == 0) {
                    client_sockets[i] = new_socket;
                    break;
                }
            }
        }

        // Handle IO on existing clients
        for (int i = 0; i < MAX_CLIENTS; i++) {
            sd = client_sockets[i];
            if (FD_ISSET(sd, &readfds)) {
                memset(buffer, 0, BUFFER_SIZE);
                int bytes_read = read(sd, buffer, BUFFER_SIZE);
                if (bytes_read <= 0) {
                    // Client disconnected
                    printf("Client disconnected: %d\n", sd);
                    close(sd);
                    client_sockets[i] = 0;
                } else {
                    // Echo the message back to the client
                    printf("Received from client %d: %s", sd, buffer);
                    write(sd, buffer, bytes_read);
                }
            }
        }
    }

    close(server_fd);
    return 0;
}

while (1) {
    int bytes_read = read(fd, buffer, BUFFER_SIZE);
    if (bytes_read < 0) {
        if (errno == EAGAIN) {
            break; // No more data to read
        } else {
            perror("read error");
            close(fd);
            break;
        }
    } else if (bytes_read == 0) {
        // Connection closed
        close(fd);
        break;
    } else {
        // Process the data
        process_data(buffer, bytes_read);
    }
}