අපි බහු-නූල් මලකඩ සමඟ තනි-නූල් C++ අතුරුමුහුණත් කළෙමු

බහු නූල් සහිත රස්ට් සමඟ තනි-නූල් C++ කේත අතුරුමුහුණත කිරීම කළ හැකි දෙයක් පමණක් නොවේ - එය සම්පූර්ණ නැවත ලිවීමකින් තොරව උරුම පද්ධති නවීකරණය කිරීමේ වඩාත් ප්‍රායෝගික ක්‍රමයකි. Mewayz හිදී, අපගේ 207-මොඩියුල ව්‍යාපාරික OS පරිශිලකයන් 138,000කට සේවා සැපයීම සඳහා පරිමාණය කිරීමේදී අපි මෙම නියම අභියෝගයට මුහුණ දුන් අතර, ප්‍රතිඵල මගින් පද්ධති අන්තර් ක්‍රියාකාරීත්වය ගැන අප සිතන ආකාරය මූලික වශයෙන් වෙනස් විය.

ඔබ බහු-නූල් මලකඩ සමග තනි-නූල් C++ අතුරුමුහුණත් කරන්නේ ඇයි?

බොහෝ නිෂ්පාදන පද්ධති වසර ගණනාවක් සටන්-පරීක්ෂා කරන ලද C++ කේතය රැගෙන යයි. සෑම දෙයක්ම රස්ට් තුළ නැවත ලිවීම කඩදාසි මත සිත් ඇදගන්නාසුළුයි, නමුත් එය දැවැන්ත අවදානමක් සහ මාස ගණනක ඉංජිනේරු කාලය හඳුන්වා දෙයි. ප්‍රායෝගික ප්‍රවේශය වර්ධක අනුගතවීමයි - රස්ට්හි හිමිකාරිත්වයේ ආකෘතියට සමගාමී-බර වැඩ බර පැටවීමේදී පවතින C++ තර්කනය එතීම.

අපගේ නඩුවේදී, මූලික ව්‍යාපාර තාර්කික මොඩියුල වසර ගණනාවක් තිස්සේ තනි-නූල් C++ තුළ විශ්වාසදායක ලෙස ක්‍රියාත්මක විය. ඔවුන් අනුක්‍රමික කාර්ය සැකසීම, ලේඛන උත්පාදනය සහ මූල්‍ය ගණනය කිරීම් සිදු කළහ. නමුත් අපගේ පරිශීලක පදනම 100K ඉක්මවා වර්ධනය වූ විට, අපට සමාන්තර දත්ත සැකසීම, සමගාමී API හැසිරවීම සහ ආරක්ෂිත හවුල්-රාජ්‍ය කළමනාකරණය අවශ්‍ය විය. රස්ට්ගේ Send සහ Sync ගතිලක්ෂණ අපට සම්පාදනය-කාල සමගාමී සහතිකයක් ලබා දුන්නේ C++ හට පුළුල් අතින් විගණනයකින් තොරව ලබාදිය නොහැකි බවයි.

ප්‍රධාන පෙළඹවීම අවදානම් අඩු කිරීමයි. ඔබ ක්‍රියා කරන දේ තබා ගන්නා අතර, ඔබ කුමන පරිමාණයන් එකතු කරයි — කිසිදා අවසන් කළ නොහැකි සංක්‍රමණයක් මත ඔබේ සම්පූර්ණ කේත පදනම සූදුවකින් තොරව.

FFI සීමාව සැබවින්ම ක්‍රියා කරන්නේ කෙසේද?

C++ සහ Rust අතර විදේශීය ක්‍රියාකාරී අතුරුමුහුණත (FFI) C-අනුකූල ශ්‍රිත අත්සන් හරහා ක්‍රියාත්මක වේ. Rust's extern "C" blocks C++ ට සෘජුවම ඇමතීමට හැකි ක්‍රියාකාරකම් නිරාවරණය කරයි, සහ අනෙක් අතට. Rust හි බහු-නූල් ධාවන කාලයට තනි-නූල් C++ කේතය ආරක්ෂිතව ක්‍රියාත්මක කිරීමට අවශ්‍ය වූ විට තීරණාත්මක අභියෝගය මතු වේ.

