😧 🧑🏽‍🤝‍🧑🏽 🗯️ रूबी में जीआईएल कैसे काम करता है। भाग २ 🤦🏽 🤺 🤱🏼

पिछली बार, मैंने जीआईएल कार्यान्वयन को समझने और शेष सवालों के जवाब देने के लिए एमआरआई कोड देखने का सुझाव दिया था। आज हम क्या करेंगे।

इस लेख का मसौदा संस्करण सी कोड के बिट्स के साथ भरा गया था, हालांकि, इस वजह से, विवरण में सार खो गया था। अंतिम संस्करण में लगभग कोई कोड नहीं है, लेकिन उन लोगों के लिए जो स्रोत में खुदाई करना पसंद करते हैं, मैंने उन कार्यों के लिंक को छोड़ दिया, जिनका मैंने उल्लेख किया था।

पिछली श्रृंखला में

पहले भाग के बाद, दो प्रश्न बने रहे:

क्या एक GIL array << nil परमाणु ऑपरेशन करता है?
क्या GIL रूबी कोड थ्रेड को सुरक्षित बनाता है?

आप कार्यान्वयन को देखकर पहले प्रश्न का उत्तर दे सकते हैं, तो चलिए इसके साथ शुरू करते हैं।

पिछली बार, हमने निम्नलिखित कोड का पता लगाया था:

 array = [] 5.times.map do Thread.new do 1000.times do array << nil end end end.each(&:join) puts array.size

सरणी को थ्रेड सुरक्षित माना जाता है, यह अपेक्षा करना तर्कसंगत है कि परिणामस्वरूप हमें पांच हजार तत्वों के साथ एक सरणी मिलती है। चूंकि सरणी वास्तव में थ्रेड सुरक्षित नहीं है, जब आप JRuby या Rubinius कोड चलाते हैं, तो आपको अपेक्षा से अलग परिणाम मिलता है (पांच हजार से कम तत्वों वाला एक सरणी)।

एमआरआई अपेक्षित परिणाम देता है, लेकिन क्या यह एक दुर्घटना या एक पैटर्न है? आइए रूबी कोड के एक छोटे से टुकड़े के साथ अपना शोध शुरू करें।

 Thread.new do array << nil end

से शुरू करें

यह समझने के लिए कि कोड के इस टुकड़े में क्या चल रहा है, आपको यह देखने की जरूरत है कि एमआरआई एक नया धागा कैसे बनाता है, मुख्य रूप से कोड thread*.c फाइलें।

Thread.new कार्यान्वयन के अंदर पहली चीज एक नया देशी धागा बना रही है जिसका उपयोग रूबी धागे द्वारा किया जाएगा। उसके बाद, thread_start_func_2 फ़ंक्शन thread_start_func_2 । आइए बिना विवरण के इसे देखें।

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

हमारे मामले में, मुख्य धागे में एक नया धागा बनाया जाता है, जिसका अर्थ है कि हम यह मान सकते हैं कि फिलहाल जीआईएल इसके पास है। आगे बढ़ने से पहले, नए धागे को ताला जारी करने के लिए मुख्य धागे की प्रतीक्षा करनी चाहिए।

