🐬 👩🏼‍🚒 🏈 विंडोज सॉकेट्स, IOCP, और डेल्फी 🤭 ♎️ 🧙🏼

प्रस्तावना

हाल ही में, मुझे विंडोज एप्लिकेशन में सॉकेट्स के साथ प्रभावी ढंग से काम करने की आवश्यकता का सामना करना पड़ा। कार्य व्यस्त सर्वर के लिए विशिष्ट है। केवल कार्यान्वयन की भाषा, डेल्फी, यहाँ असामान्य प्रतीत होगी।
मैं आई / ओ कम्प्लीशन पोर्ट का उपयोग करके बड़ी संख्या में सॉकेट्स के साथ बड़े पैमाने पर अतुल्यकालिक काम का वर्णन करना चाहता हूं। Microsoft अपने साहित्य में इस तकनीक का उपयोग करने की सलाह देता है। मुझे लगता है कि बहुत से लोग इससे परिचित हैं, लेकिन सिर्फ मामले में, मैं MSDN के लिंक को इंगित करूंगा। प्रौद्योगिकी का सार यह है कि सिस्टम घटनाओं की एक अत्यधिक कुशल कतार का आयोजन करता है, और कार्यक्रम इसे थ्रेड पूल से संसाधित करता है, जिसका आकार कंप्यूटिंग कोर की संख्या द्वारा चुना जाता है। इस दृष्टिकोण के विभिन्न एंडपॉइंट के लिए एक साथ प्रदर्शन किए गए अतुल्यकालिक इनपुट-आउटपुट संचालन की एक बड़ी संख्या के साथ फायदे हैं। तैयार स्रोत तुरंत (बेहतर) यहां देख सकता है । सब कुछ सही नहीं है, लेकिन प्रयोगों के लिए यह करेगा।

रोडमैप

मैं, एक तरह से, वस्तुओं और इनपुट-आउटपुट संचालन के संगठन से संबंधित हर चीज में Node.Js की विचारधारा का पालन करूंगा।
सर्वर साइड के मामले में, आपको निम्नलिखित को लागू करने की आवश्यकता होगी:

एक सॉकेट सुन रहा है। नए यौगिकों की स्वीकृति या अस्वीकृति।
ट्रैकिंग क्लाइंट सॉकेट क्लोज सिग्नल।

क्लाइंट के लिए, इस सूची में पहला आइटम प्रासंगिक नहीं है, लेकिन आपको सर्वर के लिए एक एसिंक्रोनस कनेक्शन लागू करना होगा। दोनों वर्गों में एक ही बिंदु पर एक साथ पढ़ने और लिखने की क्षमता होगी।
सभी बनाए गए क्लाइंट और सर्वर सॉकेट इंस्टेंस एक सामान्य संदेश कतार और एक थ्रेड पूल का उपयोग करेंगे। यह एक ही तरीके से एक आवेदन में दोनों प्रकार के सॉकेट्स का उपयोग करने में सक्षम होना आवश्यक है।

कार्यान्वयन

चलिए शुरू करते हैं। शुरू करने के लिए, मैं ध्यान देता हूं कि निर्माण के बिल्कुल अतुल्यकालिक घटना मॉडल के संबंध में, मैं कक्षाएं नहीं बल्कि इंटरफेस को लागू करूंगा। यह इस मामले में बहुत सुविधाजनक है, क्योंकि आवंटित मेमोरी की जिम्मेदारी अंतिम प्रोग्रामर से हटा दी जाती है। वैसे भी, यहां इसके उपयोग को दूसरे तरीके से ट्रैक करना या तो बहुत महंगा है या पूरी तरह से असंभव है। मॉड्यूल आरंभीकरण के दौरान बहुत सारे काम होने चाहिए।

