생각하는개발자

WSAEventSelect 모델

WSAEventSelect 모델은 윈도우 메시지 대신에 이벤트 객체를 이용한다는 점을 제외하면  WSAAsyncSelect 모델과 여러 가지로 비슷하다. 물론 표 4에 나와있는 네트워크 이벤트도 WSAAsyncSelect 모델과 공유해 쓸 수 있다. WSAEventSelect 모델을 쓰려면 먼저 다음과 같이 WSACreateEvent 함수를 이용해 이벤트 객체를 만들어야 한다.

WSAEVENT  WSACreateEvent(void);

WSACreateEvent 함수를 통해 이벤트 객체를 만들었으면 이 이벤트 핸들을 소켓에 연결해야 한다(이때 원하는 이벤트를 지정해야 한다). 이 작업은 WSAEventSelect 함수를 통해 이루어지며, 다음은 이 함수의 원형이다.

int WSAEventSelect (

  SOCKET s,              

  WSAEVENT hEventObject,

  long lNetworkEvents

);

첫 번째 인자 s는 소켓을 나타내며, 두 번째 인자 hEventObject는 WSA CreateEvent를 통해 얻은 이벤트 객체를, 마지막 인자 lNetworkEvents는 네트워크 이벤트 타입이다.

WSACreateEvent는 논시그널드(nonsignaled) 상태의 매뉴얼 리셋(manual reset) 이벤트를 생성한다. 그러므로 이벤트가 시그널 상태로 되어 적절한 처리를 해준 후 다시 논시그널드 상태로 되돌리려면 다음의 WSA ResetEvent 함수를 호출해야 한다.

BOOL WSAResetEvent(

  WSAEVENT hEvent

);

응용 프로그램에서 이벤트 객체의 사용을 마치고 제거하려면 다음 WSACloseEvent 함수를 이용해 이벤트 객체를 해제해 주어야 한다.

BOOL WSACloseEvent(

  WSAEVENT hEvent  

);

WSAAsyncSelect의 윈도우 프로시저에서 메시지를 처리하는 부분은 WSAWaitForMultipleEvents 함수를 통해 이루어지며 이 함수의 원형은 다음과 같다.

DWORD WSAWaitForMultipleEvents(

  DWORD cEvents,                 

  const WSAEVENT FAR *lphEvents, 

  BOOL fWaitAll,                 

  DWORD dwTimeOUT,               

  BOOL fAlertable                

);

WSAWaitForMultipleEvents 함수는 WIN32의 WaitForMultipleEvents 함수와 비슷한 기능을 하며 대부분의 인자 배열도 비슷하다. 단지 이 함수가 동시에 처리할 수 있는 이벤트 객체의 수는 64개로 고정되어 있다. 다시 말해 이 모델은 한 스레드에서 64개의 소켓까지만 지원할 수 있다.

WSAWaitForMultipleEvents 함수의 반환 값을 통해 어느 이벤트 객체가 시그널드 상태로 됐는지 알아낼 수 있고 다음의 WSAEnumNetworkEvents 함수를 통해 어떤 네트워크 이벤트가 발생했는지 조사할 수 있다.

int WSAEnumNetworkEvents (

  SOCKET s,                          

  WSAEVENT hEventObject,              

  LPWSANETWORKEVENTS lpNetworkEvents 

);

마지막 인자는 WSANETWORKEVENTS 구조체에 대한 포인터이며, 발생한 네트워크 이벤트와 에러 코드를 담고 있다. 그 구조는 다음과 같다.

typedef struct _WSANETWORKEVENTS {

   long lNetworkEvents;

   int iErrorCode[FD_MAX_EVENTS];

} WSANETWORKEVENTS, FAR * LPWSANETWORKEVENTS;

구조체에서 네트워크 이벤트를 조사하면서 그 이벤트에 대하여 에러가 발생했는지 같이 검사해야 한다. 다음의 예제와 같이 FD_READ 이벤트가 발생한 경우 이에 해당하는 에러코드의 배열(FD_READ_BIT)도 검사해 동작이 성공했는지 알아봐야 한다.

if (NetworkEvents.lNetworkEvents & FD_READ) {

  if (NetworkEvents.iErrorCode[FD_READ_BIT] != 0) {

    printf(“FD_ERROR failed with error %d \n”,

          NetworkEvents.iErrorCode[FD_READ_BIT]);

  }

}

리스트 3은 WSAEventSelect 모델을 사용하는 프로그램의 부분적인 코드이다.

리스트 2 : WSAAsyncSelect 모델 예제

main()

{

// 생략

   Listen = socket ()

   WSAAsyncSelect(Listen, Window, WM_SOCKET, FD_ACCEPT|FD_CLOSE);

   InternetAddr.sin_family = AF_INET;

   InternetAddr.sin_addr.s_addr = htonl(INADDR_ANY);

   InternetAddr.sin_port = htons(PORT);

   bind(Listen, (PSOCKADDR) &InternetAddr, sizeof(InternetAddr));

   listen(Listen, 5);

   while(Ret = GetMessage(&msg, NULL, 0, 0))

   {

      if (Ret == -1)

      {

         printf(“GetMessage() failed with error %d\n”, GetLastError());

         return;

      }

      TranslateMessage(&msg);

      DispatchMessage(&msg);

   }

} // main 함수

LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)

