जाओ: गोरोइन प्रदर्शन

परिचय

इस पोस्ट में हम goroutine के प्रदर्शन को देखेंगे। Goroutines एक तरह की बहुत सस्ती और हल्की धाराएँ हैं। सबसे अधिक संभावना है, वे एरलांग में प्रक्रियाओं के समान हैं।

प्रलेखन के अनुसार, हम अपने कार्यक्रमों में सैकड़ों हजारों गोरोनाइट का उपयोग कर सकते हैं। और लेख का उद्देश्य इसे सत्यापित और संक्षिप्त करना है।

स्मृति

गोरोइन के लिए आवंटित स्मृति का आकार प्रलेखित नहीं है (यह केवल यह कहा जाता है कि यह कई किलोबाइट है), लेकिन विभिन्न मशीनों पर परीक्षण और इंटरनेट पर बहुत सारी पुष्टिएं इस संख्या को 4 - 4.5 बिलोबाइट को परिष्कृत करना संभव बनाती हैं। यानी 1 मिलियन गोरोनाइट के लिए पर्याप्त के मार्जिन के साथ 5 जीबी।

उत्पादकता

यह निर्धारित करने के लिए रहता है कि जब हम कोड को गोरोइन के लिए आवंटित करते हैं तो हम कितना प्रोसेसर समय खो देते हैं। आपको याद दिला दूं कि इसके लिए आपको केवल फंक्शन को कॉल करने से पहले गो कीवर्ड डालना होगा।

go testFunc()

गोरूटाइन मुख्य रूप से मल्टीटास्किंग को प्राप्त करने का एक साधन है। डिफ़ॉल्ट रूप से, यदि GOMAXPROCS चर सिस्टम में सेट नहीं है, तो प्रोग्राम केवल एक थ्रेड का उपयोग करता है। सभी प्रोसेसर कोर का उपयोग करने के लिए, आपको उनकी संख्या इसमें लिखनी होगी: GOMAXPROCS = 2 निर्यात करें। चर को रनटाइम पर पढ़ा जाता है, इसलिए आपको प्रत्येक परिवर्तन के बाद कार्यक्रम को फिर से शुरू नहीं करना होगा।

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

सभी कार्य नेटटॉप पर किए जाते हैं:

• एटम D525 डुअल कोर 1.8 GHz
• 4Gb DDR3
• जाओ r60.3
• आर्क लिनक्स x86_64

तकनीक

यहाँ जाँच कार्यों का जनरेटर है:

 func genTest (n int) func (Res चान <- इंटरफ़ेस {}) {
         वापसी func (Res चान <- इंटरफ़ेस {}) {
                 मैं के लिए: = 0;  i <n;  मैं ++ {
                         math.Sqrt (13)
                 }
                 Res <- true
         }
 } 

और यहां प्राप्त कार्यों का एक सेट है जो क्रमशः 13, 1, 10, 100, 1000 और 5000 बार से रूट को घटाता है:

testFuncs := [] func (chan <- interface {}) { genTest(1), genTest(10), genTest(100), genTest(1000), genTest(5000) }

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

ठीक है, ज़ाहिर है, सटीकता के लिए, प्रत्येक परीक्षण कई बार किया जाता है। कार्यक्रम के कुल निष्पादन समय में लगभग 16 घंटे लगे।

एकल धागा

export GOMAXPROCS= 1


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

4 शेष कार्यों पर अधिक विस्तार से विचार करें:


यह देखा जा सकता है कि 700 हजार एक साथ काम करने वाले गोरोइन्ट्स के साथ भी, उत्पादकता 80% से अधिक नहीं गिरती है। सबसे अच्छी बात यह है कि जब फ़ंक्शन 1000 बार sqrt (13) की गणना के बराबर चलता है, तो ओवरहेड केवल 1% होता है । और 5,000 गुना पर - केवल 1%! और ये मान व्यावहारिक रूप से काम करने वाले गोरोइटों की संख्या से स्वतंत्र प्रतीत होते हैं! अर्थात्, एकमात्र सीमा स्मृति है।

निष्कर्ष:

यदि 10 जड़ों की गणना से अधिक कोड का एक स्वतंत्र टुकड़ा निष्पादित किया जाएगा (टाइमआउट सहित), और आप इसे समानांतर में निष्पादित करना चाहते हैं, तो साहसपूर्वक इसे गोरोइन में उजागर करें। यद्यपि यदि यह दर्द रहित रूप से इन साइटों में से 10 या 100 को एक साथ लाने में सक्षम है, तो उत्पादकता हानि क्रमशः 20% या 2% होगी।

कई सूत्र

अब उस स्थिति पर विचार करें जब हम एक साथ कई प्रोसेसर कोर का उपयोग करना चाहते हैं। मेरे मामले में उनमें से केवल 2 हैं:

export GOMAXPROCS= 2

अब फिर से परीक्षण कार्यक्रम चलाएं:


यहां यह स्पष्ट रूप से देखा गया है कि इस तथ्य के बावजूद कि कोर की संख्या दोगुनी हो गई है, पहले दो कार्यों का संचालन समय इसके विपरीत, बिगड़ गया है! चलो और तुच्छता से। इसका कारण यह है कि उन्हें दूसरे धागे में स्थानांतरित करने की लागत निष्पादन से अधिक है :)

अब तक, योजनाकार ऐसी स्थितियों को हल नहीं कर सकता है, लेकिन गो लेखक भविष्य में इस तरह के दोष को ठीक करने का वादा करते हैं।


और यहां हम विचार कर सकते हैं कि पिछले दो फ़ंक्शन दोनों कोर का उपयोग लगभग पूरी तरह से करते हैं। मेरे नेटटॉप पर, प्रत्येक व्यक्तिगत फ़ंक्शन क्रमशः ~ 45 μs और ~ 230 μs के लिए किया जाता है।

निष्कर्ष

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

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

पीएस अन्य भाषाओं में इसी तरह के परीक्षण देखना अच्छा होगा, उदाहरण के लिए इरलांग। विकिपीडिया ने इस पर 20 मिलियन प्रक्रियाओं को चलाने के सफल प्रयासों की रिपोर्ट दी!