विभिन्न प्रकार के सॉकेट्स की सूची बनाना।
सॉकेट सबसिस्टम का प्रारंभ।
एक संदेश कतार बनाएँ।
कतार को संसाधित करने के लिए एक पूल बनाना।
सॉकेट्स के लिए ईवेंट बनाना।
सॉकेट घटनाओं की निगरानी करने वाली धाराएं बनाना (उदाहरण के लिए, एक नया क्लाइंट कनेक्ट करना)।

और इसलिए, आरंभीकरण अनुभाग में निम्नलिखित प्रक्रिया होती है, जो सूची बिंदु को बिंदु से लागू करती है।

procedure Init; var WSAData: TWsaData; i: Integer; begin gClients := TProtoStore.Create; gListeners := TProtoStore.Create; gServerClients := TProtoStore.Create; if WSAStartup(MAKEWORD(2, 2), WSAData) <> 0 then raise IOCPClientException.Create(sErrorInit_WSAtartup); gIOCP := CreateIoCompletionPort(INVALID_HANDLE_VALUE, 0, 0, CPUCount * 2); if gIOCP = INVALID_HANDLE_VALUE then raise IOCPClientException.Create(sErrorInit_CreateIoCompletionPort); for i := 1 to CPUCount * 2 do begin SetLength(gWorkers, Length(gWorkers) + 1); gWorkers[Length(gWorkers) - 1] := TWorkerThread.Create(); end; gListenerAcceptEvent := WSACreateEvent; if gListenerAcceptEvent = WSA_INVALID_EVENT then raise IOCPClientException.Create(sErrorInit_WSACreateEvent); gServerClientsCloseEvent := WSACreateEvent; if gServerClientsCloseEvent = WSA_INVALID_EVENT then raise IOCPClientException.Create(sErrorInit_WSACreateEvent); gClisentsConnectAndCloseEvents := WSACreateEvent; if gClisentsConnectAndCloseEvents = WSA_INVALID_EVENT then raise IOCPClientException.Create(sErrorInit_WSACreateEvent); gClientSocketEventThread := TSocketEventThread.Create (gClisentsConnectAndCloseEvents, gClients, ET_EVENT_SIGNALED); gClientSocketEventThread.Start; gServerClientsSocketEventThread := TSocketEventThread.Create (gServerClientsCloseEvent, gServerClients, ET_EVENT_SIGNALED); gServerClientsSocketEventThread.Start; gServerSocketEventThread := TSocketEventThread.Create(gListenerAcceptEvent, gListeners, ET_EVENT_SIGNALED); gServerSocketEventThread.Start; end;

इस मामले में CreateIoCompletionPort फ़ंक्शन एक विशेष संदेश कतार बनाता है।
आप देख सकते हैं कि एक ही TSocketEventThread स्ट्रीम क्लास का उपयोग विभिन्न उद्देश्यों के साथ सॉकेट्स पर घटनाओं को ट्रैक करने के लिए किया जाता है। इस वर्ग की धाराएँ एक ऐसी प्रक्रिया को निष्पादित करती हैं जो सॉकेट घटनाओं की अपेक्षा करती है, और किसी घटना की घटना के बारे में तुरंत संदेश (प्रत्येक सॉकेट के लिए जो यह धारा कार्य करती है) के लिए कतारबद्ध संदेश देती है।

 procedure TSocketEventThread.WaitForClientsEvents; var WaitResult: DWORD; const TimeOut: DWORD = 100; begin WaitResult := WSAWaitForMultipleEvents(1, @fEvent, FALSE, TimeOut, FALSE); if WaitResult = WSA_WAIT_FAILED then raise IOCPClientException.Create (sErrorWaitForClientsEvents_WSAWaitForMultipleEvents); if WaitResult = WSA_WAIT_EVENT_0 then begin if not WSAResetEvent(fEvent) then raise IOCPClientException.Create (sErrorWaitForClientsEvents_WSAResetEvent); fStore.Post(fKey); end; end;

