យើង​បាន​ធ្វើ​អន្តរកម្ម C++ ដែល​មាន​ខ្សែ​តែមួយ​ជាមួយ​ច្រែះ​ច្រើន​ខ្សែ

ការភ្ជាប់កូដ C ++ ដែលមានខ្សែតែមួយជាមួយនឹងច្រែះពហុខ្សែគឺមិនគ្រាន់តែអាចធ្វើទៅបានទេ - វាគឺជាវិធីជាក់ស្តែងបំផុតមួយក្នុងការធ្វើទំនើបកម្មប្រព័ន្ធកេរ្តិ៍ដំណែលដោយមិនចាំបាច់សរសេរឡើងវិញពេញលេញ។ នៅ Mewayz យើងបានដោះស្រាយបញ្ហាប្រឈមពិតប្រាកដនេះនៅពេលធ្វើមាត្រដ្ឋានប្រព័ន្ធប្រតិបត្តិការអាជីវកម្ម 207-module របស់យើងដើម្បីបម្រើអ្នកប្រើប្រាស់ 138,000 ហើយលទ្ធផលបានផ្លាស់ប្តូរជាមូលដ្ឋានអំពីរបៀបដែលយើងគិតអំពីអន្តរប្រតិបត្តិការនៃប្រព័ន្ធ។

ហេតុ​អ្វី​បាន​ជា​អ្នក​នឹង​ធ្វើ​អន្តរកម្ម C++ Single-Threaded ជាមួយ Multi-Threaded Rust?

ប្រព័ន្ធផលិតកម្មភាគច្រើនមានកូដ C++ ដែលបានសាកល្បងជាច្រើនឆ្នាំ។ ការសរសេរឡើងវិញនូវអ្វីគ្រប់យ៉ាងនៅក្នុង Rust ស្តាប់ទៅគួរឱ្យទាក់ទាញនៅលើក្រដាស ប៉ុន្តែវាបង្ហាញពីហានិភ័យដ៏ធំ និងពេលវេលាវិស្វកម្មជាច្រើនខែ។ វិធីសាស្រ្តជាក់ស្តែងគឺការអនុម័តបន្ថែម — រុំតក្កវិជ្ជា C++ ដែលមានស្រាប់ ខណៈពេលដែលកំពុងផ្ទុកបន្ទុកធ្ងន់ស្របគ្នាទៅនឹងគំរូកម្មសិទ្ធិរបស់ Rust ។

ក្នុងករណីរបស់យើង ម៉ូឌុលតក្កវិជ្ជាធុរកិច្ចស្នូលបានដំណើរការដោយភាពជឿជាក់ក្នុង C++ តែមួយខ្សែអស់រយៈពេលជាច្រើនឆ្នាំ។ ពួកគេបានគ្រប់គ្រងដំណើរការភារកិច្ចជាបន្តបន្ទាប់ ការបង្កើតឯកសារ និងការគណនាហិរញ្ញវត្ថុ។ ប៉ុន្តែនៅពេលដែលមូលដ្ឋានអ្នកប្រើប្រាស់របស់យើងបានកើនឡើងលើសពី 100K យើងត្រូវការដំណើរការទិន្នន័យស្របគ្នា ការគ្រប់គ្រង API ស្របគ្នា និងការគ្រប់គ្រងរដ្ឋរួមគ្នាប្រកបដោយសុវត្ថិភាព។ លក្ខណៈ ផ្ញើ និង សមកាលកម្ម របស់ Rust បានផ្តល់ឱ្យយើងនូវការធានាស្របគ្នាតាមពេលវេលាដែល C++ មិនអាចផ្តល់ជូនដោយគ្មានការត្រួតពិនិត្យដោយដៃទូលំទូលាយ។

