.NET Core இல் செயல்திறன்

.NET Core இல் செயல்திறன்

அனைவருக்கும் வணக்கம்! இந்தக் கட்டுரையானது நானும் எனது சகாக்களும் வெவ்வேறு திட்டங்களில் பணிபுரியும் போது நீண்ட காலமாகப் பயன்படுத்தி வரும் சிறந்த நடைமுறைகளின் தொகுப்பாகும்.

கணக்கீடுகள் செய்யப்பட்ட இயந்திரம் பற்றிய தகவல்:BenchmarkDotNet=v0.11.5, OS=Windows 10.0.18362
இன்டெல் கோர் 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), 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 vs 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 கோர் 2.2 மற்றும் 3.0 இல் செயல்திறன் வேகம் கிட்டத்தட்ட ஒரே மாதிரியாக இருக்கும். .NET Core 3.0 இல் என்னால் பெற முடிந்தது:

ஒரு வரிசை சேகரிப்பு அதன் உள் மேம்படுத்தல்கள் மற்றும் வெளிப்படையான சேகரிப்பு அளவு ஒதுக்கீடு காரணமாக அதன் மறுசெயல்முறை செயலாக்கம் வேகமானது என்று நாம் முடிவு செய்யலாம். ஒரு பட்டியல் சேகரிப்புக்கு அதன் சொந்த நன்மைகள் உள்ளன என்பதையும், தேவையான கணக்கீடுகளைப் பொறுத்து சரியான சேகரிப்பைப் பயன்படுத்த வேண்டும் என்பதையும் நினைவில் கொள்வது மதிப்பு. சுழல்களுடன் பணிபுரிவதற்கான தர்க்கத்தை நீங்கள் எழுதினாலும், இது ஒரு சாதாரண லூப் என்பதை மறந்துவிடாதீர்கள், மேலும் இது சாத்தியமான லூப் தேர்வுமுறைக்கு உட்பட்டது. ஹப்ரில் ஒரு கட்டுரை நீண்ட காலத்திற்கு முன்பு வெளியிடப்பட்டது: 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 கோர் 3.0 மற்றும் கோர் 2.2 இல் உள்ள முடிவுகள் ஒரே மாதிரியான முடிவைக் கொண்டுள்ளன (.NET Core 3.0):

பிடிக்க முயற்சிக்கவும். குறியீட்டைப் புரிந்துகொள்வதை கடினமாக்குகிறது மற்றும் உங்கள் நிரலின் செயல்பாட்டு நேரத்தை அதிகரிக்கிறது. ஆனால் இந்த கட்டுமானம் உங்களுக்குத் தேவைப்பட்டால், பிழைகளைக் கையாளும் என்று எதிர்பார்க்கப்படாத குறியீட்டு வரிகளை நீங்கள் செருகக்கூடாது - இது குறியீட்டை எளிதாகப் புரிந்துகொள்ள உதவும். உண்மையில், விதிவிலக்குகளைக் கையாள்வது கணினியை ஏற்றுவது அல்ல, மாறாக புதிய விதிவிலக்கு கட்டமைப்பின் மூலம் பிழைகளைத் தாங்களே எறிவது.

விதிவிலக்குகளை வீசுவது சில வகுப்பை விட மெதுவாக இருக்கும், இது தேவையான வடிவமைப்பில் பிழையைச் சேகரிக்கும். நீங்கள் ஒரு படிவத்தை அல்லது சில தரவைச் செயலாக்குகிறீர்கள் மற்றும் பிழை என்னவாக இருக்க வேண்டும் என்பதை நீங்கள் தெளிவாக அறிந்திருந்தால், அதை ஏன் செயல்படுத்தக்கூடாது?

இந்த சூழ்நிலை விதிவிலக்காக இல்லாவிட்டால், நீங்கள் புதிய விதிவிலக்கு() கட்டமைப்பை எழுதக்கூடாது. விதிவிலக்கைக் கையாள்வதும் எறிவதும் மிகவும் விலை உயர்ந்தது!!!

ToLower, ToLowerInvariant, Toupper, ToupperInvariant

.NET பிளாட்ஃபார்மில் பணிபுரிந்த எனது 5 வருட அனுபவத்தில், சரம் பொருத்தத்தை பயன்படுத்திய பல திட்டங்களை நான் கண்டுள்ளேன். நான் பின்வரும் படத்தையும் பார்த்தேன்: பல திட்டங்களுடன் ஒரு நிறுவன தீர்வு இருந்தது, ஒவ்வொன்றும் சரம் ஒப்பீடுகளை வித்தியாசமாகச் செய்தன. ஆனால் எதைப் பயன்படுத்த வேண்டும், அதை எவ்வாறு ஒருங்கிணைப்பது? ரிக்டரின் CLR வழியாக C# புத்தகத்தில், 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 கோர் 3.0 இன் வருகையுடன், அடுக்கு தொகுத்தல் இயக்கப்பட்ட திட்டங்களுக்கான உருவாக்க நேரம் குறைந்துள்ளது மற்றும் இந்த தொழில்நுட்பத்துடன் தொடர்புடைய பிழைகள் சரி செய்யப்பட்டுள்ளன. முன்னதாக, இந்த தொழில்நுட்பம் ASP.NET Core இல் உள்ள முதல் கோரிக்கைகளில் பிழைகளை ஏற்படுத்தியது மற்றும் மல்டி-லெவல் தொகுத்தல் பயன்முறையில் முதல் கட்டத்தின் போது உறைகிறது. இது தற்போது .NET Core 3.0 இல் இயல்பாக இயக்கப்பட்டுள்ளது, ஆனால் நீங்கள் விரும்பினால் அதை முடக்கலாம். நீங்கள் குழுத் தலைவர், மூத்த, நடுத்தர அல்லது நீங்கள் ஒரு துறையின் தலைவராக இருந்தால், விரைவான திட்ட மேம்பாடு அணியின் மதிப்பை அதிகரிக்கிறது என்பதை நீங்கள் புரிந்து கொள்ள வேண்டும், மேலும் இந்த தொழில்நுட்பம் இரண்டு டெவலப்பர்களுக்கும் நேரத்தை மிச்சப்படுத்தும். மற்றும் திட்டத்தின் நேரம்.

.NET நிலை உயர்கிறது

உங்கள் .NET Framework / .NET கோர் பதிப்பை மேம்படுத்தவும். பெரும்பாலும், ஒவ்வொரு புதிய பதிப்பும் கூடுதல் செயல்திறன் ஆதாயங்களை வழங்குகிறது மற்றும் புதிய அம்சங்களைச் சேர்க்கிறது.

ஆனால் நன்மைகள் சரியாக என்ன? அவற்றில் சிலவற்றைப் பார்ப்போம்:

• .NET கோர் 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