सेट अप
मेरे पास एक इकाई-घटक वास्तुकला है जहाँ संस्थाओं में विशेषताओं का एक सेट हो सकता है (जो कि बिना किसी व्यवहार के शुद्ध डेटा हैं) और वहां मौजूद सिस्टम हैं जो इकाई तर्क को चलाते हैं जो उस डेटा पर कार्य करते हैं। अनिवार्य रूप से, कुछ छद्म कोड में:
Entity
{
id;
map<id_type, Attribute> attributes;
}
System
{
update();
vector<Entity> entities;
}एक ऐसी प्रणाली जो स्थिर दर पर सभी संस्थाओं के साथ चलती है
MovementSystem extends System
{
update()
{
for each entity in entities
position = entity.attributes["position"];
position += vec3(1,1,1);
}
}आवश्यक रूप से, मैं यथासंभव अपडेट () को अपडेट करने की कोशिश कर रहा हूं। यह पूरे सिस्टम को समानांतर में चलाकर किया जा सकता है, या एक सिस्टम के प्रत्येक अपडेट () घटकों के एक जोड़े को दे कर अलग-अलग धागे एक ही सिस्टम के अपडेट को निष्पादित कर सकते हैं, लेकिन उस सिस्टम के साथ पंजीकृत संस्थाओं के एक अलग सबसेट के लिए।
मुसीबत
दिखाए गए मूवमेंट सिस्टम के मामले में, समानांतरीकरण तुच्छ है। चूंकि इकाइयाँ एक दूसरे पर निर्भर नहीं होती हैं, और साझा डेटा को संशोधित नहीं करती हैं, इसलिए हम समानांतर में सभी संस्थाओं को स्थानांतरित कर सकते हैं।
हालांकि, इन प्रणालियों को कभी-कभी आवश्यकता होती है कि इकाइयां एक-दूसरे के साथ, कभी-कभी एक ही प्रणाली के भीतर (लेकिन / से डेटा पढ़ें / लिखें) के साथ परस्पर क्रिया करती हैं, लेकिन अक्सर विभिन्न प्रणालियों के बीच होती हैं जो एक-दूसरे पर निर्भर करती हैं।
उदाहरण के लिए, भौतिकी प्रणाली में कभी-कभी संस्थाएं एक-दूसरे के साथ बातचीत कर सकती हैं। दो ऑब्जेक्ट टकराते हैं, उनके स्थान, वेग और अन्य विशेषताओं को उनसे पढ़ा जाता है, अपडेट किया जाता है, और फिर अद्यतन विशेषताओं को दोनों संस्थाओं को वापस लिखा जाता है।
और इससे पहले कि इंजन में रेंडरिंग सिस्टम संस्थाओं को प्रस्तुत करना शुरू कर सके, उसे अन्य प्रणालियों के लिए निष्पादन को पूरा करने के लिए इंतजार करना होगा ताकि यह सुनिश्चित हो सके कि सभी प्रासंगिक विशेषताएँ वे हैं जो उन्हें होना चाहिए।
यदि हम नेत्रहीन रूप से इसे समानांतर करने की कोशिश करते हैं, तो यह शास्त्रीय दौड़ की स्थिति को जन्म देगा जहां विभिन्न प्रणालियां एक ही समय में डेटा को पढ़ और संशोधित कर सकती हैं।
आदर्श रूप से, एक ऐसा समाधान मौजूद होगा जहां सभी प्रणालियां अपनी इच्छानुसार किसी भी संस्था के डेटा को पढ़ सकती हैं, बिना किसी अन्य सिस्टम के बारे में चिंता किए बिना उसी समय उसी डेटा को संशोधित कर सकती हैं, और प्रोग्रामर की देखभाल के बिना निष्पादन और समानांतर रूप से व्यवस्थित करने के बारे में परवाह किए बिना। इन प्रणालियों को मैन्युअल रूप से (जो कभी-कभी संभव भी नहीं हो सकता है)।
एक बुनियादी कार्यान्वयन में, यह केवल सभी डेटा रीड और महत्वपूर्ण अनुभागों में लिखकर प्राप्त किया जा सकता है (उन्हें म्यूटेक्स के साथ संरक्षित करना)। लेकिन यह रनवे ओवरहेड की एक बड़ी मात्रा को प्रेरित करता है और संभवतः प्रदर्शन संवेदनशील अनुप्रयोगों के लिए उपयुक्त नहीं है।
उपाय?
मेरी सोच में, एक संभावित समाधान एक ऐसी प्रणाली होगी जहां डेटा पढ़ना / अपडेट करना और लिखना अलग किया जाता है, ताकि एक महंगे चरण में, सिस्टम केवल डेटा को पढ़े और गणना करें कि उन्हें क्या गणना करने की आवश्यकता है, किसी तरह परिणाम कैश करें, और फिर सभी लिखें एक अलग लेखन पास में लक्षित संस्थाओं को वापस डेटा बदल दिया। सभी सिस्टम राज्य में डेटा पर कार्य करेंगे कि यह फ्रेम की शुरुआत में था, और फिर फ्रेम के अंत से पहले, जब सभी सिस्टम अपडेट करना समाप्त कर देते हैं, एक क्रमबद्ध लेखन पास होता है जहां सभी अलग-अलग से कैश किए गए परिणाम होते हैं सिस्टम को लक्ष्य संस्थाओं के माध्यम से पुन: लिखा जाता है।
यह (शायद गलत है?) विचार पर आधारित है कि परिणाम के कैशिंग और लेखन पास के लिए आसान समानांतर जीत जीत की लागत (रनटाइम प्रदर्शन दोनों के साथ-साथ एक कोड उपरि) के मामले से आगे निकल सकती है।
प्रश्न
इष्टतम प्रदर्शन को प्राप्त करने के लिए ऐसी प्रणाली कैसे लागू की जा सकती है? ऐसी प्रणाली का कार्यान्वयन विवरण क्या हैं और इस समाधान का उपयोग करने के लिए इच्छुक इकाई-घटक प्रणाली के लिए आवश्यक शर्तें क्या हैं?