.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 કોર 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 કોર 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 કોર 3.0 અને કોર 2.2 માં પરિણામો સમાન પરિણામ ધરાવે છે (.NET કોર 3.0):

કેચ કરવાનો પ્રયાસ કરો કોડને સમજવામાં કઠિન બનાવે છે અને તમારા પ્રોગ્રામનો અમલ સમય વધારે છે. પરંતુ જો તમને આ બાંધકામની જરૂર હોય, તો તમારે કોડની તે રેખાઓ દાખલ કરવી જોઈએ નહીં કે જે ભૂલોને હેન્ડલ કરવાની અપેક્ષા નથી - આ કોડને સમજવામાં સરળ બનાવશે. વાસ્તવમાં, તે અપવાદોનું સંચાલન એટલું બધું નથી કે જે સિસ્ટમને લોડ કરે છે, પરંતુ થ્રો ન્યૂ એક્સેપ્શન કન્સ્ટ્રક્ટ દ્વારા ભૂલો જાતે જ ફેંકી દે છે.

અપવાદો ફેંકવાની પ્રક્રિયા અમુક વર્ગ કરતાં ધીમી છે જે જરૂરી ફોર્મેટમાં ભૂલને એકત્રિત કરશે. જો તમે કોઈ ફોર્મ અથવા અમુક ડેટા પર પ્રક્રિયા કરી રહ્યાં છો અને તમે સ્પષ્ટપણે જાણો છો કે ભૂલ શું હોવી જોઈએ, તો શા માટે તેની પ્રક્રિયા ન કરવી?

જો આ પરિસ્થિતિ અપવાદરૂપ ન હોય તો તમારે થ્રો ન્યૂ એક્સેપ્શન() કન્સ્ટ્રક્ટ લખવું જોઈએ નહીં. અપવાદને સંભાળવું અને ફેંકવું ખૂબ ખર્ચાળ છે !!!

ToLower, ToLowerInvariant, ToUpper, ToUpperInvariant

.NET પ્લેટફોર્મ પર કામ કરવાના મારા 5 વર્ષના અનુભવમાં, મેં ઘણા પ્રોજેક્ટ્સ જોયા છે જેમાં સ્ટ્રિંગ મેચિંગનો ઉપયોગ કરવામાં આવ્યો હતો. મેં નીચેનું ચિત્ર પણ જોયું: ઘણા પ્રોજેક્ટ્સ સાથે એક એન્ટરપ્રાઇઝ સોલ્યુશન હતું, જેમાંથી દરેક સ્ટ્રિંગ સરખામણીઓ અલગ રીતે કરે છે. પરંતુ શું વાપરવું જોઈએ અને તેને કેવી રીતે એકીકૃત કરવું? રિક્ટર દ્વારા C# દ્વારા CLR પુસ્તકમાં, મેં માહિતી વાંચી કે 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 Core 3.0 ના આગમન સાથે, ટાયર કમ્પાઇલેશન સક્ષમ ધરાવતા પ્રોજેક્ટ્સ માટે બિલ્ડ ટાઈમ ઘટ્યો છે અને આ ટેક્નોલોજી સાથે સંકળાયેલ બગ્સ ફિક્સ કરવામાં આવી છે. અગાઉ, આ ટેક્નોલોજી ASP.NET કોરમાં પ્રથમ વિનંતીઓમાં ભૂલો તરફ દોરી જાય છે અને મલ્ટિ-લેવલ કમ્પાઇલેશન મોડમાં પ્રથમ બિલ્ડ દરમિયાન થીજી જાય છે. તે હાલમાં .NET Core 3.0 માં ડિફોલ્ટ રૂપે સક્ષમ છે, પરંતુ જો તમે ઈચ્છો તો તમે તેને અક્ષમ કરી શકો છો. જો તમે ટીમ-લીડ, વરિષ્ઠ, મધ્યમ હોદ્દા પર છો અથવા તમે વિભાગના વડા છો, તો તમારે સમજવું જોઈએ કે ઝડપી પ્રોજેક્ટ વિકાસ ટીમનું મૂલ્ય વધારે છે અને આ તકનીક તમને બંને વિકાસકર્તાઓ માટે સમય બચાવવા માટે પરવાનગી આપશે. અને પ્રોજેક્ટનો સમય.

.NET સ્તર ઉપર

તમારા .NET ફ્રેમવર્ક / .NET કોર સંસ્કરણને અપગ્રેડ કરો. ઘણીવાર, દરેક નવું સંસ્કરણ વધારાના પ્રદર્શન લાભો પ્રદાન કરે છે અને નવી સુવિધાઓ ઉમેરે છે.

પરંતુ ખરેખર ફાયદા શું છે? ચાલો તેમાંથી કેટલાકને જોઈએ:

• .NET Core 3.0 એ R2R ઈમેજીસ રજૂ કરી છે જે .NET કોર એપ્લીકેશનનો સ્ટાર્ટઅપ સમય ઘટાડશે.
• સંસ્કરણ 2.2 સાથે, ટાયર કમ્પાઇલેશન દેખાયું, જેનો આભાર પ્રોગ્રામરો પ્રોજેક્ટ શરૂ કરવામાં ઓછો સમય પસાર કરશે.
• નવા .NET ધોરણો માટે સપોર્ટ.
• પ્રોગ્રામિંગ ભાષાના નવા સંસ્કરણ માટે સપોર્ટ.
• ઑપ્ટિમાઇઝેશન, દરેક નવા વર્ઝન સાથે બેઝ લાઇબ્રેરીઓ કલેક્શન/સ્ટ્રક્ટ/સ્ટ્રીમ/સ્ટ્રિંગ/રેજેક્સનું ઑપ્ટિમાઇઝેશન અને ઘણું બધું સુધારે છે. જો તમે .NET ફ્રેમવર્કમાંથી .NET કોર પર સ્થાનાંતરિત કરી રહ્યાં છો, તો તમને બોક્સની બહાર એક મોટું પ્રદર્શન બુસ્ટ મળશે. ઉદાહરણ તરીકે, હું .NET કોર 3.0 માં ઉમેરાયેલા કેટલાક ઑપ્ટિમાઇઝેશનની લિંક જોડું છું: https://devblogs.microsoft.com/dotnet/performance-improvements-in-net-core-3-0/

નિષ્કર્ષ

કોડ લખતી વખતે, તમારા પ્રોજેક્ટના વિવિધ પાસાઓ પર ધ્યાન આપવું અને શ્રેષ્ઠ પરિણામ પ્રાપ્ત કરવા માટે તમારી પ્રોગ્રામિંગ ભાષા અને પ્લેટફોર્મની સુવિધાઓનો ઉપયોગ કરવો તે યોગ્ય છે. જો તમે .NET માં ઓપ્ટિમાઇઝેશન સંબંધિત તમારું જ્ઞાન શેર કરશો તો મને આનંદ થશે.

ગીથબ સાથે લિંક કરો

સોર્સ: www.habr.com