జర్మన్ విశ్వవిద్యాలయాల నుండి పరిశోధకుల బృందం ఫలితాలు , ఈ సమయంలో 10-గిగాబిట్ ఇంటెల్ Ixgbe (X10xx) నెట్‌వర్క్ కార్డ్‌ల కోసం ప్రామాణిక డ్రైవర్ యొక్క 5 వెర్షన్‌లు వివిధ ప్రోగ్రామింగ్ భాషలలో అభివృద్ధి చేయబడ్డాయి. డ్రైవర్ వినియోగదారు స్థలంలో నడుస్తుంది మరియు C, Rust, Go, C#, Java, OCaml, Haskell, Swift, JavaScript మరియు Pythonలో అమలు చేయబడుతుంది. కోడ్‌ను వ్రాసేటప్పుడు, ప్రతి భాష యొక్క లక్షణాలను పరిగణనలోకి తీసుకొని సాధ్యమైనంత ఉత్తమమైన పనితీరును సాధించడంపై ప్రధాన దృష్టి ఉంది. అన్ని ఎంపికలు కార్యాచరణలో ఒకేలా ఉంటాయి మరియు దాదాపు 1000 లైన్ల కోడ్‌ను కలిగి ఉంటాయి. ప్రాజెక్ట్ అభివృద్ధి BSD లైసెన్స్ కింద.
డ్రైవర్ యొక్క రస్ట్ వెర్షన్ సి లాంగ్వేజ్‌లోని రిఫరెన్స్ డ్రైవర్‌కు పనితీరులో చాలా దగ్గరగా ఉన్నట్లు తేలింది. 32 ప్యాకెట్ల బ్లాక్‌లను ఏకకాలంలో పంపడంతో పాటు, రస్ట్ డ్రైవర్ కొంచెం వెనుకబడి ఉన్నాడు, అయితే ఒక్కో బ్లాక్‌కు 32 ప్యాకెట్ల కంటే ఎక్కువ ఉన్న పరీక్షలలో, వేగం ఆచరణాత్మకంగా C డ్రైవర్‌కు భిన్నంగా లేదు మరియు 28 మిలియన్లను ప్రాసెస్ చేసే స్థాయిలో పనితీరును ప్రదర్శించింది. Xeon CPU E3-1230 v2 3.3 GHzతో సర్వర్‌లో సెకనుకు ప్యాకెట్లు.
పనితీరు పరంగా తదుపరి సముచిత స్థానాన్ని Go మరియు C# భాషలలో డ్రైవర్లు ఆక్రమించారు, ఇది చాలా దగ్గరి ఫలితాలను చూపించింది (Go డ్రైవర్ గరిష్టంగా 16 ప్యాకెట్ల బ్లాక్‌లతో పరీక్షల్లో గెలిచాడు మరియు 16 ప్యాకెట్ల కంటే ఎక్కువ ఉన్న పరీక్షల్లో స్వల్పంగా ఓడిపోవడం ప్రారంభించాడు. ఒక బ్లాక్‌లో). ప్రతి బ్లాక్‌కు 256 ప్యాకెట్‌లతో, C# డ్రైవర్ యొక్క గరిష్ట పనితీరు సెకనుకు దాదాపు 28 మిలియన్ ప్యాకెట్లు, మరియు గో డ్రైవర్ సెకనుకు దాదాపు 25 మిలియన్ ప్యాకెట్లు.
తరువాత, చాలా దగ్గరి ఫలితాలతో, డ్రైవర్లు ఉన్నారు
Java, OCaml మరియు Haskell, గతంలో పరిగణించబడిన ఎంపికల కంటే ఇప్పటికే గుర్తించదగినంత వెనుకబడి ఉన్నాయి మరియు సెకనుకు 12 మిలియన్ ప్యాకెట్లను అధిగమించలేకపోయాయి. స్విఫ్ట్ మరియు జావాస్క్రిప్ట్ డ్రైవర్లు సెకనుకు 5 మిలియన్ ప్యాకెట్ల స్థాయిలో స్ట్రీమ్‌లను ప్రాసెస్ చేయగలగడం ద్వారా మరింత ఎక్కువ లాగ్‌ని చూపించాయి.
సెకనుకు 0.14 మిలియన్ ప్యాకెట్లను మాత్రమే ప్రాసెస్ చేయగలిగిన పైథాన్ డ్రైవర్ ద్వారా టాప్ ర్యాంకింగ్ పూర్తి చేయబడింది. JIT లేకుండా మరియు నిర్దిష్ట ఆప్టిమైజేషన్‌లు లేకుండా వ్యాఖ్యాతల వేగాన్ని అంచనా వేయడానికి పైథాన్ అమలు ఉపయోగించబడింది (కోడ్ CPython 3.7ని ఉపయోగించి అమలు చేయబడింది మరియు PyPyకి అనుకూలంగా లేదు, అయితే డేటా నిల్వ నిర్మాణాల యొక్క ఆప్టిమైజేషన్ పనితీరును దాదాపు 10 రెట్లు మెరుగుపరుస్తుందని గుర్తించబడింది. )
అదనంగా, బఫరింగ్ యొక్క ప్రభావాన్ని మరియు చెత్త సేకరించేవారి ప్రభావాన్ని చూపించడానికి జాప్యం పరీక్షలు జరిగాయి. ప్రతి ప్యాకెట్‌ని పంపిన ఖచ్చితమైన సమయంతో పోలిస్తే డ్రైవర్ ద్వారా ఫార్వార్డ్ చేయబడిన తర్వాత పరీక్ష ఆలస్యాన్ని కొలుస్తుంది. నాయకులు ఇప్పటికీ C మరియు రస్ట్ డ్రైవర్‌లుగా ఉన్నారు, దీని ఫలితాలు సెకనుకు 1 మిలియన్ ప్యాకెట్ల (సుమారు 20 µs) ప్రవాహానికి ఆచరణాత్మకంగా గుర్తించలేనివి. గో డ్రైవర్ మంచి పనితీరు కనబరిచాడు, నాయకుల కంటే కొంచెం వెనుకబడి 20 µs స్థాయిలో ఉన్నాడు. C# డ్రైవర్ దాదాపు 50 µs ఆలస్యాన్ని చూపించింది.
జావాస్క్రిప్ట్ మరియు జావా డ్రైవర్లు (300 µs కంటే ఎక్కువ జాప్యాలు) ద్వారా ఎక్కువ ఆలస్యాలు చూపబడ్డాయి.
C కంటే ఉన్నత-స్థాయి భాషలలో డ్రైవర్లు మరియు ఆపరేటింగ్ సిస్టమ్ భాగాలను అభివృద్ధి చేసే అవకాశాన్ని అంచనా వేయడానికి ఈ అధ్యయనం నిర్వహించబడింది. ప్రస్తుతం, Linuxలోని 39 మెమరీ సమస్యలలో 40 డ్రైవర్లకు సంబంధించినవి, కాబట్టి మరింత సురక్షితమైన భాషను ఉపయోగించడం మరియు డ్రైవర్లను కెర్నల్ నుండి మరియు వినియోగదారు స్థలంలోకి తరలించడం వంటి సమస్యలు మరియు తయారీదారులు ఇప్పటికే ఈ దిశలో చురుకుగా ప్రయోగాలు చేస్తున్నారు (ఉదాహరణకు, Google OS కోసం TCP స్టాక్‌ను అభివృద్ధి చేసింది గో భాషలో, క్లౌడ్‌ఫ్లేర్ కంపెనీ రస్ట్‌లో QUIC ప్రోటోకాల్ అమలు, Apple మొబైల్ పరికరాలలో TCP స్టాక్‌ను వినియోగదారు స్థలంలోకి తరలించింది).
పని సమయంలో, డ్రైవర్ అభివృద్ధికి రస్ట్ భాష ఉత్తమ అభ్యర్థి అని నిర్ధారించారు. రస్ట్ యొక్క సామర్థ్యాలు తక్కువ-స్థాయి మెమరీ నిర్వహణకు సంబంధించిన సమస్యలను C డ్రైవర్లతో పోల్చితే సుమారు 2% నుండి 10% పనితీరు నష్టంతో తొలగిస్తాయి. చెత్త సేకరణ వల్ల కలిగే ఉప-మిల్లీసెకన్ల జాప్యం ఆమోదయోగ్యమైన పరిస్థితుల్లో గో మరియు C# కూడా సిస్టమ్ భాగాలను రూపొందించడానికి తగినవిగా పరిగణించబడతాయి.
మూలం: opennet.ru