[Book] 게임 서버 프로그래밍 교과서 - 3장 소켓 프로그래밍 (2)

3장 소켓 프로그래밍

6. 논블록 소켓

일대일 네트워킹 프로그램을 개발할 때는 블로킹 소켓을 사용해도 무방하다.

하지만 네트워킹을 해야 하는 대상이 여럿이라면 어떻게 해야 할까?

다행히 대부분 운영체제에서는 소켓 함수가 블로킹되지 않게 하는 API를 추가로 제공한다. 이를 논블록 소켓이라 한다.

논블록 소켓을 사용하는 방법은 아래와 같다.

void NonBlockSocketOperation()
{
    s = socket(TCP);
    ...;
    s.connect(...);
    // 논블록 소켓으로 변경
    s.SetNonBlocking(true);
 
    while (true)
    {
        r = s.send(dest, data);
        if (r == EWOULDBLOCK)
        {
            // 블로킹 걸릴 상황이었다. 송신을 안 했다.
            continue;
        }
 
        if (r == OK)
        {
            // 보내기 성공에 대한 처리
        }
        else
        {
            // 보내기 실패에 대한 처리
        }
    }
}

소켓을 논블록 소켓으로 모드 전환한다.
논블록 소켓에 대해 평소처럼 송신, 수신, 연결과 관련된 함수를 호출한다.
이 함수 호출에 대해 성공 혹은 would block 오류 둘 중 하나를 무조건 즉시 리턴한다.

상대방에게 TCP 접속 역할을 하는 connect() 함수를 논블로킹으로 쓸 때는 조금 다르다. 왜냐하면 would block이 송수신 함수에서 리턴된다면 아무 일도 일어나지 않지만, 연결 함수에서 리턴된다면 문제가 발생한 것이기 때문이다. 그래서 잘 연결된 것인지 확인이 필요하다. 다시 connect()를 다시 시도하는 것보단 0바이트 송신 방식을 통해 확인하는 것이 좋다.

void NonBlockSocketOperation()
{
    result = s.connect();
    if (result = = EWOULDBLOCK)
    {
        while (true)
        {
            byte emptyData[0]; // 길이 0인 배열
            result = s.send(emptyData);
            if (result == OK)
            {
                // 연결 성공 처리
            }
            else if (result == ENOTCONN)
            {
                // 연결이 아직 진행 중이다.
            }
            else
            {
                // 연결 실패 처리
            }
        }
    }
}

TCP는 스트림 기반 프로토콜이기 때문에 0바이트를 보내는 것은 사실상 아무것도 하지 않는 셈이다.
성공을 리턴하면 TCP 연결이 되어 있다는 의미이다.
ENOTCONN을 리턴하면 TCP 연결이 진행 중이다.
기타 오류 코드가 나오면 TCP 연결 시도가 실패한 것이다.

논블록 소켓을 사용하면 한 스레드에서 여러 소켓을 한꺼번에 다룰 수 있다.

List<Socket> sockets;
 
void NonBlockSocketOperation()
{
    foreach(s in sockets) // 각 소켓에 대해
    {
        // 논블록 수신. 오류 코드와 수신된 데이터를 받는다.
        (result, data) = s.receive();
        if (data.length > 0) // 잘 수신했으면
        {
            print(data); // 출력
        }
        else if (result != EWOULDBLOCK)
        {
            // would block이 아니면 오류가 난 것이므로
            // 필요한 처리를 한다.
            ...;
        }
    }
}

수신할 데이터가 없으면 would block 오류를 리턴한다.

예시 코드들을 실제로 구동하면 해당 스레드는 소켓이 would block인 상태에서는 계속해서 루프를 돌고 CPU를 쉬지 못하는 바쁜 상태로 만든다. 즉, CPU 코어 하나가 100% 사용량을 차지한다. select()나 poll() 함수를 사용한다면 CPU 폭주 문제를 해결할 수 있다.