අපි මෙය කැපවූ ගෘහ නිර්මාණ ශිල්පයක් භාවිතයෙන් විසඳා ගත්තෙමු:

• ත්‍රෙඩ්-සීමිත C++ ක්‍රියාත්මක කරන්නා: සියලුම C++ ඇමතුම් තනි නූලක් හරහා පණිවිඩ යැවීමේ නාලිකාවක් භාවිතයෙන් ලබා දෙනු ලැබේ, තනි නූල් වෙනස් නොවන බව සහතික කරයි.
• Rust async bridge layer: Tokio කර්තව්‍යයන් C++ executor වෙත වැඩ භාර දෙන අතර Rust පැත්ත සම්පූර්ණයෙන්ම අසමමුහුර්තව තබා ගනිමින් oneshot නාලිකා හරහා ප්‍රතිඵල පොරොත්තු කරයි.
• පාරා දර්ශක කළමනාකරණය: C++ වස්තු, භාෂා සීමාව හරහා මතක කාන්දුවීම් වළක්වමින්, තීරණාත්මක පිරිසිදු කිරීම සඳහා Drop ක්‍රියාත්මක කරන Rust structs වලින් ඔතා ඇත.
• මායිමෙහි අනුක්‍රමිකකරණය: සංකීර්ණ දත්ත ව්‍යුහයන් FFI ස්ථරයේ FlatBuffers වෙත අනුක්‍රමික කර ඇත, බිඳෙනසුලු ව්‍යුහාත්මක පිරිසැලසුම් ගැලපීම වළක්වා සහ එක් එක් පැත්තේ ස්වාධීන පරිණාමය සක්‍රීය කරයි.
• භීතිකාව හුදකලා කිරීම: රස්ට්ගේ catch_unwind සෑම FFI ඇතුල්වීමේ ලක්ෂ්‍යයක්ම ආවරණය කරයි, එවිට භීතියක් කිසි විටෙකත් භාෂා සීමාව ඉක්මවා නොයන අතර එය නිර්වචනය නොකළ හැසිරීමකි.

මෙම රටාව මුල් ව්‍යාපාරික නීතිවල එක පේළියක්වත් නැවත ලිවීමකින් තොරව - ඔප්පු කළ C++ තර්කයේ විශ්වසනීයත්වය සහිත බහු-නූල් රස්ට් ප්‍රතිදානය අපට ලබා දුන්නේය.

වැළැක්විය යුතු ලොකුම අන්තරායන් මොනවාද?

වඩාත්ම භයානක වැරැද්ද නම් C++ කේතය නූල්-ආරක්ෂිත නොවන විට එය උපකල්පනය කිරීමයි. ගෝලීය තත්ත්‍වය, ස්ථිතික විචල්‍යයන් සහ නැවත ඇතුළත් නොවන පුස්තකාල ඇමතුම් මගින් රස්ට්‍ගේ සම්පාදකයාට FFI සීමාව හරහා හඳුනාගත නොහැකි දත්ත ධාවන තරඟ ඇති කරයි. රස්ට්ගේ ආරක්‍ෂිත සහතික අනාරක්ෂිත අවහිරය මත නතර වේ — ඇතුළත ඇති සියල්ල ඔබේ වගකීමකි.

ප්‍රධාන තීක්ෂ්ණ බුද්ධිය: මලකඩ තමන්ගේම කේතය තුළ මතක ආරක්ෂාව සහතික කරයි, නමුත් ඔබ C++ වෙත FFI සීමාවක් පසු කරන මොහොතේ, 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++ වස්තු රස්ට්ගේ ණය පරීක්‍ෂාවට සහභාගී නොවේ. C++ තවමත් පොයින්ටරයක් ​​තබාගෙන සිටියදී රස්ට් යොමුවක් වැටේ නම්, ඔබට රෝග විනිශ්චය කිරීමට අපහසු වන භාවිතයෙන් පසු-නිදහස් දෝෂ ලැබේ. දැඩි හිමිකාරිත්ව අර්ථකථන ක්‍රියාත්මක කිරීමෙන් අපි මෙය ආමන්ත්‍රණය කළෙමු: C++ වස්තු සෑම විටම හරියටම එක් රස්ට් දවටනයක් සතු වන අතර, හවුල් ප්‍රවේශය රස්ට් පැත්තේ චාප පදනම් කරගත් යොමු ගණන් කිරීම හරහා සිදුවේ.

