微信公众号搜"智元新知"关注
微信扫一扫可直接关注哦！

windows的IOCPInput Output Completion Port，输入输出完成端口

分类：Windows作者：编程之家

windows的IOCP（Input Output Completion Port，输入输出完成端口）

2019年6月2日

12:27

如果仅仅只是代码层面上的话，windows上的IOCP逻辑好像也不是太难。但是实际上总是有一种雾里看花的感觉。因为能力所限，不能去深入了解一下到底是怎么回事

? ?

为了突破select等传统I/O模型的极限，每种操作系统（内核级别）都会提供特有的I/O模型以提高性能。其中最具代表性的有Linux的epoll、BSD的kqueue及Windows的IOCP。他们都在操作系统界别提供支持并完成功能。

? ?

问：epoll快还是IOCP快？

服务器端的响应事件和并发服务器数是衡量服务器端好坏的重要因素。但对于普通人来讲，这两种模型已经非常优秀。基于epoll实现的服务器端在并发数量上有缺陷，但换成IOCP后没有任何问题。IOCP的响应时间太慢是个问题，换成epoll后就解决了。

在硬件性能和分配带宽充足的情况下，如果响应时间和并发数量出现了问题，首先应怀疑以下两点，修正后通常会解决大部分问题。

  • 低效的IO结构或者低效的cpu使用
  • 数据库设计和查询语句（Query）的结构

虽然IOCP拥有在其他IO模型不具备的优点，但这并非左右服务器端性能的绝对因素，并且不可能任何情况下都体现这种优点。他们的主要差异在于操作系统的内部工作机制。

? ?

通过重叠IO理解IOCP

创建非阻塞模式的套接字

? ?

SOCKET hLisnSock;

int mode = 1;

…

hListSock = WSASocket(PF_INET,SOCK_STREAM,NULL,WSA_FLAG_OVERLAPPED);

ioctlsocket(hLisnSock,FIONBIO,&mode); // for non-blocking socket

…

? ?

ioctlsocket函数完成以下功能：

将hLisnSock句柄引用的套接字IO模式（FIONBIO）改为变量mode中指定的形式。

FIONBIO为设置选项，mode中的值即为设置启用与否。函数调用完成后，mode值为非0，则以更改为非阻塞模式，否则为阻塞模式

? ?

非阻塞模式套接字除了以非阻塞模式进行IO以外，还具有如下功能：

所以针对非阻塞套接字调用accept函数并返回INVALID_SOCKET时，应该通过WSAGetLastError函数确认返回INVALID_SOCKET的理由，然后进行处理

? ?

使用重叠IO方法实现类似IOCP的服务端代码

? ?

#include <stdio.h>

#include <stdlib.h>

#include <winsock2.h>

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

#pragma warning(disable: 4996)

? ?

#define BUF_SIZE 1024

void CALLBACK ReadCompRoutine(DWORD,DWORD,LPWSAOVERLAPPED,DWORD);

void CALLBACK WriteCompRoutine(DWORD,DWORD);

void ErrorHandling(const char * message);

? ?

typedef struct

{

SOCKET hClntSock;

char buf[BUF_SIZE];

WSABUF wsaBuf;

} PER_IO_DATA,* LPPER_IO_DATA;

? ?

int main(int argc,char* argv[])

