पाठकों का प्रभावी कार्यान्वयन - "इंटरलेक्लेबल वैरिएबल एक्सेस" पर आधारित लेखक लॉक

प्रविष्टि

जिस परियोजना में मैं काम करता हूं, उसकी बारीकियां ऐसी हैं, जिसमें एक तरफ, थर्ड-पार्टी लाइब्रेरी के उपयोग की अनुमति नहीं है (कुछ अपवादों के साथ), और दूसरी तरफ, बहुत गहरे कोड अनुकूलन पर जोर दिया गया है। इसलिए आपको अक्सर पहिया को अपने स्वयं के कार्यान्वयन के रूप में सुदृढ़ करना होगा।

इस प्रकाशन के दौरान, मैं तथाकथित परमाणु लेखकों के आधार पर प्रसिद्ध पाठक-लेखक लॉक सिंक्रोनाइज़ेशन आदिम लागू करने के विचार को साझा करना चाहता हूं। जैसा कि आप जानते हैं, पाठकों-लेखक लॉक को एक साझा संसाधन तक पहुंच को सिंक्रनाइज़ करने की समस्या को इस तरह से हल करने के लिए डिज़ाइन किया गया है कि एक साथ पढ़ने और लिखने से बचें, लेकिन साथ ही साथ एक मनमाने ढंग से बड़ी संख्या में थ्रेड्स के समानांतर पढ़ने की अनुमति देने के लिए।

समाधान के लिए खोजें

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

कार्यान्वयन

परियोजना को QNX सिस्टम (जो उत्पाद वास्तव में उन्मुख है) और विंडोज (इम्यूलेशन, डीबगिंग, आदि) के लिए समर्थन की आवश्यकता है। चूंकि दूसरा बहुत अधिक लोकप्रिय है, इसलिए मैं विशेष रूप से इसके लिए C ++ कार्यान्वयन दे दूंगा। हालाँकि, मैं POSIX में पोर्टिंग के एक पल पर ध्यान केन्द्रित करूँगा। तो:

क्लास खाली

class CRwLock { public: CRwLock(); void readLock(); void writeLock(); void readUnlock(); void writeUnlock(); private: static const LONG WRITER_BIT = 1L << (sizeof(LONG) * 8 - 2); LONG mWriterReaders; }; 

कार्यों के एक सेट के साथ, सब कुछ स्पष्ट है और मेरी राय में टिप्पणियों की आवश्यकता नहीं है। चलो mWriterReaders वर्ग के एक एकल क्षेत्र के बारे में बात करते हैं:

• अंतिम गैर-साइन बिट एक एकल "लेखक" की उपस्थिति के संकेत के तहत दिया गया है और इसे तब सेट किया जाना चाहिए जब वह संसाधन का मालिक हो। दरअसल, इसके साथ काम करने के लिए, निरंतर WRITER_BIT
• बाकी का उपयोग 30-बिट प्राइम पूर्णांक के रूप में किया जाएगा। वे संसाधन पढ़ने वाले थ्रेड्स की संख्या रिकॉर्ड करेंगे (यदि "लेखक" बिट सेट नहीं है) या पढ़ने के लिए इंतजार कर रहे हैं (जब क्रमशः "लेखक" बिट एक साथ सेट किया जाता है)।

क्लास कंस्ट्रक्टर

 CRwLock::CRwLock() : mWriterReaders(0) { } 

यह एकमात्र कार्य को पूरा करने के लिए कहा जाता है - संसाधन के मालिक किसी की अनुपस्थिति के लिए प्रारंभिक राज्य को स्थापित करने के लिए, या, और अधिक सरल रूप से, सभी बिट्स को 0 पर रीसेट करना।

ताला पढ़ें

जैसा कि आपने शायद अनुमान लगाया था, मैं अपने लक्ष्य को प्राप्त करने के लिए एक पूर्णांक चर पर परमाणु संचालन का उपयोग करने जा रहा हूं।

 void CRwLock::readLock() { if(::InterlockedExchangeAdd(&mWriterReaders, 1) >= WRITER_BIT) { while(::InterlockedCompareExchange(&mWriterReaders, 0, 0) >= WRITER_BIT) { Sleep(0); } } } 

