🤱🏼 🔕 🍮 AMD APP SDK: इंटरमीडिएट भाषा (IL) 🏤 🔡 ⏬

ATI स्ट्रीम SDK का नाम बदलकर AMD त्वरित समानांतर प्रसंस्करण (APP) SDK कर दिया गया और OpenCL ने ब्रूक + की गणना के लिए मुख्य प्रोग्रामिंग भाषा GPGPU का स्थान ले लिया। हालांकि, बहुत से लोगों को यह पता नहीं है कि एटीआई कार्ड के लिए कोड लिखना एक अन्य तकनीक का उपयोग करना संभव है: एएमडी कंप्यूट एब्स्ट्रेक्शन लेयर (सीएएल) / इंटरमीडिएट लैंग्वेज (आईएल)। CAL तकनीक को कोड लिखने के लिए डिज़ाइन किया गया है जो GPU के साथ इंटरैक्ट करता है और CPU पर चलता है, जबकि IL तकनीक आपको कोड लिखने की अनुमति देती है जो सीधे GPU पर चलेगा।

यह लेख OpenCL पर IL तकनीक, इसके दायरे, सीमाओं और लाभों की जांच करेगा। बिल्ली के नीचे, कौन परवाह करता है।

परिचय

आरंभ करने के लिए, यहाँ Nvidia CUDA SDK से कुछ तुलना की गई है:

उच्च स्तरीय प्रोग्रामिंग भाषा:
- एनवीडिया: क्यूडा सी ++ एक्सटेंशन
- एएमडी: ओपनसीएल 1.1 या कंप्यूट एब्स्ट्रक्शन लेयर (CAL)
निम्न स्तर की प्रोग्रामिंग भाषा (छद्म कोडक *):
- एनवीडिया: समानांतर धागा निष्पादन (PTX)
- AMD: मध्यवर्ती भाषा (IL)
"तोते की संख्या प्रति सेकंड" (उदाहरण के लिए, प्रति सेकंड छांटे गए हैश की संख्या) का अनुपात "अनुपात मूल्य:"
- एनवीडिया: एक्स
- एएमडी: सीएएल / आईएल बंडल का उपयोग करते समय ~ 2x

* इसका मतलब है कि हालांकि भाषा कोडांतरक के समान है, यह अभी भी संकलक द्वारा अनुकूलित है और विभिन्न GPU के लिए अलग कोड में परिवर्तित किया गया है

आप ऐसा प्रदर्शन कैसे प्राप्त कर सकते हैं?

AMD GPU आर्किटेक्चर के फीचर्स

यदि आप एनवीडिया पीटीएक्स विनिर्देश और एएमडी आईएल विनिर्देश को ध्यान से पढ़ते हैं, तो आप देखेंगे कि एनवीडिया पीटीएक्स में ऑपरेंडर्स एकल-घटक वैक्टर (यानी, सरल एन-बिट रजिस्टर) हैं, जबकि एएमडी आईएल बैंड्स एन-बिट रजिस्टरों के 4-घटक वैक्टर हैं। । यदि हम दोनों भाषाओं में गुणा के संचालन पर विचार करेंगे तो यह और स्पष्ट हो जाएगा:

# Nvidia PTX mul.u32 %r0, %r1, %r2 # AMD IL umul r0.xyzw, r1.xyzw, r2.xyzw

इस प्रकार, एक (लगभग एक में) ऑपरेशन में, एएमडी जीपीयू 4 एन-बिट रजिस्टर में बदल सकता है, और एनवीडिया जीपीयू केवल एक एन-बिट रजिस्टर (एक जीपीयू स्ट्रीम के भीतर अर्थ) बदल सकता है। लेकिन OpenCL आपको मल्टीकोम्पोनेंट वैक्टर घोषित करने और उनके साथ काम करने की भी अनुमति देता है! फिर क्या अंतर है और यह आईएल आखिर क्यों जरूरी है?

OpenCL के विपरीत

और सभी अंतर इस बात से स्पष्ट हैं कि AMD APP SDK के डेवलपर्स या तो कठिन थे या तकनीकी रूप से एक कंपाइलर बनाने में असंभव थे जो कि OpenCL विनिर्देशन के अनुसार कोड को AMD IL पर लिखे गए कोड में अनुवाद करता हो। इसलिए OpenCL मानक के लिए समर्थन पर सीमाएं :

OpenCL 1.0 लगभग Radeon HD 4000 सीरीज (बीटा लेवल सपोर्ट) से शुरू होने के लिए समर्थित है (छवि ऑब्जेक्ट के लिए कोई समर्थन नहीं हो सकता है, अर्थात् बनावट मेमोरी)
OpenCL 1.1 को Radeon HD 5000 सीरीज के आसपास शुरू करने का समर्थन किया गया है
OpenCL 1.2 को Radeon HD 7000 के आसपास शुरू करने का समर्थन किया गया है, लेकिन मानक के इस संस्करण का समर्थन करने वाला SDK अभी तक जारी नहीं किया गया है

यह ध्यान देने योग्य है कि AMD IL आपको GPGPU कंप्यूटिंग के लिए Radeon HD 3000 श्रृंखला और यहां तक कि Radeon HD 2000 श्रृंखला से कुछ कार्ड का उपयोग करने की अनुमति देता है! (पूरी तरह से सटीक होने के लिए, ये R600, RV610, RV630 और RV670 चिप्स पर आधारित GPU हैं)
इसके अलावा, संक्षिप्तता के लिए, हम सभी GPU को Radeg HD HD 5000 श्रृंखला के साथ Evergreen GPUs के रूप में शुरू करेंगे (यह एक Radeon HD 5700 चिप है), क्योंकि केवल इन कार्डों के लिए कुछ दिलचस्प संचालन समर्थित हैं।

एएमडी आईएल के लिए कोड लिखने के सिद्धांतों की व्याख्या करने के लिए आगे बढ़ने से पहले, मैं आपका ध्यान आकर्षित करना चाहूंगा

स्मृति के साथ काम करने की विशेषताएं

जैसा कि मैंने उल्लेख किया है, एएमडी जीपी 4 घटक वैक्टर एन-बिट रजिस्टरों के साथ काम करता है, जहां एन = 32 (64-बिट रजिस्टरों के साथ कैसे काम करना है, आगे)। यह मेमोरी पर एक प्रमुख सीमा लगाता है: मेमोरी को केवल 16 बाइट्स के कई में आवंटित किया जा सकता है। यह याद रखना चाहिए कि मेमोरी से खरबूजे को लोड करते समय, ये 16 बाइट्स फिर से न्यूनतम ट्रांसमिशन क्षमता हैं। यही है, यह बिल्कुल भी मायने नहीं रखता है कि क्या आप इंगित करते हैं कि आपकी मेमोरी में 1 बाइट के 4 घटक वैक्टर शामिल हैं (char4), 4 बाइट्स के 4 घटक वैक्टर में से प्रत्येक (int4), परिणाम एक होगा - मेमोरी के लिए, एक एक्सचेंज ऑपरेशन लोड होगा 16 बाइट्स।

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

और अंत में: फिर से, एनवीडिया जीपीयू के विपरीत, केवल एक वैश्विक मेमोरी है जो रीड-राइट के लिए काम करती है (इसके बाद यह "जी []" होगा), और बनावट मेमोरी के कई अलग-अलग स्रोत हैं (इसके बाद यह "0 "," i1 "होगा) ", आदि) और निरंतर मेमोरी (इसके बाद यह" cb0 "," cb1 ", आदि) होगा, जो केवल पढ़ने के लिए हैं।
निरंतर मेमोरी की एक विशेषता कैशिंग की उपस्थिति है जब सभी जीपीयू थ्रेड्स एक डेटा क्षेत्र तक पहुंचते हैं (यह रजिस्टरों के रूप में तेजी से काम करता है)।
बनावट मेमोरी की एक विशेषता कैशिंग (8 केबी से, यदि मेरी मेमोरी मुझे प्रति एक स्ट्रीम प्रोसेसर पर मिलती है) और वास्तविक निर्देशांक द्वारा मेमोरी तक पहुंचने की क्षमता है। जब आप बनावट की सीमाओं से परे जाते हैं, तो आप या तो सीमा तत्व को पढ़ सकते हैं, या लूप को पहले पढ़ सकते हैं (समन्वय को मॉडुलो को बनावट की चौड़ाई / लंबाई के रूप में लिया जाता है)।

और अब मज़ेदार हिस्से के लिए:

AMD IL के लिए कोड संरचना

रजिस्टरों के साथ काम करें

सबसे पहले, संचालन में रजिस्टरों के बीच विनिमय कैसे होता है, इसकी एक छोटी व्याख्या।
वेक्टर घटक के स्थान पर आउटपुट रजिस्टर में घटक का नाम या चिह्न "_" हो सकता है, जिसका अर्थ है कि यह घटक परिवर्तित नहीं होगा।
प्रत्येक घटक के स्थान पर प्रत्येक इनपुट रजिस्टर में चार घटकों का कोई भी नाम हो सकता है, या तो "0" या "1"। इसका मतलब यह है कि या तो इनपुट रजिस्टर घटक या एक निरंतर आउटपुट रजिस्टर के संगत घटक पर ऑपरेशन में शामिल है। मैं समझाता हूँ कि एक उदाहरण के साथ क्या कहा गया था:

 # r0.x = r1.z # r0.y = r1.w # r0.w = r1.y mov r0.xy_w, r1.zwyy # r0.y = 1 # r0.z = 0 mov r0._yz_, r1.x100

