完成端口iocp编程模型

最新推荐文章于 2022-12-30 23:20:46 发布
最新推荐文章于 2022-12-30 23:20:46 发布
阅读量1.5k 收藏 2
点赞数
分类专栏： 网络编程 文章标签： iocp socket windows overlapped
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/hacode/article/details/7089848
版权

简介

完成端口的基本思想和计算机组成原理中的dma非常类似，客户调用overlap操作抛出一个读写请求，然后在工作线程在一个位置（port）等待完成，如果完成，客户根据返回值进行后续的读写操作。在用户抛出异步读写请求以后，就可以转而去做其他事情了。


1，定义异步请求保存数据的结构

enum IO_OPERATION {
    IO_READ     =   1, 
    IO_SEND     =   2,
    IO_ACCEPT   =   3,
};

struct IO_DATA{
    WSAOVERLAPPED               Overlapped;
    // 原子锁
    DWORD                       dwLock;
    // 上次接受到数据的时间, 判断连接的不活动时间
    DWORD                       dwEnterTick;    
    // 操作代码
    IO_OPERATION                opCode;
    // 网络套接字句柄
    SOCKET                      activeSocket;
    // 网络地址
    DWORD                       dwIpAddr;
    // 端口
    WORD                        wPort;
    // 请求类型 
    char                        cReqType; //PROXY_HTTP;PROXY_NONE;
    // 缓冲区
    WSABUF                      wsabuf;
    // 已经处理的io字节数
    DWORD                       dwRecved;
    // 缓冲区总字节数
    DWORD                       dwRecvBufTail;
    // wsaBuf指向的缓冲区
    char                        RecvBuffer[MAX_BUFF_SIZE];
    // 已经处理的io字节数
    DWORD                       dwSent;
    // 缓冲区总字节数
    DWORD                       dwSendBufTail;
    // wsaBuf指向的缓冲区
    char                        SendBuffer[MAX_BUFF_SIZE];
};

2, 初始化listen

void ListenThread(void * args)
{
    { // Init winsock2
        WSADATA wsaData;
        ZeroMemory(&wsaData,sizeof(WSADATA));
        int retVal = -1;
        if( (retVal = WSAStartup(MAKEWORD(2,2), &wsaData)) != 0 ) {
            PUTLOG("WSAStartup Failed::Reason Code:: %u\n", retVal);
            return;
        }
    }

    { // Init Tls Index
        if (!InitTlsIndex())
            return ;
    }

    {  //Create socket
        g_ServerSocket = WSASocket(AF_INET,SOCK_STREAM
                                  , IPPROTO_TCP
                                  , NULL
                                  ,0
                                  ,WSA_FLAG_OVERLAPPED);

        if( g_ServerSocket == INVALID_SOCKET ) 
        {
            PUTLOG("Server Socket Creation Failed::Reason Code:: %u\n"
                    , WSAGetLastError());
            return;
        }
    }

    {   //bind
        sockaddr_in service;
        service.sin_family = AF_INET;
        service.sin_addr.s_addr = htonl(INADDR_ANY);
        service.sin_port = htons(PHONE_PORT);
        int retVal = bind(g_ServerSocket,(SOCKADDR *)&service,sizeof(service));
        if( retVal == SOCKET_ERROR ) {
            PUTLOG("Server Soket Bind Failed::Reason Code:: %u\n"
                    , WSAGetLastError());
            return;
        }
    }

    {   //listen
        int retVal = listen(g_ServerSocket, 100);
        if( retVal == SOCKET_ERROR ) 
        {
            PUTLOG("Server Socket Listen Failed::Reason Code:: %u\n" 
                    , WSAGetLastError());
            return;
        }
        PUTLOG("Server Socket Listen at:: %d \n", PHONE_PORT);;
    }

    {   // Create IOCP
        SYSTEM_INFO sysInfo;
        ZeroMemory(&sysInfo,sizeof(SYSTEM_INFO));
        GetSystemInfo(&sysInfo);
        g_ThreadCount = sysInfo.dwNumberOfProcessors + 1;
        g_hIOCP = CreateIoCompletionPort(INVALID_HANDLE_VALUE,NULL,0,g_ThreadCount);
        if (g_hIOCP == NULL) 
        {
            PUTLOG("CreateIoCompletionPort() Failed::Reason:: %u\n"
                    , GetLastError());
            return;            
        }

       if (CreateIoCompletionPort((HANDLE)g_ServerSocket,g_hIOCP,0,0) == NULL)
       {
            PUTLOG("Binding Server Socket to IO Completion Port Failed::Reason Code:: %u\n"
                    , GetLastError());
            return ;    
        }
    }

    {  //Create worker threads
        for( DWORD dwThread=0; dwThread < g_ThreadCount; dwThread++ )
        {
            HANDLE  hThread;
            DWORD   dwThreadId;

            hThread = CreateThread(NULL, 0, WorkerThread, 0, 0, &dwThreadId);
            CloseHandle(hThread);
        }
    }

    { 
        // accept new connection
        // Load the AcceptEx function into memory using WSAIoctl.
        // The WSAIoctl function is an extension of the ioctlsocket()
        // function that can use overlapped I/O. The function's 3rd
        // through 6th parameters are input and output buffers where
        // we pass the pointer to our AcceptEx function. This is used
        // so that we can call the AcceptEx function directly, rather
        // than refer to the Mswsock.lib library.
        GUID GuidAcceptEx = WSAID_ACCEPTEX;
        DWORD dwBytes = 0;
        int iResult = WSAIoctl(g_ServerSocket
            , SIO_GET_EXTENSION_FUNCTION_POINTER,
            &GuidAcceptEx, sizeof (GuidAcceptEx), 
            &g_lpfnAcceptEx, sizeof (g_lpfnAcceptEx), 
            &dwBytes, NULL, NULL);

        if (iResult == SOCKET_ERROR) {
            wprintf(L"WSAIoctl failed with error: %u\n", WSAGetLastError());
            closesocket(g_ServerSocket);
            WSACleanup();
            return ;
        }

        // 投递accept操作
        enum {
            nMaxAcceptRequest = 1,
        };
        IO_DATA * pIoData = new IO_DATA [nMaxAcceptRequest];
        memset(pIoData, 0, sizeof(IO_DATA)*nMaxAcceptRequest);

        for (int xReq = 0; xReq < nMaxAcceptRequest; xReq++)
        {
            if (!PostAcceptRequest(pIoData + xReq))
                break;
        } //END OF POST ACCEPT
    }
}

2， 3个投递函数，

2.a 投递accept请求

bool PostAcceptRequest(IO_DATA * pIoData)
{
    DWORD dwBytes = 0;
    // Create an accepting socket
    SOCKET AcceptSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    if (AcceptSocket == INVALID_SOCKET) 
    {
        PUTLOG("Create accept socket failed with error: %u\n"
                , WSAGetLastError());
        return false;
    }

    // Empty our overlapped structure and accept connections.
    memset(&pIoData->Overlapped, 0, sizeof(pIoData->Overlapped));

    pIoData->opCode = IO_ACCEPT;
    pIoData->activeSocket = AcceptSocket;

    BOOL bRetVal = g_lpfnAcceptEx(g_ServerSocket
        , AcceptSocket
        , pIoData->RecvBuffer
        , 0 //, sizeof(pIoData[nCocurrent].Buffer)
            //  -((sizeof(sockaddr_in)+16)*2)
        , sizeof (sockaddr_in) + 16
        , sizeof (sockaddr_in) + 16
        , &dwBytes
        , &pIoData->Overlapped);

    if (bRetVal == FALSE && GetLastError() != ERROR_IO_PENDING) 
    {
        PUTLOG("AcceptEx failed with error: %u\n"
                , WSAGetLastError());
        closesocket(AcceptSocket);
        return false;
    }

    // associate
    if (NULL == (CreateIoCompletionPort((HANDLE) AcceptSocket
                                        , g_hIOCP
                                        , (u_long) 0
                                        , 0))) 
    {
        PUTLOG("CreateIoCompletionPort associate failed with error: %u\n"
                , GetLastError());                
        closesocket(AcceptSocket);
        return false;
    }

    return true;
}

