IOCP高端模型完美再现

最新推荐文章于 2022-07-30 17:39:46 发布
最新推荐文章于 2022-07-30 17:39:46 发布
阅读量1.9k 收藏 2
点赞数
分类专栏： C/C++ Socket编程 完成端口IOCP 服务器设计

当我们投递WSA_Send、WSA_Recv请求时，有时会返回错误代码WSA_IO_PENDING，这个代码表明当前IO挂起。由于投递的请求比较多，OS来不及处理，需要排队等待，当轮到处理指定请求的时候，OS才会处理这个请求，请求处理完之后（完成了收发操作之后），会把完成的结果返回。如果成功地完成I/O请求，会返回0，否则，将返回其他错误。我们也可以绑定一个事件，让这个事件通知我们什么时候完成了请求以及完成的情况如何。

// IOCP2.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include <WinSock2.h>
#include <MSWSock.h>
#include <Windows.h>
#include <process.h>
#pragma comment(lib, "WS2_32.lib")

#define MAX_BUFFER	256
#define MAX_TIMEOUT 1000
#define MAX_SOCKET  1024
#define MAX_THREAD	64
#define MAX_ACCEPT  5

typedef enum _OPERATION_INFO_
{
	OP_NULL,
	OP_ACCEPT,
	OP_READ,
	OP_WRITE
}OPERATIONINFO;

typedef struct _PER_HANDLE_DATA_
{
public:
	_PER_HANDLE_DATA_()
	{
		clean();
	}
	~_PER_HANDLE_DATA_()
	{
		clean();
	}
protected:
	void clean()
	{
		sock = INVALID_SOCKET;
		memset(&addr, 0, sizeof(addr));
		addr.sin_addr.S_un.S_addr = INADDR_ANY;
		addr.sin_port = htons(0);
		addr.sin_family = AF_INET;
	}
public:	
	SOCKET sock;
	SOCKADDR_IN addr;
}PERHANDLEDATA, *PPERHANDLEDATA;

typedef struct _PER_IO_DTATA_
{
public: 
	_PER_IO_DTATA_()
	{
		clean();
	}
	~_PER_IO_DTATA_()
	{
		clean();
	}
	void clean()
	{
		ZeroMemory(&ol, sizeof(ol));
		memset(buf, 0, sizeof(buf));
		sAccept = INVALID_SOCKET;
		sListen = INVALID_SOCKET;
		wsaBuf.buf = buf;
		wsaBuf.len = MAX_BUFFER;
		opType =  OP_NULL;
	}
public:
	WSAOVERLAPPED ol;
	SOCKET sAccept; // Only valid with AcceptEx
	SOCKET sListen; // Only valid with AcceptEx
	WSABUF wsaBuf;
	char buf[MAX_BUFFER];
	OPERATIONINFO opType;
}PERIODATA, *PPERIODATA;

HANDLE hThread[MAX_THREAD] = {0};
PERIODATA* pAcceptData[MAX_ACCEPT] = {0};
int g_nThread = 0;
BOOL g_bExitThread = FALSE;
LPFN_ACCEPTEX lpfnAcceptEx = NULL;
LPFN_GETACCEPTEXSOCKADDRS lpfnGetAcceptExSockAddrs = NULL;
GUID GuidAcceptEx = WSAID_ACCEPTEX;
GUID GuidGetAcceptExSockAddrs = WSAID_GETACCEPTEXSOCKADDRS;

unsigned __stdcall ThreadProc(LPVOID lParam);
BOOL PostAccept(PERIODATA* pIoData);

