रेफरी स्थानीय और रेफरी C #: प्रदर्शन नुकसान में

बहुत शुरुआत से, मूल्य के आधार पर या संदर्भ द्वारा सी # समर्थित पासिंग तर्क। लेकिन संस्करण 7 से पहले, सी # संकलक ने एक विधि (या संपत्ति) से मूल्य वापस करने के लिए केवल एक ही तरीके का समर्थन किया - मूल्य द्वारा वापसी। C # 7 में, दो नई सुविधाओं की शुरूआत के साथ स्थिति बदल गई है: प्रतिफल और स्थानीय लोगों को परिष्कृत करें। उनके बारे में और उनके प्रदर्शन के बारे में - कट के तहत।

कारणों

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

इसे प्रदर्शित करने के लिए, हमें निषिद्ध विधि की ओर मुड़ना होगा - परिवर्तनशील मूल्य प्रकार का उपयोग करें:

public struct Mutable { private int _x; public Mutable(int x) => _x = x; public int X => _x; public void IncrementX() { _x++; } } [Test] public void CheckMutability() { var ma = new[] {new Mutable(1)}; ma[0].IncrementX(); // X has been changed! Assert.That(ma[0].X, Is.EqualTo(2)); var ml = new List<Mutable> {new Mutable(1)}; ml[0].IncrementX(); // X hasn't been changed! Assert.That(ml[0].X, Is.EqualTo(1)); } 

परीक्षण सफल होगा क्योंकि सरणी अनुक्रमणिका सूची अनुक्रमणिका से काफी भिन्न है।

सी # कंपाइलर एरे इंडेक्सर - लेडलेमा को एक विशेष निर्देश देता है, जो इस एरे के एक तत्व के लिए एक प्रबंधित लिंक देता है। मूलतः, एक सरणी अनुक्रमणिका एक तत्व को संदर्भ द्वारा लौटाती है। हालाँकि, सूची समान व्यवहार नहीं कर सकती है, क्योंकि C # में आंतरिक स्थिति का एक उपनाम वापस करना संभव नहीं था। इसलिए, सूची अनुक्रमणिका किसी तत्व को मान से लौटाती है, अर्थात इस तत्व की एक प्रति लौटाती है।

* जैसा कि हम जल्द ही देखेंगे, सूची अनुक्रमणिका अभी भी संदर्भ द्वारा एक तत्व नहीं लौटा सकती है।

इसका मतलब यह है कि मा [0] .IncrementX () विधि को कहता है जो सरणी के पहले तत्व को संशोधित करता है, जबकि ml [0] .IncrementX () उस विधि को कहता है जो मूल सूची को प्रभावित किए बिना तत्व की प्रतिलिपि को संशोधित करता है।

वापसी मान और संदर्भ स्थानीय चर: मूल बातें

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

1. एक सरल उदाहरण:

 [Test] public void RefLocalsAndRefReturnsBasics() { int[] array = { 1, 2 }; // Capture an alias to the first element into a local ref int first = ref array[0]; first = 42; Assert.That(array[0], Is.EqualTo(42)); // Local function that returns the first element by ref ref int GetByRef(int[] a) => ref a[0]; // Weird syntax: the result of a function call is assignable GetByRef(array) = -1; Assert.That(array[0], Is.EqualTo(-1)); } 

2. लौटे संदर्भ मूल्यों और आसानी से संशोधक

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

 class EncapsulationWentWrong { private readonly Guid _guid; private int _x; public EncapsulationWentWrong(int x) => _x = x; // Return an alias to the private field. No encapsulation any more. public ref int X => ref _x; // Return a readonly alias to the private field. public ref readonly Guid Guid => ref _guid; } [Test] public void NoEncapsulation() { var instance = new EncapsulationWentWrong(42); instance.X++; Assert.That(instance.X, Is.EqualTo(43)); // Cannot assign to property 'EncapsulationWentWrong.Guid' because it is a readonly variable // instance.Guid = Guid.Empty; } 

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

3. मौजूदा प्रतिबंध। एक उपनाम लौटना खतरनाक हो सकता है: विधि पूरी होने के बाद ढेर पर रखे गए चर के लिए एक उपनाम का उपयोग करने से एप्लिकेशन क्रैश हो जाएगा। इस फ़ंक्शन को सुरक्षित बनाने के लिए, C # कंपाइलर विभिन्न प्रतिबंधों को लागू करता है:

• स्थानीय चर के लिंक को वापस करने में असमर्थ।
• संरचनाओं में इसके संदर्भ को वापस करने में असमर्थ।
• आप ढेर पर स्थित एक चर के लिए एक लिंक वापस कर सकते हैं (उदाहरण के लिए, एक वर्ग के सदस्य के लिए)।
• आप रेफरी / आउट मापदंडों के लिए एक लिंक वापस कर सकते हैं।

अधिक जानकारी के लिए, हम अनुशंसा करते हैं कि आप रेफरी के लिए नियमों को वापस करने के लिए उत्कृष्ट प्रकाशन सेफ की जाँच करें। लेख के लेखक, व्लादिमीर सैडोव, सी # संकलक के लिए वापसी संदर्भ समारोह के निर्माता हैं।

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

अनुक्रमित में लौटे संदर्भ मूल्यों का उपयोग करना

प्रदर्शन पर इन कार्यों के प्रभाव का परीक्षण करने के लिए, हम NaiveImmutableList <T> नामक एक अद्वितीय, अपरिवर्तनीय संग्रह बनाएंगे और इसे T [] और विभिन्न आकारों (4, 16, 32 और 48) की संरचनाओं के लिए सूची के साथ तुलना करेंगे।

 public class NaiveImmutableList<T> { private readonly int _length; private readonly T[] _data; public NaiveImmutableList(params T[] data) => (_data, _length) = (data, data.Length); public ref readonly T this[int idx] // R# 2017.3.2 is completely confused with this syntax! // => ref (idx >= _length ? ref Throw() : ref _data[idx]); { get { // Extracting 'throw' statement into a different // method helps the jitter to inline a property access. if ((uint)idx >= (uint)_length) ThrowIndexOutOfRangeException(); return ref _data[idx]; } } private static void ThrowIndexOutOfRangeException() => throw new IndexOutOfRangeException(); } struct LargeStruct_48 { public int N { get; } private readonly long l1, l2, l3, l4, l5; public LargeStruct_48(int n) : this() => N = n; } // Other structs like LargeStruct_16, LargeStruct_32 etc 

एक प्रदर्शन परीक्षण सभी संग्रह के लिए किया जाता है और प्रत्येक आइटम के लिए सभी एन संपत्ति मूल्यों को जोड़ता है:

 private const int elementsCount = 100_000; private static LargeStruct_48[] CreateArray_48() => Enumerable.Range(1, elementsCount).Select(v => new LargeStruct_48(v)).ToArray(); private readonly LargeStruct_48[] _array48 = CreateArray_48(); [BenchmarkCategory("BigStruct_48")] [Benchmark(Baseline = true)] public int TestArray_48() { int result = 0; // Using elementsCound but not array.Length to force the bounds check // on each iteration. for (int i = 0; i < elementsCount; i++) { result = _array48[i].N; } return result; } 

परिणाम इस प्रकार हैं:



जाहिर है, कुछ गलत है! हमारे NaiveImmutableList <T> संग्रह का प्रदर्शन सूची के समान है। क्या हुआ था?

आसानी से संशोधक के साथ मान लौटाएँ: यह कैसे काम करता है

जैसा कि आप देख सकते हैं, NaiveImmutableList <T> इंडेक्स केवल रीड रीडऑन संशोधक का उपयोग करके एक लिंक-केवल लिंक देता है। यह पूरी तरह से उचित है, क्योंकि हम एक अपरिवर्तनीय संग्रह की अंतर्निहित स्थिति को बदलने के लिए ग्राहकों की क्षमता को सीमित करना चाहते हैं। हालांकि, प्रदर्शन परीक्षण में हम जिन संरचनाओं का उपयोग करते हैं वे न केवल पठनीय हैं।

यह परीक्षण हमें मूल व्यवहार को समझने में मदद करेगा:

 [Test] public void CheckMutabilityForNaiveImmutableList() { var ml = new NaiveImmutableList<Mutable>(new Mutable(1)); ml[0].IncrementX(); // X has been changed, right? Assert.That(ml[0].X, Is.EqualTo(2)); } 

परीक्षण विफल! लेकिन क्यों? क्योंकि "रीड-ओनली लिंक्स" की संरचना मॉडिफायर की संरचना और संरचना के संबंध में आसानी से फ़ील्ड के समान है: कंपाइलर हर बार एक सुरक्षा प्रतिलिपि बनाता है जब एक संरचना तत्व का उपयोग किया जाता है। इसका मतलब है कि मिलीलीटर [को ०]। अभी भी पहले तत्व की एक प्रति बनाता है, लेकिन यह अनुक्रमणिका द्वारा नहीं किया जाता है: प्रतिलिपि कॉल के बिंदु पर बनाई जाती है।

यह व्यवहार वास्तव में समझ में आता है। C # कंपाइलर मान के द्वारा, तर्क द्वारा, और "रीड ओनली लिंक" को संशोधक में प्रयोग करके (विवरण के लिए, देखें ) इन-मोडिफायर और C # में रीडऑनली स्ट्रक्चर्स ("इन मॉडिफ़ायर एंड रीड-ओनली स्ट्रक्चर्स इन सी" का समर्थन करता है। "))। अब संकलक एक विधि से मूल्य वापस करने के लिए तीन अलग-अलग तरीकों का समर्थन करता है: मूल्य से, संदर्भ से और केवल-पढ़ने के लिए लिंक से।

केवल-पढ़ने के लिए लिंक नियमित लिंक के समान हैं कि कंपाइलर अपने रिटर्न मानों के बीच अंतर करने के लिए एक ही InAttribute का उपयोग करता है:

 private int _n; public ref readonly int ByReadonlyRef() => ref _n; 

इस स्थिति में, ByReadonlyRef पद्धति कुशलतापूर्वक इसमें संकलित है:

 [InAttribute] [return: IsReadOnly] public int* ByReadonlyRef() { return ref this._n; } 

संशोधक और रीड-ओनली लिंक के बीच समानता का मतलब है कि ये कार्य नियमित संरचनाओं के लिए बहुत उपयुक्त नहीं हैं और प्रदर्शन समस्याओं का कारण बन सकते हैं। एक उदाहरण पर विचार करें:

 public struct BigStruct { // Other fields public int X { get; } public int Y { get; } } private BigStruct _bigStruct; public ref readonly BigStruct GetBigStructByRef() => ref _bigStruct; ref readonly var bigStruct = ref GetBigStructByRef(); int result = bigStruct.X + bigStruct.Y; 

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

अनुक्रमित में लौटे संदर्भ मूल्यों का उपयोग करना। प्रयास नंबर 2

आइए विभिन्न आकारों की केवल-पठन संरचनाओं के लिए परीक्षणों का एक ही सेट आज़माएँ:



अब परिणाम बहुत अधिक समझ में आता है। बड़ी संरचनाओं के लिए प्रसंस्करण समय अभी भी बढ़ रहा है, लेकिन यह अपेक्षित है, क्योंकि 100 हजार से अधिक बड़ी संरचनाओं को संसाधित करने में अधिक समय लगता है। लेकिन अब NaiveimmutableList <T> के लिए रनटाइम T [] के समय के बहुत करीब है और सूची के मामले में बहुत बेहतर है।

निष्कर्ष

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

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

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