3.b 抛出recv请求 

bool PostRecvRequest(IO_DATA * const ioReq, SOCKET sockfd)
{
     IO_DATA * data = ioReq;
     data->activeSocket = sockfd;
     ZeroMemory(&data->Overlapped,sizeof(data->Overlapped));
     data->opCode = IO_OPERATION(IO_READ);
     data->wsabuf.buf  = data->RecvBuffer + data->dwRecved;
     data->dwRecvBufTail = sizeof(data->RecvBuffer);
     data->wsabuf.len  = data->dwRecvBufTail - data->dwRecved;

     DWORD dwRecvNumBytes=0;
     DWORD dwFlags=(MSG_PEEK & (~MSG_PEEK));

     int nRet = WSARecv(data->activeSocket
                     , &data->wsabuf
                     , 1
                     , &dwRecvNumBytes
                     , &dwFlags
                     , &data->Overlapped
                     , NULL);

     if(nRet == SOCKET_ERROR  && (ERROR_IO_PENDING != WSAGetLastError()))
     {
         PUTLOG("WASRecv Failed::Reason Code:: %u\n"
                , WSAGetLastError());
         return false;
     }

     return true;
}


3.c 抛出send请求

bool PostSendRequest(IO_DATA * const ioReq, SOCKET sockfd)
{
     IO_DATA * data = ioReq;
     data->activeSocket = sockfd;
     ZeroMemory(&data->Overlapped,sizeof(data->Overlapped));
     data->opCode = IO_OPERATION(IO_SEND);
     data->wsabuf.buf  = data->SendBuffer + data->dwSent;
     data->wsabuf.len  = data->dwSendBufTail - data->dwSent;

     DWORD dwSendNumBytes=0;
     DWORD dwFlags=(MSG_PEEK & (~MSG_PEEK));

     int nRet = WSASend(data->activeSocket
                     , &data->wsabuf
                     , 1
                     , &dwSendNumBytes
                     , dwFlags
                     , &data->Overlapped
                     , NULL);

     if(nRet == SOCKET_ERROR  && (ERROR_IO_PENDING != WSAGetLastError()))
     {
         PUTLOG("WSASend Failed::Reason Code:: %u\n"
                , WSAGetLastError());
         return false;
     }

     return true;
}

4，工作线程 

