🧝🏻 👨🏿‍🔬 👧🏻 नौकरी की व्यवस्था। दूसरी तरफ से अवलोकन 👦 ✈️ 🌶️

2018 में एकता के नए संस्करण में, उन्होंने अंततः आधिकारिक तौर पर शॉर्ट के लिए नई एंटिटी घटक प्रणाली, या ईसीएस को जोड़ा, जो आपको ऑब्जेक्ट के घटकों के साथ सामान्य कार्य के बजाय केवल उनके डेटा के साथ काम करने की अनुमति देता है।

एक अतिरिक्त कार्य प्रणाली आपको अपने कोड के प्रदर्शन को बेहतर बनाने के लिए समानांतर कंप्यूटिंग शक्ति का उपयोग करने की पेशकश करती है।

साथ में, ये दो नए सिस्टम ( ईसीएस और जॉब सिस्टम ) एक नए स्तर की डेटा प्रोसेसिंग प्रदान करते हैं।

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

नई व्यवस्था

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

कार्य

नई प्रणाली में किसी भी गणना को करने के लिए, उन कार्यों का उपयोग करना आवश्यक है जो गणना के लिए तरीकों और डेटा से मिलकर ऑब्जेक्ट हैं।

ईसीएस प्रणाली के किसी भी अन्य डेटा की तरह, जॉब सिस्टम में कार्यों को उन संरचनाओं के रूप में भी दर्शाया जाता है जो तीन इंटरफेसों में से एक को प्राप्त करती हैं।

IJob

सरलतम कार्य इंटरफ़ेस जिसमें एक निष्पादन विधि है जो मापदंडों के रूप में कुछ भी नहीं लेता है और कुछ भी नहीं देता है।

कार्य स्वयं इस तरह दिखता है:

IJob

public struct JobStruct : IJob { public void Execute() {} }

निष्पादित विधि में, आप आवश्यक गणना कर सकते हैं।

IJobParallelFor

एक ही एक्सिक्यूट विधि के साथ एक अन्य इंटरफ़ेस, जो बदले में पहले से ही संख्यात्मक पैरामीटर इंडेक्स को स्वीकार करता है।

IJobParallelFor

 public struct JobStruct : IJobParallelFor { public void Execute(int index) {} }

यह IJobParallelFor इंटरफ़ेस, IJob इंटरफ़ेस के विपरीत, किसी कार्य को कई बार निष्पादित करने और न केवल निष्पादित करने की पेशकश करता है, बल्कि इस निष्पादन को उन ब्लॉकों में तोड़ता है जो थ्रेड्स के बीच वितरित किए जाएंगे।

स्पष्ट नहीं है इस बारे में चिंता न करें, मैं आपको और बताऊंगा।

IJobParallelForTransform

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

IJobParallelForTransform

 public struct JobStruct : IJobParallelForTransform { public void Execute(int index, TransformAccess transform) {} }

इस तथ्य के कारण कि आप सीधे कार्य में एकता वस्तुओं के साथ काम नहीं कर सकते हैं, यह इंटरफ़ेस केवल डेटा को एक अलग ट्रांसफॉर्मैस संरचना के रूप में बदल सकता है।

हो गया, अब आप जानते हैं कि कार्य संरचना कैसे बनाई जाती है, आप अभ्यास के लिए आगे बढ़ सकते हैं।

कार्य पूर्ण होना

आइजोब इंटरफ़ेस से विरासत में मिला एक सरल कार्य बनाते हैं और इसे पूरा करते हैं। इसके लिए हमें किसी भी सरल मोनोबीवियर लिपि और कार्य की संरचना की आवश्यकता है।

TestJob

 public class TestJob : MonoBehaviour { void Start() {} }

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

SimpleJob

 using Unity.Jobs; public struct SimpleJob : IJob { public void Execute() { Debug.Log("Hello parallel world!"); } }