यहाँ विधि fStore.Post (fKey) है; यह कतार को संदेश भी भेजता है।

 procedure TProtoStore.Post(CompletionKey: DWORD); var i: Integer; begin fLock.Enter; try for i := 0 to Length(ProtoArray) - 1 do begin ProtoArray[i]._AddRef; if not PostQueuedCompletionStatus(gIOCP, 0, CompletionKey, POverlapped(ProtoArray[i])) then begin ProtoArray[i]._Release; raise IOCPClientException.Create(sErrorPost_PostQueuedCompletionStatus); end; end; finally fLock.Leave; end; end;

विशेष रूप से नोट इंटरफेस के साथ वस्तुओं का उपयोग है।
_AddRef पद्धति का उपयोग यह इंगित करने के लिए किया जाता है कि ऑब्जेक्ट "कतार में" है और इसे नष्ट नहीं किया जाना चाहिए। (बाद में, प्रसंस्करण के बाद, _Release कहा जाएगा)। PostQueuedCompletionStatus प्रक्रिया सीधे संदेश को कतारबद्ध करती है।
पूल प्रत्येक संदेश को अतुल्यकालिक रूप से संसाधित करेगा।
ऐसा करने के लिए, वह निम्नलिखित प्रक्रिया करता है।

 procedure TWorkerThread.ProcessIOCP; var NumberOfBytes: DWORD; CompletionKey: NativeUInt; Overlapped: POverlapped; Proto: TIOCPSocketProto; begin if not((not GetQueuedCompletionStatus(gIOCP, NumberOfBytes, CompletionKey, Overlapped, INFINITE)) and (Overlapped = nil)) then begin if CompletionKey = ET_EVENT_SIGNALED then begin Proto := TIOCPSocketProto(Overlapped); with Proto do begin IOCPProcessEventsProc(); _Release; end end else if CompletionKey <> 0 then begin Proto := TIOCPSocketProto(CompletionKey); if Proto.IOCPProcessIOProc(NumberOfBytes, Overlapped) then Proto._Release; end; end end;

GetQueuedCompletionStatus प्रक्रिया का उपयोग कतार से संदेश प्राप्त करने के लिए किया जाता है। अगला, यह निर्धारित किया जाता है कि क्या यह संदेश पूर्ण इनपुट / आउटपुट के बारे में एक संदेश है या किसी घटना के बारे में यह संदेश है। कतार के माध्यम से कुछ जानकारी पारित करने के लिए दो तरीके यहां दिखाए गए हैं, इस मामले में सॉकेट क्लास के एक विशिष्ट उदाहरण के लिए एक लिंक।
प्रसंस्करण सभी प्रकार के सॉकेट्स के लिए एकीकृत है, यह एक सामान्य पूर्वज से विरासत का उपयोग करके प्राप्त किया जाता है जिसमें आम हैंडलर होते हैं, उनके पुनर्वित्त की अनुमति है।
सॉकेट घटनाओं के प्रसंस्करण के लिए तंत्र पर विचार करें।

 procedure TIOCPSocketProto.IOCPProcessEventsProc(); var WSAEvents: TWsaNetworkEvents; AcceptedSocket: TSocket; RemoteAddress: string; begin if fStateLock <> CLI_SOCKET_LOCK_CLOSED then begin fClosingLock.BeginRead; try if (fStateLock <> CLI_SOCKET_LOCK_CLOSED) then if WSAEnumNetworkEvents(fSocket, 0, WSAEvents) <> SOCKET_ERROR then begin if ((WSAEvents.lNetworkEvents and FD_CONNECT) <> 0) then begin if 0 = WSAEvents.iErrorCode[FD_CONNECT_BIT] then InterlockedExchange(fStateLock, CLI_SOCKET_LOCK_CONNECTED); CallOnConnect; end; if ((WSAEvents.lNetworkEvents and FD_CLOSE) <> 0) and (0 = WSAEvents.iErrorCode[FD_CLOSE_BIT]) then CallOnClose; if ((WSAEvents.lNetworkEvents and FD_ACCEPT) <> 0) and (0 = WSAEvents.iErrorCode[FD_ACCEPT_BIT]) then begin AcceptedSocket := DoAccept(RemoteAddress); if AcceptedSocket <> INVALID_SOCKET then begin fClientClass.Create(AcceptedSocket, fOnConnect, fOnClose, RemoteAddress).Prepare; end; end; end finally fClosingLock.EndRead; end; end; end;