DWORD WINAPI WorkerThread (LPVOID WorkThreadContext) 
{
    for (;;) 
    {
        BOOL bSuccess = FALSE;
        DWORD dwIoSize = 0;
        void * lpCompletionKey = NULL;
        LPWSAOVERLAPPED lpOverlapped = NULL;
        bSuccess = GetQueuedCompletionStatus(g_hIOCP
                                            , &dwIoSize
                                            , (LPDWORD)&lpCompletionKey
                                            , (LPOVERLAPPED *)&lpOverlapped
                                            , INFINITE);

         if(!bSuccess)
         {
            PUTLOG("GetQueuedCompletionStatus() failed: %u\n",
                    GetLastError());
         }

         IO_DATA * lpIOContext = (IO_DATA *)lpOverlapped;

         // 新的套接字连接上来
         if(lpIOContext->opCode == IO_ACCEPT) // a read operation complete
         {
            // 更新AccpetEx返回的socket状态
            int ErrorCode= setsockopt(lpIOContext->activeSocket, 
                                    SOL_SOCKET,
                                    SO_UPDATE_ACCEPT_CONTEXT,
                                    (char*)&g_ServerSocket,
                                    sizeof(g_ServerSocket));

            // 提交读取请求
            IO_DATA * data = new IO_DATA;
            if (data)
            {
                PostRecvRequest(data, lpIOContext->activeSocket);   
            }
            else
            {
                closesocket(data->activeSocket); 
                data->activeSocket = INVALID_SOCKET;
                delete data;
            }

            // 提交一个新的accept
            PostAcceptRequest(lpIOContext);

            continue ;
         }
        
        if(dwIoSize == 0) //socket closed?
        {
            PUTLOG("Client Dis-connected.\n");
            closesocket(lpIOContext->activeSocket); 
            lpIOContext->activeSocket = INVALID_SOCKET;
            continue;
        }
        
        // 读取完毕
        if(lpIOContext->opCode == IO_READ)
        {
            // 重置超时
            lpIOContext->dwEnterTick = GetTickCount();

            // 累加总请求长度
            lpIOContext->dwRecved += dwIoSize;

            bool IsReqReady = true;
            // 
            // 如果数据包读取完毕
            // 开始处理
            // 处理完投递发送请求
            // 
            // ...
            if (IsReqReady)
            {
                lpIOContext->dwSent = 0;
                lpIOContext->dwSendBufTail = 0;

                memcpy(lpIOContext->SendBuffer + lpIOContext->dwSendBufTail
                        , "\r\n\r\nServerEcho: "
                        , 16);
                lpIOContext->dwSendBufTail += 16;

                memcpy(lpIOContext->SendBuffer + lpIOContext->dwSendBufTail
                    , lpIOContext->RecvBuffer
                    , lpIOContext->dwRecved);

                lpIOContext->dwSendBufTail += lpIOContext->dwRecved;

                memcpy(lpIOContext->SendBuffer + lpIOContext->dwSendBufTail
                    , "\r\n\r\n"
                    , 4);

                lpIOContext->dwSendBufTail += 4;

                PostSendRequest(lpIOContext, lpIOContext->activeSocket);
            }
            // 
            // 如果没有读取完毕
            // 继续投递读取请求
            //
            // ...
            else
            {
                PostRecvRequest(lpIOContext, lpIOContext->activeSocket);
            }
            continue ;
        }

        // 发送完毕
        if (lpIOContext->opCode == IO_SEND)
        {
            // 重置超时
            lpIOContext->dwEnterTick = GetTickCount();

            lpIOContext->dwSent += dwIoSize;

            bool IsRespReady 
                = (lpIOContext->dwSent == lpIOContext->dwSendBufTail);

            // 
            // 如果数据包发送完毕
            // 开始回话后处理
            // 处理完投递读取请求
            // 
            // ...
            if (IsRespReady)
            {
                lpIOContext->dwRecved = 0;
                lpIOContext->dwRecvBufTail = sizeof(lpIOContext->RecvBuffer);

                PostRecvRequest(lpIOContext, lpIOContext->activeSocket);
            }

            // 
            // 如果没有发送完毕
            // 继续投递发送请求
            //
            // ...
            else
            {
                PostSendRequest(lpIOContext, lpIOContext->activeSocket);
            }
            continue ;
        }
    }
    return 0;
}

5, 用一个main启动看看效果 

int main(int argc, char * argv [])
{
    ListenThread(NULL);
    
    PUTLOG("Press any key to quit server.");
    getchar();
    return 0;
}

输出：


=====================================================================

项目文件下载：

http://hi.youkuaiyun.com/attachment/201112/26/0_1324859981Zd6C.gif


