[리눅스 개발환경] 21. 다중 입출력

[tonykang22]

21. 다중 입출력

다중 입출력 개요

• 앞장에서, 하나의 서버에 하나의 클라이언트가 접속하는 메커니즘과 그 구현에 초점을 맞췄었다.
• 이번에는 서버에 연결된 클라이언트, 즉 소켓이 여러 개가 있는 상황을 가정해보자.
• 만약 서버를 구현하고 있는데 클라이언트 2개가 접속하여 accept된 상황을 생각해 보면,

listen(sfd, BACKLOG);
client1 = accept(sfd, &addr, &addr_size);

listen(sfd, BACKLOG);
client2 = accept(sfd, &addr, &addr_size);

• 위와 같이 2개의 클라이언트가 접속이 성공하였고, 2개의 클라이언트가 각각 데이터를 서버로 전송하는 경우를 생각해보면, 어느 클라이이언트, 즉 어느 소켓을 먼저 recv 처리해야할까?
• 만약 client2에서 send한 데이터가 먼저 서버로 도착했는데, client1 소켓에서 recv를 하면 도착한 데이터가 없기 때문에 블록킹 모드라면 무한 대기 상태에 빠져들 것이고, 넌블록킹 모드라면 에러가 발생할 것이다.
• 이와 같은 상황을 위해 다중 입출력(I/O Multiplexing) 메커니즘이 존재한다.
• 먼저 데이터가 도착(이벤트가 발생)한 소켓을 인지하여 해당 소켓이 어떤 소켓인지를 알려주는 메커니즘이다.

• 다중 입출력, 즉 I/O Multiplexing은 이벤트를 감지할 수 있다.
• 다중 입출력 지원함수들로 아래와 같은 함수들이 존재한다.
  • select : 기본적인 다중 입출력 함수, 소켓 파일 기술자가 클 경우(int 번호가 큰 경우) 비효율적이다.
  • pselect : timeout 시 나노 초까지 설정할 수 있으며, 시그널 마스크 값을 설정할 수 있다.
  • poll : select 대비 효율성
    • select의 경우 이벤트 감지를 위해 항상 max_fd 만큼 loop, 이에 반해 poll은 원하는 만큼만 지정해 loop
  • epoll : 고성능, 엣지 트리거(edge trigger) 지원 가능

select

#include <sys/select.h>

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

• select()는 프로그램이 여러 파일 디스크립터를 모니터 할 수 있게 하여 하나 이상의 파일 디스크립터가 일부 I/O 조작 클래스(예: 입력 가능)에 대해 준비될 때까지 대기한다.
• 세 개의 독립적인 파일 디스크립터 세트가 감시된다.
  • readfds : 읽기를 감시
  • writefds : 쓰기를 감시
  • exceptfds : 예외를 감시
  • nfds는 세 세트 중에 하나에 1을 더한 파일 번호이다.
• 성공하면 select()는 반환된 세 개의 디스크립터 세트에 포함된 파일 디스크립터 수를 반환한다.
  • 즉, readfds, writefds, exceptfds를 포함한 총 비트 수
• timeout 시간이 만료되면 0이 반환되며 오류가 발생하면 -1이 반환되고 errno가 설정된다.

void FD_CLR(int fd, fd_set *set); 
int FD_ISSET(int fd, fd_set *set); 
void FD_SET(int fd, fd_set *set); 
void FD_ZERO(fd_set *set);

• 세트를 조작하기 위해 4개의 매크로가 제공된다.
  • FD_ZERO()는 세트를 지운다.
  • FD_SET() 및 FD_CLR()은 각각 주어진 파일 디스크립터를 세트에서 추가하고 제거한다.
  • FD_ISSET()은 파일 디스크립터가 세트의 일부인지 여부를 테스트한다.
    • select()가 리턴 된 후 체크에 유용하다.

pselect

#include <sys/select.h>

int pselect(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, const struct timespec *timeout, const igset_t *sigmask);

• select()와 pselect()의 작동은 다음 세 가지 차이점 외에는 동일하다.
  1. select()는 struct timeval (초 및 마이크로 초) 인 시간 초과를 사용하는 반면 pselect()는 struct timespec (초 및 나노초)을 사용한다.
  2. select()는 시간 초과 인수를 업데이트하여 남은 시간을 나타낸다. pselect()는 이 인수를 변경하지 않는다.
  3. select()에는 sigmask 인수가 없으며 pselect()는 sigmask 설정이 가능하다.
