ការប្រៀបធៀបដំណើរការកម្មវិធីបញ្ជាបណ្តាញនៅក្នុងកំណែជា 10 ភាសាសរសេរកម្មវិធី

ក្រុមអ្នកស្រាវជ្រាវមកពីសាកលវិទ្យាល័យអាល្លឺម៉ង់ បានផ្សព្វផ្សាយ ការរកប្រាក់ចំណូល ពិសោធន៍ក្នុងអំឡុងពេលនោះ កំណែ 10 នៃកម្មវិធីបញ្ជាស្តង់ដារសម្រាប់កាតបណ្តាញ 10-gigabit Intel Ixgbe (X5xx) ត្រូវបានបង្កើតឡើងជាភាសាសរសេរកម្មវិធីផ្សេងៗគ្នា។ កម្មវិធីបញ្ជាដំណើរការក្នុងចន្លោះអ្នកប្រើប្រាស់ ហើយត្រូវបានអនុវត្តនៅក្នុង C, Rust, Go, C#, Java, OCaml, Haskell, Swift, JavaScript និង Python ។ នៅពេលសរសេរកូដ ការផ្តោតសំខាន់គឺទៅលើការសម្រេចបាននូវដំណើរការល្អបំផុតដែលអាចធ្វើទៅបាន ដោយគិតគូរពីលក្ខណៈនៃភាសានីមួយៗ។ ជម្រើសទាំងអស់គឺដូចគ្នាបេះបិទនៅក្នុងមុខងារ ហើយមានកូដប្រហែល 1000 ជួរ។ ការអភិវឌ្ឍន៍គម្រោង ការ​ឆ្លង​រាលដាល ក្រោមអាជ្ញាប័ណ្ណ BSD ។

កំណែ Rust របស់កម្មវិធីបញ្ជាបានប្រែក្លាយថាមានភាពស្និទ្ធស្នាលក្នុងការអនុវត្តជាមួយកម្មវិធីបញ្ជាយោងជាភាសា C ។ នៅក្រោមបន្ទុកជាមួយនឹងការបញ្ជូនដំណាលគ្នានៃប្លុកចំនួន 32 កញ្ចប់កម្មវិធីបញ្ជា Rust នៅពីក្រោយបន្តិចប៉ុន្តែនៅក្នុងការធ្វើតេស្តដែលមានច្រើនជាង 32 កញ្ចប់ក្នុងមួយប្លុកល្បឿនគឺមិនខុសពីកម្មវិធីបញ្ជា C ហើយបានបង្ហាញពីដំណើរការនៅកម្រិតនៃដំណើរការ 28 លាន។ កញ្ចប់ក្នុងមួយវិនាទីនៅលើម៉ាស៊ីនមេដែលមានស៊ីភីយូ Xeon E3-1230 v2 3.3 GHz ។

ទីផ្សារពិសេសបន្ទាប់ទាក់ទងនឹងការអនុវត្តត្រូវបានកាន់កាប់ដោយអ្នកបើកបរនៅក្នុងភាសា Go និង C# ដែលបង្ហាញពីលទ្ធផលជិតស្និទ្ធ (អ្នកបើកបរ Go បានឈ្នះក្នុងការធ្វើតេស្តជាមួយនឹងប្លុករហូតដល់ 16 កញ្ចប់ ហើយចាប់ផ្តើមបាត់បង់បន្តិចក្នុងការធ្វើតេស្តដែលមានច្រើនជាង 16 កញ្ចប់។ នៅក្នុងប្លុក) ។ ជាមួយនឹង 256 កញ្ចប់ក្នុងមួយប្លុក ប្រសិទ្ធភាពខ្ពស់បំផុតរបស់កម្មវិធីបញ្ជា C# គឺប្រហែល 28 លានកញ្ចប់ក្នុងមួយវិនាទី ហើយកម្មវិធីបញ្ជា Go មានប្រហែល 25 លានកញ្ចប់ក្នុងមួយវិនាទី។

បន្ទាប់មកជាមួយនឹងលទ្ធផលជិតស្និទ្ធដោយស្មើភាពគឺជាអ្នកបើកបរសម្រាប់
Java, OCaml និង Haskell ដែលមានភាពយឺតយ៉ាវគួរឱ្យកត់សម្គាល់ពីជម្រើសដែលបានពិចារណាពីមុន ហើយមិនអាចយកឈ្នះលើ 12 លានកញ្ចប់ក្នុងមួយរបារទីពីរបានទេ។ កម្មវិធីបញ្ជា Swift និង JavaScript បានបង្ហាញពីភាពយឺតយ៉ាវកាន់តែខ្លាំង ដោយអាចដំណើរការស្ទ្រីមក្នុងកម្រិត 5 លានកញ្ចប់ក្នុងមួយវិនាទី។