{

WSADATA wsaData;

SOCKET hListenSock,hRecvSock;

SOCKADDR_IN listenAddr,recvAddr;

LPWSAOVERLAPPED lpOvlp;

DWORD recvBytes;

LPPER_IO_DATA hbInfo;

int mode = 1,recvAddrSz,flagInfo = 0;

? ?

if (argc != 2)

{

printf("Usage: %s <port> \n",argv[0]);

exit(1);

}

? ?

if (WSAStartup(MAKEWORD(2,2),&wsaData) != 0)

ErrorHandling("WSAStartup() error");

? ?

hListenSock = WSASocket(PF_INET,WSA_FLAG_OVERLAPPED);

ioctlsocket(hListenSock,&mode);

? ?

memset(&listenAddr,sizeof(listenAddr));

listenAddr.sin_family = AF_INET;

listenAddr.sin_addr.S_un.S_addr = htonl(INADDR_ANY);

listenAddr.sin_port = htons(atoi(argv[1]));

? ?

if (bind(hListenSock,(SOCKADDR*)&listenAddr,sizeof(listenAddr)) != 0)

ErrorHandling("bind() error");

if (listen(hListenSock,5) != 0)

ErrorHandling("listen() error");

? ?

recvAddrSz = sizeof(recvAddr);

while (1)

{

SleepEx(100,TRUE); // for alertable wait state

hRecvSock = accept(hListenSock,(SOCKADDR*)&recvAddr,&recvAddrSz);

if (hRecvSock == INVALID_SOCKET)

{

if (WSAGetLastError() == WSAEWOULDBLOCK)

continue;

else

ErrorHandling("accept() error");

}

puts("Client connected...");

? ?

lpOvlp = (LPWSAOVERLAPPED)malloc(sizeof(WSAOVERLAPPED));

memset(lpOvlp,sizeof(WSAOVERLAPPED));

? ?

hbInfo = (LPPER_IO_DATA)malloc(sizeof(PER_IO_DATA));

hbInfo->hClntSock = hRecvSock;

(hbInfo->wsaBuf).buf = hbInfo->buf;

(hbInfo->wsaBuf).len = BUF_SIZE;

? ?

lpOvlp->hEvent = (HANDLE)hbInfo;

WSARecv(hRecvSock,&(hbInfo->wsaBuf),1,&recvBytes,&flagInfo,lpOvlp,ReadCompRoutine);

? ?

}

closesocket(hRecvSock);

closesocket(hListenSock);

WSACleanup();

? ?

return 0;

}

? ?

void CALLBACK ReadCompRoutine(DWORD dwError,DWORD szRecvBytes,LPWSAOVERLAPPED lpOverlapped,DWORD flags)

{

LPPER_IO_DATA hbInfo = (LPPER_IO_DATA)(lpOverlapped->hEvent);

SOCKET hSock = hbInfo->hClntSock;

LPWSABUF bufInfo = &(hbInfo->wsaBuf);

DWORD sentBytes;

? ?

if (szRecvBytes == 0)

{

closesocket(hSock);

free(lpOverlapped->hEvent);

free(lpOverlapped);

}

else //echo

{

bufInfo->len = szRecvBytes;

WSASend(hSock,bufInfo,&sentBytes,lpOverlapped,WriteCompRoutine);

}

}

void CALLBACK WriteCompRoutine(DWORD dwError,DWORD szSendBytes,DWORD flags)

{

LPPER_IO_DATA hbInfo = (LPPER_IO_DATA)(lpOverlapped->hEvent);

SOCKET hSock = hbInfo->hClntSock;

LPWSABUF bufInfo = &(hbInfo->wsaBuf);

DWORD recvBytes;

? ?

int flagInfo = 0;

bufInfo->len = BUF_SIZE;

WSARecv(hSock,ReadCompRoutine);

}

void ErrorHandling(const char* message)

{

fprintf(stderr,"%s,Error Code %d \n",message,WSAGetLastError());

exit(1);

}

? ?

可以很容易明白就是对于每一个连接起来的客户端创建了一个ReadCompRoutine和WriteCompRoutine互相调用的环，而这个圆环的接缝就是Sleepex函数。

接着也就很容易明白为什么需要非阻塞的套接字。

同时可以看到每次连接到了一个客户端都会创建一个PER_IO_DATA结构体，以便将新创建的套接字句柄和缓冲信息传递给ReadCompRoutine函数和WriteCompRoutine函数。该结构体的地址由WSAOVERLAPPED结构体成员的hEvent保存。因为在使用Completion Routine的重叠IO中，不需要使用WSAOVERLAPPED结构体的hEvent成员（其他的成员还需要使用？）。

