क्या पायथन जीआईएल वास्तव में मृत है?

सभी को नमस्कार! अगले सोमवार, पायथन डेवलपर पाठ्यक्रम के नए समूह में कक्षाएं शुरू होंगी, जिसका अर्थ है कि हमारे पास एक और दिलचस्प सामग्री प्रकाशित करने का समय है, जो हम अब करेंगे। अच्छी पढाई हो।



2003 में वापस, इंटेल ने नया पेंटियम 4 "एचटी" प्रोसेसर जारी किया। यह प्रोसेसर 3GHz पर पहुंच गया और हाइपर-थ्रेडिंग तकनीक का समर्थन किया।



अगले वर्षों में, इंटेल और एएमडी ने बस की गति, एल 2 कैश आकार में वृद्धि और विलंबता को कम करने के लिए मैट्रिक्स आकार को कम करके सर्वश्रेष्ठ डेस्कटॉप प्रदर्शन को प्राप्त करने के लिए संघर्ष किया। 2004 में, 3 गीगाहर्ट्ज़ की आवृत्ति वाले HT मॉडल को 580 प्रीस्कॉट मॉडल द्वारा ओवरक्लॉकिंग के साथ 4 GHz में बदल दिया गया था।



ऐसा लग रहा था कि आगे बढ़ने के लिए घड़ी की आवृत्ति बढ़ाना आवश्यक था, हालांकि, नए प्रोसेसर उच्च बिजली की खपत और गर्मी लंपटता से पीड़ित थे।

क्या आपका डेस्कटॉप प्रोसेसर आज 4 गीगाहर्ट्ज का डिलीवर करता है? यह संभावना नहीं है, क्योंकि प्रदर्शन में सुधार करने का मार्ग अंततः बस की गति बढ़ाने और कोर की संख्या में वृद्धि के माध्यम से होता है। 2006 में, इंटेल कोर 2 ने पेंटियम 4 को बदल दिया और घड़ी की गति बहुत कम थी।

विस्तृत उपयोगकर्ता दर्शकों के लिए मल्टी-कोर प्रोसेसर जारी करने के अलावा, 2006 में कुछ और हुआ। अजगर 2.5 ने आखिरकार प्रकाश देखा! यह पहले से ही कीवर्ड के साथ बीटा संस्करण के साथ आया था, जिसे आप सभी जानते हैं और प्यार करते हैं।

जब इंटेल कोर 2 या एएमडी एथलॉन एक्स 2 का उपयोग करने की बात आई तो पायथन 2.5 की एक प्रमुख सीमा थी।
यह एक जीआईएल था।

GIL क्या है?

GIL (Global Interpreter Lock) पायथन इंटरप्रिटर में एक म्यूटेक्स द्वारा संरक्षित बूलियन मूल्य है। मुख्य CPython bytecode गणना लूप में लॉक का उपयोग यह निर्धारित करने के लिए किया जाता है कि वर्तमान में कौन सा धागा निर्देश निष्पादित कर रहा है।

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

जीआईएल मल्टीथ्रेडेड पायथन प्रोग्रामिंग को सरल बनाता है।



जीआईएल हमें यह भी बताता है कि जबकि सीपीथॉन को बहु-सूत्रित किया जा सकता है, जबकि एक समय में केवल एक धागा निष्पादित किया जा सकता है। इसका मतलब है कि आपका क्वाड-कोर प्रोसेसर कुछ ऐसा करता है (नीली स्क्रीन के अपवाद के साथ, उम्मीद है)।

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

जीआईएल को हटाने के किसी भी सुझाव को इस तथ्य से उचित ठहराया गया था कि इंटरप्रेटर की वैश्विक लॉकिंग को एकल-थ्रेडेड कोड के प्रदर्शन को कम नहीं करना चाहिए। जिसने भी 2003 में हाइपरथ्रेडिंग को सक्षम करने की कोशिश की वह समझ जाएगा कि मैं किस बारे में बात कर रहा हूं ।

सीपीथॉन में गिल का परित्याग

यदि आप वास्तव में सीपीथॉन में कोड को समानांतर बनाना चाहते हैं, तो आपको कई प्रक्रियाओं का उपयोग करना होगा।

सीपीथॉन 2.6 में, मल्टीप्रोसेसिंग मॉड्यूल को मानक पुस्तकालय में जोड़ा गया था। मल्टीप्रोसेसिंग ने CPython में प्रक्रियाओं की पीढ़ी (प्रत्येक प्रक्रिया अपने GIL के साथ) का सामना किया।

from multiprocessing import Process def f(name): print 'hello', name if __name__ == '__main__': p = Process(target=f, args=('bob',)) p.start() p.join() 

प्रक्रियाएं बनाई जाती हैं, उन्हें संकलित मॉड्यूल और पायथन कार्यों का उपयोग करके कमांड भेजे जाते हैं, और फिर उन्हें मुख्य प्रक्रिया में शामिल किया जाता है।

मल्टीप्रोसेसिंग एक कतार या चैनल के माध्यम से चर के उपयोग का भी समर्थन करता है। उसके पास एक लॉक ऑब्जेक्ट है, जिसका उपयोग मुख्य प्रक्रिया में ऑब्जेक्ट्स को लॉक करने और अन्य प्रक्रियाओं से लिखने के लिए किया जाता है।

