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

लेख HighLoad ++ में मेरी प्रस्तुति के आधार पर लिखा गया था । यह मुख्य रूप से NVIDIA द्वारा प्रस्तावित प्रौद्योगिकियों की चर्चा करता है। मेरे पास किसी भी उत्पाद का विज्ञापन करने का कोई उद्देश्य नहीं है, मैं उन्हें केवल एक उदाहरण के रूप में देता हूं, और निश्चित रूप से प्रतिस्पर्धी निर्माताओं में ऐसा ही कुछ पाया जा सकता है।

GPU पर क्यों भरोसा करें?

दो प्रोसेसर की तुलना अलग-अलग मानदंडों के अनुसार की जा सकती है, शायद सबसे लोकप्रिय आवृत्ति और कोर की संख्या, कैश का आकार, आदि हैं, लेकिन अंत में, हम इस बात में रुचि रखते हैं कि एक प्रोसेसर प्रति यूनिट कितने ऑपरेशन कर सकता है, यह किस तरह का ऑपरेशन है, लेकिन एक अलग सवाल है। एक सामान्य मेट्रिक प्रति सेकंड फ्लोटिंग पॉइंट ऑपरेशन की संख्या है - फ्लॉप। और जब हम सॉफ्ट से गर्म की तुलना करना चाहते हैं, और सीपीयू के साथ हमारे मामले में जीपीयू, यह मीट्रिक काम में आता है।

नीचे दिया गया ग्राफ़ प्रोसेसर और वीडियो कार्ड के लिए समय के साथ इन समान फ्लॉप की वृद्धि को दर्शाता है।

(डेटा को खुले स्रोतों से एकत्र किया गया है, 2019-20 वर्षों के लिए कोई डेटा नहीं है, क्योंकि वहां सब कुछ बहुत सुंदर नहीं है, लेकिन GPU अभी भी जीतते हैं)

खैर, यह आकर्षक है, है ना? हम CPU से सभी गणनाओं को GPU में स्थानांतरित करते हैं और आठ गुना सर्वश्रेष्ठ प्रदर्शन प्राप्त करते हैं!

लेकिन, ज़ाहिर है, सब कुछ इतना सरल नहीं है। आप बस सब कुछ GPU में स्थानांतरित नहीं कर सकते, क्यों, हम आगे बात करेंगे।

GPU वास्तुकला और सीपीयू के साथ इसकी तुलना

मैं सीपीयू की वास्तुकला और बुनियादी तत्वों के साथ कई परिचित चित्र लाता हूं:

सीपीयू कोर

क्या खास है? एक कोर और सहायक ब्लॉकों का एक गुच्छा।

अब हम GPU वास्तुकला को देखते हैं:

GPU Core

A वीडियो कार्ड में बहुत से संसाधन कोर होते हैं, आमतौर पर कई हजार, लेकिन उन्हें ब्लॉक में जोड़ा जाता है; NVIDIA वीडियो कार्ड के लिए, आमतौर पर 32 प्रत्येक, और सामान्य तत्व शामिल होते हैं और रजिस्टर। GPU कोर और तार्किक तत्वों की वास्तुकला सीपीयू की तुलना में बहुत सरल है, अर्थात्, कोई प्रीफैचर्स, ब्रंच भविष्यवक्ता और बहुत कुछ नहीं हैं।

खैर, ये सीपीयू और जीपीयू की वास्तुकला में अंतर के प्रमुख बिंदु हैं, और वास्तव में, वे प्रतिबंध लगाते हैं या, इसके विपरीत, संभावनाओं को खोलते हैं जो हम GPU पर प्रभावी रूप से पढ़ सकते हैं।

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

GPU सीमाओं और सुविधाओं

यह आर्किटेक्चर निष्पादन योग्य एल्गोरिदम पर क्या सीमाएँ लगाता है:

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

यह क्या अवसर खोलता है:

