Fe wnaethon ni Ryngwynebu C++ Edau Sengl â Rhwd Aml-Edefyn

Mae rhyngwynebu cod C++ un edafedd â Rust aml-edau nid yn unig yn bosibl - mae'n un o'r ffyrdd mwyaf ymarferol o foderneiddio systemau etifeddiaeth heb ailysgrifennu llawn. Yn Mewayz, aethom i'r afael â'r union her hon wrth raddio ein OS busnes 207-modiwl i wasanaethu 138,000 o ddefnyddwyr, a newidiodd y canlyniadau yn sylfaenol sut yr ydym yn meddwl am ryngweithredu systemau.

Pam Fyddech chi'n Rhyngwynebu C++ Edau Sengl â Rhwd Aml-Edefyn?

Mae gan y rhan fwyaf o systemau cynhyrchu flynyddoedd o god C++ a brofwyd gan frwydr. Mae ailysgrifennu popeth yn Rust yn swnio'n apelgar ar bapur, ond mae'n cyflwyno risg enfawr a misoedd o amser peirianneg. Y dull pragmatig yw mabwysiadu cynyddrannol - gan lapio'r rhesymeg C++ bresennol wrth ddadlwytho llwythi gwaith trwm arian cyfred i fodel perchnogaeth Rust.

Yn ein hachos ni, roedd modiwlau rhesymeg busnes craidd wedi bod yn rhedeg yn ddibynadwy mewn C++ un edau ers blynyddoedd. Buont yn ymdrin â phrosesu tasgau dilyniannol, cynhyrchu dogfennau, a chyfrifiadau ariannol. Ond wrth i'n sylfaen defnyddwyr dyfu y tu hwnt i 100K, roedd angen prosesu data cyfochrog, trin API cydamserol, a rheoli cyflwr a rennir yn ddiogel. Roedd nodweddion Send a Sync Rust yn rhoi gwarantau cydamserol amser llunio i ni na allai C++ eu cynnig heb archwiliad llaw helaeth.

Y cymhelliad allweddol yw lleihau risg. Rydych chi'n cadw'r hyn sy'n gweithio, ac rydych chi'n ychwanegu pa raddfeydd - heb gamblo'ch sylfaen cod cyfan ar fudo na fyddai byth yn gorffen.

Sut Mae Ffin y FFI yn Gweithio Mewn Gwirionedd?

Mae'r Rhyngwyneb Swyddogaeth Tramor (FFI) rhwng C++ a Rust yn gweithredu trwy lofnodion ffwythiant sy'n gydnaws â C. Mae blociau extern "C" Rust yn amlygu swyddogaethau y gall C++ eu galw'n uniongyrchol, ac i'r gwrthwyneb. Daw'r her hollbwysig i'r amlwg pan fydd angen i amser rhedeg aml-edau Rust ddefnyddio cod C++ un edau yn ddiogel.

Rydym wedi datrys hyn gan ddefnyddio pensaernïaeth bwrpasol:

• Edefyn C++ wedi'i gyfyngu i edau: Mae pob galwad C++ yn cael ei sianelu drwy un edefyn pwrpasol gan ddefnyddio sianel sy'n pasio neges, gan sicrhau nad yw'r amrywiad un edau byth yn cael ei dorri.
• Haen pont async rhwd: Mae tasgau Tokio yn cyflwyno gwaith i'r ysgutor C++ ac aros canlyniadau trwy sianeli un llun, gan gadw ochr Rust yn gwbl anghydamserol.
• Rheoli pwyntydd afloyw: Mae gwrthrychau C++ wedi'u lapio mewn strwythurau Rust sy'n gweithredu Drop ar gyfer glanhau penderfyniaethol, gan atal gollyngiadau cof ar draws ffin yr iaith.
• Cyfresi ar y ffin: Mae strwythurau data cymhleth yn cael eu cyfresoli i FlatBuffers ar yr haen FFI, gan osgoi paru cynllun strwythur bregus a galluogi esblygiad annibynnol o bob ochr.
• Ynysu panig: Mae catch_unwind Rust yn lapio pob pwynt mynediad FFI fel nad yw panig byth yn croesi ffin yr iaith, a fyddai'n ymddygiad anniffiniedig.

Rhoddodd y patrwm hwn y mewnbwn o Rust aml-edau i ni gyda dibynadwyedd rhesymeg C++ profedig - heb ailysgrifennu llinell sengl o'r rheolau busnes gwreiddiol.

Beth Yw'r Peryglon Mwyaf i'w Osgoi?

Y camgymeriad mwyaf peryglus yw cymryd bod cod C++ yn edau-ddiogel pan nad yw. Bydd cyflwr byd-eang, newidynnau statig, a galwadau llyfrgell nad ydynt yn dychwelyd yn achosi rasys data na all casglwr Rust eu canfod ar draws ffin yr FFI. Mae gwarantau diogelwch Rust yn stopio wrth y bloc anniogel - eich cyfrifoldeb chi yw popeth y tu mewn.

Mewnwelediad allweddol: Mae Rust yn gwarantu diogelwch cof o fewn ei god ei hun, ond yr eiliad y byddwch chi'n croesi ffin FFI i C++, rydych chi'n etifeddu pob problem diogelwch edefyn sydd gan C++. Mae'r bensaernïaeth o amgylch y ffin honno yn bwysicach na'r cod ar y naill ochr iddo.

💡 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 →