int _tmain(int argc, _TCHAR* argv[])
{
	WORD wVersionRequested = MAKEWORD(2, 2);
	WSADATA wsaData;
	if(0 != WSAStartup(wVersionRequested, &wsaData))
	{
		printf("WSAStartup failed with error code: %d/n", GetLastError());
		return EXIT_FAILURE;
	}

	if(2 != HIBYTE(wsaData.wVersion) || 2 != LOBYTE(wsaData.wVersion))
	{
		printf("Socket version not supported./n");
		WSACleanup();
		return EXIT_FAILURE;
	}

	// Create IOCP
	HANDLE hIOCP = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, NULL, 0);
	if(NULL == hIOCP)
	{
		printf("CreateIoCompletionPort failed with error code: %d/n", WSAGetLastError());
		WSACleanup();
		return EXIT_FAILURE;
	}

	// Create worker thread
	SYSTEM_INFO si = {0};
	GetSystemInfo(&si);
	for(int i = 0; i < (int)si.dwNumberOfProcessors+2; i++)
	{
		hThread[g_nThread] = (HANDLE)_beginthreadex(NULL, 0, ThreadProc, (LPVOID)hIOCP, 0, NULL);
		if(NULL == hThread[g_nThread])
		{
			printf("_beginthreadex failed with error code: %d/n", GetLastError());
			continue;
		}
		++g_nThread;

		if(g_nThread > MAX_THREAD)
		{
			break;
		}
	}

	// Create listen SOCKET
	SOCKET sListen = WSASocket(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);
	if(INVALID_SOCKET == sListen)
	{
		printf("WSASocket failed with error code: %d/n", WSAGetLastError());
		goto EXIT_CODE;
	}

	// Associate SOCKET with IOCP
	if(NULL == CreateIoCompletionPort((HANDLE)sListen, hIOCP, NULL, 0))
	{
		printf("CreateIoCompletionPort failed with error code: %d/n", WSAGetLastError());
		if(INVALID_SOCKET != sListen)
		{
			closesocket(sListen);
			sListen = INVALID_SOCKET;
		}
		goto EXIT_CODE;
	}

	// Bind SOCKET
	SOCKADDR_IN addr;
	memset(&addr, 0, sizeof(addr));
	addr.sin_family = AF_INET;
	addr.sin_addr.S_un.S_addr = inet_addr("127.0.0.1");
	addr.sin_port = htons(5050);
	if(SOCKET_ERROR == bind(sListen, (LPSOCKADDR)&addr, sizeof(addr)))
	{
		printf("bind failed with error code: %d/n", WSAGetLastError());
		if(INVALID_SOCKET != sListen)
		{
			closesocket(sListen);
			sListen = INVALID_SOCKET;
		}
		goto EXIT_CODE;
	}

	// Start Listen
	if(SOCKET_ERROR == listen(sListen, 200))
	{
		printf("listen failed with error code: %d/n", WSAGetLastError());
		if(INVALID_SOCKET != sListen)
		{
			closesocket(sListen);
			sListen = INVALID_SOCKET;
		}
		goto EXIT_CODE;
	}

	printf("Server start, wait for client to connect .../n");

	DWORD dwBytes = 0;
	if(SOCKET_ERROR == WSAIoctl(sListen, SIO_GET_EXTENSION_FUNCTION_POINTER, &GuidAcceptEx, sizeof(GuidAcceptEx), &lpfnAcceptEx,
		sizeof(lpfnAcceptEx), &dwBytes, NULL, NULL))
	{
		printf("WSAIoctl failed with error code: %d/n", WSAGetLastError());
		if(INVALID_SOCKET != sListen)
		{
			closesocket(sListen);
			sListen = INVALID_SOCKET;
		}
		goto EXIT_CODE;
	}

	if(SOCKET_ERROR == WSAIoctl(sListen, SIO_GET_EXTENSION_FUNCTION_POINTER, &GuidGetAcceptExSockAddrs, 
		sizeof(GuidGetAcceptExSockAddrs), &lpfnGetAcceptExSockAddrs, sizeof(lpfnGetAcceptExSockAddrs), 
		&dwBytes, NULL, NULL))
	{
		printf("WSAIoctl failed with error code: %d/n", WSAGetLastError());
		if(INVALID_SOCKET != sListen)
		{
			closesocket(sListen);
			sListen = INVALID_SOCKET;
		}
		goto EXIT_CODE;
	}

	// Post MAX_ACCEPT accept
	for(int i=0; i<MAX_ACCEPT; i++)
	{
		pAcceptData[i] = new PERIODATA;
		pAcceptData[i]->sListen = sListen;
		PostAccept(pAcceptData[i]);
	}
	// After 1 hour later, Server shutdown.
	Sleep(1000 * 60 *60);