• select()는 이벤트 감지 도중(블록킹 중) 시그널이 발생하면 에러를 반환하고 빠져나가기 때문에 시그널 핸들러를 사용한다 면 전역적인 시그널 차단 마스크를 설정해야 한다. (sigprocmask 사용)
• pselect ()는 디스크립터를 검사하기 전에 sigmask가 가리키는 신호 세트로 호출자의 시그널 마스크를 대체하고 반환하기 전에 호출자의 시그널 마스크를 복원합니다.
• sigmask가 NULL 인 pselect()를 호출하는 것은 select ()를 호출하는 것과 같다.

select 실습

• 다음은 select_server.c 의 코드이다.

#include <stdio.h> 
#include <unistd.h> 
#include <stdlib.h> 
#include <string.h> 
#include <sys/types.h> 
#include <sys/socket.h> 
#include <netinet/in.h> 
#include <arpa/inet.h>

#define handle_error(msg) \
    do { perror(msg); exit(EXIT_FAILURE); } while (0)

#define LISTEN_BACKLOG 50 
#define MAX(a, b) ((a>b)?a:b) 
#define MAX_SOCKFDS 50

int sockfds[MAX_SOCKFDS]; // store socket file descriptor int cnt_sockfds; // 
int cnt_sockfds; // count of stored socket file descriptor

void init_sockfds() 
{
    int i;
    for (i = 0; i < MAX_SOCKFDS; i++)
        sockfds[i] = -1; 
        cnt_sockfds = 0;
}

int add_socket(int fd) 
{
    if (cnt_sockfds >= MAX_SOCKFDS) 
        return -1;

    sockfds[cnt_sockfds++] = fd;
    return cnt_sockfds; 
}

void del_socket(int fd) 
{
    int i, lastidx = cnt_sockfds-1; 
    for (i = 1; i < cnt_sockfds; i++) {
        if (sockfds[i] == fd) { 
            if (i != lastidx)
                sockfds[i] = sockfds[lastidx]; 
            sockfds[lastidx] = -1; 
            cnt_sockfds--;
            break;
        } 
    }
}

int main(int argc, char *argv[]) 
{
    int sfd, cfd;
    int portnum;
    struct sockaddr_in saddr; 
    struct sockaddr_in caddr; 
    socklen_t caddr_len;
    int ret;
    char buf[1024] = {0,};

    fd_set readfds; 
    int ret_select; 
    int i, maxfd = 0;

    if (argc < 2) {
        printf("Usage: %s <port>\n", argv[0]); 
        exit(1);
    }

    portnum = atoi(argv[1]);

    sfd = socket(AF_INET, SOCK_STREAM, 0); 
    if (sfd == -1)
        handle_error("socket");

    memset(&saddr, 0, sizeof(struct sockaddr_in)); 
    saddr.sin_family = AF_INET; 
    saddr.sin_addr.s_addr = INADDR_ANY; 
    saddr.sin_port = htons(portnum);

    if (bind(sfd, (struct sockaddr *)&saddr, sizeof(saddr)) == -1) 
        handle_error("bind");

    if (listen(sfd, LISTEN_BACKLOG) == -1) 
        handle_error("listen");

    init_sockfds();

    add_socket(sfd);

    while(1) {
        maxfd = 0; 
        FD_ZERO(&readfds);
        for (i = 0; i < cnt_sockfds; i++) {
            FD_SET(sockfds[i], &readfds);
            maxfd = MAX(maxfd, sockfds[i]); 
        }

        ret_select = select(maxfd+1, &readfds, NULL, NULL, NULL); 
        if (ret_select == -1) {
            perror("select error");
            exit(1); 
        }

        if (FD_ISSET(sfd, &readfds)) { // is connect ?
            caddr_len = sizeof(caddr);
            cfd = accept(sfd, (struct sockaddr *)&caddr, &caddr_len); 
            if (cfd == -1)
                handle_error("accept");

            if (add_socket(cfd) == -1) {
                printf("error: current socket count (%d) / max socket scount (%d)\n",
                    cnt_sockfds, MAX_SOCKFDS); 
            } else {
                printf("add socket(%d) OK! (IP: %s, Port: %d)\n", cfd, 
                    inet_ntoa(((struct sockaddr_in *)&caddr)->sin_addr), 
                    ntohs(((struct sockaddr_in *)&caddr)->sin_port));
            }
            continue; 
        }

        for (i = 1; i < cnt_sockfds; i++) {
            int sockfd = sockfds[i];
            if (sockfd >= 0 && FD_ISSET(sockfd, &readfds)) {
                memset(buf, 0, sizeof(buf));
                ret = recv(sockfd, buf, sizeof(buf), 0); 
                if (ret == -1)
                    handle_error("recv"); 
                else if (ret == 0) { // close
                    del_socket(sockfd);
                    printf("del socket(%d) OK!\n", sockfd); 
                    close(sockfd);
                } else {
                    printf("recv data (sock: %d): %s\n", sockfd, buf);
                } 
            }
        } 
    }

    return 0;
}

• 실행 결과