여러 소켓 중 하나라도 would block이었던 상태에 변화가 일어나면, 즉 송신 버퍼에 빈 공간이 생기거나 수신 버퍼에 뭔가가 들어온다면 그 상황을 알려 준다.
혹은 그것을 알려 주기 전까지는 블로킹 중이어서 CPU 사용량 폭주를 해결한다.

List<Socket> sockets;
 
void NonBlockSocketOperation()
{
    while (true)
    {
        // 100밀리초까지 대기
        // 1개라도 I/O 처리를 할 수 있는 상태가 되면
        // 그 전에라도 리턴
        select(sockets, 100ms);
 
        foreach(s in sockets)
        {
            // 논블록 수신
            (result, data) = s.receive();
            if (data.length > 0)
            {
                print(data);
            }
            else if (result != EWOULDBLOCK)
            {
                // 소켓 오류 처리를 한다.
            }
        }
    }
}

7. Overlapped I/O 혹은 비동기 I/O

논블록 소켓의 단점은 다음과 같다.

소켓 I/O 함수가 리턴한 코드가 would block인 경우 재시도 호출 낭비가 발생한다.
소켓 I/O 함수를 호출할 때 입력하는 데이터 블록에 대한 복사 연산이 발생한다.

이러한 단점을 해결해주는 것이 Overlapped 또는 Asynchronous(비동기) I/O이다.

소켓에 대해 Overlapped 액세스를 걸고 성공했는지 확인 후 성공했으면 결괏값을 얻어 와서 나머지를 처리한다.
완료되기 전까지 Overlapped status 객체가 데이터 블록을 중간에 훼손하지 말아야 한다.

void OverlappedSocketOperation()
{
    var overlappedSendStatus;
    (result, length) = s.OverlappedSend( // 블로킹 소켓 그대로 사용
        data,
        overlappedSendStatus);
 
    // 즉시 리턴
    if (length > 0)
    {
        // 보내기 성공
    }
    else if (result == WSA_IO_PENDING)
    {
        // Overlapped I/O가 진행 중
        while (true)
        {
            (result, length) =
                GetOverlappedResult(s,
                    overlappedSendStatus);
            if (length > 0)
            {
                // 잘 보냈다.
            }
            else
            {
                // 아직 I/O pending이다.
            }
        }
    }
}

논블록 소켓과 Overlapped I/O은 소켓 개수가 많을 때 루프를 돌며 처리하기 때문에 성능 문제가 발생한다.

이러한 루프 없이 한 번에 끝내는 방법은 없을까?

그래서 등장한 것이 IOCP와 epoll이다.

8. epoll

epoll은 해당 소켓이 I/O 가능 상태가 되면 이를 감지해서 사용자에게 알림을 해주는 역할을 한다.

소켓 2가 I/O 가능이 되는 순간 epoll은 이 상황을 내장 큐에 push 한다.
사용자는 epoll에서 이러한 이벤트 정보를 pop 할 수 있다.

따라서 소켓이 1만 개라고 해도 이 중에서 I/O 가능이 된 것들만 얻을 수 있다.

예시 코드는 다음과 같다.

epoll = new epoll();
foreach(s in sockets)
{
    epoll.add(s, GetUserPtr(s));
}
 
events = epoll.wait(100ms);
 
foreach(event in events)
{
    s = event.socket;
    // 위 epoll.add에 들어갔던 값을 얻는다.
    userPtr = event.userPtr;
    // 수신? 송신?
    type = event.type;
    if (type = = ReceiveEvent)
    {
        (result, data) = s.recv();
        if (data.length > 0)
        {
            // 수신된 데이터를 처리한다.
            Process(userPtr, s, data);
        }
    }
}

모든 소켓에 대한 select() 함수 대신 epoll에서 이벤트를 꺼내 오는 wait() 함수를 호출한다. 이 함수는 사용자가 원하는 시간까지만 블로킹되며 그전에 이벤트가 생기는 즉시 리턴한다. 출력 값에는 꺼내온 이벤트들이 있다.
각 이벤트에 대해 루프를 돌며 이벤트가 가리키는 소켓 객체와 사용자 정의 값을 꺼내와 처리한다.