{

   SOCKET Accept;

   LPSOCKET_INFORMATION SocketInfo;

   DWORD RecvBytes, SendBytes;

   DWORD Flags;

   if (uMsg == WM_SOCKET)

   {

      if (WSAGETSELECTERROR(lParam))

      {

         printf(“Socket failed with error %d\n”, WSAGETSELECTERROR(lParam));

         FreeSocketInformation(wParam);

      }

      else

      {

         switch(WSAGETSELECTEVENT(lParam))

         {

            case FD_ACCEPT:

               Accept = accept(wParam, NULL, NULL));

               WSAAsyncSelect(Accept, hwnd, WM_SOCKET,

                            FD_READ|FD_WRITE|FD_CLOSE);

               break;

            case FD_READ:

               // 데이터 읽기 작업

               break;

            case FD_WRITE:

               // 데이터 쓰기 작업

               break;

            case FD_CLOSE:

                    closesocket(wParam);

               break;

         }

      }

      return 0;

   }

   return DefWindowProc(hwnd, uMsg, wParam, lParam);

}

WSAEventSelect

WSAEventSelect 함수는 FD_XXX 네트웍 이벤트와 연관되는 이벤트 객체를 지정하기위해 사용되는 함수입니다.

int WSAEventSelect (
        SOCKET  s,
        WSAEVENT  hEventObject,
        long  lNetworkEvents
);

Parameters

s
[입력] 대상 소켓 기술자

hEventObject
[입력] FD_XXX 네트웍 이벤트와 연관되는 이벤트 객체를 명시한 핸들

lNetworkEvents
[입력] 어플리케이션에서 발생시키고자 하는 FD_XXX 네트웍 이멘트의 비트조합

Remarks

WSAEventSelect 함수는 선택된 FD_XXX 네트웍 이벤트(INetworkEvents)와 연관될 이벤트 객체(hEventObject)를 명시하는데 사용하는 함수입니다. 이벤트 객체가 명시될 소켓은 s 매개변수입니다. 이벤트 객체는 등록된 네트웍 이벤트가 발생했을 때 설정됩니다.

WSAEventSelect 함수는 WSAAsyncSelect 함수와 매우 유사하게 동작합니다. 차이점이라면, 등록된 네트웍 이벤트가 발생됐을 때 동작되는 부분이죠. WSAAsyncSelect 함수는 명시된 윈도즈 메시지가 메시지 큐에 포스팅 되는 형태이고, WSAEventSelect 함수는 관련된 이벤트 객체를 설정하고, 내부적인 네트웍 이벤트의 발생을 남기는 형태입니다.

어플리케이션은 대기하거나 네트웍 이벤트 객체를 폴링하기 위해 WSAWaitForMultipleEvents 함수를 사용할 수 있습니다. 그리구, WSAEnumNetworkEvents 함수를 사용하여 내부적으로 발생한 네트웍 이벤트의 내용을 얻어낼 수 있습니다. 즉, 이렇게 함으로써 발생한 네트웍 이벤트가 어떠한건지 알아낼 수 있다는 거죠.

WSAEventSelect 함수는 INetworkEvents 의 값과는 상관없이 자동으로 소켓 s 를 비동기 모드로 설정합니다. 소켓을 다시 동기모드로 되돌려놓는 방법에 대해 알고 싶으며, ioctlsocket/WSAIoctl 함수를 살펴보도록 하세요.

INetworkEvents 매개변수는 아래에 나열된 값들을 OR 연산해서 얻은 값으로 구성됩니다.

한 소켓에 대해서 WSAEventSelect 함수를 호출하게되면, 같은 소켓에 대해서 이전에 WSAAsyncSelect 함수나 WSAEventSelect 함수의 호출을 무시하게 되고, 이전에 설정되었던 내부적 네트웍 이벤트 등록을 없애버립니다. 한 예로, 읽기와 쓰기 네트웍 이벤트 양쪽을 받고자 하는 상태를 만들기 위해서는 아래의 코드와 같이 FD_READ와 FD_WRITE를 양쪽다 같이 설정해 주어야 합니다. 달리 말하자면, 먼저 FD_READ하고 나중에 FD_WRITE 한다고 읽기와 쓰기 모두에 대해서 통지 메시지를 받지는 않는다는 점을 꼭 기억하세요. 이렇게 하면, FD_READ는 무시되고 FD_WRITE만 통지 받게 됩니다.

rc = WSAEventSelect(s, hEventObject, FD_READ|FD_WRITE);

다른 네트웍 이벤트에 대해서 다른 이벤트 객체를 명시하는 방법은 불가능 합니다. 아래의 코드는 제대로 동작하지 않을 것입니다. 즉, 두 번째 구문의 호출이 첫 번째 구문의 호출의 효과를 무시해 버릴 것입니다. 그리고, 단지 FD_WRITE 네트웍 이벤트 만이 hEventObject2에 대해서 발생할 것입니다.

rc = WSAEventSelect(s, hEventObject1, FD_READ);
rc = WSAEventSelect(s, hEventObject2, FD_WRITE);

관련된 그리고 한 소켓에 대해서 선택된 네트웍 이벤트를 취소하기 위해서 INetworkEvent 를 0으로 설정해서 WSAEventSelect 함수를 호출하면 됩니다. 이렇게 하면, hEventObject 매개변수는 앞으로 무시될 것입니다.

rc = WSAEventSelect(s, hEventObject, 0);

closesocket 함수로 소켓을 종료하게 되면 소켓에 대해서 WSAEventSelect로 지정된 네트웍 이벤트를 취소하게 됩니다. 하지만, 어플리케이션은 반드시 WSACloseEvent 함수를 호출해서 이벤트 객체와 리소스를 반환 해 줘야 합니다.

