ජර්මානු විශ්වවිද්‍යාලවල පර්යේෂකයන් පිරිසක් результаты 10-ගිගාබිට් Intel Ixgbe (X10xx) ජාල කාඩ්පත් සඳහා සම්මත ධාවකයක අනුවාද 5ක් විවිධ ක්‍රමලේඛන භාෂාවලින් සංවර්ධනය කරන ලදී. ධාවකය පරිශීලක අවකාශයේ ධාවනය වන අතර C, Rust, Go, C#, Java, OCaml, Haskell, Swift, JavaScript සහ Python හි ක්රියාත්මක වේ. කේතය ලිවීමේදී, එක් එක් භාෂාවේ ලක්ෂණ සැලකිල්ලට ගනිමින්, හැකි උපරිම කාර්ය සාධනය සාක්ෂාත් කර ගැනීම සඳහා ප්රධාන අවධානය යොමු විය. සියලුම විකල්ප ක්‍රියාකාරීත්වයෙන් සමාන වන අතර ආසන්න වශයෙන් කේත පේළි 1000 කින් සමන්විත වේ. ව්යාපෘති සංවර්ධන BSD බලපත්‍රය යටතේ.
ධාවකයේ රස්ට් අනුවාදය C භාෂාවෙන් යොමු ධාවකයට කාර්ය සාධනය ඉතා සමීප විය. එකවර පැකට් 32 ක බ්ලොක් යැවීම සමඟ බරක් යටතේ, රස්ට් රියදුරු තරමක් පසුපසින් සිටියේය, නමුත් බ්ලොක් එකකට පැකට් 32 කට වඩා ඇති පරීක්ෂණ වලදී, වේගය ප්‍රායෝගිකව C ධාවකයට වඩා වෙනස් නොවූ අතර මිලියන 28 ක් සැකසීමේ මට්ටමින් කාර්ය සාධනය පෙන්නුම් කළේය. Xeon CPU E3-1230 v2 3.3 GHz සහිත සේවාදායකයක තත්පරයට පැකට්.
කාර්ය සාධනය අනුව මීළඟ ස්ථානය Go සහ C# භාෂා වල රියදුරන් විසින් අත්පත් කරගෙන ඇති අතර, එය තරමක් සමීප ප්රතිඵල පෙන්නුම් කළේය (Go ධාවකය පැකට් 16 ක් දක්වා වූ පරීක්ෂණ වලින් ජයග්‍රහණය කළ අතර පැකට් 16 කට වඩා වැඩි පරීක්ෂණ වලදී තරමක් පරාජය වීමට පටන් ගත්තේය. බ්ලොක් එකක). බ්ලොක් එකකට පැකට් 256ක් සමඟින්, C# ධාවකයේ උපරිම කාර්ය සාධනය තත්පරයකට පැකට් මිලියන 28ක් පමණ වූ අතර Go Driver එක තත්පරයකට පැකට් මිලියන 25ක් පමණ විය.
ඊළඟට, තරමක් සමීප ප්රතිඵල සහිතව, රියදුරන් විය
Java, OCaml සහ Haskell, කලින් සලකා බැලූ විකල්පයන්ට වඩා දැනටමත් සැලකිය යුතු ලෙස පසුගාමී වූ අතර තත්පරයට පැකට් මිලියන 12 ක සීමාව ඉක්මවා යාමට නොහැකි විය. Swift සහ JavaScript ධාවකයන් තත්පරයකට පැකට් මිලියන 5ක මට්ටමින් ප්‍රවාහ සැකසීමට හැකි වීම, ඊටත් වඩා විශාල ප්‍රමාදයක් පෙන්නුම් කළේය.
තත්පරයකට පැකට් මිලියන 0.14 ක් පමණක් සැකසීමට හැකි වූ Python ධාවකය විසින් ඉහළ ශ්‍රේණිගත කිරීම සම්පූර්ණ කරන ලදී. JIT නොමැතිව සහ විශේෂිත ප්‍රශස්තිකරණයකින් තොරව පරිවර්තකයන්ගේ වේගය ඇගයීමට Python ක්රියාත්මක කිරීම භාවිතා කරන ලදී (කේතය ක්රියාත්මක කර ඇත්තේ CPython 3.7 භාවිතයෙන් වන අතර PyPy සමඟ නොගැලපේ, නමුත් දත්ත ගබඩා ව්‍යුහයන් ප්‍රශස්ත කිරීම මඟින් කාර්ය සාධනය 10 ගුණයකින් පමණ වැඩි දියුණු කළ හැකි බව සටහන් වේ. )
මීට අමතරව, බෆරයේ සඵලතාවය සහ කසළ එකතු කරන්නාගේ බලපෑම පෙන්වීම සඳහා ප්‍රමාද පරීක්ෂණ සිදු කරන ලදී. එක් එක් පැකට්ටුව යවන ලද නිශ්චිත වේලාවට සාපේක්ෂව රියදුරු විසින් යොමු කිරීමෙන් පසු පරීක්ෂාව මගින් ප්‍රමාදය මනිනු ලැබේ. නායකයින් තවමත් C සහ රස්ට් රියදුරන් වූ අතර, එහි ප්රතිඵල තත්පරයකට පැකට් මිලියන 1ක (ආසන්න වශයෙන් 20 µs) ප්‍රවාහයක් සඳහා ප්‍රායෝගිකව වෙන්කර හඳුනාගත නොහැකි විය. Go ධාවකය හොඳින් ක්රියාත්මක වූ අතර, නායකයින්ට වඩා මඳක් පිටුපසින් සිටි අතර 20 µs මට්ටමේ රැඳී සිටියේය. C# ධාවකය ආසන්න වශයෙන් 50 µs ප්‍රමාදයන් පෙන්නුම් කළේය.
දීර්ඝතම ප්‍රමාදයන් ජාවාස්ක්‍රිප්ට් සහ ජාවා ධාවක මගින් පෙන්වනු ලැබේ (300 µsට වැඩි ප්‍රමාදයන්).
C ට වඩා ඉහළ මට්ටමේ භාෂාවලින් ධාවක සහ මෙහෙයුම් පද්ධති සංරචක සංවර්ධනය කිරීමේ හැකියාව තක්සේරු කිරීම සඳහා මෙම අධ්‍යයනය සිදු කරන ලදී. දැනට, ලිනක්ස් හි මතක ගැටළු 39 න් 40 ක්ම ධාවක සම්බන්ධ වේ, එබැවින් වඩාත් ආරක්ෂිත භාෂාවක් භාවිතා කිරීම සහ ධාවක කර්නලයෙන් සහ පරිශීලක අවකාශයට ගෙන යාමේ ගැටළු සහ නිෂ්පාදකයින් දැනටමත් මෙම දිශාවට සක්‍රියව අත්හදා බලමින් සිටී (උදාහරණයක් ලෙස, ගූගල් විසින් OS සඳහා TCP තොගයක් සංවර්ධනය කර ඇත Go භාෂාවෙන්, CloudFlare සමාගම රස්ට් හි QUIC ප්‍රොටෝකෝලය ක්රියාත්මක කිරීම, ඇපල් විසින් ජංගම උපාංගවල TCP තොගය පරිශීලක අවකාශයට ගෙන ගොස් ඇත).
කාර්යය අතරතුර, රියදුරු සංවර්ධනය සඳහා හොඳම අපේක්ෂකයා රස්ට් භාෂාව බව නිගමනය විය. රස්ට්ගේ හැකියාවන්, C ධාවකවලට සාපේක්ෂව 2% සිට 10% දක්වා කාර්ය සාධන පාඩුවකින් අඩු මට්ටමේ මතක කළමනාකරණය හා සම්බන්ධ ගැටළු ඉවත් කරයි. කසළ එකතු කිරීම නිසා ඇති වන උප මිලි තත්පර ප්‍රමාදය පිළිගත හැකි අවස්ථාවන්හිදී පද්ධති සංරචක නිර්මාණය කිරීම සඳහා Go සහ C# සුදුසු යැයි සැලකේ.
මූලාශ්රය: opennet.ru