GPU पर तुलनाएं इतनी महंगी क्यों हैं?

Question

अपने टकराव का पता लगाने वाले वर्ग के प्रदर्शन को बेहतर बनाने की कोशिश करते हुए, मैंने पाया कि ~ 80% समय जीपीयू में बिताया है, इस पर खर्च किया है कि क्या / और स्थितियां सिर्फ बाल्टी के लिए सीमा का पता लगाने की कोशिश कर रही हैं, जिसके माध्यम से लूप होना चाहिए।

ज्यादा ठीक:

1. प्रत्येक थ्रेड को एक आईडी मिलती है, उस आईडी से वह मेमोरी से अपने त्रिकोण (प्रत्येक में 3 पूर्णांक) लाती है और उन 3 से वह अपने वर्टिकल (3 फ्लोट प्रत्येक) को लाती है।

2. फिर यह लंबों को पूर्णांक ग्रिड बिंदुओं (वर्तमान में 8x8x8) में बदल देता है और उन्हें इस ग्रिड पर त्रिभुज सीमा में बदल देता है

3. 3 बिंदुओं को सीमा में बदलने के लिए, यह प्रत्येक बिंदु के बीच प्रत्येक आयाम का न्यूनतम / अधिकतम पाता है

चूंकि मैं जिस प्रोग्रामिंग लैंग्वेज का इस्तेमाल कर रहा हूं, वह मिनमैक्स इंट्रेंसिक याद आ रही है, मैंने खुद को बनाया है, इस तरह दिखता है:

procedure MinMax(a, b, c):
   local min, max

   if a > b:
      max = a
      min = b
   else:
      max = b
      min = a
   if c > max:
      max = c
   else:
      if c < min:
         min = c

   return (min, max)

तो औसत पर यह 2.5 * 3 * 3 = 22.5 तुलना होना चाहिए जो वास्तविक त्रिकोण - बढ़त चौराहे परीक्षणों (लगभग 100 * 11-50 निर्देशों) की तुलना में अधिक समय तक खाने का अंत करता है।

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

तो एक gpu पर तुलनात्मक रूप से इतनी धीमी गति क्यों है?

Comments

आपका प्रश्न एक विशिष्ट प्रकार के हार्डवेयर पर कोड के विशिष्ट टुकड़े के अनुदेश-स्तर के प्रदर्शन के बारे में है। यह मेरे लिए एक कंप्यूटर विज्ञान प्रश्न की तुलना में एक प्रोग्रामिंग प्रश्न की तरह बहुत अधिक लगता है।

— डेविड रिचेर्बी

मेरा अनुमान है कि यह तुलनात्मक नहीं है बल्कि महंगी हैं लेकिन शाखाएं हैं। यदि संकलक पूर्वानुमान का उपयोग नहीं करता है (या GPU ऐसा प्रदान नहीं करता है), तो शाखाओं का उपयोग किया जाएगा जो "थ्रेड" forking का कारण बनता है (क्योंकि GPUs SIMD- उन्मुख हैं)। हालत को एक मास्क में बदलना और सशर्त चाल / स्वैप को संश्लेषित करने के लिए मास्क का उपयोग करना एक उचित विकल्प हो सकता है।

— पॉल ए। क्लेटन

@DavidRicherby मुझे यकीन नहीं है कि यह हालांकि विशिष्ट है। क्या यह प्रश्न किसी भी SIMD वास्तुकला पर लागू नहीं होगा?

— कैस्परल्ड

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

— भटकना तर्क

जैसा कि वैंडरिंग लॉजिक द्वारा उत्तर कम स्पष्ट तरीके से दिया गया है, GPU यह मानकर काम करते हैं कि कई "थ्रेड्स" एक ही निर्देश पर एक साथ हैं। तो GPUs, मोटे तौर पर बोल, बस हर शाखा लेने के बजाय सच शाखाओं। यही कारण है कि GPUs इस तथ्य का फायदा उठाते हैं कि पड़ोसी आमतौर पर समान शाखाएं लेते हैं; और जब यह सच नहीं है तो प्रदर्शन भयानक है।

— राब

Answer 1