दरअसल, उन्हीं SIMD गणनाओं का त्वरण। सबसे सरल उदाहरण मैट्रिसेस का मूल तत्व जोड़ है, और चलो इसका विश्लेषण करते हैं।

SIMD प्रतिनिधित्व के लिए शास्त्रीय एल्गोरिदम की कमी

परिवर्तन

हमारे पास दो सरणियाँ हैं, ए और बी, और हम सरणी ए के प्रत्येक तत्व में सरणी ए से एक तत्व जोड़ना चाहते हैं। नीचे सी में एक उदाहरण है, हालांकि मुझे आशा है कि यह उन लोगों के लिए स्पष्ट होगा जो इस भाषा को नहीं बोलते हैं:

void func(float *A, float *B, size)
{ 
   for (int i = 0; i < size; i++) 
   { 
       A[i] += B[i]
   } 
}

एक लूप और रैखिक रनटाइम में तत्वों का शास्त्रीय लूपबैक।

अब देखते हैं कि GPU के लिए ऐसा कोड कैसा दिखेगा:

void func(float *A, float *B, size) 
{ 
   int i = threadIdx.x; 
   if (i < size) 
      A[i] += B[i] 
}

और यहाँ यह पहले से ही दिलचस्प है, थ्रेडआईडीएक्स चर दिखाई दिया, जिसे हमने कहीं भी घोषित नहीं किया। हां, इसकी प्रणाली हमें प्रदान करती है। कल्पना करें कि पिछले उदाहरण में सरणी में तीन तत्व हैं, और आप इसे तीन समानांतर थ्रेड में चलाना चाहते हैं। ऐसा करने के लिए, आपको एक और पैरामीटर - इंडेक्स या स्ट्रीम नंबर जोड़ना होगा। यह वह वीडियो कार्ड है जो हमारे लिए करता है, हालांकि यह सूचकांक को एक स्थिर चर के रूप में पारित करता है और एक साथ कई आयामों के साथ काम कर सकता है - x, y, z।

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

int i = blockIdx.x * blockDim.x + threadIdx.x; // blockIdx –  , blockDim –  , threadIdx –

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

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

एकत्रीकरण

आइए अब देखते हैं कि SIMD प्रतिनिधित्व के लिए एकत्रीकरण कैसे दिखेगा:

हमारे पास n तत्वों की एक सरणी है। पहले चरण में, हम n / 2 धागे शुरू करते हैं और प्रत्येक धागा दो तत्वों को जोड़ता है, अर्थात। एक पुनरावृत्ति में, हम सरणी में तत्वों के आधे हिस्से को जोड़ते हैं। और फिर लूप में हम नए बनाए गए सरणी के लिए एक ही बात दोहराते हैं, जब तक कि हम पिछले दो तत्वों को एकत्र नहीं करते हैं। जैसा कि आप देख सकते हैं, सरणी का आकार जितना छोटा होगा, उतने ही कम समानांतर धागे हम शुरू कर सकते हैं, अर्थात्। एक GPU पर, यह पर्याप्त रूप से बड़े आकार के सरणियों को समझ में आता है। इस तरह के एक एल्गोरिथ्म का उपयोग तत्वों की राशि की गणना करने के लिए किया जा सकता है (वैसे, आपके द्वारा काम कर रहे डेटा के प्रकार के संभावित अतिप्रवाह के बारे में मत भूलना), अधिकतम, न्यूनतम या बस खोज के लिए खोज करें।

छंटाई

लेकिन पहले से ही छंटाई बहुत अधिक जटिल लगती है।

GPU पर दो सबसे लोकप्रिय छँटाई एल्गोरिदम हैं:

Bitonic-तरह
मूलांक-तरह