TMultiReadExclusiveWriteSynchronizer वर्ग दिलचस्प तरीके से यहां लागू किया गया है। इसका उपयोग सॉकेट को बंद करने और पूल में किसी अन्य धागे से ऑब्जेक्ट को नष्ट करने के प्रयासों को रोकने के लिए किया जाता है (fClosingLock.BeginRead)। सॉकेट के साथ सभी संचालन इस सिंक्रनाइज़ेशन ऑब्जेक्ट के लिए रीड ऑपरेशन के रूप में किए जाते हैं, सॉकेट के निर्माण और समापन संचालन को छोड़कर - वे ऑपरेशन लिखते हैं और इसलिए संसाधन के अनन्य स्वामित्व के साथ ही प्रदर्शन किया जा सकता है।
अन्य सभी मामलों में, इस प्रक्रिया में सॉकेट्स के साथ काम करना पूरी तरह से सामान्य है।
इस प्रक्रिया में विचार करने योग्य एकमात्र चीज एक नए क्लाइंट को सर्वर, DoAccept विधि से जोड़ रही है।

 function TIOCPSocketProto.DoAccept(var RemoteAddress: string): TSocket; var addr: TSockAddr; addrlen: Integer; dwCallbackData: NativeUInt; RemoteAddrLen: DWORD; begin dwCallbackData := NativeUInt(self); addrlen := SizeOf(addr); Result := WSAAccept(fSocket, @addr, @addrlen, ServerAcceptCallBack, dwCallbackData); if Result <> INVALID_SOCKET then begin SetLength(RemoteAddress, 255); RemoteAddrLen := Length(RemoteAddress); if WSAAddressToString(addr, addrlen, nil, PChar(@RemoteAddress[1]), RemoteAddrLen) = SOCKET_ERROR then raise IOCPClientException.Create(sErrorAccept_WSAAddressToString); SetLength(RemoteAddress, RemoteAddrLen - 1) end end;

यहाँ मुख्य बिंदु WSAAccept का उपयोग करना है। यह फ़ंक्शन आपको क्लाइंट कनेक्शन को अस्वीकार करने की अनुमति देता है ताकि क्लाइंट वास्तव में FD_CONNECT ईवेंट प्राप्त करे।
तथाकथित कालाकारों को संगठित करने का यह पसंदीदा तरीका है।
हम और आगे बढ़ें। इनपुट आउटपुट के संगठन पर विचार करें। हम उदाहरण के रूप में रीड ऑपरेशन का उपयोग करके ऐसा करेंगे।

 procedure TIOCPSocketProto.Read(Length: DWORD; OnRead, OnReadProcess: TOnReadEvent); var Bytes, Flags: DWORD; WsaBuf: TWsaBuf; begin fClosingLock.BeginRead; try if fStateLock = CLI_SOCKET_LOCK_CONNECTED then begin if InterlockedCompareExchange(fReadLock, IO_PROCESS, IO_IDLE) = IO_IDLE then begin fOnRead := OnRead; fOnReadProcess := OnReadProcess; fReaded := 0; fReadBufLength := Length; fReadBuffer := nil; GetMem(fReadBuffer, Length); if fReadBuffer <> nil then begin Bytes := 0; FillChar(fOverlappedRead, SizeOf(fOverlappedRead), 0); WsaBuf.buf := fReadBuffer; WsaBuf.len := fReadBufLength; Flags := 0; Bytes := 0; _AddRef; if (WSARecv(fSocket, @WsaBuf, 1, Bytes, Flags, @fOverlappedRead, nil) = SOCKET_ERROR) and (WSAGetLastError <> WSA_IO_PENDING) then begin FreeMem(fReadBuffer, Length); InterlockedExchange(fReadLock, IO_IDLE); _Release; raise IOCPClientException.Create(sErrorRead_WSARecv); end; end else raise IOCPClientException.Create(sErrorRead_GetMem); end else raise IOCPClientException.Create(sErrorRead_InProcess); end else raise IOCPClientException.Create(sErrorRead_NotConnected); finally fClosingLock.EndRead; end; end;