जीपीयू सिमड आर्किटेक्चर हैं। SIMD आर्किटेक्चर में हर निर्देश को आपके द्वारा प्रोसेस किए जाने वाले प्रत्येक तत्व के लिए निष्पादित करने की आवश्यकता होती है। (इस नियम का अपवाद है, लेकिन यह शायद ही कभी मदद करता है)।

इसलिए आपकी MinMaxदिनचर्या में न केवल सभी कॉल को सभी तीन शाखा निर्देशों को लाने की आवश्यकता होती है, (भले ही औसतन केवल 2.5 का मूल्यांकन किया जाता है), लेकिन प्रत्येक असाइनमेंट स्टेटमेंट एक चक्र भी लेता है (भले ही यह वास्तव में "निष्पादित" न हो। )।

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

आपके कोड में, प्रत्येक SIMD निष्पादन लेन कर रहा है:

compare (a > b)
assign (max = a if a>b)
assign (min = b if a>b)
assign (max = b if not(a>b))
assign (min = a if not(a>b))
compare (c > max)
assign (max = c if c>max)
compare (c < min if not(c>max))
assign (min = c if not(c>max) and c<min)

यह मामला हो सकता है कि कुछ GPU पर, सशर्त रूप से पूर्वनिर्धारण के लिए यह रूपांतरण धीमा है यदि GPU स्वयं कर रहा है। जैसा कि @ पॉलए.केटलटन ने बताया है, अगर आपकी प्रोग्रामिंग लैंग्वेज और आर्किटेक्चर में एक प्रेडिकेटेड कंडीशनल मूव ऑपरेशन है (खासकर फॉर्म में से एक if (c) x = y else x = z) तो आप बेहतर कर सकते हैं। (लेकिन शायद ज्यादा बेहतर नहीं)।

इसके अलावा, रखने c < minसशर्त अंदर elseकी c > maxअनावश्यक है। यह निश्चित रूप से आपको कुछ भी नहीं बचा रहा है, और (यह देखते हुए कि GPU को स्वचालित रूप से इसे संकेत में परिवर्तित करना है) वास्तव में इसे दो अलग-अलग सशर्त में नेस्टेड होने के लिए चोट पहुँचा सकता है।

Comments

(क्षमा करें, यदि इसका कोई भाग अस्पष्ट नहीं है, तो मैं उत्तर देने से पहले सिद्धांतकारों को विषय के रूप में प्रश्न बंद करने की कोशिश कर रहा हूं।)

— भटकते हुए तर्क

मूल बातें पर अधिक जानकारी के लिए: http.developer.nvidia.com/GPUGems2/gpugems2_chapter34.html और अधिक हालिया वर्कआर्ड के लिए: eecis.udel.edu/~cavazos-cisc879/paper/a3-han.pdf

— Fizz

यह इस अर्थ में विषय है कि कुछ एल्गोरिदम को SIMD समानता के माध्यम से नहीं देखा जा सकता है। (अर्थात: वर्क, स्पैन, इत्यादि के अधिक सैद्धांतिक उपचार के लिए)

— रोब

यहाँ divergence people.maths.ox.ac.uk/gilesm/cuda/lecs/lec3-2x2.pdf के मूल आधारों पर एक और व्याख्यान दिया गया है , इन पर ध्यान दें कि समस्या (वैसे भी एनवीडिया पर) केवल प्रति-ताना है। अलग-अलग वार पर चल रहे कोड खुशी-खुशी विचलन कर सकते हैं। और इसे टालने के लिए एक अन्य विधि का प्रस्ताव: hal.inria.fr/file/index/docid/649650/filename/sbiswi.pdf

— Fizz

थोड़े अलग सौदे पर, लेकिन मैंने टिप्पणी के तहत लिखी गई टिप्पणियों के अनुसार eprint.iacr.org/2012/137.pdf पढ़ने लायक है: अनुमानित प्रदर्शन की तुलना में 10x मंदी एक जीपीयू के लिए "सामान्य" हो सकती है जब तक कि आप नीचे न उतरें इसकी विधानसभा के लिए (आमतौर पर आधिकारिक तौर पर असमर्थित उपकरण के साथ)। यह संभव है कि GPU- लक्ष्यीकरण संकलक बेहतर हो गए, लेकिन मैं अपनी सांस नहीं रोक पा रहा था।

— फिजा