EXIT_CODE:
	g_bExitThread = TRUE;

	PostQueuedCompletionStatus(hIOCP, 0, NULL, NULL);
	WaitForMultipleObjects(g_nThread, hThread, TRUE, INFINITE);
	for(int i = 0; i < g_nThread; i++)
	{
		CloseHandle(hThread[g_nThread]);
	}

	for(int i=0; i<MAX_ACCEPT; i++)
	{
		if(pAcceptData[i])
		{
			delete pAcceptData[i];
			pAcceptData[i] = NULL;
		}
	}

	if(INVALID_SOCKET != sListen)
	{
		closesocket(sListen);
		sListen = INVALID_SOCKET;
	}
	CloseHandle(hIOCP); // Close IOCP

	WSACleanup();
	return 0;
}

BOOL PostAccept(PERIODATA* pIoData)
{
	if(INVALID_SOCKET == pIoData->sListen)
	{
		return FALSE;
	}

	DWORD dwBytes = 0;
	pIoData->opType = OP_ACCEPT;
	pIoData->sAccept = WSASocket(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);
	if(INVALID_SOCKET == pIoData->sAccept)
	{
		printf("WSASocket failed with error code: %d/n", WSAGetLastError());
		return FALSE;
	}

	if(FALSE == lpfnAcceptEx(pIoData->sListen, pIoData->sAccept, pIoData->wsaBuf.buf, pIoData->wsaBuf.len - ((sizeof(SOCKADDR_IN)+16)*2), 
		sizeof(SOCKADDR_IN)+16, sizeof(SOCKADDR_IN)+16, &dwBytes, &(pIoData->ol)))
	{
		if(WSA_IO_PENDING != WSAGetLastError())
		{
			printf("lpfnAcceptEx failed with error code: %d/n", WSAGetLastError());

			return FALSE;
		}
	}
	return TRUE;
}

unsigned __stdcall ThreadProc(LPVOID lParam)
{
	HANDLE hIOCP = (HANDLE)lParam;

	PERHANDLEDATA* pPerHandleData = NULL;
	PERIODATA* pPerIoData = NULL;
	WSAOVERLAPPED* lpOverlapped = NULL;
	DWORD dwTrans = 0;
	DWORD dwFlags = 0;
	while(!g_bExitThread)
	{
		BOOL bRet = GetQueuedCompletionStatus(hIOCP, &dwTrans, (PULONG_PTR)&pPerHandleData, &lpOverlapped, MAX_TIMEOUT);
		if(!bRet)
		{
			// Timeout and exit thread
			if(WAIT_TIMEOUT == GetLastError())
			{
				continue;
			}
			// Error
			printf("GetQueuedCompletionStatus failed with error: %d/n", GetLastError());
			continue;
		}
		else
		{
			pPerIoData = CONTAINING_RECORD(lpOverlapped, PERIODATA, ol);
			if(NULL == pPerIoData)
			{
				// Exit thread
				break;
			}

			if((0 == dwTrans) && (OP_READ == pPerIoData->opType || OP_WRITE == pPerIoData->opType))
			{
				// Client leave.
				printf("Client: <%s : %d> leave./n", inet_ntoa(pPerHandleData->addr.sin_addr), ntohs(pPerHandleData->addr.sin_port));
				closesocket(pPerHandleData->sock);
				delete pPerHandleData;
				delete pPerIoData;
				continue;
			}
			else
			{
				switch(pPerIoData->opType)
				{
				case OP_ACCEPT: // Accept
					{	
						SOCKADDR_IN* remote = NULL;
						SOCKADDR_IN* local = NULL;
						int remoteLen = sizeof(SOCKADDR_IN);
						int localLen = sizeof(SOCKADDR_IN);
						lpfnGetAcceptExSockAddrs(pPerIoData->wsaBuf.buf, pPerIoData->wsaBuf.len - ((sizeof(SOCKADDR_IN)+16)*2),
							sizeof(SOCKADDR_IN)+16, sizeof(SOCKADDR_IN)+16, (LPSOCKADDR*)&local, &localLen, (LPSOCKADDR*)&remote, &remoteLen);
						printf("Client <%s : %d> come in./n", inet_ntoa(remote->sin_addr), ntohs(remote->sin_port));
						printf("Recv Data: <%s : %d> %s./n", inet_ntoa(remote->sin_addr), ntohs(remote->sin_port), pPerIoData->wsaBuf.buf);

						if(NULL != pPerHandleData)
						{
							delete pPerHandleData;
							pPerHandleData = NULL;
						}
						pPerHandleData = new PERHANDLEDATA;
						pPerHandleData->sock = pPerIoData->sAccept;

						PERHANDLEDATA* pPerHandle = new PERHANDLEDATA;
						pPerHandle->sock = pPerIoData->sAccept;
						PERIODATA* pPerIo = new PERIODATA;
						pPerIo->opType = OP_WRITE;
						strcpy_s(pPerIo->buf, MAX_BUFFER, pPerIoData->buf);
						DWORD dwTrans = strlen(pPerIo->buf);
						memcpy(&(pPerHandleData->addr), remote, sizeof(SOCKADDR_IN));
						// Associate with IOCP
						if(NULL == CreateIoCompletionPort((HANDLE)(pPerHandleData->sock), hIOCP, (ULONG_PTR)pPerHandleData, 0))
						{
							printf("CreateIoCompletionPort failed with error code: %d/n", GetLastError());
							closesocket(pPerHandleData->sock);
							delete pPerHandleData;
							continue;
						}

						// Post Accept
						memset(&(pPerIoData->ol), 0, sizeof(pPerIoData->ol));
						PostAccept(pPerIoData);

						// Post Receive						
						DWORD dwFlags = 0;
						if(SOCKET_ERROR == WSASend(pPerHandle->sock, &(pPerIo->wsaBuf), 1, 
							&dwTrans, dwFlags, &(pPerIo->ol), NULL))
						{
							if(WSA_IO_PENDING != WSAGetLastError())
							{
								printf("WSASend failed with error code: %d/n", WSAGetLastError());
								closesocket(pPerHandle->sock);
								delete pPerHandle;
								delete pPerIo;
								continue;
							}
						}
					}
					break;

				case OP_READ: // Read
					printf("recv client <%s : %d> data: %s/n", inet_ntoa(pPerHandleData->addr.sin_addr), ntohs(pPerHandleData->addr.sin_port), pPerIoData->buf);
					pPerIoData->opType = OP_WRITE;
					memset(&(pPerIoData->ol), 0, sizeof(pPerIoData->ol));
					if(SOCKET_ERROR == WSASend(pPerHandleData->sock, &(pPerIoData->wsaBuf), 1, &dwTrans, dwFlags, &(pPerIoData->ol), NULL))
					{
						if(WSA_IO_PENDING != WSAGetLastError())
						{
							printf("WSASend failed with error code: %d./n", WSAGetLastError());
							continue;
						}
					}
					break;

				case OP_WRITE: // Write
					{
						pPerIoData->opType = OP_READ;
						dwFlags = 0;
						memset(&(pPerIoData->ol), 0, sizeof(pPerIoData->ol));
						memset(pPerIoData->buf, 0, sizeof(pPerIoData->buf));
						pPerIoData->wsaBuf.buf = pPerIoData->buf;
						dwTrans = pPerIoData->wsaBuf.len = MAX_BUFFER;
						if(SOCKET_ERROR == WSARecv(pPerHandleData->sock, &(pPerIoData->wsaBuf), 1, &dwTrans, &dwFlags, &(pPerIoData->ol), NULL))
						{
							if(WSA_IO_PENDING != WSAGetLastError())
							{
								printf("WSARecv failed with error code: %d./n", WSAGetLastError());
								continue;
							}
						}
					}
					break;

				default:
					break;
				}
			}
		}
	}
	return 0;
}

Allen_Kao
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
IOCP 完成端口模型简单封装
11-04
采用IOCP模型简单封装的网络通信模型，可以用来学习交流使用。代码里面有些是根据个人业务修改的部分，也可以自己修改成所需，还有一些功能没有完善，不过可以使用。
老早写过的IOCP模型demo代码；
漫步者
12-27 2442
仅供参考下！ #ifndef __IOCPMODEL_H #define __IOCPMODEL_H #include #include #pragma comment(lib,"ws2_32.lib") #define OP_READ 1 #define OP_WRITE 2 #define OP_ACCEPT 3 #define OP_END -1 #define
完整的IOCP模型 Echo服务器及代码分析
HLW0522的博客
12-18 978
首先，先感谢http://www.cnblogs.com/talenth/p/7068392.html 这篇博文，作者写的通俗易懂，语言幽默，偶然一次在公交车上见到这篇博文相见恨晚，一口气读下来很长一篇，有了整体的认知，又翻看代码，查看其它资料，反复研究每个细节，终于IOCP模型基本懂了，下面给出一些心得。建议先看一遍上面提及的博客，再看这篇文章，应该会很快就能理解。 IOCP模型也称完成端口，...
异步通信之IOCP详解
对自己笑
06-22 2966
一、 概述 学习完网络基础，在写C/S应用程序时，大多童靴写服务器基本都没有用到io模型，基本都是采用“accept同步拥塞通讯和多线程方式”与客户端通讯。但当有成千上万客户端请求连接并与服务器通讯时，多线程的创建与CPU上下文的切换，服务器端压力可想而知，在资源有限的情况在，选择一个好的io模型才能搭建高性能服务器。其中IOCP广泛运用于个高性能服务器程序，apache服务器就是IOCP实现。 同步通讯和异步通信 在写网络程序时，我们知道CPU运行速度非常快，而在与IO设备进行数据交换时速度简直不忍直视。
五种网络IO模型分析
阿呆的隐秘角落
07-30 420
IO模型
IOCP模型源码
04-20
经过几天的学习，翻资料，看别人代码，自己封装的IOCP模型源码，注释写的很详细，供新手学习参考，欢迎指正。PS：本不想要分的，CSDN最低限制2分。很无奈。我的其他资源本来都是不需要分的，后来CSDN后台系统自己给...
☆网云IOCP服务器模型支持库
07-24
☆网云IOCP服务器模型支持库
c++ IOCP模型服务端
10-27
研究中的C++IOCP模型，大家可研究，正在研究 send群发效应
IOCP模型客户端服务端demo
05-02
该代码来源于国外一个网站，当初为了学习，无意间看到的，下载后进行了深入学习，现在提供给大家一起学习，仅供学习和参考使用。
IOCP 内存池线程池的一个例子
04-06
IOCP 内存池线程池的一个例子 主要优化在性能上 包括IO收发的重叠结构用了内存池技术
openssl 结合 IOCP的例子
11-23
这个是一个结合了OpenSSL 和 IOCP的一个例子，需要的可以参考一下的。
Windows IOCP框架
08-17
这是一个IOCP框架，易扩展、易复用、易维护。 代码已有所变更，详情请看： http://blog.csdn.net/chenyu2202863/archive/2010/08/17/5818920.aspx
winsock网络通信(select和IOCP模型,客户端和服务器都有)
06-24
select和IOCP模型
完成端口IOCP实现高并发服务器——一篇非常好的学习资源
10-31
IOCP 实现高并发服务器demo+详解 转载自https://www.cnblogs.com/talenth/p/7068392.html
TCPSocketEnging分析 2011-6-9 00:29 阅读(13)
weixin_30391339的博客
06-19 156
赞 转载 分享 评论 复制地址 举报 更多 上一篇|下一篇：TimerEngine 相关UML：网络引擎整体结构：SocketItem细节：先来看几个底层结构： //重叠结构类classCOverLapped{//变量定义public:WSABUF...
IOCP简单例子
03-23 148
Server: View Code {*******************************************************}{ }{ IOCP Server Sample ...
网狐棋牌（一） ServerKernel中的IQueueService接口分析
mergerly的专栏
11-18 4969
相关UML如下： 添加： 处理 关键代码解析： 1//开始服务 2bool __cdecl CQueueService::StartService() 3{ 4    //效验参数 5    ASSERT(m_bService==false); 6    ASSERT(m_hCompletionPort==NULL); 7    AS
红孩儿网狐Cocos经典棋牌开发教程
09-15
由知名Cocos技术讲师红孩儿讲解的基于网狐源码进行棋牌开发的系列教程。
IOCP模型c++代码
最新发布
03-02
IOCP是一种高效的I/O多路复用模型，适用于Windows系统上的网络编程。下面是一个简单的使用IOCP模型的C代码示例，实现了一个简单的回显服务器： ``` #include #include #include #include #include #define ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值