यहाँ मुझे इंटरलॉकिंग लॉकिंग का उपयोग करना पड़ा, क्योंकि यह बहुत तेज़ है और I / O विकल्प को वापस बुलाने के प्रयास में कटौती करने की आवश्यकता को संतुष्ट करता है। मेमोरी को प्रत्येक ऑपरेशन में एक बार बफर के तहत आवंटित किया जाता है। अगला, एसिंक्रोनस मोड में सॉकेट से पढ़ना कहा जाता है। ऑब्जेक्ट को AddRef के साथ "चिह्नित" भी किया जाता है, ताकि कतार में रहते हुए उसे हटा दिया जा सके। पैकेट पढ़ने के पूरा होने पर, इस बारे में संदेश स्वचालित रूप से पंक्तिबद्ध हो जाते हैं।
विचार करें कि क्या होता है जब पूरा इनपुट / आउटपुट के बारे में एक संदेश कतार से चुना जाता है।

 function TIOCPSocketProto.IOCPProcessIOProc(NumberOfBytes: DWORD; Overlapped: POverlapped): Boolean; var Bytes, Flags: DWORD; WsaBuf: TWsaBuf; begin Result := FALSE; fClosingLock.BeginRead; try if Overlapped = @fOverlappedRead then begin if NumberOfBytes <> 0 then begin if fReadLock = IO_PROCESS then begin inc(fReaded, NumberOfBytes); if fReaded < fReadBufLength then begin CallOnReadProcess; WsaBuf.buf := fReadBuffer; inc(WsaBuf.buf, fReaded); WsaBuf.len := fReadBufLength; dec(WsaBuf.len, fReaded); Flags := 0; Bytes := 0; if (WSARecv(fSocket, @WsaBuf, 1, Bytes, Flags, @fOverlappedRead, nil) = SOCKET_ERROR) and (WSAGetLastError <> WSA_IO_PENDING) then begin CallOnRead; Result := True; end end else begin CallOnReadProcess; CallOnRead; Result := True; end; end end else begin CallOnRead; Result := True; end; end else if Overlapped = @fOverlappedWrite then begin if NumberOfBytes <> 0 then begin if fWriteLock = IO_PROCESS then begin inc(fWrited, NumberOfBytes); if fWrited < fWriteBufLength then begin CallOnWriteProcess; WsaBuf.buf := fWriteBuffer; inc(WsaBuf.buf, fWrited); WsaBuf.len := fWriteBufLength; dec(WsaBuf.len, fWrited); Flags := 0; Bytes := 0; if (WSASend(fSocket, @WsaBuf, 1, Bytes, Flags, @fOverlappedWrite, nil) = SOCKET_ERROR) and (WSAGetLastError <> WSA_IO_PENDING) then begin CallOnWrite; Result := True; end end else begin CallOnWriteProcess; CallOnWrite; Result := True; end; end end else begin CallOnWrite; Result := True; end; end finally fClosingLock.EndRead; end; end;