그러나 위 코드가 이상적으로 보이지만 현실은 다르다. 소켓의 송신 버퍼가 빈 공간이 없는 순간을 유지하는 시간이 상대적으로 짧아서 거의 대부분은 송신 가능 상태이다. 이러한 특징 때문에 필요 이상의 루프를 또 돌게 된다. 이 문제를 해결하기 위해서는 레벨(level) 트리거 대신 에지(edge) 트리거를 써야 한다.

레벨 트리거는 '소켓이 I/O 가능하다'를 의미하고 에지 트리거는 소켓이 I/O 가능이 아니었는데, 이제 가능이 되었다'를 의미한다. 따라서 가능으로 변하는 순간에만 꺼내진다.
에지 트리거를 쓸 때는 소켓은 논블록으로 미리 설정되어 있어야 하며 I/O 호출을 한 번만 하지 말고 would block이 발생할 때까지 반복해야 한다.

foreach(event in events)
{
    s = event.socket;
    // 위 epoll.add에 들어갔던 값을 얻는다.
    userPtr = event.userPtr;
    // 수신? 송신?
    type = event.type;
    if (type = = ReceiveEvent)
    {
        while (true)
        {
            (result, data) = s.recv();
            if (data.length > 0)
            {
                // 수신된 데이터를 처리한다.
                Process(userPtr, s, data);
            }
            if (result == EWOULDBLOCK)
                break;
        }
    }
}

9. IOCP

IOCP는 소켓의 Overlapped I/O가 완료되면 이를 감지해서 사용자에게 알려주는 역할을 한다.

소켓 2가 완료되는 순간 IOCP는 이 상황을 내장 큐에 push 한다.
사용자는 IOCP에서 I/O가 완료되었음을 알려주는 완료 신호를 pop 할 수 있다.

따라서 소켓이 1만 개라고 해도 이 중에서 I/O 가능이 된 것들만 얻을 수 있다.

예시 코드는 다음과 같다.

epoll과 거의 유지하지만 차이점이 있다면, epoll은 I/O 가능인 것을 알려 주지만 IOCP는 I/O 완료인 것을 알려준다.

iocp = new iocp();
foreach(s in sockets)
{
    iocp.add(s, GetUserPtr(s));
    s.OverlappedReceive(data[s],
        receiveOverlapped[s]);
}

events = iocp.wait(100ms);
 
foreach(event in events)
{
    // 위 iocp.add에 들어갔던 값을 얻는다.
    userPtr = event.userPtr;
    ov = event.overlappedPtr;
    s = GetSocketFromUserPtr(userPtr);
 
    if (ov = = receiveOverlapped[s])
    {
        // overlapped receive가 성공했으니,
        // 받은 데이터를 처리한다.
        Process(s, userPtr, data[s]);
 
        s.OverlappedReceive(data[s],
            receiveOverlapped[s]);
    }
}

IOCP는 오래전에 나온 API이기 때문에 epoll보다 구현이 복잡한 기능이 있지만 반대로 성능상 유리한 기능도 있다.

바로 스레드 풀링을 쉽게 구현할 수 있다는 점이다.

어떤 소켓에 대해 Overlapped I/O를 하지 않는 이상 그 소켓에 대한 완료 신호는 전혀 발생하지 않는다. 즉, 소켓 하나에 대한 완료 신호를 스레드 하나만 처리할 수 있게 보장된다. 이러한 특징 덕분에 IOCP 하나를 여러 스레드가 기다리도록 구현하기가 쉽고 많은 소켓에 대한 I/O 처리를 동시다발적으로 수행할 때 여러 스레드가 완료 신호 처리를 골고루 나누어서 처리할 수 있다. 이는 대규모 동시접속자 게임 서버를 만들고자 멀티코어를 모두 활용해야 할 때 유리하다.

저작자표시 (새창열림)

3장 소켓 프로그래밍

6. 논블록 소켓

7. Overlapped I/O 혹은 비동기 I/O

8. epoll

9. IOCP

티스토리툴바