리슨소켓으로 접속허용(accepted)되어 생성된 소켓은 리슨소켓과 같은 속성을 가지게 됩니다. 예를들어 리슨소켓이 FD_ACCEPT, FD_READ, 그리고 FD_WRITE 속성을 가지도록 설정되어 있다면, 접속허용된 소켓도 리슨 소켓과 같은 FD_ACCEPT, FD_READ, FD_WRITE 속성을 가지게 된다는 것입니다. 새로 생성된 접속허용된 소켓에 다른 네트웍 이벤트를 설정하고 싶으면, WSAEventSelect 함수를 호출하여 새로운 정보로 설정해 주어야 합니다.

select 나 WSAAsyncSelect 함수의 경우와 같이 WSAEventSelect 함수는 데이터 전송/수신 연산(send/recv)이 일어날 수 있는 시점을 결정하는데 자주 사용됩니다. 하지만, 100%정확하게 이러한 시점에서 데이터를 전송하거나 수신할 수 있는 것은 아닙니다. 예외적인 상황이 발생 할 수도 있다는 거죠. 예를들어 데이터를 수신해도 된다는 FD_READ 이벤트를 받고나서 데이터를 수신했을 때 WSAEWOULDBLOCK 이라는 에러가 발생 할 수도 있다는 의미입니다. 그러므로 튼튼한 어플리케이션을 만들려면, 이러한 예외적인 상황에 대비할 수 있는 준비를 해야 합니다. 아래에 이러한 상황이 일어날 수 있는 시나리오를 한번 생각해 봤습니다. 참고하세요.

1. 데이터가 소켓 s 에 도착 했습니다. 윈도즈 소켓은 WSAEventSelect 이벤트 객체를 설정합니다.

2. 어플리케이션은 몇몇 다른 작업을 진행하고 있는 도중입니다.

3. 작업을 진행하고 있는동안 ioctlsocket( s, FIONREAD...)를 호출했다고 해봅시다. 그러면, 읽을 수 있는 데이터가 있다는 사실을 알게 되겠죠.

4. 어플리케이션은 데이터를 읽기 위해서 recv(s, ...)를 호출 할 것입니다.

5. 하던 작업이 끝나면, 1.에서 설정된 이벤트 객체가 있으므로 데이터를 읽을 수 있는 상태라는 것을 알 수 있게 됩니다.

6. 어플리케이션은 데이터를 읽기 위해서 recv(s, ...)를 호출할 것이고, 이미 이 데이터는 읽혀졌지 때문에 WSAEWOULDBLOCK 에러를 내면서 실패 하게 됩니다.

이벤트 객체와 연관된 신호와 네트웍 이벤트의 발생을 계속 성공적으로 발생시키려면, 네트웍 이벤트가 통지 되었을 때 이벤트 객체와 연관된 재활성화(re-enabling) 함수를 명시적으로 호출해 주어야 합니다. 그래야만, 다음에 발생하는 네트웍 이벤트나 신호를 받을 수 있게 됩니다. 아래의 표에 각 네트웍 이벤트에 해당하는 재활성화 함수(re-enabling function)을 나열해 보았습니다.

FD_READ, FD_OOB, 그리고 FD_ACCEPT 이벤트에 대한 메시지 포스팅 방법은 "level-triggered"라고 합니다. 무슨 말이냐구요? 만약 재활성화 루틴이 호출되고, 이와 관련된 상태가 루틴 호출후에도 여전히 남아 있다면, 메시지는 어플리케이션에 다시 포스팅 됩니다. 이러한 포스팅 방법으로 어플리케이션은 메시지 구동 방식이 됩니다. 아직 이해가 잘 않되시죠? 아래의 순서를 한번 생각해 보세요... 지금 제가 한말을 쉽게 이해 할 수 있을 겁니다.

1. 네트웍 전송/수신 스택이 소켓에 100 바이트의 데이터를 수신받고, 윈속이 FD_READ 메시지를 포스팅 했습니다.

2. 어플리케이션이 recv( s, buffer, 50, 0 )을 호출해서 50바이트를 수신했습니다.

3. 읽을 데이터가 여전히 남아있는 동안 FD_READ 메시지가 포스팅 됩니다.

이러한 구조상에서, 어플리케이션은 하나의 FD_READ 메시지에 대해서 모든 가능한 데이터를 읽어낼 필요가 없습니다. 각각의 FD_READ 메시지에 대해서 하나의 recv를 사용하는 것이 적절한 방법입니다. 만약 어플리케이션이 하나의 FD_READ에 대해서 여러개의 recv를 호출할 경우, 여러개의 FD_READ 메시지를 수신할 수도 있습니다. 이러한 어플리케이션에서는 recv함수를 호출하기전에 WSAAsyncSelect 함수를 FD_READ 이벤트를 셋팅하지 않는 방법으로 FD_READ 메시지 수신을 막아 버려야할 필요가 있습니다.

FD_QOS 그리고 FD_GROUP_QOS 이벤트는 "edge triggered"로 간주됩니다. 메시지는 Quality Of Service가 바뀌었을 때 정확히 한번 포스팅 됩니다. 게다가 메시지는 프로바이더가 QOS에서의 다른 변화를 감지하든지, 아니면, 어플리케이션이 소켓에 대한 QOS를 재설정할 때 까지 메시지는 수신되지 않습니다.

FD_ROUTING_INTERFACE_CHANGE 메시지는 SIO_ROUTING_INTERFACE_CHANGE 컴맨드로 WSAIoctl 함수가 호출될 때 포스팅 됩니다.