ការលើកទឹកចិត្តសំខាន់គឺការកាត់បន្ថយហានិភ័យ។ អ្នករក្សានូវអ្វីដែលដំណើរការ ហើយអ្នកបន្ថែមកម្រិតណា — ដោយមិនចាំបាច់លេងល្បែងមូលដ្ឋានកូដរបស់អ្នកទាំងស្រុងលើការផ្លាស់ប្តូរដែលប្រហែលជាមិនបញ្ចប់។

តើព្រំដែន FFI ពិតជាដំណើរការយ៉ាងដូចម្តេច?

ចំណុចប្រទាក់អនុគមន៍បរទេស (FFI) រវាង C ++ និង Rust ដំណើរការតាមរយៈហត្ថលេខាមុខងារ C-compatible ។ extern "C" របស់ Rust រារាំងមុខងារដែល C++ អាចហៅដោយផ្ទាល់ និងច្រាសមកវិញ។ បញ្ហាប្រឈមដ៏សំខាន់កើតឡើងនៅពេលដែលពេលវេលាដំណើរការពហុខ្សែស្រឡាយរបស់ Rust ត្រូវការហៅកូដ C++ តែមួយខ្សែដោយសុវត្ថិភាព។

យើងបានដោះស្រាយវាដោយប្រើស្ថាបត្យកម្មពិសេស៖

• ប្រតិបត្តិករ C++ ដែលបង្ខាំងខ្សែស្រឡាយ៖ ការហៅទូរសព្ទ C++ ទាំងអស់ត្រូវបានដំណើរការតាមរយៈខ្សែស្រលាយតែមួយ ដោយប្រើបណ្តាញបញ្ជូនសារ ដោយធានាថា វិចារណញាណដែលមានខ្សែតែមួយមិនបំពានឡើយ។
• ស្រទាប់ស្ពាន Rust async៖ កិច្ចការ Tokio បញ្ជូនការងារទៅអ្នកប្រតិបត្តិ C++ ហើយលទ្ធផល រង់ចាំ តាមរយៈប៉ុស្តិ៍ oneshot ដោយរក្សាផ្នែកខាង Rust យ៉ាងអសមកាល។
• ការ​គ្រប់គ្រង​ទ្រនិច​ស្រអាប់៖ វត្ថុ C++ ត្រូវ​បាន​រុំ​ក្នុង​រចនាសម្ព័ន្ធ Rust ដែល​អនុវត្ត Drop សម្រាប់​ការ​សម្អាត​ដោយ​កំណត់ ដោយ​ការពារ​ការ​លេច​ធ្លាយ​អង្គ​ចងចាំ​ឆ្លង​កាត់​ព្រំដែន​ភាសា។
• Serialization នៅព្រំដែន៖ រចនាសម្ព័ន្ធទិន្នន័យស្មុគ្រស្មាញត្រូវបានដាក់សៀរៀលទៅ FlatBuffers នៅស្រទាប់ FFI ដោយជៀសវាងការផ្គូផ្គងប្លង់រចនាសម្ព័ន្ធដែលផុយស្រួយ និងបើកដំណើរការការវិវត្តឯករាជ្យនៃផ្នែកនីមួយៗ។
• ភាពឯកោដោយភ័យស្លន់ស្លោ៖ catch_unwind របស់ Rust រុំរាល់ចំណុចចូលរបស់ FFI ដូច្នេះការភ័យស្លន់ស្លោមិនឆ្លងផុតព្រំដែនភាសា ដែលជាអាកប្បកិរិយាមិនកំណត់។

គំរូនេះបានផ្តល់ឱ្យយើងនូវដំណើរការនៃច្រែះពហុខ្សែជាមួយនឹងភាពជឿជាក់នៃតក្កវិជ្ជា C++ ដែលបានបញ្ជាក់ — ដោយមិនចាំបាច់សរសេរឡើងវិញនូវបន្ទាត់តែមួយនៃច្បាប់អាជីវកម្មដើម។

តើ​អ្វី​ទៅ​ជា​ឧបសគ្គ​ធំ​បំផុត​ដែល​ត្រូវ​ជៀសវាង?

កំហុសដ៏គ្រោះថ្នាក់បំផុតគឺការសន្មត់ថា កូដ C++ គឺមានសុវត្ថិភាពខ្សែ នៅពេលដែលវាមិនមាន។ ស្ថានភាពសកល អថេរឋិតិវន្ត និងការហៅចូលបណ្ណាល័យមិនដំណើរការឡើងវិញនឹងបង្កឱ្យមានការប្រណាំងទិន្នន័យដែលកម្មវិធីចងក្រងរបស់ Rust មិនអាចរកឃើញនៅទូទាំងព្រំដែន FFI ។ ការធានាសុវត្ថិភាពរបស់ Rust ឈប់នៅប្លុក unsafe — អ្វីគ្រប់យ៉ាងនៅខាងក្នុងគឺជាការទទួលខុសត្រូវរបស់អ្នក។

ការយល់ដឹងគន្លឹះ៖ Rust ធានាសុវត្ថិភាពនៃការចងចាំនៅក្នុងកូដរបស់វា ប៉ុន្តែនៅពេលដែលអ្នកឆ្លងកាត់ព្រំដែន FFI ចូលទៅក្នុង C++ អ្នកទទួលមរតករាល់បញ្ហាសុវត្ថិភាពខ្សែស្រឡាយដែល C++ មាន។ ស្ថាបត្យកម្ម​ជុំវិញ​ព្រំដែន​នោះ​មាន​សារៈ​សំខាន់​ជាង​កូដ​នៅ​ផ្នែក​ម្ខាង​នៃ​វា។

💡 DID YOU KNOW?

Mewayz replaces 8+ business tools in one platform

CRM · Invoicing · HR · Projects · Booking · eCommerce · POS · Analytics. Free forever plan available.

Start Free →

បញ្ហាទូទៅមួយទៀតគឺការគ្រប់គ្រងពេញមួយជីវិត។ វត្ថុ C ++ មិនចូលរួមក្នុងកម្មវិធីពិនិត្យប្រាក់កម្ចីរបស់ Rust ទេ។ ប្រសិនបើ Rust ទម្លាក់ឯកសារយោង ខណៈពេលដែល C ++ នៅតែកាន់ទ្រនិច នោះអ្នកទទួលបានកំហុសក្នុងការប្រើប្រាស់បន្ទាប់ពីគ្មានមេរោគ ដែលពិបាកវិនិច្ឆ័យយ៉ាងឃោរឃៅ។ យើងបានដោះស្រាយវាដោយការពង្រឹងអត្ថន័យនៃភាពជាម្ចាស់យ៉ាងតឹងរ៉ឹង៖ វត្ថុ C++ តែងតែជាកម្មសិទ្ធិដោយ Rust wrapper ពិតប្រាកដមួយ ហើយការចូលប្រើរួមគ្នាឆ្លងកាត់ការរាប់យោងផ្អែកលើ Arc នៅផ្នែកខាង Rust ។

ការហៅទូរស័ព្ទ FFI ហួសហេតុ ប្រកបដោយប្រសិទ្ធភាព បង្កើតបានពីការផ្លាស់ប្តូរបរិបទ និងសៀរៀល។ យើង​ធ្វើ​ប្រតិបត្តិការ​បណ្តុំ​នៅ​កន្លែង​ណា​ដែល​អាច​ធ្វើ​ទៅ​បាន ដោយ​ផ្ញើ​ជួរ​នៃ​ធាតុ​ការងារ​ទៅ​អ្នក​ប្រតិបត្តិ C++ ជាជាង​ធ្វើការ​ហៅ​ឆ្លង​ភាសា​បុគ្គល។

តើ​វិធី​នេះ​បាន​អនុវត្ត​ក្នុង​ផលិតកម្ម​ដោយ​របៀប​ណា?

បន្ទាប់​ពី​ដាក់​ពង្រាយ​ស្ថាបត្យកម្ម​កូនកាត់​នៅ​ទូទាំង​វេទិកា​របស់​យើង យើង​បាន​វាស់វែង​ការ​កែលម្អ​ជាក់ស្តែង។ សំណើឆ្លងកាត់កើនឡើង 3.4x សម្រាប់ម៉ូឌុលដែលពីមុនបានរារាំងលើដំណើរការ C++ ជាបន្តបន្ទាប់។ ភាពយឺតយ៉ាវនៃកន្ទុយ (p99) បានធ្លាក់ចុះ 61% ដោយសារតែពេលវេលាដំណើរការ async របស់ Rust អាចដំណើរការសំណើឯករាជ្យក្នុងពេលដំណាលគ្នា ខណៈពេលដែល C++ ដោះស្រាយកិច្ចការដែលធ្ងន់ក្នុងការគណនាលើខ្សែស្រឡាយដែលខិតខំប្រឹងប្រែងរបស់វា។

សំខាន់ជាងនេះទៅទៀត យើងមានកំហុសដែលទាក់ទងនឹងរូបិយប័ណ្ណសូន្យក្នុងរយៈពេលប្រាំមួយខែដំបូងនៃការផលិត។ លំនាំការបង្ខាំងខ្សែស្រឡាយបានធ្វើឱ្យវាមិនអាចទៅរួចទេជារចនាសម្ព័ន្ធសម្រាប់កូដ C ++ ដែលត្រូវបានហៅពីខ្សែស្រឡាយច្រើន ខណៈដែលប្រព័ន្ធប្រភេទរបស់ Rust បានរារាំងការប្រណាំងទិន្នន័យនៅផ្នែកម្ខាងនៃព្រំដែនរបស់វា។ នេះគឺជាការកែលម្អយ៉ាងសំខាន់លើវិធីសាស្រ្តពីមុនរបស់យើងក្នុងការព្យាយាមបន្ថែមខ្សែស្រឡាយទៅ C ++ ជាមួយ mutexes ដែលបានបង្កើតឧប្បត្តិហេតុលក្ខខណ្ឌប្រណាំងចំនួនបីក្នុងត្រីមាសតែមួយ។

ក្រុមវិស្វករក៏បានរាយការណ៍អំពីវដ្តនៃការធ្វើឡើងវិញលឿនជាងមុនផងដែរ។ មុខងារថ្មីអាចត្រូវបានបង្កើតឡើងនៅក្នុង Rust ជាមួយនឹងការគាំទ្រស្របគ្នាពេញលេញ ខណៈដែលម៉ូឌុល C++ ដែលមានស្រាប់នៅតែបន្តដំណើរការដោយគ្មានការកែប្រែ។ យុទ្ធសាស្ត្របន្ថែមនេះមានន័យថា ពួកយើងមិនដែលមានការធ្វើចំណាកស្រុក "បន្ទុះ" ដែលមានហានិភ័យខ្ពស់នោះទេ - គ្រាន់តែមានភាពប្រសើរឡើង និងអាចវាស់វែងបាន។

សំណួរដែលគេសួរញឹកញាប់

តើ Rust អាចហៅបណ្ណាល័យ C++ ដែលមានខ្សែតែមួយដោយគ្មានការកែប្រែបានទេ?

បាទ/ចាស ប៉ុន្តែអ្នកត្រូវតែធានាថាការហៅទូរសព្ទទាំងអស់ទៅកាន់បណ្ណាល័យនោះកើតឡើងពីខ្សែតែមួយ។ លំនាំស្ដង់ដារគឺដើម្បីបង្កើតខ្សែស្រឡាយប្រតិបត្តិករជាក់លាក់ដែលធ្វើស៊េរីការហៅ C ++ ទាំងអស់តាមរយៈឆានែលមួយ។ ភារកិច្ចធ្វើសមកាលកម្មរបស់ Rust បញ្ជូនសំណើ និងរង់ចាំការឆ្លើយតបដោយមិនរារាំងពេលវេលាដំណើរការពហុខ្សែ។ កូដ C++ ខ្លួនវាមិនតម្រូវឱ្យមានការផ្លាស់ប្តូរទេ — កម្រិតសុវត្ថិភាពត្រូវបានអនុវត្តទាំងស្រុងលើផ្នែក Rust ។

