C언어 비동기 I/O로 성능 최적화하기

#include <aio.h>
#include <fcntl.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>

int main() {
    struct aiocb cb;
    int fd = open("example.txt", O_RDONLY);
    if (fd < 0) {
        perror("File open error");
        return -1;
    }

    char buffer[1024] = {0};
    memset(&cb, 0, sizeof(cb));
    cb.aio_fildes = fd;
    cb.aio_buf = buffer;
    cb.aio_nbytes = sizeof(buffer);

    if (aio_read(&cb) == -1) {
        perror("aio_read error");
        close(fd);
        return -1;
    }

    while (aio_error(&cb) == EINPROGRESS) {
        printf("Reading in progress...\n");
    }

    if (aio_return(&cb) > 0) {
        printf("Data: %s\n", buffer);
    } else {
        perror("aio_read failed");
    }

    close(fd);
    return 0;
}

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

int main() {
    int epoll_fd = epoll_create1(0);
    if (epoll_fd == -1) {
        perror("epoll_create1 failed");
        return -1;
    }

    int fd = open("example.txt", O_RDONLY | O_NONBLOCK);
    if (fd == -1) {
        perror("File open failed");
        return -1;
    }

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

    if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, fd, &event) == -1) {
        perror("epoll_ctl failed");
        return -1;
    }

    struct epoll_event events[10];
    int event_count = epoll_wait(epoll_fd, events, 10, -1);
    for (int i = 0; i < event_count; i++) {
        if (events[i].events & EPOLLIN) {
            printf("Readable data available on fd %d\n", events[i].data.fd);
        }
    }

    close(fd);
    close(epoll_fd);
    return 0;
}

#include <sys/event.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>

int main() {
    int kq = kqueue();
    if (kq == -1) {
        perror("kqueue creation failed");
        return -1;
    }

    int fd = open("example.txt", O_RDONLY | O_NONBLOCK);
    if (fd == -1) {
        perror("File open failed");
        return -1;
    }

    struct kevent change;
    EV_SET(&change, fd, EVFILT_READ, EV_ADD | EV_ENABLE, 0, 0, NULL);

    if (kevent(kq, &change, 1, NULL, 0, NULL) == -1) {
        perror("kevent failed");
        return -1;
    }

    struct kevent event;
    int nev = kevent(kq, NULL, 0, &event, 1, NULL);
    if (nev > 0 && event.filter == EVFILT_READ) {
        printf("Readable data available on fd %d\n", (int)event.ident);
    }

    close(fd);
    close(kq);
    return 0;
}

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

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

// 소켓을 논블로킹 모드로 설정
int set_nonblocking(int fd) {
    int flags = fcntl(fd, F_GETFL, 0);
    return fcntl(fd, F_SETFL, flags | O_NONBLOCK);
}

int main() {
    int server_fd, epoll_fd;
    struct sockaddr_in address;
    struct epoll_event event, events[MAX_EVENTS];

    // 소켓 생성 및 바인드
    server_fd = socket(AF_INET, SOCK_STREAM, 0);
    if (server_fd == -1) {
        perror("Socket creation failed");
        return -1;
    }
    set_nonblocking(server_fd);

    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);
        return -1;
    }

    // 리슨 상태 설정
    if (listen(server_fd, SOMAXCONN) < 0) {
        perror("Listen failed");
        close(server_fd);
        return -1;
    }

    // epoll 인스턴스 생성
    epoll_fd = epoll_create1(0);
    if (epoll_fd == -1) {
        perror("Epoll creation failed");
        close(server_fd);
        return -1;
    }

    event.data.fd = server_fd;
    event.events = EPOLLIN;
    if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, server_fd, &event) == -1) {
        perror("Epoll control failed");
        close(server_fd);
        close(epoll_fd);
        return -1;
    }

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

    while (1) {
        int event_count = epoll_wait(epoll_fd, events, MAX_EVENTS, -1);
        for (int i = 0; i < event_count; i++) {
            if (events[i].data.fd == server_fd) {
                // 새 클라이언트 연결 수락
                int client_fd = accept(server_fd, NULL, NULL);
                if (client_fd < 0) {
                    perror("Accept failed");
                    continue;
                }
                set_nonblocking(client_fd);
                event.data.fd = client_fd;
                event.events = EPOLLIN | EPOLLET;
                epoll_ctl(epoll_fd, EPOLL_CTL_ADD, client_fd, &event);
                printf("New connection accepted\n");
            } else {
                // 클라이언트 요청 처리
                char buffer[BUFFER_SIZE];
                int bytes_read = read(events[i].data.fd, buffer, sizeof(buffer) - 1);
                if (bytes_read <= 0) {
                    // 클라이언트 종료
                    close(events[i].data.fd);
                    printf("Client disconnected\n");
                } else {
                    buffer[bytes_read] = '\0';
                    printf("Received: %s\n", buffer);
                    write(events[i].data.fd, buffer, bytes_read);
                }
            }
        }
    }

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