🗃️ ⚖️ 🤸 गो में नियोजन: भाग II - द गो शेड्यूलर 🤳 🤸 🐯

हेलो, हेब्र! तीन-भाग श्रृंखला में यह दूसरी पोस्ट है, जो गो में अनुसूचक के काम के यांत्रिकी और शब्दार्थ का एक विचार देगा। यह पोस्ट गो प्लानर के बारे में है। इस श्रृंखला

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

आपका कार्यक्रम शुरू हो रहा है

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

आप देख सकते हैं कि मेरे पास 4 भौतिक कोर के साथ एक प्रोसेसर है। यह रिपोर्ट भौतिक कोर प्रति हार्डवेयर थ्रेड्स की संख्या का खुलासा नहीं करती है। Intel Core i7 प्रोसेसर में हाइपर-थ्रेडिंग तकनीक है, जिसका अर्थ है कि भौतिक कोर में 2 हार्डवेयर थ्रेड हैं। यह गो बताता है कि समानांतर में ओएस थ्रेड चलाने के लिए 8 आभासी कोर उपलब्ध हैं। इसे सत्यापित करने के लिए, निम्नलिखित कार्यक्रम पर विचार करें:

package main

import (
	"fmt"
	"runtime"
)

func main() {

    // NumCPU returns the number of logical
    // CPUs usable by the current process.
    fmt.Println(runtime.NumCPU())
}

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

प्रत्येक गो कार्यक्रम को एक प्रारंभिक गोरोइन ( जी) दिया जाता है।) गोराउटाइन मूल रूप से कोराटीन है, लेकिन यह गो है, इसलिए हम पत्र सी को जी के साथ बदल देते हैं और गोरोइन शब्द प्राप्त करते हैं। आप Goroutines को एप्लिकेशन-स्तरीय थ्रेड्स के रूप में सोच सकते हैं, और वे OS थ्रेड्स की तरह हैं। जिस तरह कर्नेल द्वारा OS थ्रेड्स को ऑन और ऑफ किया जाता है, उसी तरह से संदर्भ प्रोग्राम ऑन और ऑफ होते हैं।

अंतिम पहेली निष्पादन कतार है। गो अनुसूचक में दो अलग-अलग निष्पादन कतारें हैं: वैश्विक निष्पादन कतार (GRQ) और स्थानीय निष्पादन कतार (LRQ)। प्रत्येक P को एक LRQ दिया जाता है जो P के संदर्भ में निष्पादित करने के लिए असाइन किए गए गोरोइंटिन को नियंत्रित करता है। ये goroutines उस संदर्भ M से इस P को दिया गया और बंद हो जाता है। GRQ उन गोरआउट के लिए है जो P को नहीं सौंपे गए हैं। गोरआउट को स्थानांतरित करने के लिए एक प्रक्रिया है। GRQ से LRQ तक, जिस पर हम बाद में चर्चा करेंगे।

छवि इन सभी घटकों को एक साथ दिखाती है।

सहकारी योजनाकार

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

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

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

गोरूटिन राज्य

धाराओं की तरह ही, गोरोइटिन में तीन उच्च-स्तरीय राज्य होते हैं। वे उस भूमिका को निर्धारित करते हैं जो गो योजनाकार किसी गोरोइन के साथ निभाता है। गोरोटिन तीन अवस्थाओं में से एक में हो सकता है: वेटिंग, रेडी या फ़ुलिलिंग।

प्रतीक्षा : इसका मतलब है कि गोरोइन को रोक दिया जाता है और कुछ जारी रखने की प्रतीक्षा की जाती है। यह ऑपरेटिंग सिस्टम (सिस्टम कॉल) की प्रतीक्षा करने या कॉल (परमाणु और म्यूटेक्स संचालन) के सिंक्रनाइज़ेशन जैसे कारणों से हो सकता है। इस प्रकार की देरी खराब प्रदर्शन का मुख्य कारण है।

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

पूर्ति : इसका मतलब है कि गोरोइन को एम में रखा गया है और इसके निर्देशों का पालन कर रहा है। आवेदन से जुड़ा काम पूरा हो गया है। हर कोई यही चाहता है।

संदर्भ स्विच

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

घटनाओं के चार वर्ग हैं जो आपके गो कार्यक्रमों में होते हैं जो नियोजक को निर्णय लेने की अनुमति देते हैं। इसका मतलब यह नहीं है कि यह हमेशा इन घटनाओं में से एक पर होगा। इसका मतलब यह है कि अनुसूचक को अवसर मिलता है।

गो कीवर्ड का उपयोग करना
कचरा इकट्ठा करने वाला
सिस्टम कॉल
तादात्म्य

गो
कीवर्ड का उपयोग करना, गो कीवर्ड आप गोरोइन कैसे बनाते हैं। जैसे ही एक नया गोरआउट बनाया जाता है, यह प्लानर को योजना बनाने का निर्णय लेने का अवसर देता है।

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

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

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

अतुल्यकालिक प्रणाली कॉल

जब आप जिस ऑपरेटिंग सिस्टम पर काम कर रहे होते हैं, उसमें सिस्टम कॉल को असिंक्रोनस तरीके से प्रोसेस करने की क्षमता होती है, जिसे नेटवर्क पोलर कहा जाता है, सिस्टम कॉल को अधिक कुशलता से प्रोसेस करने के लिए इस्तेमाल किया जा सकता है। यह इन संबंधित OS में kqueue (MacOS), epoll (Linux) या iocp (Windows) का उपयोग करके प्राप्त किया जाता है।

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

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

निम्नलिखित आकृति में, गोरुटिन -1 (G1) एक नेटवर्क सिस्टम कॉल करना चाहता है, इसलिए G1 नेटवर्क पराग को ले जाता है और इसे एसिंक्रोनस नेटवर्क सिस्टम कॉल के रूप में माना जाता है। एक बार जब G1 को नेटवर्क पराग में ले जाया जाता है, M अब LRQ से एक और गोरोइन को निष्पादित करने के लिए उपलब्ध है। इस मामले में, गोर्यूटिन -2 एम

में बदल जाता है। निम्नलिखित आकृति में, सिस्टम नेटवर्क कॉल एक एसिंक्रोनस नेटवर्क कॉल के साथ समाप्त होता है, और G1 P के लिए LRQ पर वापस चला जाता है। G1 के बाद M पर वापस स्विच किया जा सकता है, Go से संबंधित कोड, जिसके लिए वह जवाब देता है फिर से निष्पादित कर सकता है। बड़ी जीत यह है कि नेटवर्क सिस्टम कॉल करने के लिए किसी अतिरिक्त सुश्री की आवश्यकता नहीं है। नेटवर्क पोलर में एक OS थ्रेड होता है, और यह एक इवेंट लूप के माध्यम से प्रोसेस होता है।

सिंक्रोनस सिस्टम कॉल

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

विंडोज ऑपरेटिंग सिस्टम फाइल-आधारित एसिंक्रोनस सिस्टम कॉल कर सकता है। तकनीकी रूप से, विंडोज पर काम करते समय, आप नेटवर्क पोलर का उपयोग कर सकते हैं।

आइए देखें कि एक सिंक्रोनस सिस्टम कॉल के साथ क्या होता है (उदाहरण के लिए, फ़ाइल I / O) जो एम ब्लॉक करेगा। आंकड़ा हमारे बुनियादी नियोजन आरेख को दिखाता है, लेकिन इस बार G1 एक तुल्यकालिक सिस्टम कॉल करने जा रहा है जो M1 को ब्लॉक करेगा।

निम्न आकृति में, शेड्यूलर यह निर्धारित कर सकता है कि G1 ने M लॉक का कारण बनाया है। इस बिंदु पर, शेड्यूलर P1 को M से रोकता है जिसमें एक अवरुद्ध G1 अभी भी जुड़ा हुआ है। शेड्यूलर तब पी। की सेवा के लिए एक नया एम 2 पेश करता है। इस बिंदु पर, जी 2 को एलआरक्यू से चुना जा सकता है और एम 2 संदर्भ में शामिल किया गया है। यदि एम पहले से ही एक पिछले एक्सचेंज के कारण मौजूद है, तो यह संक्रमण एक नया एम बनाने की आवश्यकता से तेज है।

अगला चरण G1 द्वारा किए गए लॉक सिस्टम कॉल को पूरा करता है। इस बिंदु पर, G1 LRQ में वापस आ सकता है और P. M1 द्वारा फिर से सेवा की जा सकती है, फिर भविष्य के उपयोग के लिए एक तरफ जाता है यदि इस परिदृश्य को दोहराया जाना चाहिए।

चोरी का काम करना

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

आंकड़े में, हमारे पास बहु-थ्रेडेड गो कार्यक्रम है जिसमें दो पीएस चार जीएस की सेवा करते हैं और जीआरक्यू में एक जी। यदि P में से कोई एक अपने G की शीघ्रता से सेवा करता है, तो क्या होता है?

इसके अलावा, P1 के पास अब निष्पादित करने के लिए गोरआउट्स नहीं हैं। लेकिन वहाँ काम कर रहे हालत में goroutines हैं, दोनों p2 के लिए LRQ में, और GRQ में। यह वह क्षण है जब P1 को गोरोइन चुराने की जरूरत होती है।

गोरोइनों को चुराने के नियम इस प्रकार हैं। सभी कोड रनटाइम स्रोतों में देखे जा सकते हैं।

runtime.schedule() {
    // only 1/61 of the time, check the global runnable queue for a G.
    // if not found, check the local queue.
    // if not found,
    //     try to steal from other Ps.
    //     if not, check the global runnable queue.
    //     if not found, poll network.
}

इस प्रकार, इन नियमों के आधार पर, पी 1 को अपने एलआरक्यू में गोरोइटिन की उपस्थिति के लिए पी 2 की जांच करनी चाहिए और इसे जो भी मिलता है उसका आधा हिस्सा लेना चाहिए।

अगर P2 अपने सभी प्रोग्रामों को पूरा करता है और LR1 में कुछ नहीं बचा है तो क्या होगा?

पी 2 ने अपना सारा काम पूरा कर लिया है और अब गोरोनेसियों की चोरी करनी होगी। सबसे पहले, वह LRQ P1 को देखेगा, लेकिन उसे कोई भी गोरटाइन नहीं मिलेगा। इसके बाद वह GRQ को देखेंगे। वहां वह G9 खोजेगा।

P2 जीआरक्यू से जी 9 चुराता है और काम करना शुरू कर देता है। इस चोरी के बारे में जो अच्छा है वह यह है कि यह एम को व्यस्त रहने देता है और निष्क्रिय नहीं होने देता है।

व्यावहारिक उदाहरण

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

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

इसके बाद, धारा 2 संदर्भ में वापस आ जाती है जब धारा 2 से संदेश स्ट्रीम 1 से प्राप्त होता है। अब, रन 2 स्थिति से स्टैंडबाय स्थिति में धारा 2 स्विच करें, और स्टैंडबाय स्थिति से 1 स्विच को तैयार स्थिति में स्ट्रीम करें और अंत में रन स्थिति में वापस आ जाता है, जो इसे संसाधित करने की अनुमति देता है। और एक नया संदेश वापस भेजें। इन सभी संदर्भ स्विच और राज्य परिवर्तनों को पूरा होने में समय लगता है, जो काम की गति को सीमित करता है। चूंकि प्रत्येक संदर्भ स्विच में ~ 1000 नैनोसेकेंड की देरी होती है, और हम आशा करते हैं कि हार्डवेयर 12 निर्देश प्रति नैनोसेकंड चलाता है, आप 12,000 निर्देशों को देखते हैं जो कम से कम इन संदर्भ स्विच के दौरान निष्पादित नहीं होते हैं। चूंकि ये प्रवाह अलग-अलग नाभिकों के बीच भी अंतर करते हैं,एक अतिरिक्त कैश-लाइन मिस की देरी की संभावना भी अधिक है।

आकृति में दो गोरूटिन हैं जो एक दूसरे के साथ सद्भाव रखते हैं, संदेश को आगे और पीछे से गुजरते हैं। G1 को संदर्भ स्विच M1 मिलता है, जो कोर 1 पर चलता है, जो G1 को अपना काम करने की अनुमति देता है।

इसके अलावा, जब G1 ने संदेश भेजना समाप्त कर दिया, तो अब उसे प्रतिक्रिया की प्रतीक्षा करने की आवश्यकता है। यह जी 1 को एम 1 संदर्भ से काट दिया जाएगा और निष्क्रिय स्थिति में डाल देगा। जैसे ही G2 को संदेश के बारे में सूचित किया जाता है, यह एक स्वस्थ स्थिति में चला जाता है। अब गो शेड्यूलर संदर्भ स्विचिंग कर सकता है और M1 पर G2 चला सकता है, जो अभी भी Core 1 पर चलता है। तब G2 संदेश को संसाधित करता है और G1 पर एक नया संदेश भेजता है।

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

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

यदि गोरोइन का उपयोग किया जाता है, तो सभी प्रसंस्करण के लिए एक ही ओएस थ्रेड और कर्नेल का उपयोग किया जाता है। इसका मतलब यह है कि ओएस के दृष्टिकोण से, ओएस फ्लो कभी प्रतीक्षा की स्थिति में नहीं जाता है; कभी नहीँ। नतीजतन, उन सभी निर्देशों को जिन्हें हमने गोरटीन का उपयोग करते समय धाराओं का उपयोग करते समय संदर्भों को खो दिया है, खोए नहीं हैं।

अनिवार्य रूप से, ओएस स्तर पर प्रोसेसर-बाउंड जॉब में आईओ / ब्लॉकिंग कार्य को चालू करें। चूंकि सभी संदर्भ स्विचिंग अनुप्रयोग स्तर पर होते हैं, इसलिए हम संदर्भ स्विचिंग पर उसी ~ 12 हजार निर्देशों (औसतन) को नहीं खोते हैं जो हमने धाराओं का उपयोग करते समय खो दिया था। गो में, एक ही संदर्भ स्विच की लागत ~ 200 नैनोसेकंड या ~ 2.4 हजार कमांड है। अनुसूचक भी स्ट्रिंग और NUMA के प्रदर्शन को बेहतर बनाने में मदद करता है। इसलिए हमें वर्चुअल कोर की तुलना में अधिक थ्रेड की आवश्यकता नहीं है। गो समय के साथ अधिक काम कर सकता है, क्योंकि गो अनुसूचक कम धागे का उपयोग करने और प्रत्येक थ्रेड पर अधिक करने की कोशिश करता है, जो ओएस और हार्डवेयर पर लोड को कम करने में मदद करता है।

निष्कर्ष

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

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

गो में नियोजन: भाग II - द गो शेड्यूलर