ចំណាត់ថ្នាក់កំពូលត្រូវបានបញ្ចប់ដោយអ្នកបើកបរ Python ដែលអាចដំណើរការបានត្រឹមតែ 0.14 លានកញ្ចប់ក្នុងមួយវិនាទី។ ការអនុវត្ត Python ត្រូវបានប្រើដើម្បីវាយតម្លៃល្បឿនរបស់អ្នកបកប្រែដោយគ្មាន JIT និងដោយគ្មានការបង្កើនប្រសិទ្ធភាពជាក់លាក់ (កូដត្រូវបានប្រតិបត្តិដោយប្រើ CPython 3.7 និងមិនឆបគ្នាជាមួយ PyPy ប៉ុន្តែវាត្រូវបានកត់សម្គាល់ថាការបង្កើនប្រសិទ្ធភាពនៃរចនាសម្ព័ន្ធផ្ទុកទិន្នន័យអាចធ្វើឱ្យប្រសើរឡើងនូវការអនុវត្តប្រហែល 10 ដង។ )

លើសពីនេះទៀត ការធ្វើតេស្តភាពយឺតយ៉ាវត្រូវបានអនុវត្ត ដើម្បីបង្ហាញពីប្រសិទ្ធភាពនៃការបណ្ដោះអាសន្ន និងផលប៉ះពាល់របស់អ្នកប្រមូលសំរាម។ ការធ្វើតេស្តបានវាស់វែងភាពយឺតយ៉ាវ បន្ទាប់ពីកញ្ចប់នីមួយៗត្រូវបានបញ្ជូនបន្តដោយអ្នកបើកបរ ធៀបនឹងពេលវេលាពិតប្រាកដដែលវាត្រូវបានផ្ញើ។ អ្នកដឹកនាំនៅតែជាអ្នកបើកបរ C និង Rust ដែលលទ្ធផលនៃការអនុវត្តមិនអាចបែងចែកបានសម្រាប់លំហូរនៃ 1 លានកញ្ចប់ក្នុងមួយវិនាទី (ប្រហែល 20 µs) ។ អ្នកបើកបរ Go ដំណើរការបានល្អ ដោយគ្រាន់តែនៅពីក្រោយអ្នកដឹកនាំបន្តិចប៉ុណ្ណោះ ហើយក៏នៅមានកម្រិត 20 µs ផងដែរ។ កម្មវិធីបញ្ជា C# បង្ហាញពីការពន្យារពេលប្រហែល 50 µs ។
ការពន្យារពេលយូរបំផុតត្រូវបានបង្ហាញដោយកម្មវិធីបញ្ជា JavaScript និង Java (latencies ច្រើនជាង 300 µs) ។

ការសិក្សានេះត្រូវបានធ្វើឡើងដើម្បីវាយតម្លៃលទ្ធភាពនៃការអភិវឌ្ឍន៍កម្មវិធីបញ្ជា និងសមាសធាតុប្រព័ន្ធប្រតិបត្តិការជាភាសាកម្រិតខ្ពស់ជាងភាសា C ។ បច្ចុប្បន្ននេះ បញ្ហាអង្គចងចាំចំនួន 39 ក្នុងចំណោម 40 នៅក្នុងលីនុចគឺទាក់ទងនឹងកម្មវិធីបញ្ជា ដូច្នេះបញ្ហានៃការប្រើប្រាស់ភាសាដែលមានសុវត្ថិភាពជាងមុន និងការផ្លាស់ទីកម្មវិធីបញ្ជាចេញពីខឺណែល និងចូលទៅក្នុងកន្លែងអ្នកប្រើប្រាស់។ នៅតែពាក់ព័ន្ធ ហើយអ្នកផលិតកំពុងធ្វើការពិសោធន៍យ៉ាងសកម្មក្នុងទិសដៅនេះ (ឧទាហរណ៍ Google បានបង្កើតជង់ TCP សម្រាប់ប្រព័ន្ធប្រតិបត្តិការ Fuchsia នៅក្នុងភាសា Go ក្រុមហ៊ុន CloudFlare បានបង្កើត ការអនុវត្តពិធីការ QUIC នៅក្នុង Rust ក្រុមហ៊ុន Apple បានផ្លាស់ប្តូរជង់ TCP នៅលើឧបករណ៍ចល័តទៅក្នុងទំហំអ្នកប្រើប្រាស់)។

នៅក្នុងដំណើរការការងារ វាត្រូវបានសន្និដ្ឋានថា ភាសា Rust គឺជាបេក្ខជនដ៏ល្អបំផុតសម្រាប់ការអភិវឌ្ឍន៍អ្នកបើកបរ។ សមត្ថភាពរបស់ Rust លុបបំបាត់បញ្ហាដែលទាក់ទងនឹងការគ្រប់គ្រងអង្គចងចាំកម្រិតទាបក្នុងការចំណាយប្រហែល 2% ទៅ 10% ការបាត់បង់ដំណើរការបើប្រៀបធៀបទៅនឹង C drivers ។ Go និង C# ក៏ត្រូវបានចាត់ទុកថាសមរម្យសម្រាប់ការបង្កើតសមាសធាតុប្រព័ន្ធក្នុងស្ថានភាពដែលភាពយឺតយ៉ាវរងមីលីវិនាទីដែលបណ្តាលមកពីការប្រមូលសំរាមអាចទទួលយកបាន។

ប្រភព: opennet.ru