.NET कोर में प्रदर्शन

.NET कोर में प्रदर्शन

नमस्ते! यह लेख सर्वोत्तम प्रथाओं का एक संग्रह है जिसका उपयोग मैं और मेरे सहकर्मी विभिन्न परियोजनाओं पर काम करते समय लंबे समय से कर रहे हैं।

उस मशीन के बारे में जानकारी जिस पर गणनाएँ की गईं:बेंचमार्कडॉटनेट=v0.11.5, ओएस=विंडोज 10.0.18362
Intel Core i5-8250U CPU 1.60GHz (कैबी लेक R), 1 CPU, 8 लॉजिकल और 4 फिजिकल कोर
.NET कोर SDK=3.0.100
[होस्ट]: .NET कोर 2.2.7 (CoreCLR 4.6.28008.02, CoreFX 4.6.28008.03), 64 बिट RyuJIT
कोर: .NET कोर 2.2.7 (CoreCLR 4.6.28008.02, CoreFX 4.6.28008.03), 64 बिट RyuJIT
[होस्ट]: .NET कोर 3.0.0 (CoreCLR 4.700.19.46205, CoreFX 4.700.19.46214), 64 बिट RyuJIT
कोर: .NET कोर 3.0.0 (CoreCLR 4.700.19.46205, CoreFX 4.700.19.46214), 64 बिट RyuJIT

जॉब=कोर रनटाइम=कोर

ToList बनाम ToArray और साइकिल

मैंने इस जानकारी को .NET Core 3.0 के रिलीज़ के साथ तैयार करने की योजना बनाई थी, लेकिन उन्होंने मुझे इसमें हरा दिया, मैं किसी और की महिमा चुराना और अन्य लोगों की जानकारी की नकल नहीं करना चाहता, इसलिए मैं केवल बताना चाहता हूँ एक अच्छे लेख का लिंक जहां तुलना का विस्तार से वर्णन किया गया है.

अपनी ओर से, मैं केवल आपको अपने माप और परिणाम प्रस्तुत करना चाहता हूं; लेखन लूप की "सी++ शैली" के प्रेमियों के लिए मैंने उनमें रिवर्स लूप जोड़े हैं।

कोड:

public class Bench
    {
        private List<int> _list;
        private int[] _array;

        [Params(100000, 10000000)] public int N;

        [GlobalSetup]
        public void Setup()
        {
            const int MIN = 1;
            const int MAX = 10;
            Random random = new Random();
            _list = Enumerable.Repeat(0, N).Select(i => random.Next(MIN, MAX)).ToList();
            _array = _list.ToArray();
        }

        [Benchmark]
        public int ForList()
        {
            int total = 0;
            for (int i = 0; i < _list.Count; i++)
            {
                total += _list[i];
            }

            return total;
        }
        
        [Benchmark]
        public int ForListFromEnd()
        {
            int total = 0;t
            for (int i = _list.Count-1; i > 0; i--)
            {
                total += _list[i];
            }

            return total;
        }

        [Benchmark]
        public int ForeachList()
        {
            int total = 0;
            foreach (int i in _list)
            {
                total += i;
            }

            return total;
        }

        [Benchmark]
        public int ForeachArray()
        {
            int total = 0;
            foreach (int i in _array)
            {
                total += i;
            }

            return total;
        }

        [Benchmark]
        public int ForArray()
        {
            int total = 0;
            for (int i = 0; i < _array.Length; i++)
            {
                total += _array[i];
            }

            return total;
        }
        
        [Benchmark]
        public int ForArrayFromEnd()
        {
            int total = 0;
            for (int i = _array.Length-1; i > 0; i--)
            {
                total += _array[i];
            }

            return total;
        }
    }

.NET Core 2.2 और 3.0 में प्रदर्शन गति लगभग समान है। यहां बताया गया है कि मैं .NET Core 3.0 में क्या प्राप्त करने में सक्षम था:

हम यह निष्कर्ष निकाल सकते हैं कि किसी ऐरे संग्रह का पुनरावृत्तीय प्रसंस्करण उसके आंतरिक अनुकूलन और स्पष्ट संग्रह आकार आवंटन के कारण तेज़ है। यह भी याद रखने योग्य है कि सूची संग्रह के अपने फायदे हैं और आपको आवश्यक गणनाओं के आधार पर सही संग्रह का उपयोग करना चाहिए। भले ही आप लूप के साथ काम करने के लिए तर्क लिखते हैं, यह न भूलें कि यह एक साधारण लूप है और यह संभावित लूप अनुकूलन के अधीन भी है। काफी समय पहले habr पर एक लेख प्रकाशित हुआ था: https://habr.com/ru/post/124910/. यह अभी भी प्रासंगिक है और पढ़ने के लिए अनुशंसित है।

फेंकना

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

कोड:

        public bool ContainsHash()
        {
            bool result = false;
            foreach (var file in _files)
            {
                var extension = Path.GetExtension(file);
                if (_hash.Contains(extension))
                    result = true;
            }

            return result;
        }

        public bool ContainsHashTryCatch()
        {
            bool result = false;
            try
            {
                foreach (var file in _files)
                {
                    var extension = Path.GetExtension(file);
                    if (_hash.Contains(extension))
                        result = true;
                }
                
                if(!result) 
                    throw new Exception("false");
            }
            catch (Exception e)
            {
                result = false;
            }

            return result;
        }

.NET Core 3.0 और Core 2.2 के परिणाम समान हैं (.NET Core 3.0):

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

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

यदि यह स्थिति असाधारण नहीं है तो आपको नया अपवाद() निर्माण नहीं लिखना चाहिए। अपवाद को संभालना और फेंकना बहुत महंगा है!!!

ToLower, ToLowerInvariant, ToUpper, ToUpperInvariant

.NET प्लेटफ़ॉर्म पर काम करने के अपने 5 वर्षों के अनुभव के दौरान, मुझे ऐसे कई प्रोजेक्ट मिले हैं जिनमें स्ट्रिंग मिलान का उपयोग किया गया था। मैंने निम्नलिखित चित्र भी देखा: कई परियोजनाओं के साथ एक एंटरप्राइज़ समाधान था, जिनमें से प्रत्येक ने स्ट्रिंग तुलना अलग-अलग तरीके से की। लेकिन क्या उपयोग किया जाना चाहिए और इसे कैसे एकीकृत किया जाए? रिक्टर द्वारा C# के माध्यम से CLR पुस्तक में, मैंने जानकारी पढ़ी कि ToUpperInvariant() विधि ToLowerInvariant() से तेज़ है।

पुस्तक से अंश:

बेशक, मुझे इस पर विश्वास नहीं हुआ और मैंने .NET फ्रेमवर्क पर कुछ परीक्षण चलाने का फैसला किया और परिणाम ने मुझे चौंका दिया - 15% से अधिक प्रदर्शन में वृद्धि। फिर, अगली सुबह काम पर पहुंचने पर, मैंने ये माप अपने वरिष्ठों को दिखाए और उन्हें स्रोत कोड तक पहुंच प्रदान की। इसके बाद, नए मापों को समायोजित करने के लिए 2 में से 14 परियोजनाओं को बदल दिया गया, और यह देखते हुए कि ये दो परियोजनाएं विशाल एक्सेल तालिकाओं को संसाधित करने के लिए मौजूद थीं, परिणाम उत्पाद के लिए महत्वपूर्ण से अधिक था।

मैं आपके लिए .NET कोर के विभिन्न संस्करणों के लिए माप भी प्रस्तुत करता हूं, ताकि आप में से प्रत्येक सबसे इष्टतम समाधान का चयन कर सके। और मैं बस यह जोड़ना चाहता हूं कि जिस कंपनी में मैं काम करता हूं, हम स्ट्रिंग्स की तुलना करने के लिए ToUpper() का उपयोग करते हैं।

कोड:

public const string defaultString =  "VXTDuob5YhummuDq1PPXOHE4PbrRjYfBjcHdFs8UcKSAHOCGievbUItWhU3ovCmRALgdZUG1CB0sQ4iMj8Z1ZfkML2owvfkOKxBCoFUAN4VLd4I8ietmlsS5PtdQEn6zEgy1uCVZXiXuubd0xM5ONVZBqDu6nOVq1GQloEjeRN8jXrj0MVUexB9aIECs7caKGddpuut3";

        [Benchmark]
        public bool ToLower()
        {
            return defaultString.ToLower() == defaultString.ToLower();
        }

        [Benchmark]
        public bool ToLowerInvariant()
        {
            return defaultString.ToLowerInvariant() == defaultString.ToLowerInvariant();
        }

        [Benchmark]
        public bool ToUpper()
        {
            return defaultString.ToUpper() == defaultString.ToUpper();
        }

        [Benchmark]
        public bool ToUpperInvariant()
        {
            return defaultString.ToUpperInvariant() == defaultString.ToUpperInvariant();
        }

.NET कोर 3.0 में, इनमें से प्रत्येक विधि के लिए वृद्धि ~x2 है और कार्यान्वयन को आपस में संतुलित करती है।

स्तरीय संकलन

अपने पिछले लेख में मैंने इस कार्यक्षमता का संक्षेप में वर्णन किया था, मैं अपने शब्दों को सही और पूरक करना चाहूंगा। बहु-स्तरीय संकलन आपके समाधान के स्टार्टअप समय को गति देता है, लेकिन आप त्याग करते हैं कि आपके कोड के कुछ हिस्सों को पृष्ठभूमि में अधिक अनुकूलित संस्करण में संकलित किया जाएगा, जो एक छोटा ओवरहेड पेश कर सकता है। NET Core 3.0 के आगमन के साथ, स्तरीय संकलन सक्षम परियोजनाओं के निर्माण का समय कम हो गया है और इस तकनीक से जुड़े बग्स को ठीक कर दिया गया है। पहले, इस तकनीक के कारण ASP.NET कोर में पहले अनुरोधों में त्रुटियां हुईं और बहु-स्तरीय संकलन मोड में पहले निर्माण के दौरान यह रुक गया। यह वर्तमान में .NET Core 3.0 में डिफ़ॉल्ट रूप से सक्षम है, लेकिन आप चाहें तो इसे अक्षम कर सकते हैं। यदि आप टीम-लीड, सीनियर, मिडिल के पद पर हैं, या आप किसी विभाग के प्रमुख हैं, तो आपको यह समझना चाहिए कि तेजी से परियोजना विकास से टीम का मूल्य बढ़ता है और यह तकनीक आपको दोनों डेवलपर्स के लिए समय बचाने की अनुमति देगी। और परियोजना का समय ही।

.NET स्तर ऊपर

अपने .NET फ्रेमवर्क/.NET कोर संस्करण को अपग्रेड करें। अक्सर, प्रत्येक नया संस्करण अतिरिक्त प्रदर्शन लाभ प्रदान करता है और नई सुविधाएँ जोड़ता है।

लेकिन वास्तव में लाभ क्या हैं? आइए उनमें से कुछ पर नजर डालें:

• .NET Core 3.0 ने R2R छवियां पेश कीं जो .NET कोर अनुप्रयोगों के स्टार्टअप समय को कम कर देंगी।
• संस्करण 2.2 के साथ, टियर कंपाइलेशन सामने आया, जिसकी बदौलत प्रोग्रामर किसी प्रोजेक्ट को लॉन्च करने में कम समय खर्च करेंगे।
• नए .NET मानकों के लिए समर्थन।
• प्रोग्रामिंग भाषा के नए संस्करण के लिए समर्थन.
• अनुकूलन, प्रत्येक नए संस्करण के साथ आधार पुस्तकालयों संग्रह/संरचना/स्ट्रीम/स्ट्रिंग/रेगेक्स का अनुकूलन और बहुत कुछ बेहतर होता है। यदि आप .NET फ्रेमवर्क से .NET कोर पर माइग्रेट कर रहे हैं, तो आपको बॉक्स से एक बड़ा प्रदर्शन बढ़ावा मिलेगा। उदाहरण के तौर पर, मैं .NET Core 3.0 में जोड़े गए कुछ अनुकूलन का लिंक संलग्न करता हूँ: https://devblogs.microsoft.com/dotnet/performance-improvements-in-net-core-3-0/

निष्कर्ष

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

जीथब से लिंक करें

स्रोत: www.habr.com