आइए देखें कि क्या होता है जब एक नया धागा जीआईएल पर कब्जा करने की कोशिश करता है।

 static void gvl_acquire_common(rb_vm_t *vm) { if (vm->gvl.acquired) { vm->gvl.waiting++; if (vm->gvl.waiting == 1) { rb_thread_wakeup_timer_thread_low(); } while (vm->gvl.acquired) { native_cond_wait(&vm->gvl.cond, &vm->gvl.lock); }

यह gvl_acquire_common फ़ंक्शन का एक हिस्सा है जिसे तब कहा जाता है जब एक नया धागा GIL पर कब्जा करने की कोशिश करता है।

सबसे पहले, वह देखती है कि ताला पहले से ही आयोजित है। यदि आयोजित किया जाता है, तो waiting विशेषता बढ़ जाती है। हमारे कोड के मामले में, यह 1 बराबर हो जाता है। अगली पंक्ति यह देखने के लिए जांच करती है कि waiting विशेषता 1 बराबर है या नहीं। यह बराबर है, इसलिए अगली पंक्ति टाइमर स्ट्रीम को जगाती है।

टाइमर थ्रेड एमआरआई धागे प्रदान करता है, एक ऐसी स्थिति को रोकता है जिसमें से एक लगातार जीआईएल रखता है। लेकिन टाइमर स्ट्रीम के विवरण पर आगे बढ़ने से पहले, हम GIL से निपटेंगे।

मैंने पहले ही कई बार उल्लेख किया है कि एमआरआई में प्रत्येक धागे के पीछे एक मूल धागा है। यह है, लेकिन यह योजना मानती है कि एमआरआई धाराएं समानांतर, साथ ही साथ देशी भी काम करती हैं। जीआईएल इसे रोकता है। हम योजना के पूरक हैं और इसे वास्तविकता से अधिक अनुमानित करते हैं।

देशी धागे को सक्षम करने के लिए, रूबी धागे को पहले जीआईएल पर कब्जा करना चाहिए। GIL रूबी थ्रेड्स और संबंधित देशी थ्रेड्स के बीच एक मध्यस्थ के रूप में कार्य करता है, जो कि संक्षिप्त रूप से सीमित है। पिछले आरेख में, रूबी धागे समानांतर में मूल धागे का उपयोग कर सकते हैं। एमआरआई के मामले में दूसरी योजना वास्तविकता के करीब है - केवल एक धागा किसी समय में जीआईएल को पकड़ सकता है, इसलिए समानांतर कोड निष्पादन पूरी तरह से समाप्त हो जाता है।

विकास टीम के लिए, MRI GIL सिस्टम की आंतरिक स्थिति की सुरक्षा करता है । जीआईएल के लिए धन्यवाद, आंतरिक डेटा संरचनाओं को ताले की आवश्यकता नहीं होती है। यदि दो धागे एक ही समय में सामान्य डेटा को नहीं बदल सकते हैं, तो दौड़ की स्थिति असंभव है।

एक डेवलपर के रूप में, आपने जो ऊपर लिखा है, उसका मतलब है कि एमआरआई में संगामिति बहुत सीमित है।

समय का प्रवाह

जैसा कि मैंने कहा, एक टाइमर धागा जीआईएल को एक धागे द्वारा लगातार आयोजित होने से रोकता है। एक टाइमर धागा आंतरिक एमआरआई जरूरतों के लिए एक देशी धागा है; इसमें एक समान रूबी धागा नहीं है। यह तब शुरू होता है जब दुभाषिया rb_thread_create_timer_thread फ़ंक्शन में शुरू होता है।

जब एमआरआई अभी शुरू हुआ है और केवल मुख्य धागा चल रहा है, टाइमर थ्रेड सो रहा है। लेकिन जैसे ही कुछ धागा जीआईएल की रिलीज के लिए इंतजार करना शुरू करते हैं, टाइमर थ्रेड जाग जाता है।

यह आरेख आगे बताता है कि जीआरआई एमआरआई में कैसे लागू किया जाता है। दाईं ओर का धागा अभी शुरू हुआ है और चूंकि यह केवल GIL के जारी होने का इंतजार कर रहा है, टाइमर थ्रेड जागता है।

हर 100 एमएस, टाइमर थ्रेड उस थ्रेड इंटरप्ट फ्लैग को सेट करता है, जिसे जीआईएल वर्तमान में रखती है, RUBY_VM_SET_TIMER_INTERRUPT मैक्रो का उपयोग करके। ये विवरण समझने के लिए महत्वपूर्ण हैं कि क्या अभिव्यक्ति array << nil परमाणु है।

यह ओएस में टाइम स्लाइसिंग की अवधारणा के समान है, अगर यह आपके परिचित है।

ध्वज को स्थापित करने से तुरंत स्ट्रीम बाधित नहीं होती है (यदि ऐसा किया गया, तो यह कहना सुरक्षित होगा कि अभिव्यक्ति array << nil परमाणु नहीं है)।

बीच में झंडे को संभालना

vm_eval.c फ़ाइल के vm_eval.c में रूबी में एक विधि कॉल को संसाधित करने के लिए कोड है। यह विधि को कॉल करने के लिए वातावरण सेट करता है और आवश्यक फ़ंक्शन को कॉल करता है। vm_call0_body फ़ंक्शन के अंत में, विधि लौटने से ठीक पहले, इंटरप्ट फ़्लैग की जाँच की जाती है।

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

यहाँ पहले सवाल का जवाब है: array << nil एक परमाणु ऑपरेशन है। जीआईएल के लिए धन्यवाद, सी में विशेष रूप से कार्यान्वित सभी रूबी विधियां परमाणु हैं।

यह कोड है:

 array = [] 5.times.map do Thread.new do 1000.times do array << nil end end end.each(&:join) puts array.size

एमआरआई पर लॉन्च किए जाने पर अपेक्षित परिणाम देने की गारंटी (हम केवल सरणी की लंबाई की भविष्यवाणी के बारे में बात कर रहे हैं, तत्वों के क्रम के बारे में कोई गारंटी नहीं है - लगभग।)

लेकिन ध्यान रखें कि यह रूबी कोड से पालन नहीं करता है । यदि आप इस कोड को किसी अन्य कार्यान्वयन पर चलाते हैं जिसमें GIL नहीं है, तो यह अप्रत्याशित परिणाम देगा। यह जानना उपयोगी है कि GIL क्या प्रदान करता है, लेकिन GIL पर निर्भर कोड लिखना एक अच्छा विचार नहीं है। ऐसा करने से, आप अपने आप को वेंडर लॉक के समान स्थिति में पाते हैं।

GIL एक सार्वजनिक API प्रदान नहीं करता है। GIL पर कोई दस्तावेज या विनिर्देश नहीं है। एक बार MRI डेवलपमेंट टीम GIL के व्यवहार को बदल सकती है या पूरी तरह से इससे छुटकारा पा सकती है। यही कारण है कि कोड को लिखना जो जीआईएल पर निर्भर करता है उसके वर्तमान कार्यान्वयन में एक अच्छा विचार नहीं है।

रूबी में लागू किए गए तरीकों के बारे में क्या?

तो हम जानते हैं कि array << nil एक परमाणु ऑपरेशन है। इस अभिव्यक्ति में, एक विधि को Array#<< कहा जाता है, जिसे एक पैरामीटर के रूप में एक स्थिरांक दिया जाता है और जिसे C. में लागू किया जाता है। संदर्भ को स्विच करना, यदि ऐसा होता है, तो डेटा अखंडता उल्लंघन नहीं होगा - यह विधि किसी भी मामले में GIL को केवल नामांकन से पहले जारी करेगी।

ऐसा कुछ क्या है?

 array << User.find(1)

इससे पहले कि आप Array#<< विधि को कॉल करें, आपको पैरामीटर मान की गणना करने की आवश्यकता है, अर्थात User.find(1) कॉल करें। जैसा कि आप जानते हैं कि User.find(1) बदले में रूबी में लिखी कई विधियों को कहता है।

लेकिन GIL C. में लागू परमाणु विधियां ही बनाती है। रूबी में विधियों की कोई गारंटी नहीं है।

क्या Array#<< अभी भी नए उदाहरण में परमाणु है? हां, लेकिन यह मत भूलो कि आपको अभी भी दाएं हाथ की अभिव्यक्ति करने की आवश्यकता है। दूसरे शब्दों में, आपको पहले User.find(1) पद्धति पर कॉल करने की आवश्यकता है, जो परमाणु नहीं है, और उसके बाद ही इसके द्वारा लौटाए गए मान को Array#<< पास किया जाएगा।

यह सब मेरे लिए क्या मायने रखता है?

लेख के पहले भाग में , हमने देखा कि क्या हो सकता है यदि संदर्भ स्विचिंग फ़ंक्शन के बीच में कहीं होता है। जीआईएल ऐसी स्थितियों को रोकता है - भले ही संदर्भ स्विचिंग होता है, अन्य थ्रेड निष्पादन को जारी रखने में सक्षम नहीं होंगे, क्योंकि उन्हें जीआईएल जारी होने तक इंतजार करने के लिए मजबूर किया जाएगा। यह सब केवल इस शर्त के तहत होता है कि विधि C में लागू है, रूबी कोड का उपयोग नहीं करता है और GIL को स्वयं जारी नहीं करता है ( मूल लेख में टिप्पणियों में, एक उदाहरण दिया गया है - C में लागू साहचर्य सरणी (हैश) में एक तत्व जोड़ना परमाणु नहीं है, क्योंकि यह संबोधित करता है रूबी कोड को एक तत्व का हैश प्राप्त करने के लिए - लगभग।

जीआईएल एमआरआई कार्यान्वयन के अंदर दौड़ की स्थिति को असंभव बनाता है, लेकिन रूबी कोड थ्रेड को सुरक्षित नहीं बनाता है। हम कह सकते हैं कि जीआईएल केवल MRI की एक विशेषता है, जिसे इंटरप्रेटर की आंतरिक स्थिति की सुरक्षा के लिए डिज़ाइन किया गया है।

अनुवादक टिप्पणी और रचनात्मक आलोचना सुनकर खुश होगा।