उदाहरण के लिए, निष्पादित विधि में, कंसोल के लिए एक सरल रेखा प्रिंट करें।

अब चलिए TestJob स्क्रिप्ट की स्टार्ट विधि पर चलते हैं, जहाँ हम कार्य का एक उदाहरण बनाएँगे और फिर उस पर अमल करेंगे।

TestJob

 public class TestJob : MonoBehaviour { void Start() { SimpleJob job = new SimpleJob(); job.Schedule().Complete(); } }

यदि आपने उदाहरण के रूप में सब कुछ किया है, तो गेम शुरू करने के बाद आपको चित्र के अनुसार कंसोल को एक सरल संदेश मिलेगा।

यहां क्या होता है: शेड्यूल विधि को कॉल करने के बाद, शेड्यूलर कार्य को हैंडल में रखता है और अब इसे पूर्ण विधि कहकर पूरा किया जा सकता है।

यह एक कार्य का एक उदाहरण था जो केवल पाठ को कंसोल पर मुद्रित करता था। किसी भी समानांतर संगणना को करने के लिए एक कार्य के लिए, इसे डेटा से भरना आवश्यक है।

कार्य में डेटा

ईसीएस प्रणाली की तरह, कार्यों में एकता वस्तुओं तक पहुंच नहीं है, आप गेमऑबजेक्ट को कार्य में नहीं ला सकते हैं और वहां उसका नाम बदल सकते हैं। आप बस इतना कर सकते हैं कि कुछ अलग-अलग ऑब्जेक्ट पैरामीटर को कार्य में स्थानांतरित करें, इन मापदंडों को बदलें, और कार्य पूरा करने के बाद, इन परिवर्तनों को वापस ऑब्जेक्ट पर लागू करें।

कार्य में ही डेटा की कई सीमाएँ हैं: सबसे पहले, यह संरचनाएं होनी चाहिए, और दूसरी बात, यह परिवर्तनीय डेटा प्रकार नहीं होनी चाहिए, अर्थात, आप कार्य के लिए एक ही बूलियन या स्ट्रिंग पास नहीं कर सकते।

SimpleJob

 public struct SimpleJob : IJob { public float a, b; public void Execute() { float result = a + b; Debug.Log(result); } }

और मुख्य स्थिति: एक कंटेनर में संलग्न नहीं डेटा केवल कार्य के अंदर पहुँचा जा सकता है!

कंटेनर

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

कंटेनर कई प्रकार के होते हैं:
NativeArray । एक निश्चित आकार के साथ एक सरल सरणी के रूप में सबसे सरल और सबसे अधिक इस्तेमाल किया जाने वाला कंटेनर प्रस्तुत किया गया है।
मूल निवासी । एक अन्य कंटेनर - एक सरणी, जैसा कि अनुवाद से स्पष्ट है, NativeArray को टुकड़ों में काटने के लिए डिज़ाइन किया गया है।

ये दो मुख्य कंटेनर एक ईसीएस सिस्टम को जोड़ने के बिना उपलब्ध हैं। अधिक उन्नत संस्करण में, कई और प्रकार के कंटेनर हैं।

मूल निवासी । यह डेटा की एक नियमित सूची है।
NativeHashMap । एक कुंजी और एक मूल्य के साथ एक शब्दकोश का एक एनालॉग।
NativeMultiHashMap । एक ही कुंजी के तहत केवल कुछ मूल्यों के साथ एक ही NativeHashMap ।
NativeQueue। डेटा कतारों की सूची।

चूँकि हम ECS सिस्टम को जोड़े बिना काम करते हैं, केवल NativeArray और NativeSlice हमारे लिए उपलब्ध हैं ।

व्यावहारिक भाग पर आगे बढ़ने से पहले, सबसे महत्वपूर्ण बिंदु का विश्लेषण करना आवश्यक है - उदाहरणों का निर्माण।

कंटेनर बनाएँ

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

