एक छाया में लूप प्रदर्शन


11

मैं सोच रहा हूँ कि एक shader में डायनेमिक लूप फ़ंक्शन को एकीकृत करने का सबसे अच्छा तरीका क्या है?

पहला, ऐसा लगता है कि गतिशील सरणियाँ संभव नहीं हैं। तो, क्या अधिकतम आकार का सरणी बनाना बेहतर है और केवल इसका एक हिस्सा भरना है या पूर्वनिर्धारित आकारों के साथ सरणियों को परिभाषित करना है?

फिर, इस सरणी पर पुनरावृति करने का सबसे अच्छा तरीका क्या है?

4 से 128 पुनरावृत्तियों के बीच किसी चीज़ के लिए अनियंत्रित लूप या डायनेमिक लूप का उपयोग करना बेहतर है? मैंने यह भी देखा है कि इसे पुनरावृत्तियों की अधिकतम पूर्वनिर्धारित संख्या में अनियंत्रित करना संभव है, फिर इसे एक शर्त के साथ बंद कर दें if (i == myCurrentMaximumIterationNumber)


2
आप सरणी और लूप के साथ क्या करने की कोशिश कर रहे हैं? मैं पूछ रहा हूँ क्योंकि यह किसी तरह मेरे लिए एक XY समस्या की तरह लग रहा है। चूंकि GPU पर स्थितियों और छोरों का उपयोग करने का सबसे अच्छा तरीका उन्हें उपयोग करने से बचना है, शायद आपके मामले में सरणियों और छोरों का उपयोग करने के बजाय और भी बेहतर तरीके हैं।
नीरो

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

जवाबों:


6

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

BTW, एक GPU पर एक गतिशील लूप के साथ सबसे बड़ा नुकसान यह है कि एक तरंग / ताना में अलग-अलग "धागे" अलग-अलग समय पर समाप्त हो जाएंगे। बाद में बंद होने वाले धागे एनओपी को निष्पादित करने के लिए जल्दी खत्म होने वाले सभी को मजबूर करते हैं।

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

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.