10 પ્રોગ્રામિંગ ભાષાઓમાં સંસ્કરણોમાં નેટવર્ક ડ્રાઇવરની કામગીરીની સરખામણી

જર્મન યુનિવર્સિટીઓના સંશોધકોનું જૂથ પ્રકાશિત результаты નિષ્ણાત, જે દરમિયાન 10-ગીગાબીટ Intel Ixgbe (X10xx) નેટવર્ક કાર્ડ માટે પ્રમાણભૂત ડ્રાઇવરના 5 સંસ્કરણો વિવિધ પ્રોગ્રામિંગ ભાષાઓમાં વિકસાવવામાં આવ્યા હતા. ડ્રાઈવર યુઝર સ્પેસમાં ચાલે છે અને તેને C, Rust, Go, C#, Java, OCaml, Haskell, Swift, JavaScript અને Python માં લાગુ કરવામાં આવે છે. કોડ લખતી વખતે, મુખ્ય ધ્યાન દરેક ભાષાની વિશેષતાઓને ધ્યાનમાં રાખીને, શ્રેષ્ઠ સંભવિત પ્રદર્શન હાંસલ કરવા પર હતું. બધા વિકલ્પો કાર્યક્ષમતામાં સમાન છે અને તેમાં કોડની લગભગ 1000 લાઇનનો સમાવેશ થાય છે. પ્રોજેક્ટ વિકાસ ફેલાવો BSD લાયસન્સ હેઠળ.

ડ્રાઇવરનું રસ્ટ વર્ઝન સી ભાષામાં સંદર્ભ ડ્રાઇવરની કામગીરીમાં ખૂબ નજીક હોવાનું બહાર આવ્યું છે. એક સાથે 32 પેકેટોના બ્લોક મોકલવાના ભાર હેઠળ, રસ્ટ ડ્રાઈવર થોડો પાછળ હતો, પરંતુ બ્લોક દીઠ 32 થી વધુ પેકેટો સાથેના પરીક્ષણોમાં, ઝડપ સી ડ્રાઈવરથી વ્યવહારીક રીતે અલગ ન હતી અને 28 મિલિયન પ્રોસેસિંગના સ્તરે પ્રદર્શન દર્શાવ્યું હતું. Xeon CPU E3-1230 v2 3.3 GHz સાથે સર્વર પર સેકન્ડ દીઠ પેકેટો.

પ્રદર્શનની દ્રષ્ટિએ આગળનું સ્થાન Go અને C# ભાષાઓમાં ડ્રાઇવરો દ્વારા કબજે કરવામાં આવ્યું હતું, જેણે એકદમ નજીકના પરિણામો દર્શાવ્યા હતા (ગો ડ્રાઇવર 16 પેકેટ સુધીના બ્લોક સાથેના પરીક્ષણોમાં જીત્યો હતો, અને 16 થી વધુ પેકેટો સાથેના પરીક્ષણોમાં થોડો હારવા લાગ્યો હતો. બ્લોકમાં). બ્લોક દીઠ 256 પેકેટો સાથે, C# ડ્રાઈવરનું પીક પરફોર્મન્સ અંદાજે 28 મિલિયન પેકેટ્સ પ્રતિ સેકન્ડ હતું, અને ગો ડ્રાઈવર પ્રતિ સેકન્ડ અંદાજે 25 મિલિયન પેકેટ્સ હતા.

આગળ, એકદમ નજીકના પરિણામો સાથે, માટે ડ્રાઇવરો હતા
Java, OCaml અને Haskell, જે પહેલાથી ધ્યાનમાં લેવામાં આવેલા વિકલ્પોથી નોંધપાત્ર રીતે પાછળ હતા અને પ્રતિ સેકન્ડ બાર દીઠ 12 મિલિયન પેકેટ્સને દૂર કરી શક્યા નથી. સ્વિફ્ટ અને જાવાસ્ક્રિપ્ટ ડ્રાઇવરોએ પ્રતિ સેકન્ડ 5 મિલિયન પેકેટ્સના સ્તરે સ્ટ્રીમ્સ પર પ્રક્રિયા કરવામાં સક્ષમ હોવાને કારણે વધુ લેગ દર્શાવ્યું હતું.

ટોચની રેન્કિંગ પાયથોન ડ્રાઇવર દ્વારા પૂર્ણ કરવામાં આવી હતી, જે પ્રતિ સેકન્ડ માત્ર 0.14 મિલિયન પેકેટો પર પ્રક્રિયા કરવામાં સક્ષમ હતી. Python અમલીકરણનો ઉપયોગ JIT વિના અને ચોક્કસ ઑપ્ટિમાઇઝેશન વિના દુભાષિયાઓની ગતિનું મૂલ્યાંકન કરવા માટે કરવામાં આવ્યો હતો (કોડ CPython 3.7 નો ઉપયોગ કરીને ચલાવવામાં આવ્યો હતો અને PyPy સાથે સુસંગત ન હતો, પરંતુ નોંધ્યું છે કે ડેટા સ્ટોરેજ સ્ટ્રક્ચર્સનું ઑપ્ટિમાઇઝેશન લગભગ 10 ગણું પ્રદર્શન સુધારી શકે છે. ).

વધુમાં, બફરિંગની અસરકારકતા અને કચરો એકત્ર કરનારની અસર બતાવવા માટે વિલંબિતતા પરીક્ષણો હાથ ધરવામાં આવ્યા હતા. પરીક્ષણમાં ડ્રાઇવર દ્વારા મોકલવામાં આવેલા ચોક્કસ સમયની તુલનામાં દરેક પેકેટ ફોરવર્ડ કર્યા પછી લેટન્સી માપવામાં આવી હતી. નેતાઓ હજુ પણ C અને રસ્ટ ડ્રાઇવરો હતા, જેના પરિણામો પ્રતિ સેકન્ડ (આશરે 1 µs) 20 મિલિયન પેકેટના પ્રવાહ માટે વ્યવહારીક રીતે અસ્પષ્ટ હતા. ગો ડ્રાઇવરે લીડર્સની થોડી પાછળ રહીને અને 20 µsના લેવલ પર રહીને સારું પ્રદર્શન કર્યું. C# ડ્રાઇવરે લગભગ 50 µs નો વિલંબ દર્શાવ્યો.
સૌથી લાંબો વિલંબ JavaScript અને Java ડ્રાઇવરો દ્વારા દર્શાવવામાં આવ્યો હતો (300 µs કરતાં વધુની વિલંબ).

આ અભ્યાસ C કરતાં ઉચ્ચ-સ્તરની ભાષાઓમાં ડ્રાઇવરો અને ઑપરેટિંગ સિસ્ટમ ઘટકો વિકસાવવાની શક્યતાનું મૂલ્યાંકન કરવા માટે હાથ ધરવામાં આવ્યો હતો. હાલમાં, Linux માં 39 માંથી 40 મેમરી સમસ્યાઓ ડ્રાઇવરો સાથે સંબંધિત છે, તેથી વધુ સુરક્ષિત ભાષાનો ઉપયોગ કરવા અને ડ્રાઇવરોને કર્નલની બહાર અને વપરાશકર્તા જગ્યામાં ખસેડવાની સમસ્યાઓ સુસંગત રહે છે અને ઉત્પાદકો પહેલેથી જ આ દિશામાં સક્રિય રીતે પ્રયોગ કરી રહ્યા છે (ઉદાહરણ તરીકે, Google એ OS માટે TCP સ્ટેક વિકસાવ્યું છે. ફ્યુશિયા ગો ભાષામાં, CloudFlare કંપની બનાવ્યું રસ્ટમાં QUIC પ્રોટોકોલનું અમલીકરણ, Apple એ મોબાઇલ ઉપકરણો પરના TCP સ્ટેકને વપરાશકર્તા જગ્યામાં ખસેડ્યું છે).

કાર્ય દરમિયાન, તે તારણ કાઢ્યું હતું કે રસ્ટ ભાષા ડ્રાઇવર વિકાસ માટે શ્રેષ્ઠ ઉમેદવાર છે. રસ્ટની ક્ષમતાઓ C ડ્રાઇવરોની સરખામણીમાં લગભગ 2% થી 10% પ્રભાવ નુકશાનના ખર્ચે નીચા-સ્તરના મેમરી મેનેજમેન્ટ સાથે સંકળાયેલ સમસ્યાઓને દૂર કરે છે. Go અને C# એ પરિસ્થિતિઓમાં સિસ્ટમ ઘટકો બનાવવા માટે પણ યોગ્ય માનવામાં આવે છે જ્યાં કચરાના સંગ્રહને કારણે સબ-મિલિસેકન્ડ લેટન્સી સ્વીકાર્ય હોય.

સોર્સ: opennet.ru