shaders

AMD GPU के लिए कोड को शेड के रूप में जारी किया जाता है। कंप्यूटर shader (Compute Shader, CS) और पिक्सेल shader (Pixel Shader, PS) दोनों को चलाना संभव है। हालाँकि, CS को केवल Radeon HD 4000 Series के साथ शुरू करने का समर्थन किया गया है। इसके अलावा, उनकी गति लगभग समान है।

यह ज्ञात है कि GPU पर एक साथ लॉन्च किए गए थ्रेड्स की संख्या लॉन्च मापदंडों द्वारा निर्धारित की जाती है: ब्लॉक की संख्या, प्रति ब्लॉक थ्रेड्स की संख्या। GPU के प्रत्येक मल्टीप्रोसेसर (8 टुकड़ों से) निष्पादन के लिए एक ब्लॉक लेता है। फिर यह प्रति ब्लॉक धागे की संख्या को टुकड़ों में विभाजित करता है (ताना, 32 का गुणक) और इसके प्रत्येक थ्रेड प्रोसेसर को निष्पादन के लिए एक ताना देता है। इस प्रकार, एक साथ चलने वाले धागों की वास्तविक संख्या है:

<multiprocessors_count> * <stream_processors_per_multiprocessor_count> * <warp_size>

यही कारण है कि सबसे तेज काम के लिए, यह आवश्यक है कि, एक ताना के ढांचे के भीतर, धागे एक ही ऑपरेशन करते हैं, बिना शाखा के। फिर यह ऑपरेशन एक बार में किया जाएगा।

वैक्यूम में एक गोलाकार घोड़े पर विचार नहीं करने के लिए, हम एक साधारण समस्या पर विचार करते हैं: प्रत्येक थ्रेड ब्लॉक (32 बिट्स), वैश्विक पहचानकर्ता (32 बिट्स) के भीतर अपने स्थानीय पहचानकर्ता की गणना करता है, निर्देश मेमोरी और डेटा मेमोरी से स्थिरांक (64 बिट्स) पढ़ता है, पढ़ता है। बनावट (128 बिट) से एक तत्व। वह आउटपुट मेमोरी में यह सब लिखता है, इसके लिए प्रत्येक थ्रेड को 256 बिट्स की आवश्यकता होगी।
नोट: बनावट की प्रत्येक पंक्ति में एक ब्लॉक के प्रवाह के लिए डेटा होता है।

पिक्सेल shader

 il_ps_2_0 ;   (cb0): ; cb0[0].x -   ; cb0[0].y -   ; cb0[0].zw -  dcl_cb cb0[1] ;     (i0) ;   -  (   ),  (     float  0  1) ;          (   uint) dcl_resource_id(0)_type(2d,unnorm)_fmtx(uint)_fmty(uint)_fmtz(uint)_fmtw(uint) ;       dcl_input_position_interp(linear_noperspective) vWinCoord0.xy__ ;   (g[]) ; ,     dcl_literal l0, 0xFFFFFFFF, 0xABCDEF01, 0x3F000000, 2 ;         ; r0.x -   x  i0   (float) (     ) ; r0.y -   y  i0   (float) (   ) ftoi r0.xyzw, vWinCoord0.xyxy ;  r0.z -    (uint) umad r0.__z_, r0.wwww, cb0[0].yyyy, r0.zzzz ;       ftoi r1.x___, vWinCoord0.xxxx mov r1._y__, r0.zzzz mov r1.__z_, cb[0].xxxx mov r1.___w, l0.yyyy ;      g[] umul r0.__z_, r0.zzzz, l0.wwww ;       mov g[r0.z+0].xyzw, r1.xyzw ;     i0 ;     float   0.5 itof r0.xy__, r0.xyyy add r0.xy__, r0.xyyy, l0.zzzz sample_resource(0)_sampler(0)_aoffimmi(0,0,0) r1, r0 ; sample_resource(0) -   i0 ; _sampler(0) -   sampler'a #0 ; _aoffimmi(0,0,0) -   x, y, z ;        ,  _aoffimmi(1,0,0);   - _aoffimmi(0,1,0) ;       mov g[r0.z+1].xyzw, r1.xyzw ;     endmain ;    end

गणना करने वाला शेडर

सभी अंतर केवल प्रवाह पहचानकर्ताओं की गणना में होंगे, बाकी सभी समान हैं।

 il_cs_2_0 dcl_num_thread_per_group 64 ;   (cb0): ; cb0[0].x -   ; cb0[0].yzw -  dcl_cb cb0[1] ;     (i0) ;   -  (   ),  (     float  0  1) ;          (   uint) dcl_resource_id(0)_type(2d,unnorm)_fmtx(uint)_fmty(uint)_fmtz(uint)_fmtw(uint) ;   (g[]) ; ,     dcl_literal l0, 0xFFFFFFFF, 0xABCDEF01, 0x3F000000, 2 ;   mov r0._y__, vThreadGrpIDFlat.xxxx ;     mov r0.x___, vTidInGrpFlat.xxxx ;    mov r0.__z_, vAbsTidFlat.xxxx ;       mov r1.x___, vTidInGrpFlat.xxxx mov r1._y__, vAbsTidFlat.xxxx mov r1.__z_, cb[0].xxxx mov r1.___w, l0.yyyy ;      g[] umul r0.__z_, r0.zzzz, l0.wwww ;       mov g[r0.z+0].xyzw, r1.xyzw ;     i0 ;     float   0.5 itof r0.xy__, r0.xyyy add r0.xy__, r0.xyyy, l0.zzzz sample_resource(0)_sampler(0)_aoffimmi(0,0,0) r1, r0 ; sample_resource(0) -   i0 ; _sampler(0) -   sampler'a #0 ; _aoffimmi(0,0,0) -   x, y, z ;        ,  _aoffimmi(1,0,0);   - _aoffimmi(0,1,0) ;       mov g[r0.z+1].xyzw, r1.xyzw ;     endmain ;    end

छाया का अंतर

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

निष्कर्ष

मैंने इस लेख में यह बताने की कोशिश की कि GPU पर निष्पादन के लिए AMD IL पर सरल कोड कैसे लिखें। अंत में, काम की गति के अनुकूलन के बारे में कुछ शब्द:

कोडांतरक के लिए अनुकूलन तकनीक अजीबोगरीब लागू करने का प्रयास न करें (स्थिरांक के साथ संचालन का स्वतंत्रकरण, स्वतंत्र संचालन की अनुमति)। यह मत भूलो कि यह अभी भी एक छद्म कोडांतरक है, इसलिए संकलक आपके लिए अनुकूलन करेगा। एल्गोरिथम के बारे में बेहतर सोचें।
कार्ड में ज्यादा से ज्यादा डाटा अपलोड करें। वेक्टर के सभी 4 घटकों के सभी 32 बिट्स का उपयोग करना उचित है।
यदि आपके पास इनपुट डेटा (उदाहरण के लिए, हैश गणना) पर एक ही प्रकार की गणना है, तो यह संचालन में घटकों की संख्या पर प्रयोग करने योग्य है: कभी-कभी r0.x ___ तेजी से काम करेगा, कभी-कभी r0.xy ___, और कभी-कभी r0.xyzw।
हालांकि एएमडी का दावा है कि एक ब्लॉक में थ्रेड्स की संख्या किसी भी <warp_size> के कई हो सकती है और GPU सही ढंग से व्यवहार करेगा, वास्तव में ऐसा नहीं है। प्रकृति में, मैंने केवल <warp_size> = 32 या 64 देखा, और मेरे GPU ने केवल <warp_size> के बराबर ब्लॉक में थ्रेड्स की संख्या के साथ सही ढंग से काम किया। इसके अलावा, Radeon HD 4650, जब एक ब्लॉक में 32 थ्रेड के साथ शुरू होता है (और तकनीकी डेटा के अनुसार, इस कार्ड के लिए <warp_size> = 32), मेरे एक एल्गोरिदम पर गलत डेटा दिया गया था, लेकिन इसने एक ब्लॉक में 64 थ्रेड के साथ धमाके के साथ काम किया। निष्कर्ष: एल्गोरिथ्म को केवल 64 थ्रेड्स प्रति ब्लॉक के साथ चलाएं (और ब्लॉक की संख्या पहले से ही विविध हो सकती है)।
सदाबहार GPU कई शांत सुविधाओं का समर्थन करते हैं: चक्रीय पारी, अतिप्रवाह झंडे का समर्थन, 64-बिट संचालन के लिए समर्थन (2 घटक इसके लिए आरक्षित हैं)। दुर्भाग्य से, एवरग्रीन से छोटे परिवार के जीपीयू इन सभी बन्स का समर्थन नहीं करते हैं। अगर कोई मुझसे कहता है कि उन पर 64-बिट ऑपरेशन कैसे लिखें, तो मैं आभारी रहूंगा।

डेटा को कार्ड में कैसे ट्रांसफर किया जाए और उससे डेटा कैसे इकट्ठा किया जाए, इसका वर्णन दूसरे भाग में एएमडी कंप्यूट एब्स्ट्रेक्शन लेयर (CAL) के बारे में किया गया है।

AMD APP SDK: इंटरमीडिएट भाषा (IL)