लेकिन रेडिक्स-सॉर्ट अभी भी अधिक बार उपयोग किया जाता है, और उत्पादन-तैयार कार्यान्वयन कुछ पुस्तकालयों में पाया जा सकता है। मैं विस्तार से विश्लेषण नहीं करूंगा कि ये एल्गोरिदम कैसे काम करते हैं? जो लोग रुचि रखते हैं, वे https://www.codeproject.com/Articles/543451/Parallel-Radix-Sort-on-the-GGU-use-Cplusplus- पर मूलांक-प्रकार का वर्णन पा सकते हैं। एएमपी और https://stackoverflow.com/a/26229897

लेकिन विचार यह है कि सॉर्टिंग के रूप में इस तरह के एक गैर-रैखिक एल्गोरिदम को भी एक सिमड दृश्य में कम किया जा सकता है।

और अब, GPU से प्राप्त की जा सकने वाली वास्तविक संख्याओं को देखने से पहले, आइए जानें कि तकनीक के इस चमत्कार के लिए कैसे प्रोग्राम करें?

कहा से शुरुवात करे

GPU के तहत प्रोग्रामिंग के लिए सबसे आम दो तकनीकों का उपयोग किया जा सकता है:

OpenCL
CUDA

OpenCL एक मानक है जो अधिकांश वीडियो कार्ड निर्माताओं द्वारा समर्थित है, जिसमें शामिल है और मोबाइल उपकरणों पर, OpenCL में लिखे गए कोड को CPU पर भी चलाया जा सकता है।

आप OpenCL का उपयोग C / C ++ से कर सकते हैं, अन्य भाषाओं में बाइंडर हैं।

OpenCL के लिए, मुझे OpenCL इन एक्शन पुस्तक सबसे ज्यादा पसंद आई । यह GPU पर विभिन्न एल्गोरिदम का भी वर्णन करता है, जिसमें शामिल है बिटोनिक-सॉर्ट और रेडिक्स-सॉर्ट।

CUDA NVIDIA की स्वामित्व तकनीक और SDK है। आप C / C ++ में लिख सकते हैं या अन्य भाषाओं में बाइंडिंग का उपयोग कर सकते हैं।

OpenCL और CUDA की तुलना करना कुछ हद तक सही नहीं है, क्योंकि एक मानक है, दूसरा पूरा एसडीके है। फिर भी, कई लोग वीडियो कार्ड के लिए विकास के लिए CUDA चुनते हैं, इस तथ्य के बावजूद कि तकनीक स्वामित्व है, हालांकि निशुल्क और केवल NVIDIA कार्ड पर काम करता है। इसके अनेक कारण हैं:

API
, GPU, (host)
, ..

विशिष्टताओं में यह तथ्य शामिल है कि CUDA अपने स्वयं के संकलक के साथ आता है, जो मानक C / C ++ कोड भी संकलित कर सकता है।

सबसे व्यापक CUDA पुस्तक जो मुझे मिली, वह थी व्यावसायिक CUDA C प्रोग्रामिंग , हालांकि यह पहले से ही थोड़ी पुरानी है, फिर भी यह NVIDIA कार्ड के लिए प्रोग्रामिंग की बहुत सारी तकनीकी बारीकियों को संबोधित करती है।

लेकिन क्या होगा अगर मैं इन किताबों को पढ़ने, वीडियो कार्ड, परीक्षण और डिबगिंग के लिए अपना खुद का कार्यक्रम लिखने और फिर यह पता लगाने में कुछ महीने खर्च नहीं करना चाहता कि यह मेरे लिए नहीं है?

जैसा कि मैंने कहा, बड़ी संख्या में पुस्तकालय हैं जो GPU के तहत विकास की जटिलता को छिपाते हैं: XGBoost, cuBLAS, TensorFlow, PyTorch और अन्य, हम जोर पुस्तकालय पर विचार करेंगे, क्योंकि यह ऊपर दिए गए अन्य पुस्तकालयों की तुलना में कम विशिष्ट है, लेकिन साथ ही यह बुनियादी एल्गोरिदम को लागू करता है, उदाहरण के लिए, छंटाई, खोज, एकत्रीकरण और एक उच्च संभावना के साथ यह आपके कार्यों में लागू हो सकता है।

