🥇 .NET Core मा प्रदर्शन | प्रोहोस्टर

.NET कोर मा प्रदर्शन

नमस्ते सबै! यो लेख विभिन्न परियोजनाहरूमा काम गर्दा मेरा सहकर्मीहरू र मैले लामो समयदेखि प्रयोग गर्दै आएका उत्तम अभ्यासहरूको सङ्ग्रह हो।

मेसिनको बारेमा जानकारी जसमा गणना गरिएको थियो:BenchmarkDotNet=v0.11.5, OS=Windows 10.0.18362
Intel Core i5-8250U CPU 1.60GHz (Kaby Lake R), 1 CPU, 8 तार्किक र 4 भौतिक कोरहरू
.NET कोर SDK=3.0.100
[होस्ट]: .NET कोर 2.2.7 (CoreCLR 4.6.28008.02, CoreFX 4.6.28008.03), 64bit RyuJIT
कोर: .NET कोर 2.2.7 (CoreCLR 4.6.28008.02, CoreFX 4.6.28008.03), 64bit RyuJIT
[होस्ट]: .NET कोर 3.0.0 (CoreCLR 4.700.19.46205, CoreFX 4.700.19.46214), 64bit RyuJIT
कोर: .NET कोर 3.0.0 (CoreCLR 4.700.19.46205, CoreFX 4.700.19.46214), 64bit RyuJIT

काम = कोर रनटाइम = कोर

ToList बनाम ToArray र साइकलहरू

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

मेरो आफ्नै तर्फबाट, म तपाईलाई मेरो मापन र परिणामहरू प्रस्तुत गर्न चाहन्छु; मैले लेख्ने लूपहरूको "C++ शैली" को प्रेमीहरूको लागि तिनीहरूमा उल्टो लूपहरू थपेको छु।

कोड:

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/। यो अझै सान्दर्भिक छ र पढ्न सिफारिस गरिएको छ।

Thrower

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

कोड:

        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 प्लेटफर्ममा काम गर्ने मेरो ५ वर्षको अनुभवमा, मैले स्ट्रिङ मिल्दो प्रयोग गर्ने धेरै परियोजनाहरू भेटेको छु। मैले निम्न तस्विर पनि देखेँ: त्यहाँ धेरै परियोजनाहरूसँग एउटा इन्टरप्राइज समाधान थियो, जसमध्ये प्रत्येकले फरक रूपमा स्ट्रिङ तुलनाहरू प्रदर्शन गर्यो। तर के प्रयोग गर्नुपर्छ र यसलाई कसरी एकीकरण गर्न? रिक्टर द्वारा C# मार्फत CLR पुस्तकमा, मैले ToUpperInvariant() विधि ToLowerInvariant() भन्दा छिटो छ भन्ने जानकारी पढेको छु।

पुस्तकबाट अंश:

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

म तपाईंलाई .NET Core को विभिन्न संस्करणहरूका लागि मापनहरू पनि प्रस्तुत गर्दछु, ताकि तपाईं प्रत्येकले सबैभन्दा उत्तम समाधानतर्फ छनौट गर्न सकून्। र म यो जोड्न चाहन्छु कि मैले काम गरेको कम्पनीमा, हामी स्ट्रिङहरू तुलना गर्न 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 Core 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 Framework बाट .NET Core मा स्थानान्तरण गर्दै हुनुहुन्छ भने, तपाइँ बाकस बाहिर ठूलो प्रदर्शन वृद्धि प्राप्त गर्नुहुनेछ। उदाहरणको रूपमा, म .NET Core 3.0 मा थपिएका केही अप्टिमाइजेसनहरूमा लिङ्क संलग्न गर्छु: https://devblogs.microsoft.com/dotnet/performance-improvements-in-net-core-3-0/

निष्कर्षमा

कोड लेख्दा, तपाइँको परियोजनाको विभिन्न पक्षहरूमा ध्यान दिन र तपाइँको प्रोग्रामिङ भाषा र प्लेटफर्मको सुविधाहरू प्रयोग गरेर उत्कृष्ट परिणाम प्राप्त गर्न लायक छ। यदि तपाईंले .NET मा अप्टिमाइजेसनसँग सम्बन्धित आफ्नो ज्ञान साझा गर्नुभयो भने म खुसी हुनेछु।

Github मा लिङ्क

स्रोत: www.habr.com

.NET कोर मा प्रदर्शन

.NET कोर मा प्रदर्शन

ToList बनाम ToArray र साइकलहरू

Thrower

ToLower, ToLowerInvariant, ToUpper, ToUpperInvariant

टियर संकलन

.NET स्तर माथि

निष्कर्षमा

एक टिप्पणी थप्न Отменить ответ