.NET कोर मध्ये कामगिरी

.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 Core 2.2.7 (CoreCLR 4.6.28008.02, CoreFX 4.6.28008.03), 64bit RyuJIT
कोर: .NET Core 2.2.7 (CoreCLR 4.6.28008.02, CoreFX 4.6.28008.03), 64bit RyuJIT
[होस्ट]: .NET Core 3.0.0 (CoreCLR 4.700.19.46205, CoreFX 4.700.19.46214), 64bit RyuJIT
कोर: .NET Core 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/. हे अजूनही संबंधित आहे आणि वाचण्याची शिफारस केली आहे.

फेकणे

एक वर्षापूर्वी, मी एका कंपनीत लेगसी प्रोजेक्टवर काम केले होते, त्या प्रोजेक्टमध्ये ट्राय-कॅच-थ्रो कंस्ट्रक्टद्वारे फील्ड प्रमाणीकरण प्रक्रिया करणे सामान्य होते. मला आधीच समजले होते की हे प्रकल्पासाठी अस्वस्थ व्यवसाय तर्क आहे, म्हणून जेव्हा शक्य असेल तेव्हा मी अशा डिझाइनचा वापर न करण्याचा प्रयत्न केला. परंतु अशा बांधकामासह त्रुटी हाताळण्याचा दृष्टीकोन का वाईट आहे ते शोधूया. मी दोन पध्दतींची तुलना करण्यासाठी एक छोटा कोड लिहिला आणि प्रत्येक पर्यायासाठी बेंचमार्क बनवले.

कोड:

        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 मध्ये ऑप्टिमायझेशनशी संबंधित तुमचे ज्ञान शेअर केल्यास मला आनंद होईल.

गिथबशी दुवा

स्त्रोत: www.habr.com