सीयूडीए समवर्ती कर्नेल निष्पादन प्रति धारा एकाधिक कर्नेल

Question

सीयूडीए कर्नेल के लिए विभिन्न धाराओं का उपयोग समवर्ती कर्नेल निष्पादन संभव बनाता है। इसलिए nn धाराओं पर कर्नेल सैद्धांतिक रूप से एक साथ चल सकते हैं यदि वे हार्डवेयर में फिट हैं, है ना?

अब मुझे निम्न समस्या का सामना करना पड़ रहा है: n विशिष्ट कर्नेल नहीं हैं लेकिन n*m जहां m कर्नेल को क्रम में निष्पादित करने की आवश्यकता है। उदाहरण n=2 और m=3 के लिए धाराओं के साथ निम्नलिखित निष्पादन योजना के लिए नेतृत्व करेंगे:

Stream 1: <<<Kernel 0.1>>> <<<Kernel 1.1>>> <<<Kernel 2.1>>> 
Stream 2: <<<Kernel 0.2>>> <<<Kernel 1.2>>> <<<Kernel 2.2>>> 

मेरे भोली धारणा है कि कर्नेल x.0 और y.1 (देखने के एक सैद्धांतिक बिंदु से) समवर्ती पर अमल करना चाहिए या कम से कम है लगातार नहीं (एक व्यावहारिक दृष्टिकोण से)। लेकिन मेरे माप मुझे दिखा रहे हैं कि यह मामला नहीं है और ऐसा लगता है कि लगातार निष्पादन किया जाता है (i। E। K0.0, K1.0, K2.0, K0.1, K1.1, K2.1)। कर्नेल स्वयं बहुत छोटे होते हैं, इसलिए समवर्ती निष्पादन एक समस्या नहीं होनी चाहिए।

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

ठीक है, सीधे बिंदु पर आ रहा है: इस स्थिति को हल करने के लिए उचित (या कम से कम अलग) दृष्टिकोण क्या होगा?

संपादित करें: सीयूडीए कार्यक्रमों का उपयोग करके मापन किया जाता है। मैंने गणना को पूरी तरह हल करने के लिए आवश्यक समय को माप लिया है, i। ई। जीपीयू को सभी n * m कर्नेल की गणना करना है। धारणा है: पूरी तरह से समवर्ती कर्नेल निष्पादन पर निष्पादन समय मोटे तौर पर (आदर्श) 1/n समय के लिए सभी कर्नेल निष्पादित करने के लिए आवश्यक है, जिससे यह संभव हो सकता है कि दो या दो से अधिक कर्नल एक साथ निष्पादित किए जा सकें। मैं इसे केवल दो अलग-अलग धाराओं का उपयोग करके सुनिश्चित कर रहा हूं।

मैं धाराओं का उपयोग करने के बीच निष्पादन समय के बारे में स्पष्ट अंतर को माप सकता हूं और बताए गए कर्नलों को प्रेषित करता हूं, i। ई .:

Loop: i = 0 to m 
    EnqueueKernel(Kernel i.1, Stream 1) 
    EnqueueKernel(Kernel i.2, Stream 2) 

बनाम

Loop: i = 1 to n 
    Loop: j = 0 to m 
     EnqueueKernel(Kernel j.i, Stream i) 

एक लंबे समय तक रनटाइम के बाद होता है।

संपादित करें # 2: स्ट्रीम संख्याओं को 1 से शुरू करने के लिए बदल दिया गया (0 के बजाय, नीचे टिप्पणियां देखें)।

संपादित # 3: हार्डवेयर एक NVIDIA टेस्ला M2090 है (यानी फर्मी, गणना क्षमता 2,0)

Answer 1

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

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