यह आवंटन है जो निर्धारित करता है कि कार्य कितने समय तक कंटेनर में डेटा का उपयोग कर सकता है - दूसरे शब्दों में, पुल कब तक खुला रहेगा।

इन दो प्रक्रियाओं को बेहतर ढंग से समझने के लिए, आइए नीचे दी गई तस्वीर पर एक नज़र डालें।

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

अब तस्वीर के शीर्ष पर एक नज़र डालें।

सफेद बार आवंटन कंटेनर के जीवनकाल को दर्शाता है। पहले फ्रेम में, कंटेनर को आवंटित किया जाता है - पुल को खोला जाता है, इस क्षण तक कंटेनर मौजूद नहीं था, कार्य में सभी गणना पूरी होने के बाद, कंटेनर को मेमोरी से मुक्त कर दिया जाता है और 9 वें फ्रेम में पुल को बंद कर दिया जाता है।

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

इन खंडों की आवश्यकता क्यों है? तथ्य यह है कि अवधि तक किसी कार्य का निष्पादन अलग-अलग हो सकता है, हम उन्हें सीधे उसी तरीके से निष्पादित कर सकते हैं जहां हमने इसे बनाया था, या हम कार्य के निष्पादन समय का विस्तार कर सकते हैं यदि यह काफी जटिल है, और ये सेगमेंट बताते हैं कि कार्य कितना जरूरी है और कितनी देर तक डेटा का उपयोग कर सकते हैं कंटेनर में।

यदि यह अभी भी स्पष्ट नहीं है, तो मैं एक उदाहरण का उपयोग करके प्रत्येक प्रकार के आवंटन का विश्लेषण करूंगा।

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

अस्थायी

TestJob

 using Unity.Jobs; using Unity.Collections; public class TestJob : MonoBehaviour { void Start() { NativeArray<int> array = new NativeArray<int>(10, Allocator.Temp); } }

एक नया कंटेनर उदाहरण बनाने के लिए, आपको इसके निर्माता में आकार और आवंटन का प्रकार निर्दिष्ट करना होगा। यह उदाहरण Temp प्रकार का उपयोग करता है, क्योंकि कार्य केवल प्रारंभ विधि में किया जाएगा।

अब SimpleJob कार्य की संरचना में सटीक उसी सरणी चर को प्रारंभ करें।

SimpleJob

 public struct SimpleJob : IJob { public NativeArray<int> array; public void Execute() {} }

हो गया। अब आप कार्य स्वयं बना सकते हैं और इसके लिए एक सरणी उदाहरण पास कर सकते हैं।

प्रारंभ

 void Start() { NativeArray<int> array = new NativeArray<int>(10, Allocator.Temp); SimpleJob job = new SimpleJob(); job.array = array; }

इस समय कार्य को चलाने के लिए, हम उसी शेड्यूल विधि को कॉल करके इसे प्राप्त करने के लिए इसके जॉबहैंडल हैंडल का उपयोग करेंगे।

प्रारंभ

 void Start() { NativeArray<int> array = new NativeArray<int>(10, Allocator.Temp); SimpleJob job = new SimpleJob(); job.array = array; JobHandle handle = job.Schedule(); }

अब आप उसके हैंडल पर कम्पलीट मेथड को कॉल कर सकते हैं और यह जांच सकते हैं कि कंसोल में टेक्स्ट प्रदर्शित करने के लिए कार्य पूरा हुआ या नहीं।

प्रारंभ

 void Start() { NativeArray<int> array = new NativeArray<int>(10, Allocator.Temp); SimpleJob job = new SimpleJob(); job.array = array; JobHandle handle = job.Schedule(); handle.Complete(); if (handle.IsCompleted) print(" "); }

यदि आप इस रूप में कार्य चलाते हैं, तो खेल शुरू करने के बाद आपको यह कहते हुए एक मोटी लाल त्रुटि मिलेगी कि आपने कार्य पूरा होने के बाद संसाधनों से सरणी कंटेनर को जारी नहीं किया।

कुछ इस तरह।

इससे बचने के लिए, कार्य पूरा करने के बाद कंटेनर पर डिस्पोज विधि को कॉल करें।

प्रारंभ

 void Start() { NativeArray<int> array = new NativeArray<int>(10, Allocator.Temp); SimpleJob job = new SimpleJob(); job.array = array; JobHandle handle = job.Schedule(); handle.Complete(); if (handle.IsCompleted) print("Complete"); array.Dispose(); }

तब आप इसे सुरक्षित रूप से पुनः आरंभ कर सकते हैं।
लेकिन कार्य कुछ नहीं करता है! - फिर इसमें कुछ क्रियाओं को जोड़ें।

SimpleJob

 public struct SimpleJob : IJob { public NativeArray<int> array; public void Execute() { for(int i = 0; i < array.Length; i++) { array[i] = i * i; } } }

निष्पादित विधि में, मैं सरणी के प्रत्येक तत्व के सूचकांक को अपने द्वारा गुणा करता हूं और परिणाम सरणी में वापस प्रारंभ विधि में कंसोल को प्रिंट करने के लिए इसे लिखता हूं।

प्रारंभ

 void Start() { NativeArray<int> array = new NativeArray<int>(10, Allocator.Temp); SimpleJob job = new SimpleJob(); job.array = array; JobHandle handle = job.Schedule(); handle.Complete(); if (handle.IsCompleted) print(job.array[job.array.Length - 1]); array.Dispose(); }

यदि हम वर्ग के अंतिम तत्व को प्रिंट करते हैं तो कंसोल में परिणाम क्या होगा?

यह है कि आप कंटेनर कैसे बना सकते हैं, उन्हें कार्यों में डाल सकते हैं और उन पर कार्रवाई कर सकते हैं।

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

TempJob

इस उदाहरण में, मैं SimpleJob कार्य की संरचना को थोड़ा संशोधित करूंगा और इसे अन्य IJobParallelFor इंटरफ़ेस से विरासत में प्राप्त करूंगा ।

SimpleJob

 public struct SimpleJob : IJobParallelFor { public NativeArray<Vector2> array; public void Execute(int index) {} }

इसके अलावा, चूंकि यह कार्य एक फ्रेम से अधिक समय तक चलेगा, इसलिए हम टास्क के परिणाम को अलग-अलग अवाॅक और स्टार्ट तरीकों में जमा करेंगे और एक कोरटाइन के रूप में प्रस्तुत करेंगे। ऐसा करने के लिए, TestJob वर्ग की उपस्थिति को थोड़ा बदल दें ।

TestJob

 public class TestJob : MonoBehaviour { private NativeArray<Vector2> array; private JobHandle handle; void Awake() {} IEnumerator Start() {} }

अवेक विधि में, हम एक कार्य और वैक्टर के एक कंटेनर का निर्माण करेंगे, और प्रारंभ विधि में, प्राप्त आंकड़ों और रिलीज संसाधनों का उत्पादन करेंगे।

सचेत

 void Awake() { this.array = new NativeArray<Vector2>(100, Allocator.TempJob); SimpleJob job = new SimpleJob(); job.array = this.array; }

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

सचेत

 void Awake() { this.array = new NativeArray<Vector2>(100, Allocator.TempJob); SimpleJob job = new SimpleJob(); job.array = this.array; this.handle = job.Schedule(100, 5) }

शेड्यूल विधि में पहला पैरामीटर इंगित करता है कि कार्य कितनी बार निष्पादित किया जाएगा, यहां सरणी सरणी के आकार के समान संख्या है।
दूसरा पैरामीटर बताता है कि कार्य को साझा करने के लिए कितने ब्लॉक हैं।