FD_ADDRESS_LIST_CHANGE 메시지는 SIO_ADDRESS_LIST_CHANGE 컴맨드로 WSAIoctl 함수가 호출될 때 포스팅 됩니다.

만약 어플리케이션이 WSAAsyncSelect함수를 호출하거나 재활성(re-enabling)함수를 호출했을 때 이미 이벤트가 발생되었다면, 이때의 메시지는 적절히 포스팅 됩니다. 이해를 쉽게 하기위해 아래의 일어날 수 순서 상황을 생각해 보세요.

1. 어플리케이션이 생성한 소켓에 대해서 listen 함수를 호출 했습니다.

2. 접속 요구가 들어왔으나 아직 accept 하지 않았습니다.

3. 어플리케이션은 이 소켓에 대해서 FD_ACCEPT로 WSAAsyncSelect 함수를 호출하였습니다. 이때 이벤트의 영속성이 보존되기 때문에 윈속은 FD_ACCEPT 메시지를 바로 포스팅 하게 됩니다.

FD_WRITE 이벤트는 약간 다르게 운용됩니다. 즉, 소켓이 connect/WSAConnect 함수의 호출로 첨 접속되었을 때, 또는 accept/WSAAccept 함수로 접속허용되었을 때, 또는, send 연산이 WSAEWOULDBLOCK 으로 실패(비동기소켓은 항상 WSAEWOULDBLOCK입니다)한 상태에서 전송용 버퍼공간이 사용 가능해졌을 때 FD_WRITE 메시지는 포스팅 됩니다. 따라서 어플리케이션은 FD_WRITE 메시지를 받았을 때 데이터의 전송이 가능하다고 판단 할 수 있습니다.

FD_OOB 이벤트는 소켓이 out-of-band 데이터를 부분적으로 수신하여 나열할 때만 사용됩니다. 만약 소켓이 out-of-band 데이터를 인라인 방식으로 수신하도록 나열 한다면, out-of-band데이터는 일반 데이터와 같이 다루어 지게 됩니다. 이때, 어플리케이션은 interest(?)를 등록해야 합니다. 일반데이터와 같이 다루어 진다는 의미는 뭔지 아시겠죠? FD_OOB 이벤트가 아닌 FD_READ이벤트가 발생했을 때 데이터를 수신한다는 의미입니다. 어플리케이션은 out-of-band 데이터가 SO_OOBINLINE 옵션으로 setsockopt함수나 getsockopt함수를 사용하여 핸들링 하는 방법을 설정할 수 있습니다.

FD_CLOSE 메시지의 에러코드는 소켓이 우아한닫힘(graceful close)인지 그렇지 않은 닫힘인지를 나타냅니다. 만약 에러코드가 0이라면, 소켓은 우아한닫힘 이라는 의미이고, 에러코드가 WSAECONNRESET 이라면, 소켓의 가상 회선망이 리셋되었다는 것을 의미합니다. 이러한 것들은 SOCK_STREAM과 같은 접속 지향형 소켓일 경우에만 사용될 수 있는 것들입니다.

FD_CLOSE 메시지는 소켓과 연관된 가상 회선망이 끊겼다는 것을 수신받았을 때 포스팅 됩니다. TCP 의 경우는 접속이 TIME WAIT 나 CLOSE WAIT 상태로 들어갔을 때 FD_CLOSE 메시지가 포스팅 되게 됩니다. 즉, 원격 종단점에서의 전송영역의 셧다운이나 closesocket 함수의 호출의 결과로 일어날 수 있는 메시지입니다. FD_CLOSE 메시지는 모든 데이터가 소켓으로부터 읽혀지고 난 후에 포스팅 됩니다 그렇긴 해도, 최대한 손실된 데이터들을 피하고자 한다면, FD_CLOSE 메시지를 받은 후에 남아있는 데이터들을 체크하는 것이 좋겠죠?

Return Values

지정된 네트웍 이벤트와 이벤트 객체가 성공적으로 설정되었으면, 함수는 0을 반환 합니다. 에러가 발생한 경우 SOCKET_ERROR을 리턴하고, WSAGetLastError 함수를 호출하여 특정한 에러코드를 얻어낼 수 있습니다.

Error Codes

QuickInfo

Windows NT : 사용가능
Windows : 사용가능
Windows CE : 지원되지 않음
Header :
          Win16/32 : winsock.h
          Win32-II : winsock2.h
Import Library :
          Win16 : winsock.lib
          Win32 : wsock32.lib
          Win32-II : ws2_32.lib

See Also

overview, WSAAsyncSelect, WSACloseEvent, WSACreateEvent, WSAEnumNetworkEvents, WSAWaitForMultipleEvents

소켓 입출력 모델 - Overlapped 모델

[동기 입출력(synchronous I/O)]

애플리캐이션은 입출력 함수를 호출한 후 입출력 작업이 끝날때 까지 대기하다 끝나면 입출력 결과를 처리하거나 다른 작업을 할수 있다

Select, WSAAsyncSelect, WSAEventSelect 소켓 모델은 모두 동기 입출력 방식으로 동작.  단 입출력 함수를 안전하게 호출할수

있는 시점을 운영체제가 알려주기 때문에 단순한 동기 입출력 방식보다 편하게 여러 소켓을 처리할수 있다

- 이와 같이 운영체제가 함수 호출 시점을 알려주는 개념을 비동기 통지라고 부른다.

[비동기 입출력(asynchronous I/O = overlapped I/O)]

어플리캐이션은 입출력 함수를 호출한 후 입출력 작업의 완료 여부와 무관하게 다른 작업을 할 수 있다

입출력 작업이 끝나면 운영체제는 작업 완료를 어플리캐이션에게 알려준다

비동기 입출력 방식에서는 입출력 완료를 운영체제에서 알려주는 개념이 반드시 필요하므로 비동기 통지도 사용한다고 볼수 있다

- Overlapped, Completion Port(IOCP)는 비동기 입출력과 비동기 통지를 결합한 형태라 할수 있다

[Overlapeed 모델]

* 사용 절차

1. 비동기 입출력을 지원하는 소켓을 생성

  - socket() 함수로 생성한 소켓은 기본적으로 비동기 입출력을 지원한다

2. 비동기 입출력을 지원하는 소켓 함수 호출(총 13개의 함수)

  - AcceptEx(), ConnectEx(), DisconnectEx(), TransmitFile(), TransmitPackets(), WSAIoctl(), WSASPIoctl(),

    WSAProviderConfigChange(), WSARecvMsg(), WSARecv(), WSARecvFrom(), WSASend(), WSASendTo()

3. 운영체제는 소켓 입출력 작업 완료를 애플리캐이션에게 알려주고(=비동기 통지), 애플리케이션은 결과를 처리

* 비동기 통지 방식에 따른 Overlapped 모델 분류

1. Overlapped 모델( I )

: 소켓 입출력 작업이 완료되면 운영체제는 애플리케이션이 등록한 이벤트 객체를 신호상태로 바꾼다

 애플리케이션은 이벤트 객체를 관찰함으로써 작업 완료를 감지할수 있다

2. Overlaped 모델( II )

: 소켓 입출력 작업이 완료되면 운영체제는 애플리케이션이 등록한 함수를 자동으로 호출한다

  일반적으로 운영체제가 호출하는 애플리케이션 함수를 콜백 함수(callback function) 라 부르는데.

  특별히 Overlapped 모델에서는 완료 루틴(completion routine) 이라 칭한다

[WSASend(), WSARecv()]

int WSASend(

    SOCKET s, LPWSABUF lpBuffers, DWORD dwBufferCount,

    LPDWORD lpNumberOfBytesSent,

    DWORD dwFlags,

    LPWSAOVERLAPPED lpOverlapped,

    LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoution

);    성공 : 0.   실패 : SOCKET_ERROR

int WSARecv(

    SOCKET s, LPWSABUF lpBUffers, DWORD dwBufferCount,

    LPDWORD lpNumberOfBytesRecvd,

    LPDWORD lpFlags,

    LPWSAOVERLAPPED lpOverlapped,

    LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine

);    성공 : 0.    실패 : SOCKET_ERROR

s : 비동기 입출력을 할 소켓

lpBuffers : WSABUF 구조체 배열의 시작주소. 각각의 배열 원소(WSABUF 타입)는  버퍼의 시작 주소와 길이(바이트단위)를 담고 있다

dwBufferCount : WSABUF 구조체 배열의 원소개수

lpNumberOfBytesSent, lpNumberOfBytesRecvd

 : DWORD 형 변수 주소값으로 함수 호출이 성공하면 이 변수에 보내거나 받은 바이트가 저장된다

dwFlags, lpFlags : send(), recv() 함수의 마지막 인자와 동일한 역활

lpOverlapped

 : WSAOVERLAPPED 구조체 변수의 주소값

   이 구조체는 비동기 입출력을 위한 정보를 운영체제에 전달하거나 운영체제가 비동기 입출력 결과를 애플리케이션에 전달할때 사용

   WSAOVERLAPPED 구조체 변수중 처음 네 개는 운영체제가 내부적으로만 사용.

   마지막 변수인 hEvent 는 이벤트 객체 핸들값으로 Overlapped 모델( I ) 에서만 사용한다.

   입출력 작업이 완료되면 hEvent 가 가리키는 이벤트 객체는 신호상태가 된다.

lpCompletionRoutine :  입출력 작업이 완료되면 운영체제가 자동으로 호출할 완료루틴(콜백함수)의 주소값

* WSASend(), WSARecv() 함수 특징

송신측에서 WSABUF 구조체를 사용하면 여려개의 버퍼에 저장된 데이터를 모아서(Gather) 보낼 수 있다.

수신측에서도 역시 WSABUF 구조체를 사용하면 여러개의 버퍼에 흩어(Scatter)저장할 수 있다.

buf[128];

buf[256];

WSABUF wsabuf[2];

wsabuf[0].buf = buf1;

wsabuf[0].len = 128;

wsabuf[1].buf = buf2;

wsabuf[1].len = 256;

// 송신측 코드

WSASend(sock, wsabuf, 2, ...);

// 수신측 코드

WSARecv(sock, wsabuf, 2, ...);

현재 개발중인 게임 서버의 소켓이 4년전에 제작한 비동기 이벤트 셀렉트 방식인 관계로 퍼포먼스를 향상시키고자 IOCP 네트워크 구조를 최근 제작하게 되었다. 실제 게임서버에 적용 가능할지는 좀 더 고려해 보아야 하겠지만, IOCP 서버를 만들면서 겪었던 점들을 공유하고자 한다.

시중의 책들과 공개된 소스들을 참고해서 IOCP를 구현해 보면, 항상 과부하 테스트시에 문제가 발생했다. 내가 설정한 과부하 테스트는 다음과 같은 상황이다:

1) 클라이언트 측에서 과도할 정도로 Connect를 시도한다.
2) 서버는 Accept 직후 랜덤하게 연결을 끊어버린다.
3) 클라이언트는 Connect된 직후 서버로 데이터를 전송한다.
4) 서버는 클라이언트로부터 데이터가 수신되면 바로 응답메시지를 전송한다. 이때 응답메시지를 전송할 내부 버퍼(소켓 버퍼 아님)가 모자라는 경우 연결을 끊는다. 이 처리와는 별도로 데이터 수신시 랜덤하게 연결을 끊는다.
5) 클라이언트는 서버로부터 데이터를 수신하면 바로 응답메시지를 전송한다. 이때 응답메시지를 전송할 내부 버퍼(소켓 버퍼 아님)가 모자라는 경우 연결을 끊는다. 이 처리와는 별도로 데이터 수신시 랜덤하게 연결을 끊는다.
6) 클라이언트는 연결이 끊어진 커넥션이 발생하면 그에 대응하는 Connect를 시도한다.

 클라이언트는 초기에 몇천개 이상의 Connect를 시도하고 연결된 커넥션들에 대해 각각 위의 규칙대로 처리를 반복하는 상황을 만들어 테스트 해 보았는데, 여러번의 삽질끝에 발견한 문제점들은 다음과 같다.

일단, 시중에 떠도는 IOCP소스들의 대부분은 에코(Echo) 서버들이다. 이 소스들은 항상 데이터를 recv한 다음 send를 하므로 참조 카운트가 1 이상 올라가지 않지만, 게임 서버는 그렇지 않다. 걸어놓은 recv에 대한 응답이 안 온 상태에서 send를 할 수 있으므로 소켓 1개에 대해 2개의 참조 카운트가 발생할 수 있다. GetQueuedCompletionStatus가 FALSE를 리턴한 경우, 대부분의 에코서버 소스에서는 바로 소켓을 close한 다음 커넥션 객체를 삭제해 버리는데, 이것은 참조 카운트가 1이상 올라가지 않기 때문이다. 이런 경우 게임서버에서는 그 소켓에 대한 참조카운트가 2라면, 그냥 소켓을 close한 다음 나머지 작업에 대한 실패 통보가 와서 참조 카운트가 0이 되었을때 커넥션 객체를 삭제해야만 한다. 마찬가지로 WSARecv에 대한 리턴이 왔는데 전송 바이트가 0인 경우에도 무조건 객체를 지워서는 안된다.

IOCP에서 WSASend, WSARecv를 사용할 때 소켓에러 없이(IO_PENDING는 에러가 아니므로 제외) 포스팅된 소켓 연산의 결과는 반드시 각각 GetQueuedCompletionStatus에서 리턴된다. 단, 함수의 반환값은 TRUE일수도 FALSE일수도 있다.

한가지 이상한 현상을 발견했는데, close한 소켓을 WSASend나 WSARecv에 사용했을때 에러가 반환되지 않는 경우가 있다. 예를 들어, 소켓 A에 대해서 WSARecv가 포스팅된 상태에서, 소켓 A를 close했다. 이 때 GetQueue... 에서 WSARecv에 대한 성공 결과가 리턴될 수 있다(close하기 전에 성공한 결과일 수 있으므로), 이때 다시 WSARecv를 걸려고 할 때 close된 소켓이므로 WSARecv가 에러를 발생해야 정상이므로 이 시점에 커넥션을 삭제하고자 했는데, WSARecv가 에러를 발생시키지 않는 거다. 원인은 잘 모르겠지만, 아마도 네트워크 과부하 상황일때 이런 현상이 발생하는게 아닌가 추측하고 있다. 결국 결국 소켓이 닫혔다는 별도의 플래그를 만들어 직접 해결할 수 밖에 없었다. 이런 상황에서 얻은 정보를 써 보자면:

서버에서 소켓을 close하는 것이 closesocket() 호출 이전에 포스팅한 WSASend, WSARecv를 꼭 실패시키지는 않는다. 성공할 수도 있고, 실패할 수도 있다.

서버에서 소켓을 close하면 이전에 포스팅된 연산에 대한 결과는 반드시 GetQueuedCompletionStatus에서 각각 모두 리턴된다.


이런 것들을 이해하고 나니, 과부하 테스트에서도 정확하게 동작하는 IOCP 네트워크 클래스를 제작할 수 있었다.
  

*동작원리

1.비동기 입출력 함수를 호출함으로써 운영체제에 입출력 작업을 요청한다.
2.해당 스레드는 곧바로 alertable wait 상태에 진입한다. 여기서 alertable wait 상태
란 비동기 입출력을 위한 특별한 대기 상태로, 비동기 입출력 함수를 호출한 스레드 이
상태에 있어야만 완료 루틴이 호출될수 있다. 스레드를 alertable wait 상태로 만드는
함수는 다양하다. 몇 가지 예를 들면 WaitForSingleObjectEx(),WaitForMulitipleOvjectsEx()
,SleepEx(),WSAWaitForMultipleEvent()등이 있다. 마지막 함수인 WSAWaitForMultipleEvents()
는 WSAEventSelect모델과 Overlapped모델(I)에서 다룸, 마지막 인자에 TRUE를 사용하면 해
당 스레드는 alertable wait상태가 된다.
3.비동기 입출력 작업이 완료되면 운영체제는 스레드의 APC큐에 결과를 저장한다.
여기서 APC큐(Asynchronous Procedure Call Queue)란 비동기 입출력 결과 저장을 위해
운영체제가 각 스레드마다 할당하는 메모리 영역이다.
4.비동기 입출력 함수를 호출한 스레드가 alertable wait 상태에 있으면 운영체제는APC
큐에 저장된 정보(완료 루틴의 주소)를 참조하여 완료 루틴을 호출한다. 완료 루틴
내부에서 는 데이터를 처리한 후 다시 alertable wait상태에 진입해야한다.


========================= 소켓 입출력 절차 ====================================

1.비동기 입출력을 지원하는 소켓을 생성한다.
2.비동기 입출력 함수를 호출한다. 이때 완료 루틴의 시작 주소를 함수 인자로 전달
한다. 비동기 입출력 작업이 곧바로 완료되지 않으면, 소켓 함수는 오류를 리턴하고
오류코드는 WSA_IO_PENDING으로 설정된다.
3.비동기 입출력 함수를 호출한 스레드를 alertable wait상태로 만든다. 앞에서 소개한
WaitForSingleObjectEx(), WaitForMultipleObjectEx(),SleepEx(),WsaWaitForMultipleEvents()
등의 함수 중에서 적절한 것을 선택하여 사용하면 된다.

4.비동기 입출력 작업이 완료되면 운영체제는 완료 루틴을 호출한다. 완료 루틴에서는
비동기 입출력 결과를 확인하고 데이터를 처리한다.

5. 완료 루틴 호출이 모두 끝나면 스레드는 alertable wait 상태에서 빠져나온다

6.새로운 소켓을 생성하면 1~5 그렇지 않으면 2~5를 반복한다.

========================= 스레드를 alertable wait 상태로 바꾸는 함수)

void CALLBACK CompletionRoutine(
     DWORD dwError,
     DWORD cbTransferred,
     LPWSAOVERLAPPED lpOverlapped,
     DWORD dwFlags);

dwError:비동기 입출력 결과를 나타낸다. 오류가 발생하면 이 값은 0이 아닌 값이된다.
cbTransferred:전송바이트 수를 나타낸다. 통신 상대가 접속을 종료하면 이 값은 0이된다.
lpOverlapped:비동기 입출력 함수 호출 시 넘겨준 WSAOVERLAPPED구조체의 주소값이 이
인자를 통해 다시 애플리케이션에 넘어온다. Overlapped모델(II)에서는 이벤트 객체
를 사용하지 않으므로 WSAOVERLAPPED 구조체를 완료 루틴 내부에서 직접 사용할 일은 거의 없다.
dwFlags:항상 0이므로 적어도 현재까지는 사용하지 않음

========================== 예제 소스 코드 ==============================
 
#include <winsock2.h>
#include <stdlib.h>
#include <stdio.h>
 
#define BUFSIZE 512
 
// 소켓 정보 저장을 위한 구조체
struct SOCKETINFO
{
WSAOVERLAPPED overlapped;
SOCKET sock;
char buf[BUFSIZE+1];
int recvbytes;
int sendbytes;
WSABUF wsabuf;
};
 
SOCKET client_sock;
 
// 소켓 입출력 함수
DWORD WINAPI WorkerThread(LPVOID arg);
void CALLBACK CompletionRoutine(
DWORD dwError, DWORD cbTransferred,
LPWSAOVERLAPPED lpOverlapped, DWORD dwFlags
);
// 오류 출력 함수
void err_quit(char *msg);
void err_display(char *msg);
void err_display(int errcode);
 
int main(int argc, char* argv[])
{
int retval;
 
// 윈속 초기화
WSADATA wsa;
if(WSAStartup(MAKEWORD(2,2), &wsa) != 0)
  return -1;
 
// socket()
SOCKET listen_sock = socket(AF_INET, SOCK_STREAM, 0);
if(listen_sock == INVALID_SOCKET) err_quit("socket()");
 
// bind()
SOCKADDR_IN serveraddr;
ZeroMemory(&serveraddr, sizeof(serveraddr));
serveraddr.sin_family = AF_INET;
serveraddr.sin_port = htons(9000);
serveraddr.sin_addr.s_addr = htonl(INADDR_ANY);
retval = bind(listen_sock, (SOCKADDR *)&serveraddr, sizeof(serveraddr));
if(retval == SOCKET_ERROR) err_quit("bind()");
 
// listen()
retval = listen(listen_sock, SOMAXCONN);
if(retval == SOCKET_ERROR) err_quit("listen()");
 
// 이벤트 객체 생성
HANDLE hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
if(hEvent == NULL) return -1;
 
// 스레드 생성
DWORD ThreadId;
HANDLE hThread = CreateThread(NULL, 0, WorkerThread,
  (LPVOID)hEvent, 0, &ThreadId);
if(hThread == NULL) return -1;
CloseHandle(hThread);
 
while(1){
  // accept()
  client_sock = accept(listen_sock, NULL, NULL);
  if(client_sock == INVALID_SOCKET){
   err_display("accept()");
   continue;
  } 
  if(!SetEvent(hEvent)) break;
}
 
// 윈속 종료
WSACleanup();
return 0;
}
 
// 스레드 함수
DWORD WINAPI WorkerThread(LPVOID arg)
{
HANDLE hEvent = (HANDLE)arg;
int retval;
 
while(1){
  while(1){
   // alertable wait
   DWORD result = WaitForSingleObjectEx(hEvent, INFINITE, TRUE);
   if(result == WAIT_OBJECT_0) break;
   if(result != WAIT_IO_COMPLETION) return -1;
  }
 
  // 접속한 클라이언트 정보 출력
  SOCKADDR_IN clientaddr;
  int addrlen = sizeof(clientaddr);
  getpeername(client_sock, (SOCKADDR *)&clientaddr, &addrlen);
  printf("[TCP 서버] 클라이언트 접속: IP 주소=%s, 포트 번호=%d\n",
   inet_ntoa(clientaddr.sin_addr), ntohs(clientaddr.sin_port));
 
  // 소켓 정보 구조체 할당과 초기화
  SOCKETINFO *ptr = new SOCKETINFO;
  if(ptr == NULL){
   printf("[오류] 메모리가 부족합니다!\n");
   return -1;
  }
  ZeroMemory(&(ptr->overlapped), sizeof(ptr->overlapped));
  ptr->sock = client_sock;
  ptr->recvbytes = 0;
  ptr->sendbytes = 0;
  ptr->wsabuf.buf = ptr->buf;
  ptr->wsabuf.len = BUFSIZE;
 
  // 비동기 입출력 시작
  DWORD recvbytes;
  DWORD flags = 0;
  retval = WSARecv(ptr->sock, &(ptr->wsabuf), 1, &recvbytes,
   &flags, &(ptr->overlapped), CompletionRoutine);
  if(retval == SOCKET_ERROR){
   if(WSAGetLastError() != WSA_IO_PENDING){
    err_display("WSARecv()");
    return -1;
   }
  }
}
 
return 0;
}
 
// 완료 루틴
void CALLBACK CompletionRoutine(
DWORD dwError, DWORD cbTransferred,
LPWSAOVERLAPPED lpOverlapped, DWORD dwFlags)
{
int retval;
 
// 클라이언트 정보 얻기
SOCKETINFO *ptr = (SOCKETINFO *)lpOverlapped;
SOCKADDR_IN clientaddr;
int addrlen = sizeof(clientaddr);
getpeername(ptr->sock, (SOCKADDR *)&clientaddr, &addrlen);
 
// 비동기 입출력 결과 확인
if(dwError != 0 || cbTransferred == 0){
  if(dwError != 0) err_display(dwError);
  closesocket(ptr->sock);
  printf("[TCP 서버] 클라이언트 종료: IP 주소=%s, 포트 번호=%d\n",
   inet_ntoa(clientaddr.sin_addr), ntohs(clientaddr.sin_port));
  delete ptr;
  return;
}
 
// 데이터 전송량 갱신
if(ptr->recvbytes == 0){
  ptr->recvbytes = cbTransferred;
  ptr->sendbytes = 0;
  // 받은 데이터 출력
  ptr->buf[ptr->recvbytes] = '\0';
  printf("[TCP/%s:%d] %s\n", inet_ntoa(clientaddr.sin_addr),
   ntohs(clientaddr.sin_port), ptr->buf);
}
else{
  ptr->sendbytes += cbTransferred;
}
 
if(ptr->recvbytes > ptr->sendbytes){
  // 데이터 보내기
  ZeroMemory(&(ptr->overlapped), sizeof(ptr->overlapped));
  ptr->wsabuf.buf = ptr->buf + ptr->sendbytes;
  ptr->wsabuf.len = ptr->recvbytes - ptr->sendbytes;
 
  DWORD sendbytes;
  retval = WSASend(ptr->sock, &(ptr->wsabuf), 1, &sendbytes,
   0, &(ptr->overlapped), CompletionRoutine);
  if(retval == SOCKET_ERROR){
   if(WSAGetLastError() != WSA_IO_PENDING){
    err_display("WSASend()");
    return;
   }
  }
}
else{
  ptr->recvbytes = 0;
 
  // 데이터 받기
  ZeroMemory(&(ptr->overlapped), sizeof(ptr->overlapped));
  ptr->wsabuf.buf = ptr->buf;
  ptr->wsabuf.len = BUFSIZE;
 
  DWORD recvbytes;
  DWORD flags = 0;
  retval = WSARecv(ptr->sock, &(ptr->wsabuf), 1, &recvbytes,
   &flags, &(ptr->overlapped), CompletionRoutine);
  if(retval == SOCKET_ERROR){
   if(WSAGetLastError() != WSA_IO_PENDING){
    err_display("WSARecv()");
    return;
   }
  }
}
}
 
// 소켓 함수 오류 출력 후 종료
void err_quit(char *msg)
{
LPVOID lpMsgBuf;
FormatMessage(
  FORMAT_MESSAGE_ALLOCATE_BUFFER|
  FORMAT_MESSAGE_FROM_SYSTEM,
  NULL, WSAGetLastError(),
  MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
  (LPTSTR)&lpMsgBuf, 0, NULL);
MessageBox(NULL, (LPCTSTR)lpMsgBuf, msg, MB_ICONERROR);
LocalFree(lpMsgBuf);
exit(-1);
}
 
// 소켓 함수 오류 출력
void err_display(char *msg)
{
LPVOID lpMsgBuf;
FormatMessage(
  FORMAT_MESSAGE_ALLOCATE_BUFFER|
  FORMAT_MESSAGE_FROM_SYSTEM,
  NULL, WSAGetLastError(),
  MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
  (LPTSTR)&lpMsgBuf, 0, NULL);
printf("[%s] %s", msg, (LPCTSTR)lpMsgBuf);
LocalFree(lpMsgBuf);
}
 
// 소켓 함수 오류 출력
void err_display(int errcode)
{
LPVOID lpMsgBuf;
FormatMessage(
  FORMAT_MESSAGE_ALLOCATE_BUFFER|
  FORMAT_MESSAGE_FROM_SYSTEM,
  NULL, errcode,
  MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
  (LPTSTR)&lpMsgBuf, 0, NULL);
printf("[오류] %s", (LPCTSTR)lpMsgBuf);
LocalFree(lpMsgBuf);
}