मल्टीप्रोसेसिंग में एक बड़ी खामी है। यह एक महत्वपूर्ण कम्प्यूटेशनल भार वहन करता है, जो प्रसंस्करण समय और मेमोरी उपयोग दोनों को प्रभावित करता है। बिना किसी साइट के भी CPython का स्टार्टअप टाइम 100-200 ms (अधिक जानने के लिए https://hackernoon.com/which-is-the-fastest-version-of-python-2ae7c61a6b2b ) देखें।

नतीजतन, आपके पास सीपीथॉन में समानांतर कोड हो सकता है, लेकिन आपको अभी भी लंबे समय से चलने वाली प्रक्रियाओं के काम की सावधानीपूर्वक योजना बनाने की आवश्यकता है जो सभी वस्तुओं को साझा करते हैं।

एक अन्य विकल्प ट्विस्टेड जैसे तीसरे पक्ष के पैकेज का उपयोग करना हो सकता है।

PEP554 और GIL की मौत?

तो, मैं आपको याद दिला दूं कि सीपीथॉन में मल्टीथ्रेडिंग सरल है, लेकिन वास्तव में यह समानांतर नहीं है, लेकिन मल्टीप्रोसेसिंग समानांतर है, लेकिन महत्वपूर्ण ओवरहेड को मजबूर करता है।

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

CPython 3.8 की विशेषताओं में से एक PEP554 है, जो मानक पुस्तकालय में एक नए interpreters मॉड्यूल के साथ उप-दुभाषियों और एपीआई का कार्यान्वयन है।

यह आपको एक ही प्रक्रिया में पायथन से कई दुभाषियों को बनाने की अनुमति देता है। एक अन्य पायथन 3.8 नवाचार यह है कि सभी दुभाषियों के पास अपनी जीआईएल होगी।



चूंकि दुभाषिया की स्थिति में स्मृति में आवंटित क्षेत्र होता है, पायथन ऑब्जेक्ट्स (स्थानीय और वैश्विक) के लिए सभी पॉइंटर्स का एक संग्रह, PEP554 में उप-निर्धारक अन्य दुभाषियों के वैश्विक चर तक नहीं पहुंच सकता है।

मल्टीप्रोसेसिंग की तरह, वस्तुओं को साझा करने वाले दुभाषियों में उन्हें क्रमबद्ध करना और आईपीसी फॉर्म (नेटवर्क, डिस्क या साझा मेमोरी) का उपयोग करना शामिल है। पायथन में वस्तुओं को अनुक्रमित करने के कई तरीके हैं, उदाहरण के लिए, marshal मॉड्यूल, pickle मॉड्यूल, या अधिक मानकीकृत तरीके जैसे कि json या simplexml । उनमें से प्रत्येक के पास इसके पेशेवरों और विपक्ष हैं, और उनमें से सभी एक कंप्यूटिंग लोड देते हैं।

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



इसके लिए एक API अभी भी विकसित किया जा रहा है, लेकिन यह संभवतः कुछ इस तरह दिखाई देगा:

 import _xxsubinterpreters as interpreters import threading import textwrap as tw import marshal # Create a sub-interpreter interpid = interpreters.create() # If you had a function that generated some data arry = list(range(0,100)) # Create a channel channel_id = interpreters.channel_create() # Pre-populate the interpreter with a module interpreters.run_string(interpid, "import marshal; import _xxsubinterpreters as interpreters") # Define a def run(interpid, channel_id): interpreters.run_string(interpid, tw.dedent(""" arry_raw = interpreters.channel_recv(channel_id) arry = marshal.loads(arry_raw) result = [1,2,3,4,5] # where you would do some calculating result_raw = marshal.dumps(result) interpreters.channel_send(channel_id, result_raw) """), shared=dict( channel_id=channel_id ), ) inp = marshal.dumps(arry) interpreters.channel_send(channel_id, inp) # Run inside a thread t = threading.Thread(target=run, args=(interpid, channel_id)) t.start() # Sub interpreter will process. Feel free to do anything else now. output = interpreters.channel_recv(channel_id) interpreters.channel_release(channel_id) output_arry = marshal.loads(output) print(output_arry) 

यह उदाहरण NumPy का उपयोग करता है। संख्यात्मक सरणी चैनल पर भेजी जाती है, इसे marshal मॉड्यूल का उपयोग करके क्रमबद्ध किया जाता है, फिर सबइंटरप्रेटर डेटा (एक अलग जीआईएल पर) को संसाधित करता है, इसलिए सीपीयू के साथ एक समांतरकरण समस्या हो सकती है, जो सबप्रिटेटर्स के लिए आदर्श है।

यह अक्षम दिखता है

marshal मॉड्यूल वास्तव में तेजी से काम करता है, लेकिन उतनी तेजी से नहीं जितना कि वस्तुओं को सीधे मेमोरी से साझा करना।

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

नए एपीआई को (विशुद्ध रूप से काल्पनिक रूप से) निम्न प्रकार से लागू किया जा सकता है -

 import _xxsubinterpreters as interpreters import threading import textwrap as tw import pickle # Create a sub-interpreter interpid = interpreters.create() # If you had a function that generated a numpy array arry = [5,4,3,2,1] # Create a channel channel_id = interpreters.channel_create() # Pre-populate the interpreter with a module interpreters.run_string(interpid, "import pickle; import _xxsubinterpreters as interpreters") buffers=[] # Define a def run(interpid, channel_id): interpreters.run_string(interpid, tw.dedent(""" arry_raw = interpreters.channel_recv(channel_id) arry = pickle.loads(arry_raw) print(f"Got: {arry}") result = arry[::-1] result_raw = pickle.dumps(result, protocol=5) interpreters.channel_send(channel_id, result_raw) """), shared=dict( channel_id=channel_id, ), ) input = pickle.dumps(arry, protocol=5, buffer_callback=buffers.append) interpreters.channel_send(channel_id, input) # Run inside a thread t = threading.Thread(target=run, args=(interpid, channel_id)) t.start() # Sub interpreter will process. Feel free to do anything else now. output = interpreters.channel_recv(channel_id) interpreters.channel_release(channel_id) output_arry = pickle.loads(output) print(f"Got back: {output_arry}") 

यह पैटर्न दिखता है

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

जैसे ही यह PEP दूसरों के साथ विलीन होता है, मुझे लगता है कि हम PyPi में कई नए API देखेंगे।

उपठेकेदार के पास कितना ओवरहेड है?

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

• __main__ और importlib में मॉड्यूल;
• sys डिक्शनरी की सामग्री;
• बिल्ट-इन फ़ंक्शंस ( print() , assert , आदि);
• बहती है;
• कर्नेल विन्यास।

कर्नेल कॉन्फ़िगरेशन को आसानी से मेमोरी से क्लोन किया जा सकता है, लेकिन मॉड्यूल आयात करना इतना सरल नहीं है। पायथन में इंपोर्टिंग मॉड्यूल धीमा है, इसलिए अगर सब-डेपेंटर बनाने का मतलब है कि मॉड्यूल को हर बार एक अलग नामस्थान में आयात किया जाए, तो लाभ कम हो जाते हैं।

Asyncio के बारे में क्या?

मानक पुस्तकालय में asyncio इवेंट asyncio का मौजूदा कार्यान्वयन मूल्यांकन के लिए स्टैक फ्रेम बनाता है, और मुख्य दुभाषिया में राज्य भी asyncio (और इसलिए जीआईएल साझा करता है)।

PEP554 के संयोजन के बाद, शायद पहले से ही Python 3.9 में, इवेंट लूप के वैकल्पिक कार्यान्वयन का उपयोग किया जा सकता है (हालांकि अभी तक किसी ने भी ऐसा नहीं किया है), जो समानांतर में उप-व्याख्याताओं में अतुल्यकालिक तरीके चलाता है।

अच्छा लगता है, मुझे भी लपेटो!

खैर, वास्तव में नहीं।
चूंकि CPython इतने लंबे समय से एक ही दुभाषिया पर चल रहा है, कोड बेस के कई हिस्से "इंटरप्रेटर स्टेट" के बजाय "रनटाइम स्टेट" का उपयोग करते हैं, इसलिए यदि PEP554 को अभी पेश किया गया था, तब भी बहुत सारी समस्याएं होंगी।

उदाहरण के लिए, कचरा संग्रहकर्ता की स्थिति (संस्करणों में 3.7 <) रनटाइम के अंतर्गत आती है।

PyCon sprints के दौरान होने वाले परिवर्तनों में, कचरा संग्राहक की स्थिति दुभाषिया की ओर बढ़ने लगती है, जिससे प्रत्येक उपप्रकारक का अपना कचरा कलेक्टर (जैसा होना चाहिए) होगा।

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

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

संक्षेप में, अभी भी कई समस्याएं हैं जिन्हें संबोधित करने की आवश्यकता है।

निष्कर्ष: क्या GIL अब सच है?

एकल-थ्रेडेड अनुप्रयोगों के लिए GIL का उपयोग जारी रहेगा। इसलिए, PEP554 का अनुसरण करते समय, आपका एकल-थ्रेडेड कोड अचानक समानांतर नहीं होगा।
यदि आप Python 3.8 में समानांतर कोड लिखना चाहते हैं, तो आपको प्रोसेसर के साथ समानांतर रूप से समस्याएँ होंगी, लेकिन यह भविष्य का टिकट भी है!

कब?

मल्टीप्रोसेसिंग के लिए अचार v5 और मेमोरी शेयरिंग सबसे अधिक संभावना पायथन 3.8 (अक्टूबर 2019) में होगी, और उप-दुभाषिए संस्करण 3.8 और 3.9 के बीच दिखाई देंगे।
यदि आपके पास प्रस्तुत उदाहरणों के साथ खेलने की इच्छा है, तो मैंने सभी आवश्यक कोड के साथ एक अलग शाखा बनाई: https://github.com/tonybaloney/cpython/tree/subinterpreters।

आप इस बारे में क्या सोचते हैं? अपनी टिप्पणी लिखें और आपको पाठ्यक्रम पर देखें।