Perygl cyffredin arall yw rheoli oes. Nid yw gwrthrychau C++ yn cymryd rhan yn gwiriwr benthyciadau Rust. Os yw Rust yn gollwng geirda tra bod C ++ yn dal i ddal pwyntydd, byddwch chi'n cael bygiau di-ddefnydd sy'n anodd iawn eu diagnosio. Aethom i'r afael â hyn drwy orfodi semanteg perchnogaeth lem: mae gwrthrychau C++ bob amser yn eiddo i un peiriant lapio Rust yn union, ac mae mynediad a rennir yn mynd trwy gyfeirnod Arc sy'n cyfrif ar yr ochr Rust.

Mae galwadau FFI gormodol o ran perfformiad yn creu gorbenion o newid cyd-destun a chyfresoli. Rydym yn sypio gweithrediadau lle bynnag y bo modd, gan anfon ciw o eitemau gwaith at yr ysgutor C++ yn hytrach na gwneud galwadau traws-iaith unigol.

Sut Perfformiodd y Dull Hwn o Gynhyrchu?

Ar ôl defnyddio'r bensaernïaeth hybrid ar draws ein platfform, fe wnaethom fesur gwelliannau concrit. Cynyddodd trwybwn ceisiadau 3.4x ar gyfer modiwlau a oedd yn flaenorol yn dagfa ar brosesu dilyniannol C++. Gostyngodd hwyrni cynffon (t99) 61% oherwydd gallai amser rhedeg async Rust brosesu ceisiadau annibynnol ar yr un pryd tra bod C++ yn trin tasgau cyfrifiadurol-trwm ar ei edefyn pwrpasol.

Yn bwysicach fyth, ni chawsom unrhyw fygiau yn ymwneud ag arian cyfred yn ystod chwe mis cyntaf y cynhyrchiad. Roedd y patrwm cyfyngu edau yn ei gwneud hi'n amhosibl yn strwythurol i god C ++ gael ei alw o edafedd lluosog, tra bod system fath Rust yn atal rasys data ar ei ochr i'r ffin. Roedd hyn yn welliant sylweddol ar ein dull blaenorol o geisio ychwanegu edafu at C++ gyda mutexes, a oedd wedi cynhyrchu tri digwyddiad cyflwr hil mewn un chwarter.

Nododd y tîm peirianneg hefyd gylchoedd iteru cyflymach. Gellid adeiladu nodweddion newydd yn Rust gyda chefnogaeth arian cyfred llawn, tra bod modiwlau C ++ presennol yn parhau i redeg heb eu haddasu. Roedd y strategaeth gynyddrannol hon yn golygu na chawsom erioed fudo “clec fawr” risg uchel - dim ond gwelliant cyson, mesuradwy.

Cwestiynau Cyffredin

All Rust ffonio llyfrgelloedd C++ un edau heb eu haddasu?

Ie, ond rhaid i chi sicrhau bod pob galwad i'r llyfrgell honno'n digwydd o un edefyn. Y patrwm safonol yw creu edefyn ysgutor pwrpasol sy'n cyfresoli pob galwad C ++ trwy sianel. Mae tasgau async Rust yn cyflwyno ceisiadau ac yn aros am ymatebion heb rwystro'r amser rhedeg aml-edau. Nid oes angen unrhyw newidiadau i'r cod C++ ei hun - mae'r cyfyngiad diogelwch yn cael ei orfodi'n gyfan gwbl ar ochr Rust.

A yw'r gorbenion FFI yn ddigon sylweddol i effeithio ar berfformiad y cais?

Ychydig iawn o orbenion sydd gan alwadau FFI unigol - fel arfer llai na 10 nanoeiliad ar gyfer galwad swyddogaeth syml. Fodd bynnag, mae cyfresoli strwythurau data cymhleth a chydamseru edau ar y ffin yn adio i fyny os gwnewch filoedd o alwadau manwl. Mae sypynnu gweithrediadau a defnyddio fformatau cyfresoli sero-copi fel FlatBuffers neu Cap'n Proto yn cadw'r gorbenion yn ddibwys hyd yn oed ar raddfa.

A ddylem ni ailysgrifennu ein sylfaen cod C++ yn Rust yn lle rhyngwynebu?

I’r rhan fwyaf o dimau, rhyngwynebu cynyddrannol yw’r llwybr mwy diogel a chyflymach. Mae ailysgrifennu llawn yn cyflwyno misoedd o risg peirianneg heb unrhyw werth i'r defnyddiwr nes ei gwblhau. Mae rhyngwynebu yn caniatáu ichi anfon gwelliannau ar unwaith, dilysu'r dull Rust wrth gynhyrchu, a mudo modiwlau un ar y tro yn seiliedig ar ble mae arian cyfred yn sicrhau'r effaith fwyaf. Ailysgrifennu'r modiwlau dim ond lle mae'r gost o gynnal ffin yr FFI yn fwy na chost ailysgrifennu.

Yn Mewayz, rydym yn adeiladu seilwaith sydd ar raddfa fawr - yn dechnegol ac yn weithredol. Mae ein AO busnes 207-modiwl yn helpu 138,000 o dimau i redeg llifoedd gwaith craffach gan ddechrau ar $ 19 / mis. P'un a ydych chi'n rheoli prosiectau, yn awtomeiddio gweithrediadau, neu'n graddio'ch busnes, mae Mewayz yn addasu i'r ffordd rydych chi'n gweithio. Dechreuwch eich treial am ddim yn app.mewayz.com a gweld beth all OS busnes modern ei wneud i'ch tîm.