इनपुट पर, हम तुरंत अपने आप को पाठकों के साथ जोड़ते हैं और एक ही समय में जांचते हैं कि क्या कोई रिकॉर्डिंग है (यह ऐसा है यदि लेखन स्ट्रीम का बिट सेट है, और इसलिए संख्या स्वयं इस मान से अधिक या बराबर है)। यदि ऐसा है, तो हमें बाकी के साथ-साथ लिखने के संचालन की समाप्ति की प्रतीक्षा करनी चाहिए। ऐसा करने के लिए, मैंने स्पिन लॉक विकल्प चुना, जिसके दौरान उसी "लेखक" बिट की जाँच की जाती है और जैसे ही इसे रीसेट किया जाता है, हर कोई जो पढ़ने के लिए इंतजार कर रहा है, उसे एक्सेस मिल जाता है (यह कार्यान्वयन थ्रेड को पढ़ने के लिए प्राथमिकता देता है, लेकिन उस पर बाद में और अधिक)।

यहां मैं तथाकथित व्यस्त प्रतीक्षा के सवाल पर ध्यान देना चाहूंगा, जब प्रतीक्षा धागा सक्रिय रूप से सीपीयू संसाधनों का उपभोग कर रहा है। इस मामले में, मैंने स्लीप (0) अनुदेश को जोड़कर समझौता किया, जो आवंटित प्रक्रिया से शेष समय को अनुसूचक को स्थानांतरित करता है, जो इसे अपनी प्राथमिकता के आधार पर अन्य थ्रेड्स को जारी कर सकता है। दूसरे शब्दों में, समय बेकार नहीं जला है, लेकिन इसका अच्छा उपयोग किया जा सकता है। दूसरी ओर, झंडे की स्थिति में परिवर्तन की प्रतीक्षा की धारा से प्रतिक्रिया की गंभीरता को सुस्त कर दिया जाता है, जो कि थ्रेड्स के लोहे के मेरे विन्यास और उनके द्वारा किए गए संचालन के मामले में परीक्षण कार्यक्रम के संचालन समय में लगभग 10% की वृद्धि हुई। लेकिन किसी भी मामले में आपको यह नहीं भूलना चाहिए कि सिस्टम पूरी तरह से नि: शुल्क सीपीयू के साथ अपने निपटान में जीतता है।

POSIX के मामले में, आप स्लीप (0) के बजाय शेड्यूल_इल्ड का उपयोग कर सकते हैं

लॉक लिखो

 void CRwLock::writeLock() { while(::InterlockedCompareExchange(&mWriterReaders, WRITER_BIT, 0) != 0) { Sleep(0); } } 

जिस धागे को लिखने की जरूरत है, वह तब तक इंतजार करना चाहिए जब तक कि हर कोई संसाधन (पूर्ण शून्य) जारी न करे और उसके बाद ही वह पाठक के लिए खुद को स्थापित करे। इसलिए पाठकों की प्राथमिकता - यहां तक ​​कि जब वे मौजूदा रिकॉर्डिंग स्ट्रीम के साथ स्टैंडबाय राज्य में स्विच करते हैं, तो उन्हें अग्रिम में उसी अवरुद्ध "लेखकों" पर प्राथमिकता देने की गारंटी दी जाती है।

अनलॉकिंग

 void CRwLock::readUnlock() { ::InterlockedExchangeAdd(&mWriterReaders, -1); } void CRwLock::writeUnlock() { ::InterlockedExchangeAdd(&mWriterReaders, -WRITER_BIT); } 

लेखन के मामले में बिट को पढ़ने और रीसेट करने के मामले में एक साधारण गिरावट।

एक आफ्टरवर्ड के बजाय

मैं यह कहना चाहता हूं कि मेरे मामले में मुझे महत्वपूर्ण खंडों के उपयोग की तुलना में एक अच्छा प्रदर्शन परिणाम मिला, जो इस मामले में अनुमानित रूप से व्यवहार करता है जब लेखन और पढ़ने की धाराओं में अनुपात बदलता है।

मुझे आपकी आलोचना और टिप्पणियों पर खुशी होगी।