කාර්ය සාධනය අනුව, අධික FFI ඇමතුම් සන්දර්භය මාරු කිරීම සහ අනුක්‍රමිකකරණයෙන් පොදු කාර්යක් නිර්මාණය කරයි. අපි හැකි සෑම තැනකදීම මෙහෙයුම් කණ්ඩායම් කරන්නෙමු, තනි තනිව හරස් භාෂා ඇමතුම් ලබා දෙනවාට වඩා වැඩ අයිතම පෝලිමක් C++ ක්‍රියාත්මක කරන්නා වෙත යවමු.

මෙම ප්‍රවේශය නිෂ්පාදනයේදී ක්‍රියාත්මක වූයේ කෙසේද?

අපගේ වේදිකාව හරහා දෙමුහුන් ගෘහ නිර්මාණ ශිල්පය යෙදවීමෙන් පසුව, අපි කොන්ක්රීට් වැඩිදියුණු කිරීම් මැනිය. අනුක්‍රමික C++ සැකසීමේදී කලින් අවහිර වූ මොඩියුල සඳහා ඉල්ලීම් ප්‍රතිදානය 3.4x කින් වැඩි විය. C++ විසින් සිය කැප වූ නූල් මත ගණනය කිරීම් අධික කාර්යයන් හසුරුවන අතර, Rust's async ධාවන කාලයට සමගාමීව ස්වාධීන ඉල්ලීම් ක්‍රියා කළ හැකි නිසා Tail latency (p99) 61% කින් පහත වැටුනි.

වඩාත් වැදගත් දෙය නම්, නිෂ්පාදනයේ පළමු මාස හය තුළ අපට සමගාමී සම්බන්ධ දෝෂ ශුන්‍ය වී තිබීමයි. නූල් සීමා කිරීමේ රටාව මඟින් C++ කේතය බහු නූල්වලින් ඇමතීම ව්‍යුහාත්මකව කළ නොහැකි වූ අතර, රස්ට් වර්ගයේ පද්ධතිය එහි මායිමේ පැත්තේ දත්ත ධාවන තරඟ වැළැක්වීය. මෙය අපගේ පෙර ප්‍රවේශයට වඩා සැලකිය යුතු දියුණුවක් වූ අතර එය mutexes සමඟින් C++ වෙත නූල් දැමීම එක් කිරීමට උත්සාහ කළ අතර, එය එක් කාර්තුවක් තුළ ධාවන තත්ත්‍වයේ සිදුවීම් තුනක් ඇති කළේය.

ඉංජිනේරු කණ්ඩායම වේගවත් පුනරාවර්තන චක්‍ර ද වාර්තා කරන ලදී. පවතින C++ මොඩියුල වෙනස් කිරීමකින් තොරව දිගටම ක්‍රියාත්මක වන අතරම, සම්පූර්ණ සමගාමී සහාය ඇතිව නව විශේෂාංග රස්ට් තුළ ගොඩනැගිය හැකිය. මෙම වර්ධක උපාය මාර්ගයෙන් අදහස් කළේ අපට කිසි විටෙක අධි අවදානම් සහිත "මහා පිපිරුම්" සංක්‍රමණයක් නොතිබූ බවයි — හුදෙක් ස්ථාවර, මැනිය හැකි දියුණුවක්.

නිතර අසන ප්‍රශ්න

රස්ට් හට වෙනස් කිරීමකින් තොරව තනි නූල් සහිත C++ පුස්තකාල ඇමතීමට හැකිද?

