.NET కోర్లో పనితీరు
అందరికి వందనాలు! ఈ కథనం నా సహోద్యోగులు మరియు నేను వేర్వేరు ప్రాజెక్ట్‌లలో పని చేస్తున్నప్పుడు చాలా కాలంగా ఉపయోగిస్తున్న ఉత్తమ అభ్యాసాల సమాహారం.
గణనలను నిర్వహించే యంత్రం గురించిన సమాచారం: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 కోర్ 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 పై ఒక కథనం ప్రచురించబడింది: . ఇది ఇప్పటికీ సంబంధితంగా ఉంది మరియు చదవడానికి సిఫార్సు చేయబడింది.
త్రో
ఒక సంవత్సరం క్రితం, నేను లెగసీ ప్రాజెక్ట్‌లో ఒక కంపెనీలో పనిచేశాను, ఆ ప్రాజెక్ట్‌లో ట్రై-క్యాచ్-త్రో నిర్మాణం ద్వారా ఫీల్డ్ ధ్రువీకరణను ప్రాసెస్ చేయడం సాధారణం. ప్రాజెక్ట్ కోసం ఇది అనారోగ్యకరమైన వ్యాపార తర్కం అని నేను ఇప్పటికే అర్థం చేసుకున్నాను, కాబట్టి సాధ్యమైనప్పుడల్లా నేను అలాంటి డిజైన్‌ను ఉపయోగించకూడదని ప్రయత్నించాను. కానీ అలాంటి నిర్మాణంతో లోపాలను నిర్వహించే విధానం ఎందుకు చెడ్డదో గుర్తించండి. నేను రెండు విధానాలను సరిపోల్చడానికి ఒక చిన్న కోడ్‌ను వ్రాసాను మరియు ప్రతి ఎంపికకు బెంచ్‌మార్క్‌లను చేసాను.
కోడ్:
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, Toupper Invariant
.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 కోర్ 3.0 రావడంతో, టైర్ కంపైలేషన్ ప్రారంభించబడిన ప్రాజెక్ట్‌ల నిర్మాణ సమయం తగ్గింది మరియు ఈ సాంకేతికతతో అనుబంధించబడిన బగ్‌లు పరిష్కరించబడ్డాయి. గతంలో, ఈ సాంకేతికత ASP.NET కోర్‌లోని మొదటి అభ్యర్థనలలో లోపాలకు దారితీసింది మరియు బహుళ-స్థాయి కంపైలేషన్ మోడ్‌లో మొదటి బిల్డ్ సమయంలో ఫ్రీజ్ అవుతుంది. ఇది ప్రస్తుతం .NET కోర్ 3.0లో డిఫాల్ట్‌గా ప్రారంభించబడింది, కానీ మీరు కోరుకుంటే దాన్ని నిలిపివేయవచ్చు. మీరు టీమ్ లీడ్, సీనియర్, మిడిల్ లేదా డిపార్ట్‌మెంట్ హెడ్‌గా ఉన్నట్లయితే, వేగవంతమైన ప్రాజెక్ట్ డెవలప్‌మెంట్ జట్టు విలువను పెంచుతుందని మీరు అర్థం చేసుకోవాలి మరియు ఈ సాంకేతికత ఇద్దరు డెవలపర్‌ల కోసం సమయాన్ని ఆదా చేయడానికి మిమ్మల్ని అనుమతిస్తుంది. మరియు ప్రాజెక్ట్ యొక్క సమయం.
.NET స్థాయి పెరిగింది
మీ .NET ఫ్రేమ్‌వర్క్ / .NET కోర్ వెర్షన్‌ని అప్‌గ్రేడ్ చేయండి. తరచుగా, ప్రతి కొత్త వెర్షన్ అదనపు పనితీరు లాభాలను అందిస్తుంది మరియు కొత్త ఫీచర్లను జోడిస్తుంది.
కానీ ఖచ్చితంగా ప్రయోజనాలు ఏమిటి? వాటిలో కొన్నింటిని చూద్దాం:
- .NET కోర్ 3.0 R2R చిత్రాలను ప్రవేశపెట్టింది, ఇది .NET కోర్ అప్లికేషన్‌ల ప్రారంభ సమయాన్ని తగ్గిస్తుంది.
- వెర్షన్ 2.2తో, టైర్ కంపైలేషన్ కనిపించింది, ప్రోగ్రామర్లు ప్రాజెక్ట్‌ను ప్రారంభించడంలో తక్కువ సమయాన్ని వెచ్చిస్తారు.
- కొత్త .NET ప్రమాణాలకు మద్దతు.
- ప్రోగ్రామింగ్ భాష యొక్క కొత్త సంస్కరణకు మద్దతు.
- ఆప్టిమైజేషన్, ప్రతి కొత్త వెర్షన్‌తో బేస్ లైబ్రరీల ఆప్టిమైజేషన్ కలెక్షన్/స్ట్రక్ట్/స్ట్రీమ్/స్ట్రింగ్/రెజెక్స్ మరియు మరిన్ని మెరుగుపడుతుంది. మీరు .NET ఫ్రేమ్‌వర్క్ నుండి .NET కోర్‌కి మైగ్రేట్ చేస్తుంటే, మీరు బాక్స్ వెలుపల పెద్ద పనితీరును పెంచుతారు. ఉదాహరణగా, నేను .NET కోర్ 3.0కి జోడించిన కొన్ని ఆప్టిమైజేషన్‌లకు లింక్‌ను జోడించాను:
తీర్మానం
కోడ్‌ను వ్రాసేటప్పుడు, మీ ప్రాజెక్ట్‌లోని విభిన్న అంశాలకు శ్రద్ధ చూపడం మరియు ఉత్తమ ఫలితాన్ని సాధించడానికి మీ ప్రోగ్రామింగ్ భాష మరియు ప్లాట్‌ఫారమ్ యొక్క లక్షణాలను ఉపయోగించడం విలువైనది. మీరు .NETలో ఆప్టిమైజేషన్‌కు సంబంధించిన మీ జ్ఞానాన్ని పంచుకుంటే నేను సంతోషిస్తాను.
మూలం: www.habr.com