🖋️ 👩🏾‍🏭 📉 पायथन में ओपनसीएल का उपयोग करना 🔤 🕜 🧔

हाल ही में, विशेष रूप से GPU का उपयोग करके समानांतर कंप्यूटिंग को मजबूती से लागू किया गया है।

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

तो, चलिए अभ्यास करने के लिए नीचे आते हैं। हम पायथन को मुख्य कार्यक्रम की भाषा के रूप में चुनेंगे। बेशक, यह अपने आप में बहुत तेज़ नहीं है, लेकिन यह "गोंद" के रूप में ठीक काम करता है - कई अनुप्रयोगों में मुख्य गणना ओपनसीएल में है, और पायथन कोड केवल "कारतूस रखता है"। एक उत्कृष्ट PyOpenCL पुस्तकालय है, जिसका हम उपयोग करेंगे।

स्थापना

लेकिन सबसे पहले, आपको ओपनसीएल के साथ काम करने के लिए आवश्यक सब कुछ स्थापित करना होगा। एनवीडिया कार्ड्स के लिए, OpenCL का समर्थन CUDA SDK के साथ-साथ आधिकारिक ड्राइवर में आता है। जहां तक मुझे पता है, अभी तक नोव्यू में कोई समर्थन नहीं है। विंडोज के लिए, आधिकारिक वेबसाइट पर एक इंस्टॉलर है, जीएनयू / लिनक्स के लिए आपको रिपॉजिटरी से आवश्यक सॉफ़्टवेयर स्थापित करना चाहिए। ArchLinux के लिए, ये संकुल cuda-toolkit, cuda-sdk, nvidia, nvidia-utils, nvidia-opencl हैं। इंटेल प्रोसेसर के लिए, एक बहुत अच्छा इंटेल ओपनसीएल एसडीके है, एएमडी के लिए एक देशी एसडीके भी है।

CUDA SDK में oclDeviceQuery का एक शानदार उदाहरण है, जो डिफ़ॉल्ट रूप से OpenCL डिवाइस पर जानकारी का एक समुद्र दिखाता है। समग्र प्रदर्शन की जांच करने के लिए एक बहुत सुविधाजनक चीज।

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

कुछ अभ्यास नोट्स

दरअसल, अभ्यास के लिए कई महत्वपूर्ण चीजें हाल के एक लेख में बताई गई थीं, इसलिए मैं आपको दृढ़ता से सलाह देता हूं कि आप इसके साथ खुद को परिचित करें। यहां मैं PyOpenCL के उपयोग की सुविधाओं पर ध्यान केंद्रित करूंगा।

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

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

प्रारंभ

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

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

प्रारंभिक होस्ट कोड

import pyopencl as cl import numpy set_simple_args(model_params) set_device() create_buffers(np.array(particles, dtype=np.float64)) program = cl.Program(self.context, open('worker.cl').read()).build() def set_device(): device = cl.get_platforms()[settings.DEVICE_NUM].get_devices(getattr(cl.device_type, settings.CL_DEVICE))[0] context = cl.Context(devices=[device], dev_type=None) cqueue = cl.CommandQueue(self.context) def set_simple_args(mp): #       numpy #       ,   OpenCL   central_size = numpy.float64(mp['central size']) dt = numpy.float64(mp['dt']) skip = numpy.int32(mp['skip']) q_e = numpy.float64(mp['e charge']) q_i = numpy.float64(mp['ion charge']) ion_m = numpy.float64(mp['ion mass']) def create_buffers(particles): # particles -      mf = cl.mem_flags buf_particles_1 = cl.Buffer(self.context, mf.READ_WRITE | mf.COPY_HOST_PTR, hostbuf=particles) buf_particles_2 = cl.Buffer(self.context, mf.READ_WRITE | mf.COPY_HOST_PTR, hostbuf=particles) buf_charge = cl.Buffer(self.context, mf.READ_WRITE | mf.COPY_HOST_PTR, hostbuf=np.float64(0.0)) buf_q_e = cl.Buffer(self.context, mf.READ_WRITE | mf.COPY_HOST_PTR, hostbuf=np.int32(0.0)) buf_q_i = cl.Buffer(self.context, mf.READ_WRITE | mf.COPY_HOST_PTR, hostbuf=np.int32(0.0))

यहां क्या हो रहा है? सबसे पहले, "सरल" तर्क उजागर किए जाते हैं - उन्हें स्थिरांक के रूप में पारित किया जाता है। अगला, वांछित डिवाइस कॉन्फ़िगर किया गया है। settings.DEVICE_NUM - डिवाइस नंबर, settings.CL_DEVICE - प्रकार (GPU, CPU या कुछ और अधिक विदेशी)। मेमोरी कार्ड बफ़र अब लोड किए गए हैं। यह चरण केवल सरणियों, साथ ही चर के लिए किया जा सकता है, जिसका मूल्य कर्नेल के निष्पादित होने के बाद पढ़ा जाना चाहिए। और अंत में, एक प्रोग्राम ऑब्जेक्ट बनाया जाता है (कार्यकर्ता में। कर्नेल स्रोत कोड)।

यह ध्यान दिया जाना चाहिए कि यदि कोई संकलन त्रुटि होती है, तो एक अपवाद फेंक दिया जाता है और स्क्रीन पर एक संबंधित संदेश प्रदर्शित किया जाता है। आप संकलक से चेतावनी और अन्य बकवास भी सक्षम कर सकते हैं। यह export PYOPENCL_COMPILER_OUTPUT=1 .bashrc में जोड़कर किया जा सकता है। यहां हम इंटेल कंपाइलर का उल्लेख कर सकते हैं, जो हमेशा स्पष्ट रूप से रिपोर्ट करता है कि एनविडिया से अधिक यूनिक्स-आधारित एक के विपरीत, यह सब कुछ कितना अच्छा है।

कर्नेल लॉन्च

यहां सब कुछ अपेक्षाकृत सरल है। हमारे तर्क कर्नेल लॉन्च फ़ंक्शन (__call __ () के माध्यम से पैरामीटर के रूप में दिए गए हैं)। इस कोड में, प्रत्येक नया पुनरावृत्ति एक नया कर्नेल लॉन्च है।

कर्नेल लॉन्च होस्ट कोड

 def iterate(): program.dust_plasma(cqueue, [global_size], None, buf_particles_1, buf_particles_2, buf_charge, buf_q_e, buf_q_i, q_e, q_i, ion_m, central_size, outer_boundary, dt, skip) output_particles, cur_charge = empty_particles, numpy.empty_like(numpy.float64(0.0)) #   output_particles   buf_particles_2 cl.enqueue_copy(cqueue, output_particles, buf_particles_2) cl.enqueue_copy(cqueue, cur_charge, buf_charge) return output_particles, cur_charge

समझने में आसानी के लिए, यहाँ OpenCL कर्नेल कोड का एक टुकड़ा है (जैसा कि आप देख सकते हैं, यह कुछ C जैसा है):

कर्नेल कोड स्निपेट

 __kernel void dust_plasma(__global double4* particles_1, //      __global double4* particles_2, //    __global double* dust_charge, __global int* charge_new_e, __global int* charge_new_i, __const double charge_e, __const double charge_i, //     __const double ion_mass, //   __const double central_size, // ,  __const double outer_boundary, //  __const double dt, __const unsigned skip) { int id = get_global_id(0); // ... for(unsigned i = 0; i < skip; i++) { //printf("Iteration %i\n", i); params.previous = &particles_1; params.next = &particles_2; one_iteration_rk2(&params); params.previous = &particles_2; params.next = &particles_1; one_iteration_rk2(&params); } barrier(CLK_GLOBAL_MEM_FENCE); // ... }

निष्कर्ष

यह ध्यान दिया जाना चाहिए कि प्रलेखन बहुत पर्याप्त और सुविधाजनक है। यदि आपके पास पुस्तकालय के बारे में प्रश्न हैं, तो आप pyopencl@tiker.net मेलिंग सूची में लिख सकते हैं, वहां का समुदाय काफी जीवंत है और जल्दी से जवाब देता है। पुस्तकालय को उदार एमआईटी लाइसेंस के तहत वितरित किया जाता है, जो बहुत अच्छा है।

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

मैं उत्कृष्ट पुस्तकालय के लिए एंड्रियास क्लोकनर नाम के PyOpenCL के लेखक को भी धन्यवाद देना चाहता हूं।

अनुरोध 1) पाठ में टाइपोस / त्रुटियों की रिपोर्ट करने के लिए 2) पीएम में।

पायथन में ओपनसीएल का उपयोग करना

स्थापना

कुछ अभ्यास नोट्स

प्रारंभ

कर्नेल लॉन्च

निष्कर्ष

संबंधित लिंक

More articles: