IOCP(Input/Output Completion Port)는 Windows 운영체제에서 제공하는 고성능 비동기 I/O 처리 메커니즘입니다. 특히 네트워크 프로그래밍과 게임 서버 개발에서 많이 활용되는 기술로, 다음과 같은 특징을 가지고 있습니다:
- 고성능 처리: 한 서버에서 수천 명의 동시 접속자를 처리할 수 있는 성능을 제공합니다.
- 비동기 I/O: 입출력 작업을 비동기적으로 처리하여 시스템 자원을 효율적으로 사용합니다.
- 스레드 풀링: 작업자 스레드 풀을 통해 CPU 코어 수에 최적화된 스레드 관리가 가능합니다.
- 효율적인 컨텍스트 스위칭: 최소한의 컨텍스트 스위칭으로 시스템 부하를 줄입니다.
IOCP는 특히 온라인 게임 서버와 같이 많은 클라이언트의 동시 접속과 실시간 데이터 처리가 필요한 환경에서 매우 유용합니다. 대규모 다중 사용자 온라인 게임(MMORPG)이나 실시간 전략 게임(RTS), 배틀로얄 게임 등의 서버 개발에 널리 사용됩니다.
IOCP는 Windows의 Overlapped I/O 모델을 기반으로 합니다. Overlapped I/O란 I/O 작업이 중첩(Overlapped)되어 처리된다는 의미로, 하나의 스레드가 여러 I/O 작업을 동시에 처리할 수 있게 해줍니다.
- Overlapped I/O: 비동기 I/O 요청을 보내고 완료를 기다리지 않고 다른 작업을 수행할 수 있습니다.
- 완료 통지 방식: I/O 작업이 완료되면 OS가 애플리케이션에 통지하는 방식으로 동작합니다. 자세한 설명
IOCP의 기본 동작 원리는 다음과 같습니다:
- Completion Port 생성:
CreateIoCompletionPort함수를 사용하여 IOCP 객체를 생성합니다. - 소켓과 IOCP 연결: 생성된 소켓을 IOCP에 연결합니다.
- 작업자 스레드 생성: IOCP에서 완료 통지를 처리할 작업자 스레드를 생성합니다.
- 비동기 I/O 요청:
WSARecv,WSASend등의 함수를 사용하여 비동기 I/O 작업을 요청합니다. - 완료 통지 대기: 작업자 스레드는
GetQueuedCompletionStatus함수를 호출하여 I/O 완료 통지를 기다립니다. - 완료 처리: I/O 작업이 완료되면 해당 작업자 스레드가 결과를 처리합니다.
- 효율적인 스레드 관리: CPU 코어 수에 맞게 스레드 수를 조절하여 최적의 성능을 발휘합니다.
- 높은 확장성: 수천 개의 동시 연결을 효율적으로 처리할 수 있습니다.
- 리소스 효율성: 스레드 풀링을 통해 시스템 리소스를 효율적으로 사용합니다.
- 부하 분산: 여러 작업자 스레드에 작업을 분산시켜 처리합니다.
IOCP를 효과적으로 학습하기 위한 로드맵은 다음과 같습니다:
- C/C++ 프로그래밍: 포인터, 메모리 관리, 객체지향 프로그래밍 등 C/C++의 기본 개념을 숙지해야 합니다.
- 네트워크 기초: TCP/IP 프로토콜, 소켓 프로그래밍의 기본 개념을 이해해야 합니다.
- 멀티스레딩: 스레드, 동기화, 경쟁 조건, 교착 상태 등 멀티스레딩 관련 개념을 학습해야 합니다.
- Windows API: Windows 운영체제의 기본 API 사용법을 익혀야 합니다.
- 소켓 프로그래밍 기초: 기본적인 소켓 프로그래밍을 학습합니다.
- 비동기 I/O 개념: Overlapped I/O와 비동기 프로그래밍 개념을 이해합니다.
- IOCP 기본 구조: IOCP의 기본 구조와 동작 원리를 학습합니다.
- IOCP 서버 구현: 간단한 IOCP 기반 에코 서버를 구현해봅니다.
- 고급 IOCP 기법: 세션 관리, 패킷 처리, 버퍼 관리 등 고급 기법을 학습합니다.
- 게임 서버 아키텍처: 게임 서버의 전체 아키텍처를 설계하고 구현합니다.
GitHub 저장소 jacking75/edu_cpp_IOCP를 참고하여 다음과 같은 단계별 학습을 진행할 수 있습니다:
- IOCP API의 기본 동작 이해
- 간단한 에코 서버 구현
CreateIoCompletionPort,GetQueuedCompletionStatus등 핵심 API 사용법 학습
OverlappedEx구조체에서 버퍼 관리 최적화- 불필요한 메모리 낭비 제거
- 코드 구조 개선
- IOCP를 네트워크 라이브러리로 분리
- 연결, 끊어짐, 데이터 수신 이벤트를 애플리케이션에 전달하는 구조 구현
- 모듈화 및 재사용성 향상
- 네트워크 처리와 게임 로직 처리를 별도의 스레드로 분리
- Send와 Recv를 다른 스레드에서 처리
- 연속적인 Send 처리 구조 구현
- 버퍼에 데이터를 쌓아두고 Send 스레드에서 처리하는 방식 구현
- 큐를 사용한 순차적 Send 처리 구현
- 네트워크 부하 분산 및 최적화
- Accept 처리를 비동기 I/O로 전환
- 모든 네트워크 동작을 비동기 I/O로 구현
- 서버 성능 향상
- 패킷 구조 설계 및 구현
- 로그인 기능 구현
- Redis를 활용한 사용자 인증
- 채팅방 입장, 퇴장, 채팅 기능 구현
GetQueuedCompletionStatusEx사용으로 성능 향상- 동적 할당 최소화
- 링 버퍼 구현으로 덮어쓰기 방지
- 락(Lock) 사용 범위 최소화
- 더미 클라이언트를 활용한 성능 테스트
- Network, Content, Host 레이어로 프로젝트 분리
- 정적 라이브러리 구성
- 모듈화 및 유지보수성 향상
IOCP 학습을 위한 실습 프로젝트를 단계별로 진행해보세요:
- 클라이언트가 보낸 메시지를 그대로 돌려주는 에코 서버 구현
- IOCP의 기본 동작 이해
- 비동기 I/O 처리 방법 학습
- 사용자 로그인 기능
- 채팅방 생성, 입장, 퇴장 기능
- 1:1 채팅 및 그룹 채팅 기능
- 사용자 목록 관리
- 플레이어 이동 및 상태 동기화
- 게임 로직 처리
- 충돌 감지 및 처리
- 게임 상태 관리
- 지역 분할(Zone) 시스템
- 인스턴스 던전 구현
- 아이템 및 인벤토리 시스템
- 퀘스트 시스템
IOCP 및 게임 서버 개발에 관한 추가 학습 자료는 다음과 같습니다:
- "Network Programming for Microsoft Windows" by Anthony Jones and Jim Ohlund
- "Windows via C/C++" by Jeffrey Richter and Christophe Nasarre
- "Game Programming Patterns" by Robert Nystrom
- "Multiplayer Game Programming" by Joshua Glazer and Sanjay Madhav
- 프로그래밍 언어: C++, C#
- 네트워크 프로그래밍: TCP/IP, UDP, 소켓 프로그래밍
- 데이터베이스: MySQL, Redis, MongoDB
- 운영체제: Windows, Linux
- 동시성 프로그래밍: 멀티스레딩, 비동기 프로그래밍
- 게임 엔진: Unreal Engine, Unity (클라이언트 이해를 위해)
- 기초부터 차근차근: 네트워크 기초, C++ 프로그래밍, 멀티스레딩 등 기본 개념부터 학습하세요.
- 실습 중심 학습: 이론만 공부하지 말고 직접 코드를 작성하고 실행해보세요.
- 오픈 소스 분석: 다른 개발자들의 코드를 분석하고 이해하는 시간을 가지세요.
- 점진적 확장: 간단한 에코 서버부터 시작하여 채팅 서버, 게임 서버로 확장해 나가세요.
- 문제 해결 능력 개발: 디버깅, 성능 최적화, 메모리 누수 해결 등 문제 해결 능력을 키우세요.
- 성능 테스트: 더미 클라이언트를 만들어 서버의 성능을 테스트하세요.
- 안정성 확보: 예외 처리, 오류 복구 메커니즘을 구현하여 서버의 안정성을 확보하세요.
- 코드 리뷰: 다른 개발자들과 코드 리뷰를 통해 피드백을 주고받으세요.
- 지속적인 학습: 새로운 기술과 패턴을 지속적으로 학습하세요.
- 포트폴리오 구축: 자신만의 게임 서버 프로젝트를 만들어 포트폴리오로 활용하세요.
IOCP를 활용한 게임 서버 개발은 복잡하지만 매우 보람 있는 분야입니다. 이 가이드를 통해 온라인 게임 서버 개발자로 성장하는 데 도움이 되길 바랍니다.
IOCP(Input/Output Completion Port)는 Windows 운영체제에서 제공하는 고성능 비동기 I/O 처리 메커니즘입니다. 특히 네트워크 프로그래밍과 게임 서버 개발에서 많이 활용되는 기술로, 수천 명의 동시 접속자를 효율적으로 처리할 수 있게 해줍니다.
IOCP를 이해하기 위해서는 다음과 같은 기본 개념을 알아야 합니다:
- 동기 I/O vs 비동기 I/O: 동기 I/O는 I/O 작업이 완료될 때까지 대기하는 방식이고, 비동기 I/O는 I/O 작업을 요청한 후 다른 작업을 수행할 수 있는 방식입니다.
- 블로킹 vs 논블로킹: 블로킹은 함수 호출 시 결과가 반환될 때까지 대기하는 방식이고, 논블로킹은 함수 호출 후 즉시 반환되는 방식입니다.
- 스레드 풀링: 여러 개의 스레드를 미리 생성해두고 필요할 때 사용하는 기법입니다.
IOCP를 배우기 전에 기본적인 소켓 프로그래밍을 이해해야 합니다.
- TCP/IP 프로토콜의 기본 개념
- 소켓 API의 기본 함수들 (socket, bind, listen, accept, connect, send, recv)
- 클라이언트-서버 모델의 이해
- 간단한 에코 서버 구현
- 기본적인 TCP 에코 서버와 클라이언트 구현
- 다중 클라이언트 처리를 위한 select 모델 구현
#include <winsock2.h>
#include <ws2tcpip.h>
#include <stdio.h>
#pragma comment(lib, "Ws2_32.lib")
#define DEFAULT_PORT "27015"
#define DEFAULT_BUFLEN 512
int main() {
WSADATA wsaData;
int iResult;
// 윈속 초기화
iResult = WSAStartup(MAKEWORD(2, 2), &wsaData);
if (iResult != 0) {
printf("WSAStartup failed: %d\n", iResult);
return 1;
}
struct addrinfo *result = NULL, hints;
ZeroMemory(&hints, sizeof(hints));
hints.ai_family = AF_INET;
hints.ai_socktype = SOCK_STREAM;
hints.ai_protocol = IPPROTO_TCP;
hints.ai_flags = AI_PASSIVE;
// 주소 정보 얻기
iResult = getaddrinfo(NULL, DEFAULT_PORT, &hints, &result);
if (iResult != 0) {
printf("getaddrinfo failed: %d\n", iResult);
WSACleanup();
return 1;
}
// 소켓 생성
SOCKET ListenSocket = socket(result->ai_family, result->ai_socktype, result->ai_protocol);
if (ListenSocket == INVALID_SOCKET) {
printf("Error at socket(): %ld\n", WSAGetLastError());
freeaddrinfo(result);
WSACleanup();
return 1;
}
// 소켓 바인딩
iResult = bind(ListenSocket, result->ai_addr, (int)result->ai_addrlen);
if (iResult == SOCKET_ERROR) {
printf("bind failed with error: %d\n", WSAGetLastError());
freeaddrinfo(result);
closesocket(ListenSocket);
WSACleanup();
return 1;
}
freeaddrinfo(result);
// 리스닝 시작
if (listen(ListenSocket, SOMAXCONN) == SOCKET_ERROR) {
printf("Listen failed with error: %ld\n", WSAGetLastError());
closesocket(ListenSocket);
WSACleanup();
return 1;
}
printf("서버가 시작되었습니다. 클라이언트 연결을 기다립니다...\n");
// 클라이언트 연결 수락
SOCKET ClientSocket = accept(ListenSocket, NULL, NULL);
if (ClientSocket == INVALID_SOCKET) {
printf("accept failed: %d\n", WSAGetLastError());
closesocket(ListenSocket);
WSACleanup();
return 1;
}
printf("클라이언트가 연결되었습니다.\n");
// 데이터 수신 및 에코
char recvbuf[DEFAULT_BUFLEN];
int recvbuflen = DEFAULT_BUFLEN;
int iSendResult;
do {
// 데이터 수신
iResult = recv(ClientSocket, recvbuf, recvbuflen, 0);
if (iResult > 0) {
printf("수신된 바이트: %d\n", iResult);
// 받은 데이터 다시 전송 (에코)
iSendResult = send(ClientSocket, recvbuf, iResult, 0);
if (iSendResult == SOCKET_ERROR) {
printf("send failed: %d\n", WSAGetLastError());
closesocket(ClientSocket);
WSACleanup();
return 1;
}
printf("전송된 바이트: %d\n", iSendResult);
}
else if (iResult == 0)
printf("연결 종료\n");
else {
printf("recv failed: %d\n", WSAGetLastError());
closesocket(ClientSocket);
WSACleanup();
return 1;
}
} while (iResult > 0);
// 정리
closesocket(ClientSocket);
closesocket(ListenSocket);
WSACleanup();
return 0;
}IOCP는 비동기 I/O를 기반으로 하므로, 비동기 I/O의 개념을 이해해야 합니다.
- 동기 I/O와 비동기 I/O의 차이점
- Windows의 Overlapped I/O 모델
- 비동기 I/O의 장단점
- 이벤트 기반 비동기 I/O
- WSAEventSelect를 사용한 비동기 서버 구현
- Overlapped I/O를 사용한 비동기 서버 구현
#include <winsock2.h>
#include <ws2tcpip.h>
#include <mswsock.h>
#include <stdio.h>
#pragma comment(lib, "Ws2_32.lib")
#pragma comment(lib, "Mswsock.lib")
#define DEFAULT_PORT "27015"
#define DEFAULT_BUFLEN 512
// Overlapped I/O를 위한 구조체
typedef struct {
OVERLAPPED overlapped;
WSABUF wsaBuf;
char buffer[DEFAULT_BUFLEN];
DWORD bytesReceived;
DWORD flags;
} PER_IO_DATA, *LPPER_IO_DATA;
int main() {
WSADATA wsaData;
int iResult;
// 윈속 초기화
iResult = WSAStartup(MAKEWORD(2, 2), &wsaData);
if (iResult != 0) {
printf("WSAStartup failed: %d\n", iResult);
return 1;
}
// 소켓 생성 및 설정 (생략)...
// Overlapped I/O 구조체 초기화
LPPER_IO_DATA perIoData = (LPPER_IO_DATA)malloc(sizeof(PER_IO_DATA));
ZeroMemory(perIoData, sizeof(PER_IO_DATA));
perIoData->wsaBuf.buf = perIoData->buffer;
perIoData->wsaBuf.len = DEFAULT_BUFLEN;
perIoData->flags = 0;
// 비동기 수신 요청
DWORD bytesReceived = 0;
iResult = WSARecv(
ClientSocket,
&(perIoData->wsaBuf),
1,
&bytesReceived,
&(perIoData->flags),
&(perIoData->overlapped),
NULL);
if (iResult == SOCKET_ERROR && WSAGetLastError() != WSA_IO_PENDING) {
printf("WSARecv failed: %d\n", WSAGetLastError());
closesocket(ClientSocket);
WSACleanup();
return 1;
}
// 비동기 I/O 완료 대기
DWORD bytesTransferred;
BOOL result = GetOverlappedResult(
ClientSocket,
&(perIoData->overlapped),
&bytesTransferred,
TRUE); // TRUE는 블로킹 모드
if (!result) {
printf("GetOverlappedResult failed: %d\n", GetLastError());
closesocket(ClientSocket);
WSACleanup();
return 1;
}
printf("수신된 바이트: %d\n", bytesTransferred);
// 정리
free(perIoData);
closesocket(ClientSocket);
WSACleanup();
return 0;
}이제 IOCP의 기본 구조와 동작 원리를 학습합니다.
- IOCP의 기본 개념과 구조
- CreateIoCompletionPort 함수의 사용법
- GetQueuedCompletionStatus 함수의 사용법
- 작업자 스레드 풀 구현
- 기본적인 IOCP 서버 프레임워크 구현
- 작업자 스레드 풀 구현 및 테스트
#include <winsock2.h>
#include <ws2tcpip.h>
#include <mswsock.h>
#include <stdio.h>
#include <process.h>
#pragma comment(lib, "Ws2_32.lib")
#pragma comment(lib, "Mswsock.lib")
#define DEFAULT_PORT "27015"
#define DEFAULT_BUFLEN 512
#define MAX_WORKER_THREAD 4
// Overlapped I/O를 위한 구조체
typedef struct {
OVERLAPPED overlapped;
WSABUF wsaBuf;
char buffer[DEFAULT_BUFLEN];
DWORD bytesReceived;
DWORD flags;
} PER_IO_DATA, *LPPER_IO_DATA;
// 클라이언트 정보 구조체
typedef struct {
SOCKET socket;
} PER_HANDLE_DATA, *LPPER_HANDLE_DATA;
// IOCP 핸들
HANDLE g_hIOCP = INVALID_HANDLE_VALUE;
// 작업자 스레드 함수
unsigned int WINAPI WorkerThread(LPVOID lpParam) {
DWORD bytesTransferred;
LPPER_HANDLE_DATA perHandleData;
LPPER_IO_DATA perIoData;
DWORD flags = 0;
while (true) {
// IOCP 큐에서 완료된 I/O 작업 가져오기
BOOL result = GetQueuedCompletionStatus(
g_hIOCP,
&bytesTransferred,
(PULONG_PTR)&perHandleData,
(LPOVERLAPPED*)&perIoData,
INFINITE);
if (!result) {
printf("GetQueuedCompletionStatus failed: %d\n", GetLastError());
continue;
}
// 클라이언트 연결 종료 확인
if (bytesTransferred == 0) {
printf("클라이언트 연결 종료\n");
closesocket(perHandleData->socket);
free(perHandleData);
free(perIoData);
continue;
}
// 데이터 처리 (에코)
printf("수신된 바이트: %d\n", bytesTransferred);
// 에코 전송
DWORD sendBytes;
WSASend(
perHandleData->socket,
&(perIoData->wsaBuf),
1,
&sendBytes,
0,
NULL,
NULL);
// 다시 수신 대기
ZeroMemory(&(perIoData->overlapped), sizeof(OVERLAPPED));
perIoData->wsaBuf.len = DEFAULT_BUFLEN;
perIoData->flags = 0;
WSARecv(
perHandleData->socket,
&(perIoData->wsaBuf),
1,
NULL,
&(perIoData->flags),
&(perIoData->overlapped),
NULL);
}
return 0;
}
int main() {
WSADATA wsaData;
int iResult;
// 윈속 초기화
iResult = WSAStartup(MAKEWORD(2, 2), &wsaData);
if (iResult != 0) {
printf("WSAStartup failed: %d\n", iResult);
return 1;
}
// 소켓 생성 및 설정 (생략)...
// IOCP 생성
g_hIOCP = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, 0, 0);
if (g_hIOCP == NULL) {
printf("CreateIoCompletionPort failed: %d\n", GetLastError());
WSACleanup();
return 1;
}
// 작업자 스레드 생성
HANDLE hThreads[MAX_WORKER_THREAD];
for (int i = 0; i < MAX_WORKER_THREAD; i++) {
hThreads[i] = (HANDLE)_beginthreadex(NULL, 0, WorkerThread, NULL, 0, NULL);
if (hThreads[i] == 0) {
printf("작업자 스레드 생성 실패\n");
WSACleanup();
return 1;
}
}
printf("서버가 시작되었습니다. 클라이언트 연결을 기다립니다...\n");
// 클라이언트 연결 수락 및 IOCP에 등록
while (true) {
SOCKET clientSocket = accept(ListenSocket, NULL, NULL);
if (clientSocket == INVALID_SOCKET) {
printf("accept failed: %d\n", WSAGetLastError());
break;
}
printf("클라이언트가 연결되었습니다.\n");
// 클라이언트 핸들 데이터 생성
LPPER_HANDLE_DATA perHandleData = (LPPER_HANDLE_DATA)malloc(sizeof(PER_HANDLE_DATA));
perHandleData->socket = clientSocket;
// 소켓을 IOCP에 연결
CreateIoCompletionPort((HANDLE)clientSocket, g_hIOCP, (ULONG_PTR)perHandleData, 0);
// I/O 데이터 초기화
LPPER_IO_DATA perIoData = (LPPER_IO_DATA)malloc(sizeof(PER_IO_DATA));
ZeroMemory(perIoData, sizeof(PER_IO_DATA));
perIoData->wsaBuf.buf = perIoData->buffer;
perIoData->wsaBuf.len = DEFAULT_BUFLEN;
perIoData->flags = 0;
// 비동기 수신 요청
DWORD bytesReceived = 0;
WSARecv(
clientSocket,
&(perIoData->wsaBuf),
1,
&bytesReceived,
&(perIoData->flags),
&(perIoData->overlapped),
NULL);
}
// 정리
for (int i = 0; i < MAX_WORKER_THREAD; i++) {
CloseHandle(hThreads[i]);
}
CloseHandle(g_hIOCP);
closesocket(ListenSocket);
WSACleanup();
return 0;
}기본 구조를 이해했다면, 이제 완전한 IOCP 서버를 구현합니다.
- 클라이언트 연결 관리
- 데이터 송수신 처리
- 오류 처리 및 예외 상황 대응
- 서버 종료 처리
- 완전한 IOCP 에코 서버 구현
- 클라이언트 연결 관리 기능 구현
- 오류 처리 및 예외 상황 대응 코드 추가
// IOOperation 열거형: 작업 유형 구분
enum IOOperation {
RECV,
SEND
};
// Overlapped 확장 구조체
struct stOverlappedEx {
OVERLAPPED m_wsaOverlapped; // Overlapped I/O 구조체
SOCKET m_socketClient; // 클라이언트 소켓
WSABUF m_wsaBuf; // 버퍼
char m_szBuf[MAX_SOCKBUF]; // 데이터 버퍼
IOOperation m_eOperation; // 작업 유형
};
// 클라이언트 정보 구조체
struct stClientInfo {
SOCKET m_socketClient; // 클라이언트 소켓
stOverlappedEx m_stRecvOverlappedEx; // 수신 Overlapped 구조체
stOverlappedEx m_stSendOverlappedEx; // 송신 Overlapped 구조체
char m_szBuf[MAX_SOCKBUF]; // 데이터 버퍼
bool m_bConnected; // 연결 상태
};
// IOCP 서버 클래스
class IOCompletionPort {
public:
IOCompletionPort(void);
~IOCompletionPort(void);
// 서버 초기화
bool InitSocket();
// IOCP 초기화
bool InitIOCP();
// 서버 시작
bool StartServer();
// 작업자 스레드 생성
bool CreateWorkerThread();
// 작업자 스레드 함수
static unsigned int WINAPI WorkerThread(LPVOID lpParam);
// 클라이언트 연결 수락
bool AcceptClient();
// 비동기 수신 요청
bool BindRecv(stClientInfo* pClientInfo);
// 비동기 송신 요청
bool SendMsg(stClientInfo* pClientInfo, char* pMsg, int nLen);
// 클라이언트 연결 해제
void CloseClient(stClientInfo* pClientInfo, bool bIsForce = false);
// 에러 출력
void DisplayError(const char* szMsg);
private:
HANDLE m_hIOCP; // IOCP 핸들
SOCKET m_listenSocket; // 리스닝 소켓
std::vector<stClientInfo*> m_clientInfos; // 클라이언트 정보 벡터
std::vector<HANDLE> m_workerThreads; // 작업자 스레드 핸들 벡터
bool m_bWorkerRun; // 작업자 스레드 실행 플래그
int m_nClientCnt; // 클라이언트 수
};기본적인 IOCP 서버를 구현했다면, 이제 고급 기법을 학습합니다.
- 세션 관리 기법
- 패킷 처리 시스템
- 버퍼 관리 최적화
- 성능 튜닝 기법
- 세션 관리 시스템 구현
- 패킷 처리 시스템 구현
- 링 버퍼 구현 및 적용
- 성능 측정 및 최적화
class RingBuffer {
public:
RingBuffer(int bufferSize = 8192)
: m_bufferSize(bufferSize), m_readPos(0), m_writePos(0)
{
m_pBuffer = new char[bufferSize];
}
~RingBuffer() {
delete[] m_pBuffer;
}
// 버퍼에 데이터 쓰기
bool Write(const char* pData, int dataSize) {
if (GetFreeSize() < dataSize)
return false;
// 남은 공간이 끝까지 충분한 경우
if (m_bufferSize - m_writePos >= dataSize) {
memcpy(m_pBuffer + m_writePos, pData, dataSize);
m_writePos += dataSize;
}
// 남은 공간이 끝까지 충분하지 않은 경우 (버퍼의 처음으로 돌아가서 쓰기)
else {
int firstPartSize = m_bufferSize - m_writePos;
memcpy(m_pBuffer + m_writePos, pData, firstPartSize);
memcpy(m_pBuffer, pData + firstPartSize, dataSize - firstPartSize);
m_writePos = dataSize - firstPartSize;
}
return true;
}
// 버퍼에서 데이터 읽기
bool Read(char* pData, int dataSize) {
if (GetDataSize() < dataSize)
return false;
// 읽을 데이터가 끝까지 연속적인 경우
if (m_bufferSize - m_readPos >= dataSize) {
memcpy(pData, m_pBuffer + m_readPos, dataSize);
m_readPos += dataSize;
}
// 읽을 데이터가 끝에서 처음으로 넘어가는 경우
else {
int firstPartSize = m_bufferSize - m_readPos;
memcpy(pData, m_pBuffer + m_readPos, firstPartSize);
memcpy(pData + firstPartSize, m_pBuffer, dataSize - firstPartSize);
m_readPos = dataSize - firstPartSize;
}
return true;
}
// 버퍼의 남은 공간 크기
int GetFreeSize() const {
if (m_readPos <= m_writePos)
return m_bufferSize - (m_writePos - m_readPos);
else
return m_readPos - m_writePos;
}
// 버퍼에 있는 데이터 크기
int GetDataSize() const {
if (m_readPos <= m_writePos)
return m_writePos - m_readPos;
else
return m_bufferSize - (m_readPos - m_writePos);
}
private:
char* m_pBuffer; // 버퍼 포인터
int m_bufferSize; // 버퍼 크기
int m_readPos; // 읽기 위치
int m_writePos; // 쓰기 위치
};마지막으로, IOCP를 활용한 게임 서버 아키텍처를 설계하고 구현합니다.
- 게임 서버 아키텍처 설계
- 레이어 분리 (네트워크, 로직, 데이터)
- 게임 로직 구현
- 분산 서버 구조
- 간단한 게임 서버 아키텍처 설계
- 레이어 분리 구현
- 간단한 게임 로직 구현
- 분산 서버 구조 설계
+---------------------+ +----------------------+ +---------------------+
| | | | | |
| 소켓 프로그래밍 기초 | --> | 비동기 I/O 개념 이해 | --> | IOCP 기본 구조 학습 |
| | | | | |
+---------------------+ +----------------------+ +---------------------+
| |
| v
| +---------------------+
| | |
| | IOCP 서버 구현 |
| | |
| +---------------------+
| |
v v
+---------------------+ +---------------------+
| | | |
| TCP/IP 기본 이해 | | 세션 관리 |
| | | |
+---------------------+ +---------------------+
| |
v v
+---------------------+ +---------------------+
| | | |
| 소켓 API 학습 | | 패킷 처리 시스템 |
| | | |
+---------------------+ +---------------------+
| |
v v
+---------------------+ +---------------------+
| | | |
| 에코 서버 구현 | | 버퍼 관리 최적화 |
| | | |
+---------------------+ +---------------------+
|
v
+---------------------+
| |
| 게임 서버 아키텍처 |
| |
+---------------------+
|
v
+---------------------+
| |
| 레이어 분리 |
| |
+---------------------+
|
v
+---------------------+
| |
| 게임 로직 구현 |
| |
+---------------------+
+---------------------+ +----------------------+ +---------------------+
| | | | | |
| 서버 초기화 | --> | IOCP 객체 생성 | --> | 작업자 스레드 생성 |
| | | | | |
+---------------------+ +----------------------+ +---------------------+
|
v
+---------------------+ +----------------------+ +---------------------+
| | | | | |
| 클라이언트 연결 해제 | <-- | 데이터 송신 | <-- | 작업자 스레드 대기 |
| | | | | |
+---------------------+ +----------------------+ +---------------------+
^ ^ |
| | v
| | +---------------------+
| | | |
| | | 클라이언트 연결 수락|
| | | |
| | +---------------------+
| | |
| | v
| | +---------------------+
| | | |
| +------------------| IOCP에 소켓 등록 |
| | |
| +---------------------+
| |
| v
| +---------------------+
| | |
| | 비동기 수신 요청 |
| | |
| +---------------------+
| |
| v
| +---------------------+
| | |
+---------------------------------------------| I/O 완료 통지 처리 |
| |
+---------------------+
위에서 제공한 예제 코드 외에도, 각 단계별로 더 자세한 예제 코드를 학습하는 것이 중요합니다. GitHub 저장소 jacking75/edu_cpp_IOCP에서 단계별 예제 코드를 확인할 수 있습니다.
// IOCP 객체 생성
HANDLE hIOCP = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, 0, 0);
if (hIOCP == NULL) {
printf("CreateIoCompletionPort failed: %d\n", GetLastError());
return false;
}
// 소켓을 IOCP에 연결
HANDLE hResult = CreateIoCompletionPort((HANDLE)clientSocket, hIOCP, (ULONG_PTR)perHandleData, 0);
if (hResult == NULL) {
printf("CreateIoCompletionPort failed: %d\n", GetLastError());
return false;
}DWORD bytesTransferred;
LPPER_HANDLE_DATA perHandleData;
LPPER_IO_DATA perIoData;
// IOCP 큐에서 완료된 I/O 작업 가져오기
BOOL result = GetQueuedCompletionStatus(
hIOCP, // IOCP 핸들
&bytesTransferred, // 전송된 바이트 수
(PULONG_PTR)&perHandleData, // Completion Key
(LPOVERLAPPED*)&perIoData, // Overlapped 구조체
INFINITE); // 대기 시간 (무한)
if (!result) {
// 오류 처리
DWORD error = GetLastError();
if (error == WAIT_TIMEOUT) {
// 타임아웃
}
else {
// 다른 오류
printf("GetQueuedCompletionStatus failed: %d\n", error);
}
}
else {
// 정상 처리
if (bytesTransferred == 0) {
// 클라이언트 연결 종료
}
else {
// 데이터 처리
}
}DWORD flags = 0;
DWORD bytesReceived = 0;
// 비동기 수신 요청
int result = WSARecv(
clientSocket, // 클라이언트 소켓
&(perIoData->wsaBuf), // WSABUF 구조체
1, // WSABUF 배열 크기
&bytesReceived, // 수신된 바이트 수
&flags, // 플래그
&(perIoData->overlapped), // Overlapped 구조체
NULL); // 완료 루틴
if (result == SOCKET_ERROR && WSAGetLastError() != WSA_IO_PENDING) {
// 오류 처리
printf("WSARecv failed: %d\n", WSAGetLastError());
return false;
}DWORD bytesSent = 0;
// 비동기 송신 요청
int result = WSASend(
clientSocket, // 클라이언트 소켓
&(perIoData->wsaBuf), // WSABUF 구조체
1, // WSABUF 배열 크기
&bytesSent, // 송신된 바이트 수
0, // 플래그
&(perIoData->overlapped), // Overlapped 구조체
NULL); // 완료 루틴
if (result == SOCKET_ERROR && WSAGetLastError() != WSA_IO_PENDING) {
// 오류 처리
printf("WSASend failed: %d\n", WSAGetLastError());
return false;
}IOCP 학습은 단계적으로 접근하는 것이 중요합니다. 소켓 프로그래밍의 기초부터 시작하여 비동기 I/O 개념을 이해하고, IOCP의 기본 구조를 학습한 후, 실제 서버를 구현하고 최적화하는 과정을 거쳐야 합니다.
위에서 제시한 학습 단계와 예제 코드를 통해 IOCP의 기본 개념부터 고급 기법까지 체계적으로 학습할 수 있습니다. 각 단계별로 실습 과제를 수행하면서 실제 코드를 작성하고 테스트하는 것이 중요합니다.
IOCP를 완전히 이해하고 활용하기 위해서는 지속적인 학습과 실습이 필요합니다. 다양한 예제 코드를 분석하고 직접 구현해보면서 경험을 쌓아가는 것이 중요합니다.
- 1단계: 기본 IOCP 에코 서버 구현
- 2단계: 메모리 최적화
- 3단계: 애플리케이션과 네트워크 코드 분리
- 4단계: 네트워크와 로직 처리 스레드 분리
- 5-6단계: 효율적인 Send 구현
- 7단계: 비동기 Accept 구현
- 8-10단계: 채팅 서버 구현
- 11단계: 서버 최적화
- 12단계: 레이어 분리
- IOCP API의 기본 동작 원리 이해
- 비동기 I/O 처리 방식 학습
- 간단한 에코 서버 구현을 통한 IOCP 기초 습득
- IOCP(I/O Completion Port): Windows 운영체제에서 제공하는 비동기 I/O 처리 메커니즘
- Overlapped I/O: 중첩된 입출력 작업을 처리하는 방식
- 작업자 스레드(Worker Thread): I/O 완료 통지를 처리하는 스레드
CreateIoCompletionPort(): IOCP 객체 생성 및 소켓과 연결GetQueuedCompletionStatus(): I/O 완료 통지 대기WSARecv(),WSASend(): 비동기 소켓 수신/송신 함수
-
IOCompletionPort.h:
IOOperation열거형: RECV, SEND 작업 구분stOverlappedEx구조체: Overlapped I/O 확장 구조체stClientInfo구조체: 클라이언트 정보 관리IOCompletionPort클래스: IOCP 서버 구현
-
main.cpp:
- 서버 포트 및 최대 클라이언트 수 설정
- IOCP 객체 생성 및 초기화
- 서버 시작 및 종료 처리
-
환경 설정:
- Visual Studio 2022 설치 (또는 하위 버전)
- GitHub 저장소 클론:
git clone https://github.com/jacking75/edu_cpp_IOCP.git - Tutorial/01 폴더의 프로젝트 열기
-
코드 분석:
- IOCompletionPort.h 파일 분석
stOverlappedEx구조체 이해: Overlapped I/O 확장을 위한 구조체stClientInfo구조체 이해: 클라이언트 정보 관리IOCompletionPort클래스 분석: IOCP 서버 구현
- main.cpp 파일 분석
- 서버 초기화 및 시작 과정 이해
- IOCompletionPort.h 파일 분석
-
실습 1: 에코 서버 구현:
- 제공된 코드를 빌드하고 실행
- 텔넷 클라이언트로 접속하여 에코 기능 테스트
- 코드 수정: 에코 메시지에 "[서버 응답]" 접두사 추가
-
실습 2: 디버깅 및 이해:
- 브레이크포인트를 설정하여 코드 흐름 추적
CreateIoCompletionPort(),GetQueuedCompletionStatus()함수 호출 과정 분석- 비동기 I/O 처리 과정 이해
-
실습 3: 코드 확장:
- 최대 클라이언트 수 변경 및 영향 분석
- 클라이언트 접속 시 로그 메시지 추가
- 클라이언트 연결 해제 시 로그 메시지 추가
- 에코 서버가 정상적으로 동작하는가?
- 여러 클라이언트가 동시에 접속했을 때 정상 작동하는가?
- IOCP의 기본 동작 원리를 이해했는가?
- 메모리 사용 최적화 방법 학습
- 코드 구조 개선을 통한 효율성 향상
- 불필요한 메모리 낭비 제거
- 메모리 최적화: 불필요한 메모리 사용 제거
- 구조체 설계: 효율적인 데이터 구조 설계
- 코드 분리: 기능별 코드 분리를 통한 유지보수성 향상
- 1단계와의 차이점:
stOverlappedEx구조체에서m_szBuf버퍼를 제거stClientInfo구조체로 버퍼 이동- 코드 구조 개선 및 분리
-
코드 분석:
- Tutorial/02 폴더의 코드 분석
- 1단계 코드와 비교하여 변경점 파악
- 메모리 사용 최적화 방식 이해
-
실습 1: 메모리 사용량 비교:
- 1단계와 2단계 코드의 메모리 사용량 비교
- 성능 모니터링 도구를 사용하여 메모리 사용 패턴 분석
- 최적화 효과 측정
-
실습 2: 코드 수정:
- 클라이언트 정보 구조체에 추가 정보 필드 추가
- 클라이언트 접속 시간, 마지막 활동 시간 등 추가
- 메모리 사용에 미치는 영향 분석
-
실습 3: 버퍼 크기 최적화:
- 버퍼 크기 변경 실험
- 다양한 크기의 메시지 처리 테스트
- 최적의 버퍼 크기 결정
- 메모리 사용량이 감소했는가?
- 서버 성능에 어떤 영향을 미쳤는가?
- 코드 구조가 개선되었는가?
- 네트워크 코드와 애플리케이션 코드 분리
- 모듈화를 통한 재사용성 향상
- 이벤트 기반 프로그래밍 패턴 학습
- 모듈화: 기능별 코드 분리
- 이벤트 처리: 네트워크 이벤트를 애플리케이션에 전달
- 콜백 함수: 이벤트 처리를 위한 콜백 메커니즘
- 2단계와의 차이점:
- 네트워크 코드를 라이브러리화
- 연결, 끊어짐, 데이터 수신 이벤트를 애플리케이션에 전달하는 구조
- 콜백 함수를 통한 이벤트 처리
-
코드 분석:
- Tutorial/03 폴더의 코드 분석
- 네트워크 코드와 애플리케이션 코드 분리 방식 이해
- 이벤트 처리 메커니즘 분석
-
실습 1: 이벤트 처리 구현:
- 새로운 이벤트 타입 추가 (예: 클라이언트 타임아웃)
- 이벤트 처리 콜백 함수 구현
- 이벤트 발생 및 처리 테스트
-
실습 2: 애플리케이션 로직 확장:
- 에코 서버를 채팅 서버로 확장
- 클라이언트 간 메시지 전달 기능 구현
- 네트워크 코드 수정 없이 애플리케이션 로직만 변경
-
실습 3: 라이브러리 재사용:
- 네트워크 라이브러리를 사용하는 새로운 애플리케이션 개발
- 파일 전송 서버 구현
- 라이브러리의 재사용성 검증
- 네트워크 코드와 애플리케이션 코드가 효과적으로 분리되었는가?
- 이벤트 처리 메커니즘이 정상적으로 동작하는가?
- 라이브러리의 재사용성이 향상되었는가?
- 네트워크 처리와 로직 처리 스레드 분리
- 멀티스레딩 프로그래밍 패턴 학습
- 스레드 간 통신 및 동기화 이해
- 스레드 분리: 네트워크 처리와 로직 처리 스레드 분리
- 스레드 간 통신: 메시지 큐를 통한 스레드 간 통신
- 동기화: 스레드 간 동기화 메커니즘
- 3단계와의 차이점:
- Send와 Recv를 다른 스레드에서 처리
- 로직 처리를 위한 별도의 스레드 구현
- 스레드 간 통신을 위한 메시지 큐 구현
-
코드 분석:
- Tutorial/04 폴더의 코드 분석
- 스레드 분리 방식 이해
- 메시지 큐 및 동기화 메커니즘 분석
-
실습 1: 스레드 모니터링:
- 각 스레드의 작업 부하 모니터링
- 스레드 간 작업 분배 분석
- 성능 병목 지점 식별
-
실습 2: 로직 스레드 확장:
- 여러 개의 로직 처리 스레드 구현
- 작업 분배 알고리즘 구현
- 성능 향상 측정
-
실습 3: 동기화 문제 해결:
- 의도적으로 동기화 문제 발생시키기
- 문제 식별 및 디버깅
- 동기화 메커니즘 개선
- 네트워크 처리와 로직 처리가 효과적으로 분리되었는가?
- 스레드 간 통신이 원활하게 이루어지는가?
- 동기화 문제 없이 안정적으로 동작하는가?
- 효율적인 Send 처리 방식 학습
- 버퍼 관리 및 큐 기반 송신 구현
- 네트워크 부하 분산 및 최적화
- 버퍼 관리: 송신 데이터 버퍼링
- 큐 기반 송신: 순차적 데이터 송신
- 부하 분산: 네트워크 부하 분산 기법
-
5단계:
- 버퍼에 데이터를 쌓아두고 Send 스레드에서 처리
- 버퍼 관리 메커니즘 구현
-
6단계:
- 큐를 사용한 순차적 Send 처리 구현
- 더 효율적인 송신 처리 구조
-
코드 분석:
- Tutorial/05와 Tutorial/06 폴더의 코드 분석
- 두 단계 간의 차이점 파악
- 버퍼 관리와 큐 기반 송신 방식 이해
-
실습 1: 버퍼 관리 최적화:
- 버퍼 크기 최적화 실험
- 버퍼 오버플로우 방지 메커니즘 구현
- 메모리 사용량과 성능 간의 균형 찾기
-
실습 2: 송신 성능 테스트:
- 대량의 데이터 송신 테스트
- 다양한 크기의 패킷 송신 테스트
- 성능 측정 및 분석
-
실습 3: 큐 기반 송신 확장:
- 우선순위 큐 기반 송신 구현
- 중요 메시지 우선 처리 기능 추가
- 성능 영향 분석
- 송신 처리가 효율적으로 이루어지는가?
- 대량의 데이터 송신 시 안정적으로 동작하는가?
- 메모리 사용량과 성능 간의 균형이 적절한가?
- 비동기 Accept 처리 방식 학습
- 모든 네트워크 동작의 비동기 처리 구현
- 서버 성능 향상 기법 이해
- 비동기 Accept: 클라이언트 연결 요청의 비동기 처리
- AcceptEx 함수: Windows 소켓의 비동기 Accept 함수
- 완전한 비동기 I/O: 모든 네트워크 동작의 비동기 처리
- 6단계와의 차이점:
- Accept 처리를 동기 I/O에서 비동기 I/O로 전환
- AcceptEx 함수 사용
- 모든 네트워크 동작의 비동기 처리
-
코드 분석:
- Tutorial/07 폴더의 코드 분석
- AcceptEx 함수 사용 방식 이해
- 비동기 Accept 처리 흐름 분석
-
실습 1: 비동기 Accept 성능 테스트:
- 대량의 동시 연결 요청 테스트
- 동기 Accept와 비동기 Accept의 성능 비교
- 서버 부하 상황에서의 동작 분석
-
실습 2: 연결 제한 및 관리:
- IP 기반 연결 제한 기능 구현
- 연결 요청 필터링 메커니즘 추가
- DoS 공격 방어 기법 구현
-
실습 3: 비동기 처리 확장:
- 비동기 연결 해제 처리 구현
- 비동기 타임아웃 처리 구현
- 완전한 비동기 네트워크 처리 구조 완성
- 비동기 Accept가 정상적으로 동작하는가?
- 대량의 동시 연결 요청을 효과적으로 처리하는가?
- 모든 네트워크 동작이 비동기적으로 처리되는가?
- 실제 게임 서버 기능 구현
- 패킷 구조 설계 및 처리
- 사용자 인증 및 채팅방 관리 기능 구현
- 패킷 구조: 클라이언트-서버 간 통신을 위한 패킷 설계
- 사용자 인증: 로그인 및 인증 처리
- 채팅방 관리: 방 생성, 입장, 퇴장, 채팅 기능
-
8단계 (ChatServer_01):
- 패킷 구조 설계 및 구현
- 로그인 기능 구현
-
9단계 (ChatServer_02):
- Redis를 활용한 사용자 인증
- 데이터 저장소 연동
-
10단계 (ChatServer_03):
- 채팅방 입장, 퇴장, 채팅 기능 구현
- 완전한 채팅 서버 구현
-
코드 분석:
- Tutorial/08, 09, 10 폴더의 코드 분석
- 패킷 구조 및 처리 방식 이해
- Redis 연동 및 채팅방 관리 로직 분석
-
실습 1: 패킷 구조 설계 및 구현:
- 새로운 패킷 타입 추가
- 패킷 직렬화/역직렬화 구현
- 패킷 처리 로직 구현
-
실습 2: Redis 연동:
- Redis 설치 및 설정
- 사용자 정보 저장 및 조회 기능 구현
- 세션 관리 기능 구현
-
실습 3: 채팅 서버 확장:
- 귓속말 기능 추가
- 채팅방 관리자 기능 구현
- 채팅 로그 저장 기능 구현
- 패킷 구조가 효율적으로 설계되었는가?
- Redis 연동이 정상적으로 동작하는가?
- 채팅 서버 기능이 완전하게 구현되었는가?
- 서버 성능 최적화 기법 학습
- 메모리 및 CPU 사용 효율화
- 부하 테스트 및 성능 분석
- GetQueuedCompletionStatusEx: 향상된 IOCP 완료 통지 함수
- 동적 할당 최소화: 메모리 사용 최적화
- 링 버퍼: 효율적인 버퍼 관리
- 락(Lock) 최적화: 동기화 오버헤드 감소
- 더미 클라이언트: 부하 테스트 도구
- 10단계와의 차이점:
- GetQueuedCompletionStatusEx 사용
- 동적 할당 최소화
- 링 버퍼 구현
- 락 사용 범위 최소화
- 설정 파일 지원
-
코드 분석:
- Tutorial/11 폴더의 코드 분석
- 최적화 기법 이해
- 성능 향상 포인트 식별
-
실습 1: 성능 측정 및 분석:
- 더미 클라이언트 구현
- 다양한 부하 상황에서 성능 측정
- 병목 지점 식별 및 분석
-
실습 2: 메모리 최적화:
- 메모리 풀 구현
- 객체 재사용 메커니즘 구현
- 메모리 누수 검사 및 해결
-
실습 3: 락 최적화:
- 다양한 락 메커니즘 실험 (뮤텍스, 스핀락, 리드-라이트 락 등)
- 락 사용 범위 최소화
- 락 프리(Lock-Free) 알고리즘 구현 시도
- 서버 성능이 향상되었는가?
- 메모리 사용이 효율적인가?
- 동시 접속자 수 처리 능력이 향상되었는가?
- 서버 아키텍처 설계 및 구현
- 레이어 분리를 통한 모듈화
- 유지보수성 및 확장성 향상
- 레이어 아키텍처: Network, Content, Host 레이어 분리
- 정적 라이브러리: 모듈화된 코드의 라이브러리화
- 인터페이스 설계: 레이어 간 통신을 위한 인터페이스
- 11단계와의 차이점:
- Network, Content, Host 레이어로 프로젝트 분리
- 정적 라이브러리 구성
- 레이어 간 인터페이스 설계
-
코드 분석:
- Tutorial/12 폴더의 코드 분석
- 레이어 분리 방식 이해
- 인터페이스 설계 분석
-
실습 1: 레이어 확장:
- 데이터베이스 레이어 추가
- 로깅 레이어 추가
- 레이어 간 의존성 관리
-
실습 2: 플러그인 아키텍처 구현:
- 플러그인 인터페이스 설계
- 동적 로딩 메커니즘 구현
- 플러그인 기반 기능 확장
-
실습 3: 분산 서버 아키텍처 설계:
- 다중 서버 구성 설계
- 서버 간 통신 프로토콜 설계
- 부하 분산 메커니즘 설계
- 레이어가 효과적으로 분리되었는가?
- 코드의 유지보수성과 확장성이 향상되었는가?
- 새로운 기능 추가가 용이해졌는가?
지금까지 학습한 내용을 바탕으로 간단한 온라인 게임 서버를 구현해보세요. 다음은 구현할 수 있는 게임 서버의 예시입니다:
- 플레이어 이동 및 상태 동기화
- 충돌 감지 및 처리
- 아이템 획득 및 사용
- 점수 관리 및 랭킹 시스템
- 플레이어 턴 관리
- 게임 상태 저장 및 로드
- AI 플레이어 구현
- 매치메이킹 시스템
- 카드 덱 관리
- 매치 시스템
- 친구 기능
- 인앱 구매 시스템
-
요구사항 분석 및 설계:
- 게임 규칙 및 기능 정의
- 서버 아키텍처 설계
- 데이터 모델 설계
- 통신 프로토콜 설계
-
기본 서버 구현:
- IOCP 기반 네트워크 레이어 구현
- 패킷 처리 시스템 구현
- 사용자 관리 시스템 구현
-
게임 로직 구현:
- 게임 상태 관리
- 게임 규칙 구현
- AI 시스템 구현 (필요시)
-
데이터 저장 시스템 구현:
- 데이터베이스 연동
- 게임 데이터 저장 및 로드
- 사용자 프로필 관리
-
테스트 및 최적화:
- 단위 테스트 및 통합 테스트
- 부하 테스트
- 성능 최적화
이 종합 프로젝트를 통해 IOCP를 활용한 게임 서버 개발의 전체 과정을 경험하고, 실제 온라인 게임 서버 개발자로서의 역량을 키울 수 있습니다.