? ?

客户端代码

? ?

#include <stdio.h>

#include <stdlib.h>

#include <winsock2.h>

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

#pragma warning(disable: 4996)

? ?

#define BUF_SIZE 1024

void ErrorHandling(const char* message);

? ?

int main(int argc,char* argv[])

{

WSADATA wsaData;

SOCKET hSocket;

SOCKADDR_IN servAddr;

char message[BUF_SIZE];

int strLen,readLen;

? ?

if (argc != 3)

{

printf("Usage: %s <IP> <port> \n",argv[0]);

exit(1);

}

if (WSAStartup(MAKEWORD(2,&wsaData) != 0)

ErrorHandling("socket() error");

? ?

hSocket = socket(PF_INET,0);

? ?

memset(&servAddr,sizeof(servAddr));

servAddr.sin_family = AF_INET;

servAddr.sin_addr.S_un.S_addr = inet_addr(argv[1]);

servAddr.sin_port = htons(atoi(argv[2]));

? ?

if (connect(hSocket,(SOCKADDR*)& servAddr,sizeof(servAddr)) != 0)

ErrorHandling("connect() error");

else

puts("Connected...");

? ?

while (1)

{

fputs("Input message(Q to quit): ",stdout);

fgets(message,BUF_SIZE,stdin);

if (!strcmp(message,"q\n") || !strcmp(message,"Q\n"))

break;

? ?

strLen = strlen(message);

send(hSocket,strLen,0);

readLen = 0;

while (1)

{

readLen += recv(hSocket,&message[readLen],BUF_SIZE - 1,0);

if (readLen >= strLen) // 这样子读取的话存在有一个问题，socket缓冲区里的其他怎么办

break;

}

message[strLen] = 0;

printf("Message from server: %s",message);

}

closesocket(hSocket);

WSACleanup();

? ?

return 0;

}

? ?

void ErrorHandling(const char* message)

{

fprintf(stderr,WSAGetLastError());

exit(1);

}

? ?

从重叠IO模型到IOCP模型

重叠IO模型回声服务器端存在的缺点：

重复调用非阻塞模式的accept函数和以进入alertable wait状态为目的的SleepEx函数将影响性能。

这属于重叠IO结构固有的缺陷。

? ?

但可以让main线程（main函数内部）调用accept函数，在单独创建线程负责客户端IO。这其实就是IOCP采用的服务器端模型。即IOCP将创建专用的IO线程，该线程负责于所有客户端进行IO。

? ?

创建完成端口

IOCP中已完成的IO信息将注册到完成端口对象（Completion Port，简称CP对象）。但这个过程需要先经过如下请求过程：当该套接字的IO完成时，请把状态信息注册到指定的CP对象。该过程称为"套接字和CP对象之间的连接请求"

so，首先要做如下两步工作：

  • 创建完成端口对象
  • 将完成套接字和指定的完成端口对象绑定

? ?

#include <windows.h>

HANDLE CreateIoCompletionPort(HANDLE FileHandle,

HANDLE ExistingCompletionPort,ULONG_PTR CompletionKey,

DWORD NumberOfConcurrentThreads);

->>成功返回cp对象句柄，失败返回NULL

? ?

FileHandle 创建CP对象时传递INVALID_HANDLE_VALUE

ExistingCompletionPort 创建CP对象时传递NULL

CompletionKey 创建CP对象时传递0

NumberOfConcurrentThreads 分配给CP对象用于处理IO的线程数。当该参数为0时，系统中cpu个数作为默认值

? ?

HANDLE hCpObject;

…

hCpObject = CreateIoCompletionPort(INVALID_HANDLE_VALUE,2);

? ?

连接完成端口和套接字

#include <windows.h>

HANDLE CreateIoCompletionPort(HANDLE FileHandle,

DWORD NumberOfConcurrentThreads);

->>成功时返回CP对象句柄，失败时返回NULL

? ?

FileHandle 要连接到CP对象的套接字句柄

ExistingCompletionPort 要连接套接字的CP对象句柄

CompletionKey 传递已完成IO相关信息

NumberOfConcurrentThreads 无论传递何值，只要该函数的第二个参数非NULL就会被忽略

? ?

HANDLE hCpObject;

SOCKET hSock;

…

CreateIoCompletionPort((HANDLE)hSock,hCpObject,(DWORD)ioInfo,0);

? ?

确认完成端口已完成的IO和线程的IO处理

#include <windows.h>

BOOL GetQueuedCompletionStatus(HANDLE CompletionPort,

LPDWORD lpNumberOfBytes,PULONG_PTR lpCompletionKey,

LPOVERLAPPED * lpOverlapped,DWORD dwMilliseconds);

->> 成功时返回TRUE，失败时返回FALSE

? ?

CompletionPort 注册有已完成IO信息的CP对象句柄

lpNumberOfBytes 用于保存IO过程中传输数据大小的变量地址值

lpCompletionKey 用于保存CreateIoCompletionPort函数的第三个参数值的变量地址值

lpOverlapped 用于保存调用WSASend、WSARecv函数时传递的OVERLAPPED结构体变量的地址

dwMilliseconds 超时信息。超过指定时间后返回FALSE并跳出函数。传递INFINITE时，阻塞。

? ?

其中lpCompletionKey以及lpOverlapped主要时为了获取所需的信息而设置的。

通过GetQueuedCompletionPort函数的第三个参数得到的是以连接套接字和CP对象为目的目的而调用的CreateCompletionPort函数的第三个参数值

通过GetQueueCompletionStatus函数的第四个参数得到的是调用WSASend、WSARecv函数时传入的WSAOVERLAPPED结构体变量地址值。

? ?

IOCP中将创建全职IO线程，有该线程针对所有客户端进行IO。而且CreateIoCompletionPort函数中也有参数用于指定分配给CP对象的最大线程数。

? ?

? ?

#include <stdio.h>

#include <stdlib.h>

#include <process.h>

#include <winsock2.h>

#include <windows.h>

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

#pragma warning(disable: 4996)

? ?

#define BUF_SIZE 1024

#define READ 3

#define WRITE 5

? ?

typedef struct //socket info

{

SOCKET hClntSock;

SOCKADDR_IN clntAddr;

} PER_HANDLE_DATA,*LPPER_HANDLE_DATA;

? ?

typedef struct // buffer info

{

OVERLAPPED overlapped;

WSABUF wsaBuf;

char buffer[BUF_SIZE];

int rwMode; // READ or WRITE

} PER_IO_DATA,*LPPER_IO_DATA;

? ?

DWORD WINAPI EchoThreadMain(LPVOID CompletionPortIO);

void ErrorHandling(char *message);

? ?

int main(int argc,char* argv[])

{

WSADATA wsaData;

HANDLE hComPort;

SYstem_INFO sysInfo;

LPPER_IO_DATA ioInfo;

LPPER_HANDLE_DATA handleInfo;

? ?

SOCKET hServSock;

SOCKADDR_IN servAddr;

int recvBytes,i,flags = 0;

? ?

if (WSAStartup(MAKEWORD(2,&wsaData) != 0)

ErrorHandling("WSAStartup() Error");

? ?

hComPort = CreateIoCompletionPort(INVALID_HANDLE_VALUE,0);

? ?

GetSystemInfo(&sysInfo);

for (i = 0; i < sysInfo.dwNumberOfProcessors; i++)

_beginthreadex(NULL,EchoThreadMain,(LPVOID)hComPort,NULL);

? ?

hServSock = WSASocket(AF_INET,WSA_FLAG_OVERLAPPED); // 必须要使用重叠IO套接字

memset(&servAddr,sizeof(servAddr));

servAddr.sin_family = AF_INET;

servAddr.sin_addr.S_un.S_addr = htonl(INADDR_ANY);

servAddr.sin_port = htons(atoi(argv[1]));

? ?

if (bind(hServSock,sizeof(servAddr)) != 0)

ErrorHandling("bind() error");;

if(listen(hServSock,5) != 0)

ErrorHandling("listen() error");

? ?

while (1)

{

SOCKET hClntSock;

SOCKADDR_IN clntAddr;

int addrLen = sizeof(clntAddr);

? ?

hClntSock = accept(hServSock,(SOCKADDR*)&clntAddr,&addrLen);

? ?

handleInfo = (LPPER_HANDLE_DATA)malloc(sizeof(PER_HANDLE_DATA));

handleInfo->hClntSock = hClntSock;

memcpy(&(handleInfo->clntAddr),&clntAddr,addrLen);

? ?

CreateIoCompletionPort((HANDLE)hClntSock,hComPort,(DWORD)handleInfo,0);

? ?

ioInfo = (LPPER_IO_DATA)malloc(sizeof(PER_IO_DATA));

memset(&(ioInfo->overlapped),sizeof(OVERLAPPED));

ioInfo->wsaBuf.len = BUF_SIZE;

ioInfo->wsaBuf.buf = ioInfo->buffer;

ioInfo->rwMode = READ;

WSARecv(handleInfo->hClntSock,&(ioInfo->wsaBuf),

&recvBytes,&flags,&(ioInfo->overlapped),NULL);

? ?

}

? ?

return 0;

}

? ?

DWORD WINAPI EchoThreadMain(LPVOID pComPort)

{

puts("I am Thread");

HANDLE hComPort = (HANDLE)pComPort;

SOCKET sock;

DWORD bytesTrans;

LPPER_HANDLE_DATA handleInfo;

LPPER_IO_DATA ioInfo;

DWORD flags = 0;

? ?

while (1)

{

GetQueuedCompletionStatus(hComPort,&bytesTrans,(LPDWORD)&handleInfo,(LPOVERLAPPED*)&ioInfo,INFINITE);

sock = handleInfo->hClntSock;

? ?

if (ioInfo->rwMode == READ)

{

puts("message received");

if (bytesTrans == 0) // 传输EOF时

{

closesocket(sock);

free(handleInfo);

free(ioInfo);

continue;

}

? ?

memset(&(ioInfo->overlapped),sizeof(OVERLAPPED));

ioInfo->wsaBuf.len = bytesTrans;

ioInfo->rwMode = WRITE;

WSASend(sock,NULL);

? ?

ioInfo = (LPPER_IO_DATA)malloc(sizeof(PER_IO_DATA));

memset(&(ioInfo->overlapped),sizeof(OVERLAPPED));

ioInfo->wsaBuf.len = BUF_SIZE;

ioInfo->wsaBuf.buf = ioInfo->buffer;

ioInfo->rwMode = READ;

WSARecv(sock,NULL);

}

else

{

puts("message send!");

free(ioInfo);

}

}

return 0;

}

void ErrorHandling(char * message)

{

fprintf(stderr,WSAGetLastError());

exit(1);

}

? ?

在此段代码中你大概会注意到，在WSARecv之前动态申请了一个PER_IO_DATA的结构体空间。一般逻辑上看来，就算是直接使用一开始的PER_IO_DATA结构体也未尝不可，正常看来应该不会出现什么问题，然而恰恰他就出现了问题。

问题原因暂时还不知道，是的。我琢磨了一下，还是没有想的很明白。但是好像有了一点点的头绪。

? ?

IOCP性能更优的原因

在代码层面上与select进行比较，发现如下特点

  • 非阻塞IO，没有IO延迟
  • 无需循环查早已完成IO
  • 不需管理IO套接字
  • 可以选用合适的处理IO线程数

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 dio@foxmail.com 举报，一经查实，本站将立刻删除。

相关推荐

Windows2012R2备用域控搭建
Windows2012R2备用域控搭建 前置操作 域控主域控的主dns：自己的ip备域控的主dns：自己的ip，备dns：主域控的ip 客户端主dns：主域控的ip，备dns：备域控的ip 一般说主和备，主要是指担任PDC放置的角色的这台DC，所有修改密码的操作必须由这台DC应答 除了修改密码、域管
主域控角色迁移和夺取（转载）
主域控角色迁移和夺取（转载） 转载自：http://yupeizhi.blog.51cto.com/3157367/1427978 操作系统版本：Windows2012R2 数据中心版 FSMO角色迁移 主域控没有挂的情况下使用FSMO角色迁移 FSMO角色迁移步骤，下面步骤在备用域控上执行 0、使
Windows2012R2 NTP时间同步
Windows2012R2 NTP时间同步 Windows2012R2里没有了internet时间，需要使用另外的方式去做时间同步 下面分两个情况 两个情况，两个情况都需要用修改组策略的方式来做 情况一 没有Windows域环境 集群中的每个服务器都要能上网，每个服务器都要执行下面的操作 开启 NT
Windows注册表操作基础代码
Windows注册表操作基础代码 Windows下对注册表进行操作使用的一段基础代码Reg.h:#pragmaonce#include&lt;assert.h&gt;#include&lt;windows.h&gt;classReg{HKEYhkey;public:voidopen(HKEYroot
黑客常用WinAPI函数整理
黑客常用WinAPI函数整理之前的博客写了很多关于Windows编程的内容，在Windows环境下的黑客必须熟练掌握底层API编程。为了使读者对黑客常用的Windows API有个更全面的了解以及方便日后使用API方法的查询，特将这些常用的API按照7大分类进行整理如下，希望对大家的学习有所帮助。一
一个简单的Windows Socket可复用框架
一个简单的Windows Socket可复用框架说起网络编程，无非是建立连接，发送数据，接收数据，关闭连接。曾经学习网络编程的时候用Java写了一些小的聊天程序，Java对网络接口函数的封装还是很简单实用的，但是在Windows下网络编程使用的Socket就显得稍微有点繁琐。这里介绍一个自己封装的一
Windows文件操作基础代码
Windows文件操作基础代码 Windows下对文件进行操作使用的一段基础代码File.h，首先是File类定义：#pragmaonce#include&lt;Windows.h&gt;#include&lt;assert.h&gt;classFile{HANDLEhFile;//文件句柄publ
Winpcap基础代码
Winpcap基础代码 使用Winpcap进行网络数据的截获和发送都需要的一段代码：#include&lt;PCAP.H&gt;#pragmacomment(lib,&quot;wpcap.lib&quot;)//#pragmacomment(lib,&quot;ws2_32.lib&quot;)#
使用vbs脚本进行批量编码转换
使用vbs脚本进行批量编码转换 最近需要使用SourceInsight查看分析在Linux系统下开发的项目代码，我们知道Linux系统中文本文件默认编码格式是UTF-8，而Windows中文系统中的默认编码格式是Gb2312。系统内的编码格式有所区别倒无伤大雅，关键的是SourceInsigh...
缓冲区溢出攻击
缓冲区溢出攻击缓冲区溢出（Buffer Overflow）是计算机安全领域内既经典而又古老的话题。随着计算机系统安全性的加强，传统的缓冲区溢出攻击方式可能变得不再奏效，相应的介绍缓冲区溢出原理的资料也变得“大众化”起来。其中看雪的《0day安全：软件漏洞分析技术》一书将缓冲区溢出攻击的原理阐述得简洁
苹果市值2025年有望达4万亿美元
pythonJavaScriptjavaHTMLreactjsC#AndroidCSSNode.jssqlrpython-3.xMysqLjQueryc++pandasFlutterangularIOSdjangolinuxswifttypescript路由器JSON路由器设置无线路由器h3c华三华三路由器设置华三路由器电脑软件教程arraysdocker软件图文教程Cvue.jslaravelspring-bootreact-native