क्या अन्य ब्लॉक?
पहले, किसी कार्य को पूरा करने के लिए, एक थ्रेड को केवल एक बार एक्सक्यूट विधि कहा जाता है, अब इस विधि को 100 बार कॉल करना आवश्यक है, इसलिए शेड्यूलर इन 100 बार पुनरावृत्तियों को ब्लॉकों में तोड़ता है जो कि थ्रेड्स के बीच वितरित करता है ताकि कोई अलग थ्रेड लोड न हो सके। उदाहरण में, एक सौ पुनरावृत्तियों को प्रत्येक 20 पुनरावृत्तियों के 5 ब्लॉकों में विभाजित किया जाएगा, अर्थात्, अनुसूचक संभवतः इन 5 ब्लॉकों को 5 थ्रेड्स में वितरित करेगा, जहां प्रत्येक थ्रेड एक्सक्यूट विधि को 20 बार कॉल करेगा। व्यवहार में, निश्चित रूप से, यह एक तथ्य नहीं है कि अनुसूचक सिर्फ इतना ही करेगा, यह सब सिस्टम के कार्यभार पर निर्भर करता है, इसलिए शायद सभी 100 पुनरावृत्ति एक धागे में होगी।

अब आप टास्क हैंडल पर कम्पलीट मेथड को कॉल कर सकते हैं।

सचेत

 void Awake() { this.array = new NativeArray<Vector2>(100, Allocator.TempJob); SimpleJob job = new SimpleJob(); job.array = this.array; this.handle = job.Schedule(100, 5); this.handle.Complete(); }

स्टार्ट कॉरआउट में, हम कार्य के निष्पादन की जांच करेंगे और फिर हम कंटेनर को साफ करेंगे।

प्रारंभ

 IEnumerator Start() { while(this.handle.isCompleted == false){ yield return new WaitForEndOfFrame(); } this.array.Dispose(); }

अब कार्य में स्वयं क्रियाओं पर चलते हैं।

SimpleJob

 public struct SimpleJob : IJobParallelFor { public NativeArray<Vector2> array; public void Execute(int index) { float x = index; float y = index; Vector2 vector = new Vector2(x * x, y * y / (y * 2)); this.array[index] = vector; } }

प्रारंभ विधि में कार्य पूरा करने के बाद, कंसोल में सरणी के सभी तत्वों को प्रदर्शित करें ।

प्रारंभ

 IEnumerator Start() { while(this.handle.IsCompleted == false){ yield return new WaitForEndOfFrame(); } foreach(Vector2 vector in this.array) { print(vector); } this.array.Dispose(); }

हो गया, आप दौड़ कर परिणाम देख सकते हैं।

IJob और IJobParallelFor के बीच अंतर को समझने के लिए , नीचे दी गई छवियों पर एक नज़र डालें।
उदाहरण के लिए, IJob में आप कई बार गणना करने के लिए लूप के लिए एक सरल का उपयोग कर सकते हैं, लेकिन किसी भी स्थिति में, एक धागा केवल कार्य की पूरी अवधि के लिए एक बार एक्सक्यूट विधि को कॉल कर सकता है - यह है कि एक व्यक्ति एक पंक्ति में सैकड़ों एक ही क्रिया को कैसे करें।

IJobParallelFor न केवल एक थ्रेड में कई बार किसी कार्य को निष्पादित करने के लिए, बल्कि अन्य थ्रेड्स के बीच इन पुनरावृत्तियों को वितरित करने के लिए भी प्रदान करता है।

सामान्य तौर पर, TempJob के आवंटन का प्रकार अधिकांश कार्यों के लिए एकदम सही है जो कई फ़्रेमों पर किए जाते हैं।

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

दृढ़

आइए TestJob वर्ग में वापस जाएं और इसे बदलें। अब हम OnEnable पद्धति में कार्य बनाएंगे , अपडेट विधि में उनके निष्पादन की जांच करेंगे और OnDisable पद्धति में संसाधनों को साफ करेंगे ।
उदाहरण में, हम ऑब्जेक्ट को अपडेट विधि में स्थानांतरित करेंगे, प्रक्षेपवक्र की गणना के लिए हम दो वेक्टर कंटेनरों का उपयोग करेंगे - इनपुटअरे जिसमें हम वर्तमान स्थिति और आउटपुट डाल देंगे जहां से हम परिणाम प्राप्त करेंगे।

TestJob

 public class TestJob : MonoBehaviour { private NativeArray<Vector2> inputArray; private NativeArray<Vector2> outputArray; private JobHandle handle; void OnEnable() {} void Update() {} void OnDisable() {} }

हम इसे एक बार निष्पादित करने के लिए IJob इंटरफ़ेस से विरासत में प्राप्त करके SimpleJob कार्य की संरचना को भी थोड़ा संशोधित करेंगे ।

SimpleJob

 public struct SimpleJob : IJob { public void Execute() {} }

कार्य में ही, हम दो वेक्टर कंटेनरों, एक स्थिति वेक्टर और एक संख्यात्मक डेल्टा को भी धोखा देंगे, जो ऑब्जेक्ट को लक्ष्य तक ले जाएगा।

SimpleJob

 public struct SimpleJob : IJob { [ReadOnly] public NativeArray<Vector2> inputArray; [WriteOnly] public NativeArray<Vector2> outputArray; public Vector2 position; public float delta; public void Execute() {} }

ReadOnly और WriteOnly विशेषताएँ कंटेनर के अंदर डेटा से जुड़ी क्रियाओं पर प्रवाह प्रतिबंध दिखाती हैं। केवल कंटेनर से डेटा पढ़ने के लिए स्ट्रीम प्रदान करता है, इसके विपरीत, WriteOnly विशेषता, स्ट्रीम को केवल कंटेनर में डेटा लिखने की अनुमति देती है। यदि आपको एक कंटेनर में एक साथ इन दो कार्यों को करने की आवश्यकता है, तो आपको इसे एक विशेषता के साथ चिह्नित करने की आवश्यकता नहीं है।

चलिए टेस्टजॉब क्लास के ऑनएनेबल तरीके पर चलते हैं जहां कंटेनरों को इनिशियलाइज़ किया जाएगा।

OnEnable

 void OnEnable() { this.inputArray = new NativeArray<Vector2>(1, Allocator.Persistent); this.outputArray = new NativeArray<Vector2>(1, Allocator.Persistent); }

कंटेनरों के आयाम एकल होंगे क्योंकि यह केवल एक बार मापदंडों को प्रसारित करने और प्राप्त करने के लिए आवश्यक है। आवंटन का प्रकार स्थायी होगा।
OnDisable पद्धति में, हम कंटेनरों के संसाधनों को जारी करेंगे।

OnDisable

 void OnDisable() { this.inputArray.Dispose(); this.outputArray.Dispose(); }

आइए एक अलग CreateJob विधि बनाएं जहां हम इसके हैंडल के साथ एक कार्य बनाएंगे और वहां हम इसे डेटा से भर देंगे।

createjob

 void CreateJob() { SimpleJob job = new SimpleJob(); job.delta = Time.deltaTime; Vector2 position = this.transform.position; job.position = position; Vector2 newPosition = position + Vector2.right; this.inputArray[0] = newPosition; job.inputArray = this.inputArray; job.outputArray = this.outputArray; this.handle = job.Schedule(); this.handle.Complete(); }

वास्तव में, inputArray की वास्तव में यहां जरूरत नहीं है, क्योंकि यह केवल दिशा के वेक्टर को कार्य में स्थानांतरित करना संभव है, लेकिन मुझे लगता है कि यह समझना बेहतर होगा कि इन ReadOnly और WriteOnly विशेषताओं की आवश्यकता क्यों है।

अपडेट विधि में, हम जांचेंगे कि क्या कार्य पूरा हो गया है, जिसके बाद हम प्राप्त परिणाम को ऑब्जेक्ट ट्रांसफॉर्म पर लागू करते हैं और इसे फिर से चलाते हैं।

अद्यतन

 void Update() { if (this.handle.IsCompleted) { Vector2 newPosition = this.outputArray[0]; this.transform.position = newPosition; CreateJob(); } }

शुरू करने से पहले, हम OnEnable पद्धति को थोड़ा मोड़ देंगे ताकि कंटेनरों के आरंभीकरण के तुरंत बाद कार्य बनाया जाए।

OnEnable

 void OnEnable() { this.inputArray = new NativeArray<Vector2>(1, Allocator.Persistent); this.outputArray = new NativeArray<Vector2>(1, Allocator.Persistent); CreateJob(); }

हो गया, अब आप स्वयं कार्य पर जा सकते हैं और एक्सक्यूट विधि में आवश्यक गणना कर सकते हैं।

निष्पादित

 public void Execute() { Vector2 newPosition = this.inputArray[0]; newPosition = Vector2.Lerp(this.position, newPosition, this.delta); this.outputArray[0] = newPosition; }

काम के परिणाम को देखने के लिए, आप किसी ऑब्जेक्ट पर टेस्टजोब स्क्रिप्ट को फेंक सकते हैं और गेम चला सकते हैं।

उदाहरण के लिए, मेरा स्प्राइट बस धीरे-धीरे दाईं ओर शिफ्ट होता है।

एनीमेशन

सामान्य तौर पर, पुन: प्रयोज्य कंटेनरों के लिए आबंटित आबंटन का प्रकार बहुत अच्छा होता है जिसे हर बार नष्ट होने और पुनः बनाने की आवश्यकता नहीं होती है।

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

अमान्य और कोई नहीं

आवंटन के दो और प्रकार हैं अमान्य और कोई नहीं , लेकिन उन्हें डीबगिंग के लिए अधिक आवश्यक है, और कार्य में भाग नहीं लेते हैं।

JobHandle

अलग-अलग, यह कार्य संभाल की क्षमताओं का विश्लेषण करने के लिए सार्थक है, क्योंकि कार्य निष्पादन की प्रक्रिया की जांच के अलावा, यह छोटा संभाल अभी भी निर्भरता के माध्यम से कार्यों के पूरे नेटवर्क का निर्माण कर सकता है (हालांकि मैं उन्हें अधिक कॉल करना पसंद करता हूं)।

उदाहरण के लिए, यदि आपको एक निश्चित अनुक्रम में दो कार्य करने की आवश्यकता है, तो इसके लिए आपको केवल एक कार्य को दूसरे के हैंडल पर संलग्न करने की आवश्यकता है।

यह कुछ इस तरह दिखता है।

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

प्रारंभ

 void Start() { Job jobA = new Job(); JobHandle handleA = jobA.Schedule(); Job jobB = new Job(); JobHandle handleB = jobB.Schedule(); JobHandle result = JobHandle.CombineDependecies(handleA, handleB); result.Complete(); }

या ऐसा है।

प्रारंभ

 void Start() { JobHandle handle; for(int i = 0; i < 10; i++) { Job job = new Job(); handle = job.Schedule(handle); } handle.Complete(); }

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

निष्कर्ष

कंटेनर

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

सुरक्षा!

स्थैतिक डेटा।

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

टास्क सिस्टम का उपयोग कब करें?

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

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

सभी उदाहरणों के साथ स्रोत

नौकरी की व्यवस्था। दूसरी तरफ से अवलोकन

नई व्यवस्था

कार्य

IJob

IJobParallelFor

IJobParallelForTransform

कार्य पूर्ण होना

कार्य में डेटा

कंटेनर

कंटेनर बनाएँ

अस्थायी

TempJob

दृढ़

JobHandle

निष्कर्ष

कंटेनर

सुरक्षा!

More articles: