🎾 📠 👩🏾‍🤝‍👨🏻 ओपन इंटरोऑपरेबिलिटी के साथ परिचित 🎍 🚛 🕛

सभी का दिन शुभ हो

मुझे उम्मीद है कि अपने पाठक में इस ब्लॉक को पढ़ते समय, मेरी तस्वीर आपको डरा नहीं पाएगी। लेकिन आज, मैं अपने छोटे पालतू-उदाहरण के उदाहरण का उपयोग करके ओपनजीएल के साथ सीयूडीए प्रौद्योगिकी के आदान-प्रदान के अनुप्रयोग का वर्णन करना चाहता हूं, जिसका पहला संस्करण मैंने पहले एक लेख में वर्णित किया था। जिन्हें अंग्रेजी नाम CUDA और OpenGL इंटरऑपरेबिलिटी के तहत जाना जाता है, में रुचि रखते हैं, कृपया यहाँ क्लिक करें।

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

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

जब आप एक परियोजना टेम्पलेट बनाना शुरू करते हैं, तो कुछ बिंदुओं को याद नहीं करना बहुत महत्वपूर्ण है:

बफर को बांधने के लिए आवश्यक कुछ कार्यों के लिए, जीएलईडब्ल्यू की आवश्यकता होती है, फिर इसके हेडर को फ्रीग्लूट हेडर फाइल के ऊपर जोड़ा जाना चाहिए।
```
#include <GL/glew.h> #include <GL/freeglut.h> ... #include <cuda_gl_interop.h> 
```
यदि ऐसा है तो संकलक आपको चेतावनी देगा।
जब संसाधन और CUDA वीडियो बफर की ओर इशारा करते आवश्यक चर घोषित गलती कोड के बीच में कहीं उन्हें छील नहीं है, यह सोच कर कि वे कार्यों की वर्तमान समय में कर रहे हैं आवश्यक नहीं हैं। मैं लंबे समय से हैरान था, यह समझने की कोशिश कर रहा था कि मुझे सेगफॉल्ट त्रुटि क्यों मिलती है:
```
 GLuint vbo; struct cudaGraphicsResource *cuda_vbo_resource; 
```
अब हम CUDA के साथ फ्रेम बफर को बांधने के लिए जिम्मेदार कार्यों में इन चरों का उपयोग कर सकते हैं:
```
 void createVBO(GLuint *vbo, struct cudaGraphicsResource **vbo_res, unsigned int vbo_res_flags) { unsigned int size = width * height * sizeof(uchar4); glGenBuffers(1, vbo); glBindBuffer(GL_PIXEL_UNPACK_BUFFER_ARB, *vbo); glBufferData(GL_PIXEL_UNPACK_BUFFER_ARB, size, NULL, GL_DYNAMIC_DRAW); HANDLE_ERROR( cudaGraphicsGLRegisterBuffer(vbo_res, *vbo, vbo_res_flags) ); } void deleteVBO(GLuint *vbo, struct cudaGraphicsResource *vbo_res) { HANDLE_ERROR( cudaGraphicsUnregisterResource(cuda_vbo_resource) ); glBindBuffer(GL_PIXEL_UNPACK_BUFFER_ARB, *vbo); glDeleteBuffers(1, vbo); *vbo = 0; } 
```
मुख्य विचार यह है कि बाद में, कोड में, आप पिक्सेल के एक सरणी के रूप में बनाए गए बफर को एक पॉइंटर प्राप्त कर सकते हैं, और फिर इसे कर्नेल में बदल सकते हैं। दुर्भाग्य से, मैं OpenGL में बहुत पारंगत नहीं हूं, और फिर मुझे इस बात की समझ नहीं है कि वे अक्सर स्थापना रद्द करने से पहले glBindBuffer को क्यों कहते हैं, और 1 को पहले तर्क के रूप में पास करें। अगर मैं सही तरीके से समझूं, तो अगर मैं अपने आवेदन में केवल एक बफर का उपयोग करता हूं, तो मैं इसे पूरा करने के तुरंत बाद साफ कर सकता हूं।
हेल्पर फ़ंक्शन बनाए गए हैं, अब हम उन्हें CUDA संसाधन बनाने और मुक्त करने के लिए उपयोग कर सकते हैं (और पिक्सेल बफर लिंक करें):
```
 HANDLE_ERROR( cudaGLSetGLDevice(deviceId) ); ... createVBO(&vbo, &cuda_vbo_resource, cudaGraphicsMapFlagsWriteDiscard); ... deleteVBO(&vbo, cuda_vbo_resource); 
```

सब कुछ लगता है! अब हम एप्लिकेशन के निष्क्रिय ईवेंट को संभाल सकते हैं, जहां फ्रेम के निर्माण में संलग्न होना है, और फिर बस इसे खींचना है। यह याद किया जाना चाहिए कि हम वीडियो कार्ड बफर में तुरंत फ्रेम खींचते हैं, और फिर इसे प्रदर्शित करने के लिए कहें।

 void idle(void) { uchar4* dev_screen; size_t size; HANDLE_ERROR( cudaGraphicsMapResources(1, &cuda_vbo_resource, 0) ); HANDLE_ERROR( cudaGraphicsResourceGetMappedPointer((void**) &dev_screen, &size, cuda_vbo_resource) ); // Render Image renderFrame<<<blocks, threads>>>(dev_screen); HANDLE_ERROR( cudaDeviceSynchronize() ); HANDLE_ERROR( cudaGraphicsUnmapResources(1, &cuda_vbo_resource, 0) ); glutPostRedisplay(); }

ps कोड से, मैंने फ्रेम बनाने के समय की गणना करने और एप्लिकेशन हेडर में प्रदर्शित करने के लिए जिम्मेदार भाग को बाहर फेंक दिया।
ड्रॉ फ़ंक्शन रेंडरिंग से संबंधित है, जिसे फ्रीग्लट द्वारा स्वचालित रूप से या glutPostRedisplay के अनुरोध पर कहा जाता है:

 void draw(void) { glClearColor(0.0, 0.0, 0.0, 1.0); glClear(GL_COLOR_BUFFER_BIT); glDrawPixels(width, height, GL_RGBA, GL_UNSIGNED_BYTE, 0); glutSwapBuffers(); }

कृपया ध्यान दें कि मैं छवि को संग्रहीत करने वाले पिक्सेल की एक सरणी निर्दिष्ट नहीं करता हूं, क्योंकि फ्रेम बफर पहले से ही बदल दिया गया है और आपको परिवर्तनों को प्रतिबिंबित करने की आवश्यकता के बारे में ओपनजीएल को बताने की आवश्यकता है।

जब मैं फ्लोट 4 की ओर चार्ज का प्रतिनिधित्व करने वाली सरल संरचनाओं का उपयोग करने से दूर चला गया, तो मैं कोड निष्पादन तेजी से करने में सक्षम था। इसलिए, उदाहरण के लिए, 10 * चार्ज के साथ 1024 * 768 का एक फ्रेम अब 25-30 एमएस में बनाया गया है। और इसने मुझे माउस के साथ चिकनी एनीमेशन बनाने की अनुमति दी - खींचें और छोड़ें:
खैर, हमेशा की तरह, आप यहां समाप्त कोड पा सकते हैं। और अगर आपके पास कोई प्रश्न या सुझाव है, तो मुझे लिखें। मैं इसे ठीक करने की कोशिश करूंगा।

अंतभाषण

भविष्य में मैं एक ऐसी विधा बनाने की योजना बना रहा हूँ जो कागज पर फेंके गए चूरा के रूप में क्षेत्र की ताकत प्रदर्शित करती है। विचार नियमित अंतराल पर छोटी रेखाएं खींचना है। यदि आप वास्तव में भाग्यशाली हैं, तो मैं इसे 3D में लागू करने का प्रयास करूंगा :)

ओपन इंटरोऑपरेबिलिटी के साथ परिचित

अंतभाषण

More articles: