सीपीयू - GPU मेमोरी डेटा प्रवाह [बंद]

Question

मैं एक नौसिखिया ग्राफिक्स प्रोग्रामर हूं और मैं हाल ही में सोच रहा हूं - आवेदन (सीपीयू मेमोरी) से ग्राफिक्स कार्ड (जीपीयू मेमोरी?) तक मॉडल डेटा (मेष और सामग्री) कैसे प्रवाहित होता है? कहें कि मेरे पास एक स्थिर मॉडल है (उदाहरण के लिए एक इमारत) जिसे मैं एक बार लोड और सेटअप करता हूं और पूरे जीवनकाल में नहीं बदलता हूं।

• क्या इसका डेटा केवल एक बार GPU मेमोरी में भेजा जाता है और हमेशा के लिए वहां बैठ जाता है?
• जब मॉडल वास्तव में प्रत्येक फ्रेम प्रदान करता है तो GPU प्रोसेसर को GPU मेमोरी से हर बार अपना डेटा प्राप्त करना पड़ता है? मेरा क्या मतलब है - अगर मेरे पास 2 मॉडल हैं, तो मैंने हर बार कई बार काम किया है - क्या इससे कोई फर्क पड़ेगा कि अगर मैंने पहली बार पहली बार कई बार और फिर दूसरी बार कई बार या अगर मैंने पहली बार सिर्फ एक बार गाया है, तो दूसरा सिर्फ एक बार। इस तरह interleaving रखा? मैं इस प्रश्न को "आंतरिक GPU डेटा प्रवाह" कह सकता हूं।
• जाहिर है ग्राफिक्स कार्ड में रैम सीमित होती है - जब यह 1 फ्रेम रेंडर करने के लिए आवश्यक सभी मॉडल डेटा को पकड़ नहीं सकता है, तो मुझे लगता है कि यह (कुछ) सीपीयू रैम से प्रत्येक फ्रेम प्राप्त करता रहता है, क्या यह सही है?

मुझे पता है कि इंटरनेट पर इसके बारे में बहुत सारी किताबें और सामान हैं, लेकिन शायद आपके पास कुछ त्वरित सामान्य दिशानिर्देश हैं कि इस डेटा प्रवाह को कैसे प्रबंधित किया जाए (कब और क्या भेजना है, कब और कैसे प्रस्तुत करना है)?

संपादित करें: मैं एक भेद करना भूल गया: डेटा को GPU में भेजना है और बफ़र्स को वर्तमान के रूप में सेट / बाइंड करना है । क्या बाद वाला कोई डेटा प्रवाह करता है?

Edit2: रक्सवन की पोस्ट पढ़ने के बाद मैं कुछ कार्यों को अलग करना चाहूंगा:

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

Comments

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

— ध्रुवीय

@ दाढ़ - बिल्कुल नहीं। जीएल वास्तव में निर्दिष्ट नहीं करता है कि कौन सी मेमोरी एक बफर ऑब्जेक्ट में संग्रहीत है, और उपयोग पैटर्न के आधार पर रनटाइम पर इसे स्थानांतरित करने के लिए भी स्वतंत्र है। GL4.4 इसे कुछ हद तक संबोधित करता है, लेकिन नोट करता है कि अंत में यह सबसे अच्छा प्रदान कर सकता है "उन मूर्खतापूर्ण संकेत चीजों में से एक"; देख opengl.org/registry/specs/ARB/buffer_storage.txt और विशेष रूप से मुद्दे 2 और 9

— मैक्सिमस कनिष्ठा

@JimmyShelter आह, धन्यवाद - यह अच्छा होगा यदि हमारे पास "उन मूर्खतापूर्ण बातें" और कम ठोस विनिर्देश हैं।

— ध्रुवीय

@ दाता - क्या कष्टप्रद है कि ARB_buffer_storage को अभी तक एक और संकेत सहित टाला जा सकता था, लेकिन डिजाइनरों ने मौका गंवा दिया। ओह ठीक है, शायद 4.5 अंत में इसे सही मिलेगा।

— मैक्सिमस मिनिमस

कृपया अपने प्रश्नों को उत्तर देने के लिए "उत्तर" न दें। इसके बजाय एक नया प्रश्न पोस्ट करें।

Answer 1

क्या इसका डेटा केवल एक बार GPU मेमोरी में भेजा जाता है और हमेशा के लिए वहां बैठ जाता है?

आमतौर पर हां, लेकिन ड्राइवर ऐसा करने के लिए स्वतंत्र है जो "इष्टतम" है, डेटा को वीआरएएम या रैम में संग्रहीत किया जा सकता है या बस यहां कैश किया जा सकता है एक एट्रिंक है जो बताता है कि वास्तव में वीबीओ प्रवाह के साथ क्या होता है ।

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

जब मॉडल वास्तव में प्रत्येक फ्रेम प्रदान करता है तो GPU प्रोसेसर को अपना डेटा हर बार GPU मेमोरी से प्राप्त करना पड़ता है, भले ही कोई मॉडल कई अनुक्रमिक समय प्रदान कर रहा हो?

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

जाहिर है ग्राफिक्स कार्ड में रैम सीमित होती है - जब यह 1 फ्रेम रेंडर करने के लिए आवश्यक सभी मॉडल डेटा को पकड़ नहीं सकता है, तो मुझे लगता है कि यह (कुछ) सीपीयू रैम से प्रत्येक फ्रेम प्राप्त करता रहता है, क्या यह सही है?

आप ऐसा नहीं चाहते हैं। लेकिन इसकी परवाह किए बिना कि अगर GPU होता है तो RAM और VRAM के बीच मेमोरी चलना शुरू हो जाएगी (GPU पर कमांड प्रोसेसर इसके लिए ज़िम्मेदार है) जो बहुत धीमी गति प्रदान करेगा जिससे GPU स्टाल के मामले में बदल जाएगा, क्योंकि इसके लिए डेटा की प्रतीक्षा करनी होगी / V / RAM से कॉपी किया जाना है।

GPU को डेटा भेज रहा है और बफ़र्स को वर्तमान के रूप में सेट / बाइंड कर रहा है। क्या बाद वाला कोई डेटा प्रवाह करता है?

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

यही कारण है कि glBegin / glEnd कारणों में से एक था, नए आदेश सबमिट करने के लिए कतार सिंक्रनाइज़ेशन (मेमोरी बाड़ / बाधाओं का उपयोग) की आवश्यकता है।

अपने अन्य बिंदुओं के लिए:

आरंभीकरण के साथ बफर निर्माण

आप बिना आरंभ के बफर को आवंटित कर सकते हैं और बाद में उपयोग के लिए रख सकते हैं। या आप इसे एक बफर आवंटित कर सकते हैं और एक ही समय में डेटा कॉपी कर सकते हैं (एपीआई स्तर के बारे में बात कर रहे हैं)।

बफ़र डेटा अद्यतन

GPU की तरफ मेमोरी को अपडेट करने के लिए आप glMapBuffer का उपयोग कर सकते हैं। क्या मेमोरी को / से RAM में कॉपी किया जाएगा या नहीं वास्तव में यह मानक का पॉवर्ट नहीं है और यह वेंडर, GPU टाइप और ड्राइवर के आधार पर बहुत भिन्न होगा।

एपीआई ड्रा कॉल (यहां मैं आपसे सुनना चाहता हूं कि वास्तव में वहां क्या होता है)।

मुख्य प्रश्न में मेरा दूसरा बिंदु इसे शामिल करता है।

बफर को सक्रिय के रूप में बांधना (क्या यह एपीआई को यह बताने का एक तरीका है कि मैं चाहता हूं कि यह ड्रॉ> अगले ड्रॉ कॉल में प्रदान किया जाए और यह अपने आप कुछ नहीं करता है?)

thisकिसी भी ऑब्जेक्ट ओरिएंटेड भाषा में पॉइंटर का उपयोग करते हुए बाइंडिंग के बारे में सोचें , हालांकि कड़ाई से समान नहीं है, कोई भी परिणामी एपीआई कॉल बाइंड बफर के सापेक्ष होगा।

Answer 2

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

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

दूसरा बिंदु : प्रतिपादन में कई तरकीबें हैं लेकिन मुख्य तरीका यह है कि बहुभुजों के साथ। एक फ्रेम पर gpu एक-एक करके बहुभुजों से बनी वस्तुओं को प्रस्तुत करेगा और यह समाप्त करने के बाद कि GPU चित्र को डिस्प्ले पर भेज देगा। वस्तुओं जैसी कोई अवधारणा नहीं है, बस बहुभुज हैं और जिस तरह से आप उन्हें एक साथ रखते हैं वह एक छवि बनाएगा। GPU का काम उन बहुभुजों को 3 डी से 2 डी तक प्रोजेक्ट करना और प्रभाव (यदि वांछित है) लागू करना है। बहुभुज केवल वान मार्ग पर चलते हैं CPU-> GPU-> स्क्रीन या GPU-> स्क्रीन सीधे (यदि बहुभुज GPU राम में पहले से ही हैं)

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

वास्तविक भेजने GPU के लिए डेटा API आप का उपयोग (इंटरनेट / OpenGL या अन्य) और बंधन और इस तरह सामान की अवधारणा द्वारा किया जाता है सिर्फ कपोल-कल्पना कर रहे हैं एपीआई समझता है ताकि आप क्या करना चाहते हैं।

संपादन के लिए संपादित करें:

• buffer creation with initialisation: यह अंतर के बीच अंतर की तरह है a = new int[10]और a[0] = 0,a[1] = 1.... etc जब आप एक बफर बनाते हैं तो आप डेटा के लिए जगह बनाते हैं और जब आप डेटा को सम्मिलित करते हैं तो आप उस सामान को वहां रख देते हैं जो आप चाहते हैं।

• buffer data updateअगर यह सीपीयू रैम पर है, तो आपके पास vertex * verticesयह है कि आप इसके साथ खेल सकते हैं, अगर यह नहीं है, तो आपको इसे जीपीयू से स्थानांतरित करना होगा vertex * vertices = map(buffer_id);(नक्शा एक पौराणिक कार्य है जो जीपीयू से सीपीयू रैम तक डेटा ले जाना चाहिए, यह भी है कि यह ऑपोजिट है buffer_id = create_buffer(vertices);

• binding the buffer as activeयह सिर्फ एक अवधारणा है जिसे वे bindingप्रतिपादन कहते हैं एक जटिल प्रक्रिया है और यह 10000 मापदंडों के साथ एक फ़ंक्शन को कॉल करने जैसा है। बाइंडिंग केवल एक शब्द है जिसका उपयोग वे यह बताने के लिए करते थे कि बफर कहाँ जाता है। इस शब्द के पीछे कोई वास्तविक जादू नहीं है, यह बफ़र्स को परिवर्तित या स्थानांतरित या स्थानांतरित नहीं करता है, बस ड्राइवर को बताता है कि अगले ड्रॉ कॉल पर इस बफर का उपयोग करें।

• API draw callसभी बाइंडिंग और सेटिंग बफ़र्स के बाद यह वह जगह है जहां रबर सड़क से मिलता है। ड्रॉ कॉल आपके द्वारा निर्दिष्ट सभी डेटा (या डेटा के आईडी बिंदु) को जीपीयू पर भेज देगा (यदि आवश्यक हो) और जीपीयू को संख्याओं को क्रंच करना शुरू करने के लिए कहें। यह सभी प्लेटफार्मों पर पूरी तरह से सच नहीं है, कई अंतर हैं, लेकिन बात को सरल रखने के लिए जीपीयू को .... ड्रा करना बताएगा।

Answer 3

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

क्या इसका डेटा केवल एक बार GPU मेमोरी में भेजा जाता है और हमेशा के लिए वहां बैठ जाता है?

आशापूर्वक हाँ। रेंडरिंग स्पीड के लिए, आप हर फ्रेम में फिर से भेजने के बजाय, GPU पर बैठने के लिए जितना डेटा चाहते हैं। VBO का यह सटीक उद्देश्य है। दोनों स्थैतिक और गतिशील वीबीओ हैं, पूर्व स्थैतिक मॉडल के लिए सबसे अच्छा है, और बाद वाले उन मॉडलों के लिए सबसे अच्छा है, जिनके कोने हर फ्रेम (जैसे, एक कण प्रणाली) को बदल देंगे। यहां तक ​​कि जब यह गतिशील वीबीओ की बात आती है, हालांकि, आप हर फ्रेम में सभी छोरों को फिर से नहीं भेजना चाहते हैं; बस जो बदल रहे हैं।

आपके भवन के मामले में, वर्टेक्स डेटा बस वहां बैठ जाएगा, और केवल एक चीज जो परिवर्तन होती है वह आपके मैट्रिसेस (मॉडल / दुनिया, प्रक्षेपण और दृश्य) हैं।

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

जब मॉडल वास्तव में प्रत्येक फ्रेम प्रदान करता है तो GPU प्रोसेसर को GPU मेमोरी से हर बार अपना डेटा प्राप्त करना पड़ता है? मेरा क्या मतलब है - अगर मेरे पास 2 मॉडल हैं, तो मैंने हर बार कई बार काम किया है - क्या इससे कोई फर्क पड़ेगा कि अगर मैंने पहली बार पहली बार कई बार और फिर दूसरी बार कई बार या अगर मैंने पहली बार सिर्फ एक बार गाया है, तो दूसरा सिर्फ एक बार। इस तरह interleaving रखा?

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

जाहिर है ग्राफिक्स कार्ड में रैम सीमित होती है - जब यह 1 फ्रेम रेंडर करने के लिए आवश्यक सभी मॉडल डेटा को पकड़ नहीं सकता है, तो मुझे लगता है कि यह (कुछ) सीपीयू रैम से प्रत्येक फ्रेम प्राप्त करता रहता है, क्या यह सही है?

आप GPU RAM से बाहर नहीं भागना चाहते हैं। यदि आप करते हैं, तो चीजों को बदल दें ताकि आप न करें। बहुत काल्पनिक परिदृश्य में, जो आप रन आउट करते हैं, यह शायद किसी तरह दुर्घटनाग्रस्त हो जाएगा, लेकिन मैंने ऐसा कभी नहीं देखा है इसलिए मैं ईमानदारी से नहीं जानता।

मैं एक भेद करना भूल गया: जीपीयू में डेटा भेज रहा है और बफ़र्स को वर्तमान के रूप में सेट / बाइंड कर रहा है। क्या बाद वाला कोई डेटा प्रवाह करता है?

कोई महत्वपूर्ण डेटा प्रवाह नहीं, नहीं। इसकी कुछ लागत है, लेकिन यह आपके द्वारा लिखी गई कोड की प्रत्येक पंक्ति के लिए सही है। यह पता लगाना कि आप कितना खर्च कर रहे हैं, फिर से, प्रोफाइलिंग किस लिए है।

आरंभीकरण के साथ बफर निर्माण

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

बफ़र डेटा अद्यतन

मैं अनुमान लगा रहा हूँ कि आप glBufferData, या उस जैसे अन्य कार्यों का मतलब है, है ना? यह वह जगह है जहां वास्तविक डेटा ट्रांसफर होता है। (जब तक आप अशक्त न हों, जैसे मैंने पिछले पैराग्राफ में कहा था।)

बफर को सक्रिय के रूप में बांधना (क्या यह एपीआई को बताने का एक तरीका है कि मैं चाहता हूं कि यह बफर अगले ड्रॉ कॉल में प्रदान किया जाए और यह अपने आप कुछ भी नहीं करता है?)

हां, लेकिन यह उससे थोड़ा ज्यादा कर सकता है। उदाहरण के लिए, यदि आप एक VAO (वर्टेक्स एरे ऑब्जेक्ट) को बांधते हैं, तो एक VBO को बांधते हैं, कि VBO VAO से बंध जाता है। बाद में, यदि आप उस वीएओ को फिर से बांधते हैं, और glDrawArrays को कॉल करते हैं, तो यह पता चलेगा कि वीबीओ को क्या आकर्षित करना है।

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

एपीआई ड्रा कॉल

यहाँ जो होता है वह बहुत सीधा (हमारे दृष्टिकोण से) है। कहते हैं कि आप एक VAO बाँधते हैं, तो glDrawArrays को कॉल करें। आप एक प्रारंभिक बिंदु, और एक गिनती निर्दिष्ट करते हैं, और यह उस सीमा में प्रत्येक शीर्ष के लिए अपना शीर्ष shader चलाता है, जो बदले में लाइन के नीचे अपने आउटपुट को पास करता है। यह पूरी प्रक्रिया अपने आप में एक और निबंध है, हालांकि।

Comments

"तब समस्या हल हो गई" हां, इंस्टेंस बहुत मदद करेगा लेकिन इसके बिना मुझे अभी भी प्रत्येक ऑब्जेक्ट के लिए एक ड्रॉ कॉल करना होगा। दोनों मामलों में समान है। इसलिए मुझे आश्चर्य है कि अगर आदेश मायने रखता है।

— एनपीएस

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

— बर्फीले अवज्ञा