ჩვენ დავაკავშირეთ ერთძაფის C++ მრავალძაფის ჟანგთან

ერთნაკადიანი C++ კოდის დაკავშირება მრავალ ხრახნიან Rust-თან არა მხოლოდ შესაძლებელია — ეს არის ერთ-ერთი ყველაზე პრაქტიკული გზა ძველი სისტემების მოდერნიზაციისთვის სრული გადაწერის გარეშე. Mewayz-ში ჩვენ ზუსტად ამ გამოწვევას გავუმკლავდით, როდესაც ჩვენი 207 მოდულიანი ბიზნეს ოპერაციული ოპერაციული სისტემა გავზარდეთ 138 000 მომხმარებლისთვის და შედეგებმა ძირეულად შეცვალა ჩვენი აზროვნება სისტემების თავსებადობაზე.

რატომ უნდა დააკავშიროთ ერთნაკადიანი C++ მრავალძაფის ჟანგით?

წარმოების სისტემების უმეტესობას აქვს წლების განმავლობაში გამოცდილი C++ კოდი. Rust-ში ყველაფრის ხელახლა გადაწერა ქაღალდზე მიმზიდველად ჟღერს, მაგრამ ეს იწვევს უზარმაზარ რისკს და თვეების საინჟინრო დროს. პრაგმატული მიდგომა არის თანდათანობითი მიღება - არსებული C++ ლოგიკის შეფუთვა, ხოლო თანმხლები დატვირთვის დატვირთვა Rust-ის მფლობელობის მოდელზე.

ჩვენს შემთხვევაში, ძირითადი ბიზნეს ლოგიკის მოდულები წლების განმავლობაში საიმედოდ მუშაობდა ერთნაკადიანი C++-ში. ისინი ამუშავებდნენ დავალების თანმიმდევრულ დამუშავებას, დოკუმენტების შექმნას და ფინანსურ გამოთვლებს. მაგრამ როდესაც ჩვენი მომხმარებელთა ბაზა გაიზარდა 100 ათასს გადააჭარბა, ჩვენ გვჭირდებოდა მონაცემთა პარალელური დამუშავება, API–ს ერთდროული დამუშავება და უსაფრთხო საერთო სახელმწიფო მენეჯმენტი. Rust-ის Send და Sync მახასიათებლებმა მოგვცა კომპილაციის დროის თანმხლები გარანტიები, რომ C++ უბრალოდ ვერ შემოგთავაზებთ ფართო ხელით აუდიტის გარეშე.

მთავარი მოტივაცია რისკის შემცირებაა. თქვენ ინახავთ იმას, რაც მუშაობს და ამატებთ რა მასშტაბებს — თქვენი მთელი კოდის ბაზის აზარტული თამაშების გარეშე მიგრაციაზე, რომელიც შეიძლება არასოდეს დასრულდეს.

როგორ მუშაობს FFI საზღვარი რეალურად?

გარე ფუნქციის ინტერფეისი (FFI) C++-სა და Rust-ს შორის მუშაობს C-თან თავსებადი ფუნქციის ხელმოწერების მეშვეობით. Rust-ის გარე "C" ბლოკები ამჟღავნებს ფუნქციებს, რომელთა გამოძახებაც C++-ს შეუძლია პირდაპირ და პირიქით. კრიტიკული გამოწვევა ჩნდება მაშინ, როდესაც Rust-ის მრავალ ხრახნიანი გაშვების დრო სჭირდება უსაფრთხოდ გამოიძახოს ერთნაკადიანი C++ კოდი.

ჩვენ ეს მოვაგვარეთ გამოყოფილი არქიტექტურის გამოყენებით:

• ძაფით შეზღუდული C++ შემსრულებელი: ყველა C++ ზარი გადის ერთი გამოყოფილი ძაფით, შეტყობინების გადაცემის არხის გამოყენებით, რაც უზრუნველყოფს ერთნაკადიანი უცვლელი არასოდეს დაირღვეს.
• Rust async bridge layer: Tokio-ს ამოცანები წარუდგენს სამუშაოს C++ შემსრულებელს და ელოდება შედეგებს oneshot არხების მეშვეობით, ინარჩუნებს Rust-ის მხარეს სრულად ასინქრონულს.
• გაუმჭვირვალე ინდიკატორის მართვა: C++ ობიექტები შეფუთულია Rust სტრუქტურებში, რომლებიც ახორციელებენ Drop განმსაზღვრელი გასუფთავებისთვის, რაც ხელს უშლის მეხსიერების გაჟონვას ენის საზღვრებს შორის.
• სერიალიზაცია საზღვარზე: მონაცემთა რთული სტრუქტურები სერიულირდება FlatBuffers-ზე FFI ფენაზე, რაც თავიდან აიცილებს მყიფე სტრუქტურის განლაგების შესაბამისობას და საშუალებას აძლევს თითოეული მხარის დამოუკიდებელ ევოლუციას.
• პანიკის იზოლაცია: Rust-ის catch_unwind ახვევს ყველა FFI შესვლის წერტილს ისე, რომ პანიკა არასოდეს გადაკვეთს ენის საზღვარს, რაც იქნება განუსაზღვრელი ქცევა.

ამ შაბლონმა მოგვცა მრავალძაფიანი Rust-ის გამტარუნარიანობა დადასტურებული C++ ლოგიკის საიმედოობით — ორიგინალური ბიზნეს წესების ერთი ხაზის გადაწერის გარეშე.

რა არის ყველაზე დიდი ხარვეზების თავიდან აცილება?

ყველაზე საშიში შეცდომაა ვივარაუდოთ, რომ C++ კოდი უსაფრთხოა ნაკადისთვის, როდესაც ის ასე არ არის. გლობალური მდგომარეობა, სტატიკური ცვლადები და ბიბლიოთეკის გამოძახებები გამოიწვევს მონაცემთა რბოლას, რომელსაც Rust-ის შემდგენელი ვერ აღმოაჩენს FFI საზღვრებში. Rust-ის უსაფრთხოების გარანტიები ჩერდება არაუსაფრთხო ბლოკზე — ყველაფერი შიგნით არის თქვენი პასუხისმგებლობა.

ძირითადი შეხედულება: 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,4-ჯერ იმ მოდულებისთვის, რომლებიც ადრე დგებოდა C++ თანმიმდევრულ დამუშავებაზე. კუდის შეყოვნება (p99) დაეცა 61%-ით, რადგან Rust-ის ასინქრონული გაშვების დრო ერთდროულად ამუშავებდა დამოუკიდებელ მოთხოვნებს, ხოლო C++ ასრულებდა გამოთვლით მძიმე ამოცანებს თავის გამოყოფილ თემაში.

რაც მთავარია, წარმოების პირველ ექვს თვეში ჩვენ არ გვქონდა კონკურენტულობასთან დაკავშირებული შეცდომები. ძაფების შეზღუდვის ნიმუში სტრუქტურულად შეუძლებელს ხდიდა C++ კოდის გამოძახებას მრავალი ძაფიდან, ხოლო Rust-ის ტიპის სისტემა ხელს უშლიდა მონაცემთა რბოლას საზღვრის მის მხარეს. ეს იყო მნიშვნელოვანი გაუმჯობესება ჩვენს წინა მიდგომასთან შედარებით, როდესაც ვცდილობდით C++-ზე threading-ს დავამატოთ mutexes-ით, რამაც გამოიწვია სამი რასის ინციდენტი ერთ კვარტალში.

საინჟინრო ჯგუფმა ასევე იტყობინება უფრო სწრაფი გამეორების ციკლები. ახალი ფუნქციები შეიძლება აშენდეს Rust-ში სრული კონკურენტული მხარდაჭერით, ხოლო არსებული C++ მოდულები აგრძელებდნენ მუშაობას ცვლილების გარეშე. ეს დამატებითი სტრატეგია ნიშნავს, რომ ჩვენ არასდროს გვქონია მაღალი რისკის "დიდი აფეთქების" მიგრაცია — უბრალოდ სტაბილური, გაზომვადი გაუმჯობესება.

ხშირად დასმული კითხვები

შეუძლია თუ არა Rust-ს გამოძახება ერთნაკადიანი C++ ბიბლიოთეკების ცვლილების გარეშე?

დიახ, მაგრამ თქვენ უნდა უზრუნველყოთ, რომ ამ ბიბლიოთეკაში ყველა ზარი განხორციელდეს ერთი თემიდან. სტანდარტული ნიმუში არის გამოყოფილი შემსრულებელი ძაფის შექმნა, რომელიც ახორციელებს ყველა C++ ზარს არხის მეშვეობით. Rust-ის ასინქრონული ამოცანები აგზავნიან მოთხოვნებს და ელოდება პასუხებს მრავალნაკადიანი მუშაობის დროის დაბლოკვის გარეშე. თავად C++ კოდი არ საჭიროებს ცვლილებებს — უსაფრთხოების შეზღუდვა მთლიანად მოქმედებს Rust-ის მხარეს.

არის თუ არა FFI ზედნადები საკმარისად მნიშვნელოვანი, რომ გავლენა მოახდინოს აპლიკაციის შესრულებაზე?

ინდივიდუალურ FFI ზარებს აქვთ მინიმალური ზედნადები — როგორც წესი, 10 ნანოწამზე ნაკლები მარტივი ფუნქციის ზარისთვის. თუმცა, მონაცემთა რთული სტრუქტურების სერიულიზაცია და ძაფების სინქრონიზაცია საზღვრებზე ემატება, თუ ათასობით წვრილმარცვლოვან ზარს განახორციელებთ. Batching ოპერაციები და ნულოვანი ასლი სერიულიზაციის ფორმატების გამოყენება, როგორიცაა FlatBuffers ან Cap'n Proto, ზედნადებს ინარჩუნებს უმნიშვნელო მასშტაბითაც კი.

ჩვენი C++ კოდების ბაზა უნდა გადავწეროთ Rust-ში ინტერფეისის ნაცვლად?

გუნდების უმეტესობისთვის დამატებითი ინტერფეისი უფრო უსაფრთხო და სწრაფი გზაა. სრული გადაწერა შემოაქვს თვეების საინჟინრო რისკს დასრულებამდე მომხმარებლისთვის მნიშვნელობის გარეშე. ინტერფეისი საშუალებას გაძლევთ დაუყოვნებლივ გაგზავნოთ გაუმჯობესებები, დაადასტუროთ Rust-ის მიდგომა წარმოებაში და გადაიტანოთ მოდულები სათითაოდ იმის მიხედვით, თუ სად მოაქვს ერთდროულობა ყველაზე მეტ გავლენას. გადაწერეთ მხოლოდ ის მოდულები, სადაც FFI საზღვრის შენარჩუნების ღირებულება აღემატება გადაწერის ღირებულებას.

Mewayz-ში ჩვენ ვაშენებთ მასშტაბურ ინფრასტრუქტურას - ტექნიკურად და ოპერაციულად. ჩვენი 207 მოდულიანი ბიზნეს ოპერაციული სისტემა ეხმარება 138000 გუნდს აწარმოოს უფრო გონივრული სამუშაო ნაკადები, დაწყებული $19/თვეში. მიუხედავად იმისა, თქვენ მართავთ პროექტებს, ავტომატიზირებთ ოპერაციებს, ან აფართოებთ თქვენს ბიზნესს, Mewayz ადაპტირდება თქვენს მუშაობასთან. დაიწყეთ უფასო საცდელი ვერსია app.mewayz.com-ზე და ნახეთ, რისი გაკეთება შეუძლია თანამედროვე ბიზნეს ოპერაციულ სისტემას თქვენი გუნდისთვის.