इस प्रक्रिया का सार यह है कि यह उस समय तक सॉकेट में पढ़ने या लिखने का कारण बनता है जब आवंटित बफर भरा नहीं है। इस मामले में एक दिलचस्प बिंदु ओवरलैड संरचना के संदर्भ में ऑपरेशन के प्रकार का निर्धारण है। यह लिंक कतार द्वारा प्रदान किया गया है और इसकी केवल कक्षा के संबंधित क्षेत्रों के साथ तुलना करना आवश्यक है जिसमें पढ़ने और लिखने के लिए संरचनाएं संग्रहीत हैं।
यह भी उल्लेखनीय है कि यदि रीड / राइट ऑपरेशन तुरंत किया गया था, तो यह अभी भी कतार में आ जाता है, हालाँकि इसे एपी के माध्यम से कॉन्फ़िगर किया जा सकता है।
यह सॉकेट क्लास बनाने और कतार बनाने पर भी विचार करने योग्य है।

 constructor TIOCPClientSocket.Create(RemoteAddress: string; OnConnect, OnClose: TOnSimpleSocketEvenet); var lRemoteAddress: TSockAddr; lRemoteAddressLength: Integer; begin inherited Create(); fStore := gClients; fOnConnect := OnConnect; fOnClose := OnClose; fStateLock := 0; fRemoteAddressStr := RemoteAddress; fSocket := WSASocket(AF_INET, SOCK_STREAM, 0, nil, 0, WSA_FLAG_OVERLAPPED); if fSocket = INVALID_SOCKET then raise IOCPClientException.Create(sErrorTIOCPClientSocket_WSASocket); if (WSAEventSelect(fSocket, gClisentsConnectAndCloseEvents, FD_CONNECT or FD_CLOSE) = SOCKET_ERROR) then raise IOCPClientException.Create(sErrorTIOCPClientSocket_WSAEventSelect); if CreateIoCompletionPort(fSocket, gIOCP, NativeUInt(self), 0) = 0 then raise IOCPClientException.Create (sErrorTIOCPClientSocket_CreateIoCompletionPort); fStateLock := CLI_SOCKET_LOCK_CREATED; fStore.Add(self); lRemoteAddressLength := SizeOf(lRemoteAddress); lRemoteAddress.sa_family := AF_INET; if WSAStringToAddress(PChar(@fRemoteAddressStr[1]), AF_INET, nil, lRemoteAddress, lRemoteAddressLength) = SOCKET_ERROR then raise IOCPClientException.Create (sErrorTIOCPClientSocket_WSAStringToAddress); if (WSAConnect(fSocket, lRemoteAddress, lRemoteAddressLength, nil, nil, nil, nil) = SOCKET_ERROR) and (WSAGetLastError <> WSAEWOULDBLOCK) then raise IOCPClientException.Create(sErrorTIOCPClientSocket_WSAConnect); end;

क्लाइंट सॉकेट कंस्ट्रक्टर में, सॉकेट (WSASocket) को तुरंत बनाया जाता है, जो कतार (CreateIoCompletionPort) में पंजीकृत होता है, जो ईवेंट से जुड़ा होता है, और एसिंक्रोनस कनेक्शन फ़ंक्शन (WSAConnect) को कॉल करता है। कनेक्शन का तथ्य उस धारा में अपेक्षित है जिसे पहले माना गया था (सॉकेट्स में घटनाओं की प्रतीक्षा की धारा)। यह बदले में इस घटना को कतार में खड़ा करेगा।

उपसंहार

यह आलेख संक्षेप में, मेरी राय में, इवेंट प्रोग्रामिंग के लिए कक्षाएं बनाने की सफल तकनीकों पर चर्चा करता है।
मैं डेल्फी के लिए सॉकेट्स के साथ उच्च प्रदर्शन वाले काम के लिए एक वर्ग बनाने में कामयाब रहा। यह विषय आम तौर पर बेहद खराब तरीके से कवर किया जाता है और IOCP (क्रिप्टोग्राफिक प्रदाताओं और Winsock Secure Socket Extensions) का उपयोग करके इंटरफेस का उपयोग करके और सुरक्षित कनेक्शन बनाने के विषय पर एक और 2 - 3 पदों के साथ इस प्रकाशन को जारी रखने की मेरी योजना है। पूरा उदाहरण कोड यहाँ है ।

विंडोज सॉकेट्स, IOCP, और डेल्फी

प्रस्तावना

रोडमैप

कार्यान्वयन

उपसंहार

More articles: