.NET കോറിലെ പ്രകടനം

.NET കോറിലെ പ്രകടനം

എല്ലാവർക്കും ഹായ്! വ്യത്യസ്ത പ്രോജക്റ്റുകളിൽ പ്രവർത്തിക്കുമ്പോൾ ഞാനും എന്റെ സഹപ്രവർത്തകരും വളരെക്കാലമായി ഉപയോഗിക്കുന്ന മികച്ച സമ്പ്രദായങ്ങളുടെ ഒരു ശേഖരമാണ് ഈ ലേഖനം.

കണക്കുകൂട്ടലുകൾ നടത്തിയ യന്ത്രത്തെക്കുറിച്ചുള്ള വിവരങ്ങൾ:BenchmarkDotNet=v0.11.5, OS=Windows 10.0.18362
ഇന്റൽ കോർ 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 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 Core 3.0, Core 2.2 എന്നിവയിലെ ഫലങ്ങൾക്ക് സമാനമായ ഫലമുണ്ട് (.NET Core 3.0):

ക്യാച്ച് ശ്രമിക്കൂ, കോഡ് മനസ്സിലാക്കാൻ ബുദ്ധിമുട്ടുള്ളതാക്കുകയും നിങ്ങളുടെ പ്രോഗ്രാമിന്റെ എക്സിക്യൂഷൻ സമയം വർദ്ധിപ്പിക്കുകയും ചെയ്യുന്നു. എന്നാൽ നിങ്ങൾക്ക് ഈ നിർമ്മാണം ആവശ്യമാണെങ്കിൽ, പിശകുകൾ കൈകാര്യം ചെയ്യുമെന്ന് പ്രതീക്ഷിക്കാത്ത കോഡിന്റെ വരികൾ നിങ്ങൾ ചേർക്കരുത് - ഇത് കോഡ് മനസ്സിലാക്കുന്നത് എളുപ്പമാക്കും. വാസ്തവത്തിൽ, ഒഴിവാക്കലുകൾ കൈകാര്യം ചെയ്യുന്നത് സിസ്റ്റത്തെ ലോഡുചെയ്യുന്നത് അല്ല, പകരം ത്രോ പുതിയ എക്‌സെപ്ഷൻ നിർമ്മാണത്തിലൂടെ പിശകുകൾ സ്വയം എറിയുന്നതാണ്.

ഒഴിവാക്കലുകൾ ത്രോ ചെയ്യുന്നത് ചില ക്ലാസുകളേക്കാൾ വേഗത കുറവാണ്, അത് ആവശ്യമായ ഫോർമാറ്റിൽ പിശക് ശേഖരിക്കും. നിങ്ങൾ ഒരു ഫോമോ കുറച്ച് ഡാറ്റയോ പ്രോസസ്സ് ചെയ്യുകയാണെങ്കിൽ, പിശക് എന്തായിരിക്കണമെന്ന് നിങ്ങൾക്ക് വ്യക്തമായി അറിയാമെങ്കിൽ, എന്തുകൊണ്ട് അത് പ്രോസസ്സ് ചെയ്തുകൂടാ?

ഈ സാഹചര്യം അസാധാരണമല്ലെങ്കിൽ നിങ്ങൾ ഒരു ത്രോ പുതിയ ഒഴിവാക്കൽ() നിർമ്മാണം എഴുതരുത്. ഒരു അപവാദം കൈകാര്യം ചെയ്യുന്നതും എറിയുന്നതും വളരെ ചെലവേറിയതാണ്!!!

ToLower, ToLowerInvariant, Toupper, ToupperInvariant

.NET പ്ലാറ്റ്‌ഫോമിൽ പ്രവർത്തിക്കുന്ന എന്റെ 5 വർഷത്തെ അനുഭവപരിചയത്തിൽ, സ്ട്രിംഗ് മാച്ചിംഗ് ഉപയോഗിക്കുന്ന നിരവധി പ്രോജക്‌റ്റുകൾ ഞാൻ കണ്ടിട്ടുണ്ട്. ഞാൻ ഇനിപ്പറയുന്ന ചിത്രവും കണ്ടു: നിരവധി പ്രോജക്‌റ്റുകളുള്ള ഒരു എന്റർപ്രൈസ് സൊല്യൂഷൻ ഉണ്ടായിരുന്നു, അവയിൽ ഓരോന്നിനും വ്യത്യസ്തമായ സ്ട്രിംഗ് താരതമ്യങ്ങൾ നടത്തി. എന്നാൽ എന്താണ് ഉപയോഗിക്കേണ്ടത്, അത് എങ്ങനെ ഏകീകരിക്കാം? റിക്ടർ എഴുതിയ CLR വഴി C# എന്ന പുസ്തകത്തിൽ, 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 കോർ 3.0 ന്റെ വരവോടെ, ടയർ കംപൈലേഷൻ പ്രവർത്തനക്ഷമമാക്കിയ പ്രോജക്റ്റുകൾക്കുള്ള ബിൽഡ് സമയം കുറയുകയും ഈ സാങ്കേതികവിദ്യയുമായി ബന്ധപ്പെട്ട ബഗുകൾ പരിഹരിക്കപ്പെടുകയും ചെയ്തു. മുമ്പ്, ഈ സാങ്കേതികവിദ്യ ASP.NET കോറിലെ ആദ്യ അഭ്യർത്ഥനകളിൽ പിശകുകൾക്ക് കാരണമാവുകയും മൾട്ടി-ലെവൽ കംപൈലേഷൻ മോഡിലെ ആദ്യ ബിൽഡ് സമയത്ത് ഫ്രീസുചെയ്യുകയും ചെയ്തു. ഇത് നിലവിൽ .NET കോർ 3.0-ൽ സ്ഥിരസ്ഥിതിയായി പ്രവർത്തനക്ഷമമാക്കിയിട്ടുണ്ട്, എന്നാൽ നിങ്ങൾക്ക് വേണമെങ്കിൽ ഇത് പ്രവർത്തനരഹിതമാക്കാം. നിങ്ങൾ ടീം-ലീഡ്, സീനിയർ, മിഡിൽ അല്ലെങ്കിൽ നിങ്ങൾ ഒരു വകുപ്പിന്റെ തലവനാണെങ്കിൽ, ദ്രുതഗതിയിലുള്ള പ്രോജക്റ്റ് വികസനം ടീമിന്റെ മൂല്യം വർദ്ധിപ്പിക്കുമെന്നും ഈ സാങ്കേതികവിദ്യ രണ്ട് ഡെവലപ്പർമാർക്കും സമയം ലാഭിക്കാൻ നിങ്ങളെ അനുവദിക്കുമെന്നും നിങ്ങൾ മനസ്സിലാക്കണം. പദ്ധതിയുടെ സമയവും.

.NET ലെവൽ അപ്പ്

നിങ്ങളുടെ .NET ഫ്രെയിംവർക്ക് / .NET കോർ പതിപ്പ് നവീകരിക്കുക. പലപ്പോഴും, ഓരോ പുതിയ പതിപ്പും അധിക പ്രകടന നേട്ടങ്ങൾ നൽകുകയും പുതിയ സവിശേഷതകൾ ചേർക്കുകയും ചെയ്യുന്നു.

എന്നാൽ കൃത്യമായി എന്താണ് പ്രയോജനങ്ങൾ? അവയിൽ ചിലത് നോക്കാം:

• .NET കോർ 3.0 R2R ഇമേജുകൾ അവതരിപ്പിച്ചു, അത് .NET കോർ ആപ്ലിക്കേഷനുകളുടെ ആരംഭ സമയം കുറയ്ക്കും.
• പതിപ്പ് 2.2 ഉപയോഗിച്ച്, ടയർ കംപൈലേഷൻ പ്രത്യക്ഷപ്പെട്ടു, ഇതിന് നന്ദി, പ്രോഗ്രാമർമാർ ഒരു പ്രോജക്റ്റ് സമാരംഭിക്കുന്നതിന് കുറച്ച് സമയം ചെലവഴിക്കും.
• പുതിയ .NET മാനദണ്ഡങ്ങൾക്കുള്ള പിന്തുണ.
• പ്രോഗ്രാമിംഗ് ഭാഷയുടെ പുതിയ പതിപ്പിനുള്ള പിന്തുണ.
• ഒപ്റ്റിമൈസേഷൻ, ഓരോ പുതിയ പതിപ്പിലും അടിസ്ഥാന ലൈബ്രറികളുടെ ഒപ്റ്റിമൈസേഷൻ / സ്ട്രക്റ്റ് / സ്ട്രീം / സ്ട്രിംഗ് / റീജക്സ് എന്നിവയും അതിലേറെയും മെച്ചപ്പെടുന്നു. നിങ്ങൾ .NET ഫ്രെയിംവർക്കിൽ നിന്ന് .NET Core-ലേക്ക് മൈഗ്രേറ്റ് ചെയ്യുകയാണെങ്കിൽ, നിങ്ങൾക്ക് ബോക്സിൽ നിന്ന് ഒരു വലിയ പ്രകടന ബൂസ്റ്റ് ലഭിക്കും. ഒരു ഉദാഹരണമായി, .NET Core 3.0-ലേക്ക് ചേർത്തിട്ടുള്ള ചില ഒപ്റ്റിമൈസേഷനുകളിലേക്ക് ഞാൻ ഒരു ലിങ്ക് അറ്റാച്ചുചെയ്യുന്നു: https://devblogs.microsoft.com/dotnet/performance-improvements-in-net-core-3-0/

തീരുമാനം

കോഡ് എഴുതുമ്പോൾ, നിങ്ങളുടെ പ്രോജക്റ്റിന്റെ വ്യത്യസ്‌ത വശങ്ങളിൽ ശ്രദ്ധ ചെലുത്തുകയും മികച്ച ഫലം നേടുന്നതിന് നിങ്ങളുടെ പ്രോഗ്രാമിംഗ് ഭാഷയുടെയും പ്ലാറ്റ്‌ഫോമിന്റെയും സവിശേഷതകൾ ഉപയോഗിക്കുകയും ചെയ്യുന്നത് മൂല്യവത്താണ്. ഒപ്റ്റിമൈസേഷനുമായി ബന്ധപ്പെട്ട നിങ്ങളുടെ അറിവ് .NET-ൽ പങ്കുവെക്കുകയാണെങ്കിൽ ഞാൻ സന്തോഷിക്കുന്നു.

github-ലേക്കുള്ള ലിങ്ക്

അവലംബം: www.habr.com