តើ FFI មានតម្លៃលើសកម្រិតគ្រប់គ្រាន់ដើម្បីប៉ះពាល់ដល់ដំណើរការកម្មវិធីដែរឬទេ?

ការហៅទូរសព្ទ FFI បុគ្គលមានការចំណាយតិចបំផុត — ជាធម្មតានៅក្រោម 10 nanoseconds សម្រាប់ការហៅមុខងារសាមញ្ញ។ ទោះជាយ៉ាងណាក៏ដោយ សៀរៀលនៃរចនាសម្ព័ន្ធទិន្នន័យស្មុគ្រស្មាញ និងការធ្វើសមកាលកម្មខ្សែស្រឡាយនៅព្រំដែនបន្ថែមប្រសិនបើអ្នកធ្វើការហៅទូរសព្ទរាប់ពាន់។ ប្រតិបត្តិការបង្រួបបង្រួម និងការប្រើទម្រង់សៀរៀលចម្លងសូន្យដូចជា FlatBuffers ឬ Cap'n Proto រក្សាការធ្វេសប្រហែសសូម្បីតែក្នុងទំហំ។

តើយើងគួរសរសេរកូដមូលដ្ឋានកូដ C++ របស់យើងឡើងវិញនៅក្នុង Rust ជំនួសឱ្យការភ្ជាប់គ្នាដែរឬទេ?

សម្រាប់ក្រុមភាគច្រើន អន្តរកម្មបន្ថែមគឺជាផ្លូវដែលមានសុវត្ថិភាព និងលឿនជាងមុន។ ការសរសេរឡើងវិញពេញលេញបង្ហាញពីហានិភ័យផ្នែកវិស្វកម្មជាច្រើនខែដោយមិនមានតម្លៃប្រឈមមុខនឹងអ្នកប្រើប្រាស់រហូតដល់ការបញ្ចប់។ Interfacing អនុញ្ញាតឱ្យអ្នកដឹកជញ្ជូនការកែលម្អភ្លាមៗ បញ្ជាក់ភាពត្រឹមត្រូវនៃវិធីសាស្រ្ត Rust នៅក្នុងការផលិត និងផ្លាស់ប្តូរម៉ូឌុលម្តងមួយៗដោយផ្អែកលើកន្លែងដែលការស្របគ្នាផ្តល់ផលប៉ះពាល់ច្រើនបំផុត។ សរសេរឡើងវិញតែម៉ូឌុលដែលតម្លៃនៃការថែរក្សាព្រំដែន FFI លើសពីតម្លៃនៃការសរសេរឡើងវិញ។

នៅ Mewayz យើងសាងសង់ហេដ្ឋារចនាសម្ព័ន្ធដែលមានទំហំ - ទាំងបច្ចេកទេស និងប្រតិបត្តិការ។ ប្រព័ន្ធប្រតិបត្តិការអាជីវកម្ម 207-module របស់យើងជួយក្រុមចំនួន 138,000 ដំណើរការលំហូរការងារកាន់តែឆ្លាតវៃដោយចាប់ផ្តើមពី $19/ខែ។ មិនថាអ្នកកំពុងគ្រប់គ្រងគម្រោង ប្រតិបត្តិការស្វ័យប្រវត្តិ ឬពង្រីកអាជីវកម្មរបស់អ្នកទេ Mewayz សម្របខ្លួនទៅនឹងរបៀបដែលអ្នកធ្វើការ។ ចាប់ផ្តើមការសាកល្បងឥតគិតថ្លៃរបស់អ្នកនៅ app.mewayz.com ហើយមើលអ្វីដែលប្រព័ន្ធប្រតិបត្តិការអាជីវកម្មទំនើបអាចធ្វើសម្រាប់ក្រុមរបស់អ្នក។