.NET Core တွင် စွမ်းဆောင်ရည်

.NET Core တွင် စွမ်းဆောင်ရည်

အားလုံးမင်္ဂလာပါ! ဤဆောင်းပါးသည် မတူညီသော ပရောဂျက်များကို လုပ်ဆောင်ရာတွင် ကျွန်ုပ်နှင့် လုပ်ဖော်ကိုင်ဖက်များ အချိန်အတော်ကြာ အသုံးပြုခဲ့သည့် အကောင်းဆုံး အလေ့အကျင့်များ စုစည်းမှုဖြစ်သည်။

တွက်ချက်မှုများ လုပ်ဆောင်ခဲ့သည့် စက်အကြောင်း အချက်အလက်-BenchmarkDotNet=v0.11.5၊ OS=Windows 10.0.18362
Intel Core i5-8250U CPU 1.60GHz (Kaby Lake R)၊ CPU 1 လုံး၊ ယုတ္တိနည်း 8 ခု နှင့် ရုပ်ပိုင်းဆိုင်ရာ core 4 ခု
.NET Core SDK=3.0.100
[Host]- .NET Core 2.2.7 (CoreCLR 4.6.28008.02၊ CoreFX 4.6.28008.03), 64bit RyuJIT
Core- .NET Core 2.2.7 (CoreCLR 4.6.28008.02၊ CoreFX 4.6.28008.03), 64bit RyuJIT
[Host]- .NET Core 3.0.0 (CoreCLR 4.700.19.46205၊ CoreFX 4.700.19.46214), 64bit RyuJIT
Core- .NET Core 3.0.0 (CoreCLR 4.700.19.46205၊ CoreFX 4.700.19.46214), 64bit RyuJIT

Job=Core Runtime=Core

ToList vs ToArray နှင့် Cycles

.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 တွင် ကျွန်ုပ် ရနိုင်သည် ။

၎င်း၏အတွင်းပိုင်း ပိုမိုကောင်းမွန်အောင်ပြုလုပ်မှုများနှင့် တိကျပြတ်သားသော စုဆောင်းမှုအရွယ်အစားခွဲဝေမှုတို့ကြောင့် ထပ်တလဲလဲလုပ်ဆောင်ခြင်းသည် ပိုမိုမြန်ဆန်ကြောင်း ကျွန်ုပ်တို့ကောက်ချက်ချနိုင်ပါသည်။ စာရင်းစုဆောင်းမှုတွင် ၎င်း၏ကိုယ်ပိုင်အားသာချက်များရှိပြီး လိုအပ်သည့်တွက်ချက်မှုပေါ်မူတည်၍ မှန်ကန်သောစုဆောင်းမှုကို အသုံးပြုသင့်သည်ကိုလည်း မှတ်သားထိုက်သည်။ loops နဲ့ အလုပ်လုပ်ဖို့အတွက် logic ရေးထားရင်တောင် ဒါက သာမန် loop တစ်ခုဖြစ်ပြီး ဖြစ်နိုင်တဲ့ loop optimization ကိုလည်း မူတည်ပါတယ်။ ဆောင်းပါးတစ်ပုဒ်ကို 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) ရှိသည်-

Try catch သည် ကုဒ်ကို နားလည်ရန် ပိုမိုခက်ခဲစေပြီး သင့်ပရိုဂရမ်၏ လုပ်ဆောင်ချိန်ကို တိုးစေသည်။ ဒါပေမယ့် ဒီတည်ဆောက်မှုကို လိုအပ်တယ်ဆိုရင်တော့ အမှားတွေကို ကိုင်တွယ်ဖြေရှင်းဖို့ မမျှော်လင့်ထားတဲ့ ကုဒ်လိုင်းတွေကို မထည့်သင့်ပါဘူး - ဒါက ကုဒ်ကို နားလည်ရလွယ်ကူစေပါလိမ့်မယ်။ အမှန်မှာ၊ ၎င်းသည် စနစ်အား တင်ဆောင်သည့် ခြွင်းချက်များကို ကိုင်တွယ်ခြင်းမှာ များစွာမဟုတ်သော်လည်း Exception အသစ်ကို ဖောက်ထွင်း၍ ၎င်းတို့ကိုယ်တိုင် အမှားများကို ပစ်ချခြင်းသာ ဖြစ်သည်။

ခြွင်းချက်များအား လွှင့်ပစ်ခြင်းသည် လိုအပ်သော ဖော်မတ်တွင် အမှားကို စုဆောင်းမည့် အချို့အတန်းများထက် နှေးကွေးသည်။ သင်သည် ဖောင်တစ်ခု သို့မဟုတ် ဒေတာအချို့ကို လုပ်ဆောင်နေပြီး အမှားအယွင်းဖြစ်သင့်သည်ကို ရှင်းရှင်းလင်းလင်းသိပါက၊ ၎င်းကို အဘယ်ကြောင့် မလုပ်ဆောင်သနည်း။

ဤအခြေအနေသည်ခြွင်းချက်မဟုတ်ပါက Exception() အသစ်တည်ဆောက်ခြင်းကို သင်မရေးသင့်ပါ။ ခြွင်းချက်တစ်ခုအား ကိုင်တွယ်ခြင်းနှင့် ပစ်ချခြင်းသည် အလွန်စျေးကြီးသည်။

အောက်သို့၊ မှ အောက်သို့ အင်ဗာရီယန်၊

.NET ပလပ်ဖောင်းတွင် အလုပ်လုပ်သည့် အတွေ့အကြုံ 5 နှစ်ကျော်၊ string matching ကိုသုံးသော ပရောဂျက်များစွာကို တွေ့ခဲ့ရသည်။ အောက်ဖော်ပြပါပုံကိုလည်း ကျွန်တော်မြင်ခဲ့သည်- ပရောဂျက်များစွာပါရှိသော Enterprise ဖြေရှင်းချက်တစ်ခုရှိပါသည်၊ တစ်ခုစီသည် string comparisons များကို ကွဲပြားစွာလုပ်ဆောင်သည်။ ဒါပေမယ့် ဘာကိုသုံးသင့်သလဲ၊ ဘယ်လိုပေါင်းစပ်ရမလဲ။ C# by Richter မှတစ်ဆင့် CLR စာအုပ်တွင်၊ ToUpperInvariant() နည်းလမ်းသည် ToLowerInvariant() ထက် ပိုမြန်ကြောင်း အချက်အလက်ကို ကျွန်ုပ်ဖတ်ခဲ့သည်။

စာအုပ်မှ ကောက်နုတ်ချက်

ဟုတ်ပါတယ်၊ ငါမယုံခဲ့ဘဲ .NET Framework မှာ စမ်းသပ်မှုအချို့ကို လုပ်ဆောင်ဖို့ ဆုံးဖြတ်ခဲ့ပြီး ရလဒ်က ငါ့ကို ထိတ်လန့်စေခဲ့တယ် - စွမ်းဆောင်ရည် 15% ကျော် တိုးလာပါတယ်။ ထို့နောက် နောက်တစ်နေ့မနက် အလုပ်သို့ ရောက်ရှိလာသောအခါ၊ ကျွန်ုပ်သည် ဤအတိုင်းအတာများကို အထက်လူကြီးများထံ ပြသပြီး အရင်းအမြစ်ကုဒ်ကို အသုံးပြုခွင့်ပေးခဲ့သည်။ ယင်းနောက်တွင်၊ တိုင်းတာမှုအသစ်များကို လိုက်လျောညီထွေဖြစ်စေရန်အတွက် ပရောဂျက် 2 ခုအနက် 14 ခုကို ပြောင်းလဲခဲ့ပြီး ဤပရောဂျက်နှစ်ခုသည် ကြီးမားသော Excel ဇယားများကို လုပ်ဆောင်ရန်အတွက် တည်ရှိနေသည်ဟု ယူဆသောကြောင့် ရလဒ်သည် ထုတ်ကုန်အတွက် သိသာထင်ရှားသည်ထက် ပိုပါသည်။

သင့်အား .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 ဖြစ်ပြီး ၎င်းတို့အချင်းချင်း အကောင်အထည်ဖော်မှုများကို ချိန်ညှိပေးသည်။

Tier Compilation

ကျွန်ုပ်၏နောက်ဆုံးဆောင်းပါးတွင် ဤလုပ်ဆောင်နိုင်စွမ်းကို အတိုချုံးဖော်ပြခဲ့ပြီး၊ ကျွန်ုပ်၏စကားလုံးများကို ပြုပြင်ဖြည့်စွက်လိုပါသည်။ Multi-level compilation သည် သင့်ဖြေရှင်းချက်၏ စတင်ချိန်ကို အရှိန်မြှင့်ပေးသည်၊ သို့သော် သင့်ကုဒ်၏ အစိတ်အပိုင်းများကို နောက်ခံတွင် ပိုကောင်းအောင် စုစည်းထားသော ဗားရှင်းအဖြစ်သို့ စွန့်စားပြီး သေးငယ်သော overhead ကို မိတ်ဆက်ပေးနိုင်ပါသည်။ NET Core 3.0 ထွန်းကားလာသည်နှင့်အမျှ၊ အဆင့်လိုက်စုစည်းမှုဖွင့်ထားသည့် ပရောဂျက်များအတွက် တည်ဆောက်ချိန်သည် လျော့နည်းသွားကာ ဤနည်းပညာနှင့်ဆက်စပ်နေသော ချွတ်ယွင်းချက်များကို ပြင်ဆင်ပြီးဖြစ်သည်။ ယခင်က၊ ဤနည်းပညာသည် ASP.NET Core တွင် ပထမဆုံးတောင်းဆိုမှုများတွင် အမှားအယွင်းများဖြစ်ပေါ်စေပြီး Multi-level compilation mode တွင် ပထမဆုံးတည်ဆောက်စဉ်တွင် ရပ်တန့်သွားခဲ့သည်။ ၎င်းကို .NET Core 3.0 တွင် ပုံမှန်အားဖြင့် လက်ရှိတွင် ဖွင့်ထားသော်လည်း သင်ဆန္ဒရှိပါက ၎င်းကို ပိတ်နိုင်သည်။ အကယ်၍ သင်သည် အဖွဲ့ခေါင်းဆောင်၊ အကြီးတန်း၊ အလယ်တန်း၊ သို့မဟုတ် သင်သည် ဌာနတစ်ခု၏ အကြီးအကဲဖြစ်ပါက၊ လျင်မြန်သောပရောဂျက်ဖွံ့ဖြိုးတိုးတက်မှုသည် အဖွဲ့၏တန်ဖိုးကို တိုးစေပြီး ဤနည်းပညာသည် သင့်အား developer နှစ်ဦးစလုံးအတွက် အချိန်ကုန်သက်သာစေမည်ဖြစ်ကြောင်း သင်နားလည်ထားရပါမည်။ ပရောဂျက်၏အချိန်လည်းဖြစ်သည်။

.NET အဆင့်တက်

သင်၏ .NET Framework / .NET Core ဗားရှင်းကို အဆင့်မြှင့်ပါ။ မကြာခဏဆိုသလို၊ ဗားရှင်းအသစ်တစ်ခုစီသည် အပိုစွမ်းဆောင်ရည် အကျိုးကျေးဇူးများကို ပေးစွမ်းပြီး အင်္ဂါရပ်အသစ်များကို ထည့်ပေးပါသည်။

ဒါပေမယ့် အတိအကျ ဘာအကျိုးကျေးဇူးတွေလဲ။ ၎င်းတို့ထဲမှ အချို့ကို ကြည့်ကြပါစို့။

• .NET Core 3.0 သည် .NET Core အပလီကေးရှင်းများ၏ စတင်ချိန်ကို လျှော့ချပေးမည့် R2R ပုံများကို မိတ်ဆက်ပေးခဲ့သည်။
• ဗားရှင်း 2.2 နှင့်အတူ၊ ပရိုဂရမ်မာများသည် ပရောဂျက်တစ်ခုစတင်ရာတွင် အချိန်ပိုနည်းသောကြောင့် Tier Compilation ပေါ်လာသည်။
• .NET စံနှုန်းအသစ်များအတွက် ပံ့ပိုးမှု။
• ပရိုဂရမ်းမင်းဘာသာစကား၏ ဗားရှင်းအသစ်အတွက် ပံ့ပိုးမှု။
• ဗားရှင်းအသစ်တစ်ခုစီတွင် ပိုမိုကောင်းမွန်အောင်ပြုလုပ်ခြင်းဖြင့် အခြေခံစာကြည့်တိုက်များ Collection/Struct/Stream/String/Regex တို့ကို ပိုမိုကောင်းမွန်အောင်ပြုလုပ်ခြင်းဖြင့် ပိုမိုတိုးတက်ကောင်းမွန်လာမည်ဖြစ်သည်။ အကယ်၍ သင်သည် .NET Framework မှ .NET Core သို့ ပြောင်းရွှေ့နေပါက၊ သင်သည် ကြီးမားသော စွမ်းဆောင်ရည်မြှင့်တင်မှုကို ရရှိမည်ဖြစ်သည်။ ဥပမာအနေနဲ့၊ .NET Core 3.0 မှာ ထည့်သွင်းထားတဲ့ ပိုမိုကောင်းမွန်အောင်လုပ်ဆောင်မှုအချို့ကို လင့်ခ်တစ်ခု တွဲတင်ထားပါတယ်- https://devblogs.microsoft.com/dotnet/performance-improvements-in-net-core-3-0/

ကောက်ချက်

ကုဒ်ရေးသောအခါတွင်၊ သင့်ပရောဂျက်၏ မတူညီသောရှုထောင့်များကို အာရုံစိုက်ပြီး အကောင်းဆုံးရလဒ်ရရှိရန် သင်၏ပရိုဂရမ်ဘာသာစကားနှင့် ပလက်ဖောင်း၏အင်္ဂါရပ်များကို အသုံးပြုခြင်းဖြင့် ထိုက်တန်ပါသည်။ .NET တွင် optimization နှင့်ပတ်သက်သည့် သင်၏အသိပညာကို မျှဝေပေးမည်ဆိုပါက ဝမ်းမြောက်မိပါသည်။

github သို့ လင့်ခ်

source: www.habr.com