C#高性能大容量SOCKET并发（一）：IOCP完成端口例子介绍
SQLDebug_Fan的专栏
01-22 6万+
例子主要包括SocketAsyncEventArgs通讯封装、服务端实现日志查看、SCOKET列表、上传、下载、远程文件流、吞吐量协议，用于测试SocketAsyncEventArgs的性能和压力，最大连接数支持65535个长连接，最高命令交互速度达到250MB/S（使用的是127.0.0.1的方式，相当于千兆网卡1Gb=125MB/S两倍的吞吐量）。服务端用C#编写，并使用log4net作为日志模块。
C# IOCP完成端口模型（简单实用高效）
12-31
C# IOCP完成端口模型（简单实用高效）
C#使用完成端口
xunmeng2002的专栏
07-20 1049
对IOCP主要做了几个函数的封装，PostConnect、PostAccept、PostSend、PostRecv、ConnectCompleted、AcceptCompleted、SendCompleted、RecvCompleted。最近在做一个C#的项目，需要作为Tcp的Server端来工作，于是研究了一下C#下面的完成端口用法，做了一些简单的封装。这里仅列出一些基础代码，全部的代码可以在。Client与Server的定义就比较简单了。此外还有一些参数设置的细节。...............
C#高性能大容量SOCKET并发完成端口例子IOCPDemo_NET_V4
12-09
C#高性能大容量SOCKET并发完成端口例子IOCPDemo_NET_V4
完成端口（IOCP) 服务器源码
06-09
Windows下IOCP模型 socket服务器端实例 1. 创建服务器socket， 并将socket设置为非阻塞模式 2. bind()绑定IP地此与端口 3. listen() 4. 创建IO完成端口，将socket绑定到IO完成端口上 5. 根据当前机器CPU个数创建工作...
windows socket网络编程之iocp完成端口模型的例子
04-17
总结来说，IOCP完成端口模型是Windows平台上进行高效并发网络编程的关键技术之一，它能够优雅地处理大量并发I/O操作，确保服务的稳定性和性能。通过阅读提供的文件和代码示例，可以更深入地理解并掌握这一技术。
商业编程-源码-IOCP完成端口模型示例代码.zip
06-21
在IT行业中，完成端口（IOCP，Input/Output Completion Port）是一种高效的多线程并发I/O模型，常用于Windows操作系统中的网络编程。这个压缩包文件"商业编程-源码-IOCP完成端口模型示例代码.zip"包含了关于如何使用...
vc以IOCP完成端口方式实现网络数据传输 iocp服务器+客户端.zip
04-18
Socket是网络通信的基础，而在IOCP模型中，我们可以将socket与完成端口关联起来。这样，socket上的所有读写操作都会通过完成端口返回结果，而非阻塞在调用上。 4. Server端实现： - 同步Accept：描述中提到服务器...
网络编程 完成端口模型
weixin_62859191的博客
12-30 1205
网络编程 完成端口模型
对于I/O完成端口机制我的理解
废弃blog
03-27 3429
研究了大概1天多的完成端口的文章、代码，刨了一下MSDN大概弄清楚了这个机制是怎么一回事。I/O完成端口是WinNT下的一个机制，看起来像是一个FIFO的消息队列。举个例子说，例如一个Winsock做的服务器（看作是工厂），主线程建立了一个完成端口（可以看作是一个流水线），然后建立了几个线程，几个线程同时用GetCompletionPortStatus()函数获取完成信息并阻塞自身（可以把线程看作
C#实现IOCP(完成端口)的详细代码示例
weixin_30657999的博客
06-23 236
C#实现IOCP(完成端口)的详细代码如下： using System; using System.Threading; // Included for the Thread.Sleep call using Continuum.Threading; namespace Sample { //=========================================...
c# 完成端口模型IOCP 网络NETWORK TCP/UDP通信 常用 字节byte环绕缓冲区 FIFO 内存池 源码
RainsSoft
11-03 2450
接受到的数据,使用环绕缓冲区来解决粘包和半包的处理 /// /// 接受到的数据,使用环绕缓冲区来解决粘包和半包的处理 /// [MultiThreadedSupport( "zh-CHS", "当前的类所有成员都可锁定,支持多线程操作" )] public class ReceiveQueue { #region zh-CHS
C# 完成端口组件实现
zhuweisky
07-01 6935
前面用C++实现了windows平台上的网络完成端口组件，那么到C#中如何做了？起初我打算通过PInvoke来调用win底层API来仿照C++实现，但问题很快就出来了－－C#中的Unsafe指针无法稳定的指向一块缓冲区的首地址，也就是说当垃圾回收进行的时候，我们的unsafe指针的值可能已经无效了。用pin？我也想过，可是锁住所有的TCP接收缓冲区，会极大的降低运行时的效率。难道没有办法了吗？想想
UDP完成端口 IOCP 示例与优化
使用完成端口可以创建一个异步的、非阻塞的事件驱动模型，以保持高效率和低延迟。 5. 代码优化：演示项目中提到对代码进行了优化，移除了不必要的二进制文件，这可能意味着项目更专注于实现核心功能，提高效率和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值