थ्रस्ट एक C ++ लाइब्रेरी है जिसका उद्देश्य स्टैण्डर्ड STL एल्गोरिदम को GPU- आधारित एल्गोरिदम से "बदलना" है। उदाहरण के लिए, एक वीडियो कार्ड पर इस लाइब्रेरी का उपयोग करके संख्याओं की एक छंटनी इस तरह दिखाई देगी:

thrust::host_vector<DataType> h_vec(size); //    
std::generate(h_vec.begin(), h_vec.end(), rand); //   
thrust::device_vector<DataType> d_vec = h_vec; //         
thrust::sort(d_vec.begin(), d_vec.end()); //    
thrust::copy(d_vec.begin(), d_vec.end(), h_vec.begin()); //   ,

(यह मत भूलो कि उदाहरण को NVIDIA से संकलक द्वारा संकलित किया जाना चाहिए)

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

मैंने एक छोटा सा बेंचमार्क लिखा इस लाइब्रेरी का उपयोग करके, जो GPU पर विभिन्न मात्रा में डेटा के साथ कई लोकप्रिय एल्गोरिदम चलाता है, आइए देखें कि परिणाम क्या हैं।

GPU एल्गोरिथम परिणाम

GPU का परीक्षण करने के लिए, मैंने एक एडब्ल्यूएस में टेस्ला k80 वीडियो कार्ड के साथ एक उदाहरण लिया, यह आज तक का सबसे शक्तिशाली सर्वर कार्ड नहीं है (सबसे शक्तिशाली टेस्ला v100), लेकिन सबसे सस्ती और बोर्ड पर है:

4992 क्यूडा कर्नेल
24 जीबी मेमोरी
480 Gb / s - मेमोरी बैंडविड्थ

और सीपीयू पर परीक्षणों के लिए, मैंने इंटेल एक्सॉन प्रोसेसर सीपीयू E5-2686 v4 @ 2.30GHz के साथ एक उदाहरण लिया

परिवर्तन

एमएसपी में GPU और CPU पर परिवर्तन निष्पादन समय

जैसा कि आप देख सकते हैं, सरणी तत्वों का सामान्य परिवर्तन लगभग उसी समय होता है, जो GPU और CPU दोनों पर होता है। और क्यों? क्योंकि कार्ड पर डेटा भेजने के लिए ओवरहेड और पूरे प्रदर्शन को बढ़ाने के लिए खाता है (हम अलग से ओवरहेड के बारे में बात करेंगे), और कार्ड पर अपेक्षाकृत कुछ गणनाएं हैं। इसके अलावा, यह मत भूलो कि प्रोसेसर भी SIMD निर्देशों का समर्थन करते हैं, और सरल मामलों में संकलक प्रभावी रूप से उनका उपयोग कर सकते हैं।

आइए अब देखते हैं कि GPU पर कितनी कुशलता से एकत्रीकरण किया जाता है।

एकत्रीकरण

एमएस

में GPU और CPU पर एकत्रीकरण निष्पादन समय एकत्रीकरण उदाहरण में, हम पहले से ही डेटा की मात्रा में वृद्धि के साथ एक महत्वपूर्ण प्रदर्शन वृद्धि देखते हैं। यह इस तथ्य पर भी ध्यान देने योग्य है कि हम कार्ड की मेमोरी में बड़ी मात्रा में डेटा पंप करते हैं, और केवल एक एकत्रित मूल्य वापस लिया जाता है, अर्थात्। कार्ड से रैम में डेटा ट्रांसफर करने के लिए ओवरहेड न्यूनतम है।

चलो सबसे दिलचस्प उदाहरण पर चलते हैं - छँटाई।

छंटाई

एमएस में जीपीयू और सीपीयू के लिए समय की छंटनी