ඔව්, නමුත් ඔබ එම පුස්තකාලයට ලැබෙන සියලුම ඇමතුම් තනි නූලකින් සිදු වන බවට සහතික විය යුතුය. සම්මත රටාව වන්නේ නාලිකාවක් හරහා සියලුම C++ ඇමතුම් අනුක්‍රමික කරන කැපවූ ක්‍රියාත්මක නූලක් නිර්මාණය කිරීමයි. රස්ට්ගේ අසමමුහුර්ත කාර්යයන් බහු-නූල් ධාවන කාලය අවහිර නොකර ඉල්ලීම් ඉදිරිපත් කරන අතර ප්‍රතිචාර බලාපොරොත්තු වේ. C++ කේතයට කිසිදු වෙනසක් අවශ්‍ය නොවේ - ආරක්‍ෂිත සීමාව සම්පූර්ණයෙන්ම රස්ට් පැත්තේ ක්‍රියාත්මක වේ.

යෙදුම් කාර්ය සාධනයට බලපෑම් කිරීමට තරම් FFI පොදු කාර්ය සැලකිය යුතුද?

තනි පුද්ගල FFI ඇමතුම් සඳහා අවම පොදු කාර්ය ඇත - සාමාන්‍යයෙන් සරල ක්‍රියාකාරී ඇමතුමක් සඳහා නැනෝ තත්පර 10ට අඩුය. කෙසේ වෙතත්, ඔබ සියුම් ඇමතුම් දහස් ගණනක් කරන්නේ නම්, සංකීර්ණ දත්ත ව්‍යුහයන් අනුක්‍රමිකකරණය කිරීම සහ මායිමේ නූල් සමමුහුර්ත කිරීම එකතු වේ. Batching මෙහෙයුම් සහ FlatBuffers හෝ Cap'n Proto වැනි ශුන්‍ය-පිටපත් අනුක්‍රමික ආකෘති භාවිතා කිරීම පරිමාණයෙන් වුවද උඩිස් නොසැලකිලිමත් ලෙස තබා ගනී.

අතුරුමුහුණත් කරනවා වෙනුවට අපි අපගේ C++ කේත පදනම Rust වලින් නැවත ලිවිය යුතුද?

බොහෝ කණ්ඩායම් සඳහා, වර්ධක අතුරුමුහුණත ආරක්ෂිත සහ වේගවත් මාර්ගය වේ. සම්පූර්ණ නැවත ලිවීමක් සම්පූර්ණ වන තෙක් පරිශීලක-මුහුණු අගයක් නොමැතිව මාස ගණනක ඉංජිනේරු අවදානමක් හඳුන්වා දෙයි. අතුරුමුහුණත මඟින් ඔබට වැඩිදියුණු කිරීම් ක්ෂණිකව නැව්ගත කිරීමට, නිෂ්පාදනයේ රස්ට් ප්‍රවේශය වලංගු කිරීමට සහ සමගාමීත්වය වැඩි බලපෑමක් ලබා දෙන ස්ථානය මත පදනම්ව වරකට මොඩියුල සංක්‍රමණය කිරීමට ඉඩ සලසයි. FFI සීමාව නඩත්තු කිරීමේ පිරිවැය නැවත ලිවීමේ පිරිවැය ඉක්මවන මොඩියුල පමණක් නැවත ලියන්න.

Mewayz හිදී, අපි තාක්‍ෂණිකව සහ ක්‍රියාකාරීව පරිමාණය කරන යටිතල පහසුකම් ගොඩනඟමු. අපගේ 207-මොඩියුල ව්‍යාපාරික OS කණ්ඩායම් 138,000කට මසකට ඩොලර් 19කින් ආරම්භ වන වඩා හොඳ කාර්ය ප්‍රවාහයන් ක්‍රියාත්මක කිරීමට උදවු කරයි. ඔබ ව්‍යාපෘති කළමනාකරණය කරන්නේද, මෙහෙයුම් ස්වයංක්‍රීය කරන්නේද, හෝ ඔබේ ව්‍යාපාරය පරිමාණය කරන්නේද, Mewayz ඔබ වැඩ කරන ආකාරයට අනුගත වේ. app.mewayz.com හි ඔබගේ නොමිලේ අත්හදා බැලීම අරඹන්න සහ නවීන ව්‍යාපාරික OS එකකට ඔබේ කණ්ඩායම සඳහා කළ හැකි දේ බලන්න.