🐍 👵🏽 🚂 जाओ समयबद्धक: अब सहकारी नहीं है? 👇🏿 👨🏿‍🏭 🍝

यदि आप संस्करण 1.14 के रिलीज़ नोट पढ़ते हैं, तो आपने संभवतः भाषा के रनटाइम में कुछ बहुत ही रोचक बदलावों को देखा है। इसलिए मुझे आइटम में बहुत दिलचस्पी थी: "गोरटाइन्स अब अतुल्यकालिक रूप से पूर्वनिर्धारित हैं।" यह पता चला है कि जीओ अनुसूचक (अनुसूचक) अब सहकारी नहीं है? खैर, संबंधित प्रस्ताव को तिरछे पढ़ने के बाद, जिज्ञासा संतुष्ट हुई।

हालांकि, थोड़ी देर बाद मैंने नवाचारों पर अधिक विस्तार से शोध करने का फैसला किया। मैं इन अध्ययनों के परिणामों को साझा करना चाहूंगा।

सिस्टम आवश्यकताएं

नीचे वर्णित बातें, GO भाषा के ज्ञान के अलावा, पाठक से आवश्यक हैं, अतिरिक्त ज्ञान, अर्थात्:

अनुसूचक के सिद्धांतों की समझ (हालांकि मैं नीचे समझाने की कोशिश करूंगा, "उंगलियों पर")
यह समझना कि कचरा उठाने वाला कैसे काम करता है
समझ जाओ कि गो असेंबलर क्या है

अंत में, मैं कुछ लिंक छोड़ दूंगा, जो मेरी राय में, इन विषयों को अच्छी तरह से कवर करते हैं।

संक्षेप में योजनाकार के बारे में

सबसे पहले, मैं आपको याद दिलाता हूं कि सहकारी और गैर-सहकारी मल्टीटास्किंग क्या है।

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

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

इसके अलावा, हम उस कोनेस्टोन पर विचार करते हैं जो अनुसूचक द्वारा संचालित होता है:

पी - तार्किक प्रोसेसर (हम रनटाइम के साथ उनकी संख्या बदल सकते हैं। GOMAXPROCS फ़ंक्शन), प्रत्येक तार्किक प्रोसेसर पर एक समय में एक गोरोइन को स्वतंत्र रूप से निष्पादित किया जा सकता है।
एम - ओएस थ्रेड्स। प्रत्येक P, M से एक धागे पर चलता है। ध्यान दें कि P हमेशा M के बराबर नहीं होता है, उदाहरण के लिए, एक धागा syscall द्वारा अवरुद्ध किया जा सकता है और फिर इसके P के लिए एक और धागा आवंटित किया जाएगा। और सीजीओ और अन्य और अन्य बारीकियां हैं।
जी - गोरुटिंस। खैर यहाँ यह स्पष्ट है, G को प्रत्येक P पर निष्पादित किया जाना चाहिए और अनुसूचक इस पर नज़र रखता है।

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

और वास्तव में समस्या क्या है?

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

बिगाड़ने वाला

func main() {
	runtime.GOMAXPROCS(1)
	go func() {
		var u int
		for {
			u -= 2
			if u == 1 {
				break
			}
		}
	}()
	<-time.After(time.Millisecond * 5) //    main   ,         

	fmt.Println("go 1.13 has never been here")
}

यदि आप इसे GO <1.14 संस्करण के साथ संकलित करते हैं, तो लाइन "गो 1.13 यहां कभी नहीं रही है" आप स्क्रीन पर नहीं देखेंगे। ऐसा इसलिए होता है, क्योंकि जैसे ही शेड्यूलर एक अनंत लूप के साथ गोरोइन को प्रोसेसर का समय देता है, यह पूरी तरह से पी को पकड़ लेता है, इस गोरोइन के अंदर कोई फ़ंक्शन कॉल नहीं होता है, जिसका अर्थ है कि हम अब शेड्यूलर को नहीं जगाएंगे। और रनटाइम के लिए केवल एक स्पष्ट कॉल। गोस्ड () हमारे कार्यक्रम को समाप्त कर देगा।

यह केवल एक उदाहरण है जहां गोरोइनट पी को कैप्चर करता है और लंबे समय तक अन्य गोरोइन्ट्स को इस पी पर निष्पादित करने से रोकता है। इस व्यवहार के कारण के लिए अधिक विकल्प इस प्रस्ताव को पढ़ने से समस्याओं का पता लगाया जा सकता है।

पार्स प्रस्ताव

इस समस्या का समाधान काफी सरल है। चलो ओएस अनुसूचक के रूप में ही करते हैं! बस, G से Goroutine को बाहर जाने दें और वहां एक और डालें, और इसके लिए हम OS टूल्स का उपयोग करेंगे।

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

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

क्या आप वहां गए, जीसी?

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

स्रोत में पाया गया

Synchronous safe-points are implemented by overloading the stack bound check in function prologues. To preempt a goroutine at the next synchronous safe-point, the runtime poisons the goroutine's stack bound to a value that will cause the next stack bound check to fail and enter the stack growth implementation, which will detect that it was actually a preemption and redirect to preemption handling.

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


j := &someStruct{}
p := unsafe.Pointer(j)
// unsafe-point start
u := uintptr(p)
//do some stuff here
p = unsafe.Pointer(u)
// unsafe-point end

यह समझने के लिए कि समस्या क्या है, चलो एक कचरा कलेक्टर की त्वचा पर प्रयास करें। हर बार जब हम काम पर जाते हैं, तो हमें रूट नोड्स (स्टैक पर पॉइंटर्स और रजिस्टरों में) का पता लगाने की आवश्यकता होती है, जिसके साथ हम मार्क करना शुरू करेंगे। चूंकि रनटाइम में यह कहना असंभव है कि क्या मेमोरी में 64 बाइट्स एक पॉइंटर हैं या सिर्फ एक नंबर है, हम स्टैक और रजिस्टर कार्ड (मेटा जानकारी के साथ कुछ कैश) की ओर मुड़ते हैं, कृपया हमें जीओ कंपाइलर द्वारा प्रदान करें। इन मानचित्रों की जानकारी हमें पॉइंटर्स खोजने की अनुमति देती है। इसलिए, हम जागे थे और काम करने के लिए भेजा जब जीओ ने लाइन नंबर 4 का प्रदर्शन किया। जगह पर पहुंचकर और कार्डों को देखते हुए, हमने पाया कि यह खाली था (और यह सच है, क्योंकि जीसी के दृष्टिकोण से uintptr एक संख्या है और एक सूचक नहीं है)। खैर, कल हमने j के लिए मेमोरी के आवंटन के बारे में सुना, क्योंकि अब हम इस मेमोरी में नहीं जा सकते हैं - हमें इसे साफ़ करने की आवश्यकता है, और मेमोरी को हटाने के बाद हम सो जाते हैं।आगे क्या होगा? खैर, अधिकारियों ने रात में जागते हुए, चिल्लाते हुए कहा, ठीक है, आप खुद समझ गए।

यह सब सिद्धांत के साथ है, मैं अभ्यास में विचार करने का प्रस्ताव करता हूं कि ये सभी संकेत, असुरक्षित बिंदु और रजिस्टर कार्ड और स्टैक कैसे काम करते हैं।

अभ्यास के लिए आगे बढ़ते हैं

मैंने डबल प्रोफाइल (1.14 पर जाएं और 1.13 पर जाएं) लेख की शुरुआत से परफेक्ट प्रोफाइलर के उदाहरण से देखा कि कौन सी सिस्टम कॉल होती है और उनकी तुलना करें। 14 वें संस्करण में आवश्यक syscall काफी जल्दी पाया गया था:

15.652 ( 0.003 ms): main/29614 tgkill(tgid: 29613 (main), pid: 29613 (main), sig: URG                ) = 0

ठीक है, जाहिर है कि रनटाइम ने SIGURG को उस धागे पर भेजा है जिस पर गोरोइन घूम रहा है। इस ज्ञान को एक प्रारंभिक बिंदु के रूप में लेते हुए, मैं यह पता लगाने के लिए कि यह संकेत कहाँ और किस कारण से भेजा गया है, जाने के लिए GO में कमिट्स को देखने के लिए गया था, और उस स्थान को खोजने के लिए भी जहाँ सिग्नल हैंडलर स्थापित है। चलो भेजने के साथ शुरू करते हैं, हम रनटाइम / os_linux.go में सिग्नल भेजने वाले फ़ंक्शन को देखेंगे


func signalM(mp *m, sig int) {
	tgkill(getpid(), int(mp.procid), sig)
}

अब हमें रनटाइम कोड में स्थान मिलते हैं, जहाँ से हम सिग्नल भेजते हैं:

जब गोरोइन्टेन सस्पेंड होता है, अगर वह चालू अवस्था में हो। सस्पेंड अनुरोध कचरा कलेक्टर से आता है। यहां, शायद, मैं कोड नहीं जोड़ूंगा, लेकिन यह फ़ाइल रनटाइम / preempt.go (suspendG) में पाया जा सकता है
यदि अनुसूचक तय करता है कि गोरोइन बहुत लंबे समय तक काम कर रहा है, तो रनटाइम / proc.go (रीटेक)
```
if pd.schedwhen+forcePreemptNS <= now {
	signalM(_p_)
}
```
forcePreemptNS - 10ms, pd.schedwhen के बराबर समय - जब pd स्ट्रीम के अनुसूचक को अंतिम बार बुलाया गया था
साथ ही सभी धाराएँ यह संकेत एक आतंक के दौरान भेजा जाता है, StopTheWorld (GC) और कुछ और मामले (जो मुझे बायपास करने हैं, क्योंकि लेख का आकार पहले से ही सीमा से परे हो जाएगा)

हमने यह पता लगाया कि रनटाइम कब और कैसे एम को सिग्नल भेजता है। अब इस सिग्नल के लिए हैंडलर ढूंढें और देखें कि स्ट्रीम प्राप्त होने पर क्या करता है।


func doSigPreempt(gp *g, ctxt *sigctxt) {
	if wantAsyncPreempt(gp) && isAsyncSafePoint(gp, ctxt.sigpc(), ctxt.sigsp(), ctxt.siglr()) {
		// Inject a call to asyncPreempt.
		ctxt.pushCall(funcPC(asyncPreempt))
	}
}

इस फ़ंक्शन से यह स्पष्ट है कि "लॉक इन" करने के लिए आपको 2 चेक से गुजरना होगा:

wantAsyncPreempt - हम जाँचते हैं कि क्या G को जबरन हटाया जाना है, यहाँ, उदाहरण के लिए, वर्तमान गोरोइनिन स्थिति की वैधता की जाँच की जाएगी।
isAsyncSafePoint - जांचें कि क्या यह अभी बाहर भीड़ जा सकता है। यहां चेक का सबसे दिलचस्प यह है कि क्या जी एक सुरक्षित या असुरक्षित बिंदु में है। इसके अलावा, हमें यह सुनिश्चित करना चाहिए कि जिस धागे पर जी चल रहा है वह भी जी को प्रीमीट करने के लिए तैयार है।

यदि दोनों चेक पास हो जाते हैं, तो निष्पादन योग्य कोड से निर्देश बुलाए जाएंगे जो राज्य जी को बचाते हैं और अनुसूचक को बुलाते हैं।

और असुरक्षित के बारे में अधिक

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

एक और अंतहीन कार्यक्रम


//go:nosplit
func infiniteLoop() {
	var u int
	for {
		u -= 2
		if u == 1 {
			break
		}
	}
}

func main() {
	runtime.GOMAXPROCS(1)
	go infiniteLoop()
	<-time.After(time.Millisecond * 5)

	fmt.Println("go 1.13 and 1.14 has never been here")
}

जैसा कि आप अनुमान लगा सकते हैं, शिलालेख "गो 1.13 और 1.14 कभी यहां नहीं था" हम GO 1.14 में नहीं देखेंगे। इसका कारण यह है कि हमने अनन्त रूप से अनन्त रूप से बाधित करने के लिए मना किया है (जाओ: nosplit) फ़ंक्शन। इस तरह के प्रतिबंध को असुरक्षित-बिंदु का उपयोग करके लागू किया जाता है, जो कि पूरे शरीर का कार्य है। आइए देखते हैं कि अनंत अनंत फ़ंक्शन के लिए संकलक क्या उत्पन्न करता है।

सावधानी असेम्बलर


        0x0000 00000 (main.go:10)   TEXT    "".infiniteLoop(SB), NOSPLIT|ABIInternal, $0-0
        0x0000 00000 (main.go:10)   PCDATA  $0, $-2
        0x0000 00000 (main.go:10)   PCDATA  $1, $-2
        0x0000 00000 (main.go:10)   FUNCDATA        $0, gclocals·33cdeccccebe80329f1fdbee7f5874cb(SB)
        0x0000 00000 (main.go:10)   FUNCDATA        $1, gclocals·33cdeccccebe80329f1fdbee7f5874cb(SB)
        0x0000 00000 (main.go:10)   FUNCDATA        $2, gclocals·33cdeccccebe80329f1fdbee7f5874cb(SB)
        0x0000 00000 (main.go:10)   XORL    AX, AX
        0x0002 00002 (main.go:12)   JMP     8
        0x0004 00004 (main.go:13)   ADDQ    $-2, AX
        0x0008 00008 (main.go:14)   CMPQ    AX, $3
        0x000c 00012 (main.go:14)   JNE     4
        0x000e 00014 (main.go:15)   PCDATA  $0, $-1
        0x000e 00014 (main.go:15)   PCDATA  $1, $-1
        0x000e 00014 (main.go:15)   RET

हमारे मामले में, PCDATA निर्देश रुचि का है। जब लिंकर इस निर्देश को देखता है, तो वह इसे "वास्तविक" कोडांतरक में परिवर्तित नहीं करता है। इसके बजाय, संगत प्रोग्राम काउंटर के बराबर कुंजी (फ़ंक्शन नाम + लाइन के बाईं ओर देखे जा सकते हैं) के साथ 2 तर्क का मान रजिस्टर या स्टैक मैप (1 तर्क द्वारा निर्धारित) में रखा जाएगा।

जैसा कि हम 10 और 15 की तर्ज पर देखते हैं, हमने क्रमशः $ 2 और -1 को $ 0 और $ 1 के नक्शे में रखा। आइए इस क्षण को याद करें और isAsyncSafePoint फ़ंक्शन के अंदर देखें, जिससे मैंने आपका ध्यान पहले ही खींच लिया है। वहाँ हम निम्नलिखित पंक्तियाँ देखेंगे:

isAsyncSafePoint


	smi := pcdatavalue(f, _PCDATA_RegMapIndex, pc, nil)
	if smi == -2 {
		return false
	}

यह इस जगह पर है कि हम जांचते हैं कि गोरोइन वर्तमान में सुरक्षित बिंदु पर है या नहीं। हम रजिस्टरों के नक्शे (_PCDATA_RegMapIndex = 0) की ओर मुड़ते हैं, और इसे वर्तमान पीसी में पास करते हुए हम मान की जाँच करते हैं, यदि -2 तो G सुरक्षित-बिंदु में नहीं है, जिसका अर्थ है कि इसे बाहर नहीं निकाला जा सकता है।

निष्कर्ष

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

जाओ अनुसूचक - एक बार और दो बार ।

असेंबलर जीओ।

जाओ समयबद्धक: अब सहकारी नहीं है?