इस तथ्य के बावजूद कि हम पूरे डेटा ऐरे को वीडियो कार्ड में भेजते हैं और इसके विपरीत, जीपीयू 800 एमबी डेटा को सॉर्ट करने पर प्रोसेसर की तुलना में लगभग 25 गुना तेज होता है।

डेटा ट्रांसफर ओवरहेड

जैसा कि परिवर्तन उदाहरण से देखा जा सकता है, यह हमेशा स्पष्ट नहीं है कि क्या उन कार्यों में भी जीपीयू प्रभावी होगा जो समानांतर रूप से अच्छी तरह से। इसका कारण कंप्यूटर की रैम से वीडियो कार्ड की मेमोरी (गेम कंसोल में, डेटा को सीपीयू और जीपीयू के बीच साझा किया जाता है, और डेटा ट्रांसफर करने की कोई आवश्यकता नहीं है) से डेटा ट्रांसफर करने के लिए एक ओवरहेड है। वीडियो कार्ड की विशेषताओं में से एक मेमोरी बैंडविड्थ या मेमोरी बैंडविड्थ है, जो कार्ड के सैद्धांतिक बैंडविड्थ को निर्धारित करता है। टेस्ला k80 के लिए यह 480 GB / s है, Tesla v100 के लिए यह पहले से ही 900 GB / s है। इसके अलावा, पीसीआई एक्सप्रेस संस्करण और कार्यान्वयन, आप कार्ड में डेटा कैसे स्थानांतरित करेंगे, यह थ्रूपुट को प्रभावित करेगा, उदाहरण के लिए, यह कई समानांतर धाराओं में किया जा सकता है।

आइए अमेज़ॅन क्लाउड में टेस्ला k80 ग्राफिक्स कार्ड के लिए प्राप्त किए गए व्यावहारिक परिणामों को देखें:

GPU में डेटा स्थानांतरित करने के लिए समय और डेटा को RAM में ms

HtoD पर

वापस स्थानांतरित करने के लिए - GPU वीडियो कार्ड में डेटा स्थानांतरित करें - वीडियो कार्ड पर सॉर्ट करें DtoH - वीडियो कार्ड से RAM में डेटा की प्रतिलिपि बनाएँ

पहली बात यह ध्यान दें कि वीडियो कार्ड से डेटा पढ़ना अधिक तेज़ है उन्हें वहाँ लिखें।

दूसरा - वीडियो कार्ड के साथ काम करते समय, आप 350 माइक्रोसेकंड से विलंबता प्राप्त कर सकते हैं, और यह पहले से ही कुछ कम विलंबता अनुप्रयोगों के लिए पर्याप्त हो सकता है।

नीचे दिया गया चार्ट अधिक डेटा के लिए एक ओवरहेड दिखाता है:

डेटा को GPU में स्थानांतरित करने के लिए, सॉर्ट करें और डेटा को ms में RAM पर वापस स्थानांतरित करें

सर्वर का उपयोग

सबसे आम सवाल यह है कि गेम वीडियो कार्ड एक सर्वर से कैसे भिन्न होता है? विशेषताओं के अनुसार, वे बहुत समान हैं, लेकिन कीमतों में काफी भिन्नता है।

सर्वर (NVIDIA) और गेम कार्ड के बीच मुख्य अंतर:

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

ये हैं, शायद, मुख्य महत्वपूर्ण अंतर जो मुझे मिला।

बहु सूत्रण

यह पता लगाने के बाद कि हम वीडियो कार्ड पर सबसे सरल एल्गोरिदम कैसे चला सकते हैं और क्या परिणाम की उम्मीद की जा सकती है, अगला तार्किक सवाल यह है कि कई समानांतर अनुरोधों को संसाधित करते समय वीडियो कार्ड कैसे व्यवहार करेगा। उत्तर के रूप में, मेरे पास GPU पर कंप्यूटिंग के दो ग्राफ हैं और 4 और 32 कोर के साथ एक प्रोसेसर है:

GPU और CPU पर गणितीय गणना करने में लगने वाला समय ms में 1000 x 60 के मैट्रिक्स के साथ

। यह ग्राफ 1000 x 60 तत्वों के मैट्रिक्स के साथ गणना करता है। कई प्रोग्राम स्ट्रीम से गणना शुरू की जाती है, प्रत्येक सीपीयू स्ट्रीम के लिए GPU के लिए एक अलग स्ट्रीम बनाई जाती है (बहुत हाइपर-क्यू का उपयोग किया जाता है)।

जैसा कि आप देख सकते हैं, प्रोसेसर इस लोड के साथ बहुत अच्छी तरह से सामना करता है, जबकि प्रति GPU एक अनुरोध के लिए विलंबता समानांतर अनुरोधों की संख्या में वृद्धि के साथ काफी बढ़ जाती है।

एमएसपी में 10,000 x 60 के साथ GPU और CPU पर गणितीय गणना करने का समय।

दूसरे ग्राफ़ पर, एक ही गणना, लेकिन 10 बार अधिक मैट्रिसेस के साथ, और GPU ऐसे लोड के तहत बेहतर व्यवहार करता है। ये रेखांकन बहुत ही सांकेतिक हैं, और हम निष्कर्ष निकाल सकते हैं: लोड के तहत व्यवहार स्वयं लोड की प्रकृति पर निर्भर करता है। एक प्रोसेसर मैट्रिक्स गणना को भी काफी कुशलता से संभाल सकता है, लेकिन कुछ हद तक। वीडियो कार्ड के लिए, यह विशेषता है कि एक छोटे कंप्यूटिंग लोड के लिए, प्रदर्शन लगभग रैखिक रूप से गिरता है। भार में वृद्धि और समानांतर धागे की संख्या के साथ, वीडियो कार्ड बेहतर तरीके से नकल करता है।

यह परिकल्पना करना मुश्किल है कि GPU विभिन्न स्थितियों में कैसे व्यवहार करेगा, लेकिन जैसा कि आप देख सकते हैं, कुछ शर्तों के तहत, एक सर्वर कार्ड कई समानांतर धाराओं से अनुरोधों को काफी कुशलता से संसाधित कर सकता है।

हम कुछ और सवालों पर चर्चा करेंगे जो आपके पास हो सकता है यदि आप अभी भी अपनी परियोजनाओं में GPU का उपयोग करने का निर्णय लेते हैं।

संसाधन की सीमा

जैसा कि हमने पहले ही कहा है, एक वीडियो कार्ड के दो मुख्य संसाधन कोर और मेमोरी की गणना कर रहे हैं।

उदाहरण के लिए, हमारे पास वीडियो कार्ड का उपयोग करने वाली कई प्रक्रियाएँ या कंटेनर हैं, और हम उनके बीच वीडियो कार्ड को साझा करने में सक्षम होना चाहेंगे। दुर्भाग्य से, इसके लिए कोई सरल एपीआई नहीं है। NVIDIA vGPU तकनीक प्रदान करता है , लेकिन मुझे समर्थित लोगों की सूची में टेस्ला k80 कार्ड नहीं मिला, और जहाँ तक मैं विवरण से समझ सकता हूं, प्रौद्योगिकी गणना की तुलना में आभासी डिस्प्ले पर अधिक केंद्रित है। शायद एएमडी कुछ अधिक उपयुक्त प्रदान करता है।

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

कंटेनर और जी.पी.यू.

यदि आपने संसाधन सीमा का पता लगा लिया है, तो निम्न तार्किक प्रश्न: क्या होगा यदि सर्वर में कई वीडियो कार्ड हैं?

फिर से, आप आवेदन स्तर पर निर्णय ले सकते हैं कि यह किस जीपीयू का उपयोग करेगा।

एक और अधिक सुविधाजनक तरीका डॉकटर कंटेनर है। आप नियमित कंटेनरों का उपयोग कर सकते हैं, लेकिन NVIDIA अपने NGC कंटेनरों को विभिन्न सॉफ्टवेयर, पुस्तकालयों और ड्राइवरों के अनुकूलित संस्करणों के साथ प्रदान करता है । एक कंटेनर के लिए, आप उपयोग किए गए GPU की संख्या और उनके दृश्यता को कंटेनर तक सीमित कर सकते हैं। कंटेनर उपयोग पर ओवरहेड लगभग 3% है।

एक क्लस्टर में काम करते हैं

एक और सवाल, अगर आप एक ही सर्वर या क्लस्टर में कई GPU पर एक कार्य करना चाहते हैं तो क्या करें?

यदि आपने थ्रस्ट या निचले स्तर के समाधान के समान एक पुस्तकालय चुना है, तो कार्य को मैन्युअल रूप से हल करना होगा। उच्च-स्तरीय रूपरेखाएँ, उदाहरण के लिए, मशीन सीखने या तंत्रिका नेटवर्क के लिए, आमतौर पर बॉक्स से बाहर कई कार्ड का उपयोग करने की क्षमता का समर्थन करती हैं।

इसके अलावा, मैं यह नोट करना चाहूंगा कि, उदाहरण के लिए, NVIDIA कार्ड के बीच सीधे डेटा विनिमय के लिए एक इंटरफ़ेस प्रदान करता है - NVLINK , जो पीसीआई एक्सप्रेस की तुलना में काफी तेज है। और अन्य PCI एक्सप्रेस उपकरणों से कार्ड की मेमोरी तक सीधे पहुंच के लिए तकनीक है - GPUDirect RDMA , incl। और नेटवर्क ।

अनुशंसाएँ

यदि आप अपनी परियोजनाओं में GPU का उपयोग करने पर विचार कर रहे हैं, तो GPU आपके लिए सबसे उपयुक्त है:

आपका कार्य एक सिमड दृश्य को कम किया जा सकता है
गणना (कैश) से पहले मानचित्र पर अधिकांश डेटा लोड करना संभव है
चुनौती में गहन कंप्यूटिंग शामिल है

आपको पहले से प्रश्न पूछना चाहिए:

कितने समानांतर प्रश्न होंगे
आप किस विलंब की उम्मीद करते हैं
क्या आपको अपने लोड के लिए एक कार्ड की आवश्यकता है? क्या आपको कई कार्डों या जीपीयू सर्वरों के क्लस्टर के साथ सर्वर की आवश्यकता है

यह सब, मुझे आशा है कि सामग्री आपके लिए उपयोगी होगी और आपको सही निर्णय लेने में मदद करेगी!

संदर्भ

बेंचमार्क और जीथब पर परिणाम - https://github.com/tishden/gpu_benchmark/tree/master/cuda

इस विषय के अलावा, रिपोर्ट की एक रिकॉर्डिंग "GPU डेटाबेस - वास्तुकला, उपयोग के लिए प्रदर्शन और संभावनाएं"

NVIDIA NGC कंटेनर वेबिनार - http : //bit.ly/2UmVIVt या http://bit.ly/2x4vJKF

GPU कम्प्यूटिंग - क्यों, कब, और कैसे। प्लस कुछ परीक्षण

GPU पर क्यों भरोसा करें?

GPU वास्तुकला और सीपीयू के साथ इसकी तुलना

GPU सीमाओं और सुविधाओं

SIMD प्रतिनिधित्व के लिए शास्त्रीय एल्गोरिदम की कमी

परिवर्तन

एकत्रीकरण

छंटाई

कहा से शुरुवात करे

GPU एल्गोरिथम परिणाम

परिवर्तन

एकत्रीकरण

छंटाई

डेटा ट्रांसफर ओवरहेड

सर्वर का उपयोग

बहु सूत्रण

संसाधन की सीमा

कंटेनर और जी.पी.यू.

एक क्लस्टर में काम करते हैं

अनुशंसाएँ

संदर्भ

More articles: