Что такое Completion Ports?

Completion Ports (IOCP) — асинхронный I/O на Windows

Completion Ports (точнее I/O Completion Ports или IOCP) — это эффективный механизм асинхронного ввода-вывода, специфичный для Windows. Это одна из самых мощных технологий для построения высоконагруженных сетевых приложений на Windows.

Основное назначение

IOCP позволяет эффективно обрабатывать тысячи одновременных I/O операций (сетевых подключений, файловых операций) с минимальным потреблением ресурсов.

Как это работает

Основная идея: вместо создания потока на каждое клиентское соединение (как в old-school socket programming), вы регистрируете I/O операции в Completion Port, и когда операция завершается, она добавляется в очередь завершённых операций.

Архитектура IOCP

Сетевой адаптер
    ↓
[Kernel I/O Completion Port]
    ↓
[Очередь завершённых операций]
    ↓
[Пул рабочих потоков] → Обработка результатов

Практический пример

#include <winsock2.h>
#include <mswsock.h>
#include <iostream>

pragma comment(lib, "ws2_32.lib")
pragma comment(lib, "mswsock.lib")

// Структура данных для каждого подключения
struct ClientContext {
    SOCKET socket;
    char buffer[4096];
    OVERLAPPED overlapped;
};

int main() {
    // 1. Создаём Completion Port
    HANDLE hCompletionPort = CreateIoCompletionPort(
        INVALID_HANDLE_VALUE,  // Новый порт
        NULL,                  // Нет родительского порта
        0,                     // Начальный ключ
        0                      // Число рабочих потоков (0 = число CPU)
    );

    // 2. Создаём слушающий сокет
    SOCKET listenSocket = WSASocket(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);
    sockaddr_in serverAddr = {};
    serverAddr.sin_family = AF_INET;
    serverAddr.sin_port = htons(8080);
    serverAddr.sin_addr.s_addr = INADDR_ANY;
    
    bind(listenSocket, (sockaddr*)&serverAddr, sizeof(serverAddr));
    listen(listenSocket, SOMAXCONN);

    // 3. Создаём рабочие потоки для обработки завершённых операций
    SYSTEM_INFO sysInfo;
    GetSystemInfo(&sysInfo);
    int numWorkerThreads = sysInfo.dwNumberOfProcessors * 2;

    for (int i = 0; i < numWorkerThreads; ++i) {
        CreateThread(NULL, 0, workerThreadProc, hCompletionPort, 0, NULL);
    }

    // 4. Основной loop — принимаем новые подключения
    while (true) {
        SOCKET clientSocket = accept(listenSocket, NULL, NULL);
        
        ClientContext* context = new ClientContext();
        context->socket = clientSocket;
        
        // Регистрируем сокет в Completion Port
        CreateIoCompletionPort((HANDLE)clientSocket, hCompletionPort, (ULONG_PTR)context, 0);
        
        // Инициируем асинхронное чтение (recv)
        DWORD bytesRead = 0;
        DWORD flags = 0;
        WSARecv(clientSocket, 
                (LPWSABUF)&context->wsaBuf, 
                1, 
                &bytesRead, 
                &flags,
                &context->overlapped,  // Асинхронная операция
                NULL);
    }

    return 0;
}

// Рабочий поток — обрабатывает завершённые операции
DWORD WINAPI workerThreadProc(LPVOID lpParam) {
    HANDLE hCompletionPort = (HANDLE)lpParam;
    DWORD bytesTransferred = 0;
    ULONG_PTR completionKey = 0;
    LPOVERLAPPED overlapped = NULL;

    while (true) {
        // Блокируемся, пока не будет завершённой операции
        BOOL success = GetQueuedCompletionStatus(
            hCompletionPort,
            &bytesTransferred,
            &completionKey,
            &overlapped,
            INFINITE
        );

        ClientContext* context = (ClientContext*)completionKey;

        if (success && bytesTransferred > 0) {
            // Обрабатываем полученные данные
            std::cout << "Received " << bytesTransferred << " bytes\n";
            
            // Инициируем следующую асинхронную операцию чтения
            DWORD bytesRead = 0;
            DWORD flags = 0;
            WSARecv(context->socket, 
                    (LPWSABUF)&context->wsaBuf, 
                    1, 
                    &bytesRead, 
                    &flags,
                    &context->overlapped,
                    NULL);
        } else {
            // Соединение закрыто или ошибка
            closesocket(context->socket);
            delete context;
        }
    }

    return 0;
}

Преимущества IOCP

1. Масштабируемость

• Одновременно может работать 10,000+ подключений
• Постоянное число рабочих потоков (не зависит от числа клиентов)
• Очень эффективное использование памяти

2. Производительность

• Kernel-level оптимизация
• Минимизирует context switching
• Максимальное использование CPU

3. Простота разработки

• Очередь автоматически распределяет задачи между потоками
• Нет необходимости в явной синхронизации потоков
• Kernel гарантирует справедливость распределения

Сравнение с другими подходами

IOCP vs Modern Alternatives

Наши дни компании часто используют:

• libuv (Node.js, используется IOCP на Windows)
• boost::asio (кроссплатформенная абстракция над IOCP/epoll)
• io_uring (современная Linux альтернатива, C++23+)

IOCP всё ещё остаётся лучшим выбором для:

• Высоконагруженных Windows-приложений
• Game servers на Windows
• Enterprise приложений (особенно в корпоративной среде Windows Server)

Когда использовать IOCP

Используй IOCP если:

• Разрабатываешь на Windows
• Нужна поддержка 1000+ одновременных соединений
• Критична производительность
• Нужна асинхронная файловая I/O

Используй альтернативы если:

• Разрабатываешь cross-platform (используй libuv/boost.asio)
• Число соединений < 100 (выбирай что-то проще)
• Работаешь на Linux (epoll/io_uring)

Итог

IOCP — это один из лучших механизмов для асинхронного I/O на Windows. Понимание его работы необходимо для разработки высоконагруженных backend-приложений на Windows платформе. Даже если ты используешь высокоуровневые библиотеки (libuv, asio), знание того, как работает IOCP под капотом, критически важно для оптимизации и отладки.