QEMU.js៖ ឥឡូវនេះធ្ងន់ធ្ងរហើយជាមួយ WASM

មានពេលមួយខ្ញុំសម្រេចចិត្តលេងសើច បង្ហាញពីភាពបញ្ច្រាសនៃដំណើរការ និងរៀនពីរបៀបបង្កើត JavaScript (កាន់តែច្បាស់ Asm.js) ពីកូដម៉ាស៊ីន។ QEMU ត្រូវបានជ្រើសរើសសម្រាប់ការពិសោធន៍ ហើយបន្តិចក្រោយមក អត្ថបទមួយត្រូវបានសរសេរនៅលើ Habr ។ នៅក្នុងមតិយោបល់ខ្ញុំត្រូវបានគេណែនាំឱ្យធ្វើគម្រោងឡើងវិញនៅក្នុង WebAssembly ហើយថែមទាំងឈប់ខ្លួនឯងទៀតផង។ ជិតរួចរាល់ហើយ។ ខ្ញុំមិនចង់បានគម្រោងទេ... ការងារកំពុងបន្ត ប៉ុន្តែយឺតណាស់ ហើយឥឡូវនេះ ថ្មីៗនេះ នៅក្នុងអត្ថបទនោះបានលេច អត្ថាធិប្បាយ លើប្រធានបទ "តើវាបញ្ចប់ដោយរបៀបណា?" ជាការឆ្លើយតបទៅនឹងចម្លើយលម្អិតរបស់ខ្ញុំ ខ្ញុំបានលឺថា "នេះស្តាប់ទៅដូចជាអត្ថបទមួយ"។ ជាការប្រសើរណាស់, ប្រសិនបើអ្នកអាចធ្វើបាន, នឹងមានអត្ថបទមួយ។ ប្រហែលជាមាននរណាម្នាក់យល់ថាវាមានប្រយោជន៍។ ពីវា អ្នកអាននឹងរៀនការពិតមួយចំនួនអំពីការរចនានៃកម្មវិធីខាងក្រោយនៃការបង្កើតកូដ QEMU ក៏ដូចជារបៀបសរសេរកម្មវិធីចងក្រង Just-in-Time សម្រាប់កម្មវិធីគេហទំព័រ។

ភារកិច្ច

ដោយសារខ្ញុំបានរៀនពីរបៀប "ដូចម្ដេច" ច្រក QEMU ទៅ JavaScript នៅពេលនេះ វាត្រូវបានសម្រេចចិត្តធ្វើវាដោយប្រាជ្ញា និងមិនធ្វើកំហុសចាស់ម្តងទៀត។

កំហុសលេខមួយ៖ សាខាពីការចេញផ្សាយចំណុច

កំហុសដំបូងរបស់ខ្ញុំគឺការបំបែកកំណែរបស់ខ្ញុំចេញពីកំណែ 2.4.1 ខាងលើ។ បន្ទាប់មកវាហាក់ដូចជាខ្ញុំជាគំនិតដ៏ល្អមួយ៖ ប្រសិនបើការចេញផ្សាយចំណុចមាន នោះវាប្រហែលជាមានស្ថេរភាពជាងសាមញ្ញ 2.4 ហើយសូម្បីតែច្រើនទៀតដូច្នេះសាខា master. ហើយចាប់តាំងពីខ្ញុំគ្រោងនឹងបន្ថែមចំនួនត្រឹមត្រូវនៃកំហុសផ្ទាល់ខ្លួនរបស់ខ្ញុំ ខ្ញុំមិនត្រូវការនរណាម្នាក់ផ្សេងទៀតទាល់តែសោះ។ នោះហើយជារបៀបដែលវាបានប្រែក្លាយ។ ប៉ុន្តែនេះគឺជារឿង៖ QEMU មិននៅស្ងៀមទេ ហើយនៅចំណុចខ្លះពួកគេថែមទាំងបានប្រកាសពីការបង្កើនប្រសិទ្ធភាពនៃកូដដែលបានបង្កើត 10 ភាគរយ។ "មែនហើយ ឥឡូវនេះខ្ញុំនឹងបង្កក" ខ្ញុំបានគិតហើយខូចចិត្ត។ នៅទីនេះយើងត្រូវធ្វើការបកស្រាយ៖ ដោយសារតែធម្មជាតិនៃខ្សែតែមួយនៃ QEMU.js និងការពិតដែលថា QEMU ដើមមិនបញ្ជាក់ពីអវត្តមាននៃខ្សែពហុខ្សែទេ (នោះគឺសមត្ថភាពក្នុងការដំណើរការក្នុងពេលដំណាលគ្នានូវផ្លូវកូដដែលមិនទាក់ទងគ្នាជាច្រើន និង មិនមែនគ្រាន់តែ "ប្រើខឺណែលទាំងអស់") គឺសំខាន់សម្រាប់វា មុខងារចម្បងនៃខ្សែស្រឡាយដែលខ្ញុំត្រូវ "បើកវាចេញ" ដើម្បីអាចហៅពីខាងក្រៅបាន។ នេះបានបង្កើតបញ្ហាធម្មជាតិមួយចំនួនក្នុងអំឡុងពេលរួមបញ្ចូលគ្នា។ ទោះជាយ៉ាងណា, ការពិតដែលថាមួយចំនួននៃការផ្លាស់ប្តូរពីសាខា masterជាមួយនឹងការដែលខ្ញុំបានព្យាយាមបញ្ចូលលេខកូដរបស់ខ្ញុំក៏ត្រូវបានជ្រើសរើសផងដែរក្នុងការចេញផ្សាយចំណុច (ហើយដូច្នេះនៅក្នុងសាខារបស់ខ្ញុំ) ក៏ប្រហែលជាមិនមានភាពងាយស្រួលបន្ថែមដែរ។

ជាទូទៅ ខ្ញុំបានសម្រេចចិត្តថាវានៅតែសមហេតុផលក្នុងការបោះចោលគំរូដើម ផ្តាច់វាសម្រាប់ផ្នែកនានា និងបង្កើតកំណែថ្មីពីដំបូងដោយផ្អែកលើអ្វីដែលថ្មីជាងនេះ ហើយឥឡូវនេះពី master.

កំហុសលេខពីរ៖ វិធីសាស្ត្រ TLP

សរុបមក នេះមិនមែនជាកំហុសទេ ជាទូទៅវាគ្រាន់តែជាលក្ខណៈពិសេសនៃការបង្កើតគម្រោងក្នុងលក្ខខណ្ឌនៃការយល់ខុសទាំងស្រុងនៃ "កន្លែងណា និងរបៀបផ្លាស់ទី?" ហើយជាទូទៅ "តើយើងនឹងទៅដល់ទីនោះ?" នៅក្នុងលក្ខខណ្ឌទាំងនេះ ការសរសេរកម្មវិធីមិនច្បាស់ គឺជាជម្រើសដ៏ត្រឹមត្រូវមួយ ប៉ុន្តែតាមធម្មជាតិ ខ្ញុំមិនចង់ធ្វើវាឡើងវិញដោយមិនចាំបាច់នោះទេ។ លើកនេះខ្ញុំចង់ធ្វើវាដោយឈ្លាសវៃ៖ ការប្តេជ្ញាចិត្តអាតូមិក ការផ្លាស់ប្តូរកូដដោយដឹងខ្លួន (និងមិនមែន "ការដាក់តួអក្សរចៃដន្យជាមួយគ្នារហូតទាល់តែវាចងក្រង (ជាមួយការព្រមាន)" ដូចដែល Linus Torvalds ធ្លាប់និយាយអំពីនរណាម្នាក់ នេះបើយោងតាម ​​Wikiquote) ។ល។

កំហុសទី 3: ចូលទៅក្នុងទឹកដោយមិនដឹង ford

ខ្ញុំនៅតែមិនទាន់បានកម្ចាត់វាចោលទាំងស្រុងនៅឡើយទេ ប៉ុន្តែឥឡូវនេះខ្ញុំបានសម្រេចចិត្តមិនដើរតាមមាគ៌ានៃការតស៊ូតិចបំផុត ហើយធ្វើវាតាម "វិធីដែលធំឡើង" ពោលគឺសរសេរកម្មវិធីខាងក្រោយ TCG របស់ខ្ញុំពីដំបូង ដើម្បីកុំឱ្យ ត្រូវតែនិយាយនៅពេលក្រោយថា "បាទ នេះជាការពិត យឺតៗ ប៉ុន្តែខ្ញុំមិនអាចគ្រប់គ្រងអ្វីៗទាំងអស់បានទេ - នោះហើយជារបៀបដែល TCI ត្រូវបានសរសេរ ... " ជាងនេះទៅទៀត នេះហាក់បីដូចជាជាដំណោះស្រាយជាក់ស្តែងតាំងពីដំបូងមកម្ល៉េះ ខ្ញុំបង្កើតកូដគោលពីរ. ដូចដែលពួកគេនិយាយថា "Ghent បានប្រមូលផ្តុំуប៉ុន្តែមិនមែនមួយនោះទេ”៖ ពិតណាស់កូដគឺប្រព័ន្ធគោលពីរ ប៉ុន្តែការគ្រប់គ្រងមិនអាចផ្ទេរទៅវាដោយសាមញ្ញបានទេ - វាត្រូវតែត្រូវបានរុញចូលទៅក្នុងកម្មវិធីរុករកយ៉ាងច្បាស់សម្រាប់ការចងក្រង ជាលទ្ធផលនៅក្នុងវត្ថុជាក់លាក់មួយពី JS world ដែលនៅតែត្រូវការ ត្រូវបានរក្សាទុកនៅកន្លែងណាមួយ។ ទោះយ៉ាងណាក៏ដោយ នៅលើស្ថាបត្យកម្ម RISC ធម្មតា តាមដែលខ្ញុំយល់ ស្ថានភាពធម្មតាគឺតម្រូវការដើម្បីកំណត់ឡើងវិញយ៉ាងច្បាស់នូវឃ្លាំងសម្ងាត់ការណែនាំសម្រាប់កូដដែលបានបង្កើតឡើងវិញ - ប្រសិនបើនេះមិនមែនជាអ្វីដែលយើងត្រូវការទេ ក្នុងករណីណាក៏ដោយ វាជិតដល់ហើយ។ លើសពីនេះទៀត ពីការប៉ុនប៉ងចុងក្រោយរបស់ខ្ញុំ ខ្ញុំបានដឹងថាការគ្រប់គ្រងហាក់ដូចជាមិនត្រូវបានផ្ទេរទៅផ្នែកកណ្តាលនៃប្លុកបកប្រែ ដូច្នេះយើងពិតជាមិនត្រូវការ bytecode ដែលត្រូវបានបកស្រាយពីអុហ្វសិតណាមួយនោះទេ ហើយយើងអាចបង្កើតវាដោយសាមញ្ញពីមុខងារនៅលើ TB .

ពួកគេបានមកទាត់

ទោះបីជាខ្ញុំចាប់ផ្តើមសរសេរកូដឡើងវិញនៅក្នុងខែកក្កដាក៏ដោយ ប៉ុន្តែការទាត់វេទមន្តបានផ្ទុះឡើងដោយមិនមាននរណាកត់សម្គាល់៖ ជាធម្មតាសំបុត្រពី GitHub មកដល់ជាការជូនដំណឹងអំពីការឆ្លើយតបទៅនឹងសំណើបញ្ហា និងការទាញ ប៉ុន្តែនៅទីនេះ ភ្លាមៗ លើកឡើងនៅក្នុងខ្សែស្រឡាយ Binaryen ជាកម្មវិធីខាងក្រោយ qemu នៅក្នុងបរិបទ "គាត់បានធ្វើអ្វីមួយដូចនោះប្រហែលជាគាត់នឹងនិយាយអ្វីមួយ" ។ យើងកំពុងនិយាយអំពីការប្រើប្រាស់បណ្ណាល័យដែលទាក់ទងរបស់ Emscripten ប៊ីណារីន ដើម្បីបង្កើត WASM JIT ។ ជាការប្រសើរណាស់, ខ្ញុំបាននិយាយថាអ្នកមានអាជ្ញាប័ណ្ណ Apache 2.0 នៅទីនោះ ហើយ QEMU ទាំងមូលត្រូវបានចែកចាយនៅក្រោម GPLv2 ហើយពួកវាមិនឆបគ្នាខ្លាំងណាស់។ ភ្លាមៗនោះវាបានប្រែក្លាយថាអាជ្ញាប័ណ្ណអាចជា ជួសជុលវាតាមរបៀបណាមួយ។ (ខ្ញុំ​មិន​ដឹង៖ ប្រហែល​ជា​ប្ដូរ​វា ប្រហែល​អាជ្ញាប័ណ្ណ​ពីរ ប្រហែល​ជា​មាន​អ្វី​ផ្សេង...)។ នេះ​ជា​ការ​ពិត​ណាស់​ធ្វើ​ឱ្យ​ខ្ញុំ​សប្បាយ​ចិត្ត ព្រោះ​ពេល​នោះ​ខ្ញុំ​បាន​មើល​យ៉ាង​ជិត​ស្និទ្ធ​ហើយ។ ទម្រង់គោលពីរ WebAssembly ហើយខ្ញុំពិតជាសោកស្តាយ និងមិនអាចយល់បាន។ វាក៏មានបណ្ណាល័យមួយដែលនឹងលេបយកប្លុកជាមូលដ្ឋានជាមួយនឹងក្រាហ្វការផ្លាស់ប្តូរ បង្កើតលេខកូដបៃ ហើយថែមទាំងដំណើរការវានៅក្នុងអ្នកបកប្រែផ្ទាល់ ប្រសិនបើចាំបាច់។

បន្ទាប់មកមានច្រើនទៀត លិខិតមួយ។ នៅលើបញ្ជីសំបុត្ររួមរបស់ QEMU ប៉ុន្តែនេះគឺនិយាយអំពីសំណួរ "តើអ្នកណាត្រូវការវា?" ហើយវាគឺ ភ្លាមៗវាបានប្រែក្លាយថាវាចាំបាច់។ យ៉ាងហោចណាស់ អ្នក​អាច​បំបែក​លទ្ធភាព​ក្នុង​ការ​ប្រើប្រាស់​ខាងក្រោម​រួម​គ្នា ប្រសិនបើវា​ដំណើរការ​លឿន​ឬតិច​ជាងនេះ៖

• បើកដំណើរការអ្វីមួយដែលអប់រំដោយមិនចាំបាច់ដំឡើងអ្វីទាំងអស់។
• និម្មិតនៅលើប្រព័ន្ធប្រតិបត្តិការ iOS ដែលយោងទៅតាមពាក្យចចាមអារ៉ាមថាកម្មវិធីតែមួយគត់ដែលមានសិទ្ធិបង្កើតកូដភ្លាមៗគឺម៉ាស៊ីន JS (តើនេះជាការពិតទេ?)
• ការបង្ហាញពី mini-OS - single-floppy, built-in, គ្រប់ប្រភេទនៃ firmware ។ល។

មុខងារកម្មវិធីរុករកតាមអ៊ីនធឺណិត

ដូចដែលខ្ញុំបាននិយាយរួចមកហើយថា QEMU ត្រូវបានភ្ជាប់ទៅនឹង multithreading ប៉ុន្តែកម្មវិធីរុករកមិនមានវាទេ។ មែនហើយ នោះគឺជា ទេ... ដំបូងវាមិនមានទាល់តែសោះ បន្ទាប់មក WebWorkers បានបង្ហាញខ្លួន - តាមដែលខ្ញុំយល់ នេះគឺជាការបញ្ជូនបន្តច្រើនដោយផ្អែកលើការបញ្ជូនសារ ដោយគ្មានអថេរដែលបានចែករំលែក. ជាធម្មតា វាបង្កើតបញ្ហាយ៉ាងសំខាន់នៅពេលបញ្ជូនកូដដែលមានស្រាប់ដោយផ្អែកលើគំរូអង្គចងចាំដែលបានចែករំលែក។ បន្ទាប់មកនៅក្រោមសម្ពាធសាធារណៈវាត្រូវបានអនុវត្តក្រោមឈ្មោះ SharedArrayBuffers. វាត្រូវបានណែនាំជាបណ្តើរៗ ពួកគេបានប្រារព្ធការបើកដំណើរការរបស់វានៅក្នុងកម្មវិធីរុករកផ្សេងៗគ្នា បន្ទាប់មកពួកគេបានប្រារព្ធពិធីចូលឆ្នាំថ្មី ហើយបន្ទាប់មករលាយ... ខ្សែស្រឡាយបង្កើនការរាប់ វាដូចគ្នាទាំងអស់។ វានឹងដំណើរការយ៉ាងត្រឹមត្រូវ។. ដូច្នេះ យើងបិទដំណើរការ multithreading ដោយប្រើអង្គចងចាំដែលបានចែករំលែក។ វាហាក់បីដូចជាក្រោយមកពួកគេបានបើកវាឡើងវិញ ប៉ុន្តែ ដូចដែលវាច្បាស់ពីការពិសោធន៍ដំបូង វានៅមានជីវិតដោយគ្មានវា ហើយប្រសិនបើដូច្នេះ យើងនឹងព្យាយាមធ្វើវាដោយមិនពឹងផ្អែកលើ multithreading ។

លក្ខណៈពិសេសទីពីរគឺភាពមិនអាចទៅរួចនៃឧបាយកលកម្រិតទាបជាមួយជង់៖ អ្នកមិនអាចគ្រាន់តែយក រក្សាទុកបរិបទបច្ចុប្បន្ន ហើយប្តូរទៅថ្មីមួយជាមួយជង់ថ្មី។ ជង់ការហៅត្រូវបានគ្រប់គ្រងដោយម៉ាស៊ីននិម្មិត JS ។ វាហាក់បីដូចជាបញ្ហាអ្វី ចាប់តាំងពីយើងនៅតែសម្រេចចិត្តគ្រប់គ្រងលំហូរពីមុនទាំងស្រុងដោយដៃ? ការពិតគឺថាប្លុក I/O នៅក្នុង QEMU ត្រូវបានអនុវត្តតាមរយៈ coroutines ហើយនេះជាកន្លែងដែលការរៀបចំជង់កម្រិតទាបនឹងមានប្រយោជន៍។ ជាសំណាងល្អ Emscipten មានយន្តការសម្រាប់ប្រតិបត្តិការអសមកាល សូម្បីតែពីរ៖ ធ្វើសមកាលកម្ម и អ្នកបកប្រែ. ទីមួយដំណើរការតាមរយៈកូដ JavaScript ដែលបានបង្កើត ហើយមិនត្រូវបានគាំទ្រទៀតទេ។ ទីពីរគឺជា "វិធីត្រឹមត្រូវ" បច្ចុប្បន្ន ហើយដំណើរការតាមរយៈការបង្កើត bytecode សម្រាប់អ្នកបកប្រែដើម។ ពិតណាស់ វាដំណើរការយឺតៗ ប៉ុន្តែវាមិនធ្វើឱ្យកូដខូចនោះទេ។ ពិត ការគាំទ្រសម្រាប់ coroutines សម្រាប់យន្តការនេះត្រូវតែត្រូវបានរួមចំណែកដោយឯករាជ្យ (មាន coroutines ដែលត្រូវបានសរសេររួចហើយសម្រាប់ Asyncify ហើយមានការអនុវត្តប្រហាក់ប្រហែល API ដូចគ្នាសម្រាប់ Emterpreter អ្នកគ្រាន់តែត្រូវការភ្ជាប់ពួកវា)។

នៅពេលនេះ ខ្ញុំមិនទាន់អាចបំបែកកូដទៅជាមួយដែលបានចងក្រងនៅក្នុង WASM និងបកស្រាយដោយប្រើ Emterpreter ដូច្នេះឧបករណ៍ទប់ស្កាត់មិនដំណើរការនៅឡើយទេ (សូមមើលនៅក្នុងស៊េរីបន្ទាប់ ដូចដែលពួកគេនិយាយ...)។ នោះ​គឺ​នៅ​ទី​បញ្ចប់​អ្នក​គួរ​តែ​ទទួល​បាន​អ្វី​មួយ​ដូច​ជា​រឿង​ស្រទាប់​គួរ​ឱ្យ​អស់​សំណើច​នេះ​:

• ប្លុក I/O ដែលត្រូវបានបកស្រាយ។ មែនហើយ តើអ្នកពិតជារំពឹងថានឹងធ្វើត្រាប់តាម NVMe ជាមួយនឹងការសម្តែងដើមមែនទេ? 🙂
• កូដ QEMU ចម្បងដែលបានចងក្រងជាស្ថាពរ (អ្នកបកប្រែ ឧបករណ៍ត្រាប់តាមផ្សេងទៀត ។ល។)
• ចងក្រងកូដភ្ញៀវដោយថាមវន្តទៅក្នុង WASM

លក្ខណៈពិសេសនៃប្រភព QEMU

ដូចដែលអ្នកប្រហែលជាបានទាយរួចហើយ កូដសម្រាប់ត្រាប់តាមស្ថាបត្យកម្មភ្ញៀវ និងកូដសម្រាប់បង្កើតការណែនាំម៉ាស៊ីនម៉ាស៊ីនត្រូវបានបំបែកនៅក្នុង QEMU ។ តាម​ពិត វា​រឹតតែ​ពិបាក​បន្តិច៖

• មានស្ថាបត្យកម្មភ្ញៀវ
• គឺ ឧបករណ៍បង្កើនល្បឿនពោលគឺ KVM សម្រាប់និម្មិតផ្នែករឹងនៅលើលីនុច (សម្រាប់ប្រព័ន្ធភ្ញៀវ និងម៉ាស៊ីនដែលឆបគ្នាជាមួយគ្នា) TCG សម្រាប់ការបង្កើតកូដ JIT គ្រប់ទីកន្លែង។ ចាប់ផ្តើមជាមួយ QEMU 2.9 ការគាំទ្រសម្រាប់ស្តង់ដារនិម្មិតផ្នែករឹង HAXM នៅលើ Windows បានបង្ហាញខ្លួន (ព័ត៌មានលម្អិត)
• ប្រសិនបើ TCG ត្រូវបានប្រើជាជាងការនិម្មិតផ្នែករឹង នោះវាមានការគាំទ្រការបង្កើតកូដដាច់ដោយឡែកសម្រាប់ស្ថាបត្យកម្មម៉ាស៊ីននីមួយៗ ក៏ដូចជាសម្រាប់អ្នកបកប្រែជាសកលផងដែរ។
• ... និងជុំវិញអ្វីៗទាំងអស់នេះ - គ្រឿងកុំព្យូទ័រដែលបានត្រាប់តាម ចំណុចប្រទាក់អ្នកប្រើ ការធ្វើចំណាកស្រុក ការថតឡើងវិញ ជាដើម។

និយាយអីញ្ចឹងតើអ្នកដឹងទេ៖ QEMU អាចត្រាប់តាមមិនត្រឹមតែកុំព្យូទ័រទាំងមូលប៉ុណ្ណោះទេ ប៉ុន្តែថែមទាំងដំណើរការសម្រាប់ដំណើរការអ្នកប្រើប្រាស់ដាច់ដោយឡែកមួយនៅក្នុងខឺណែលម៉ាស៊ីន ដែលត្រូវបានប្រើជាឧទាហរណ៍ដោយ AFL fuzzer សម្រាប់ឧបករណ៍គោលពីរ។ ប្រហែលជាមាននរណាម្នាក់ចង់បញ្ជូនរបៀបប្រតិបត្តិការនេះរបស់ QEMU ទៅ JS? 😉

ដូចជាកម្មវិធីឥតគិតថ្លៃដែលមានរយៈពេលយូរបំផុត QEMU ត្រូវបានបង្កើតឡើងតាមរយៈការហៅទូរសព្ទ configure и make. ចូរនិយាយថាអ្នកសម្រេចចិត្តបន្ថែមអ្វីមួយ៖ ផ្នែកខាងក្រោយ TCG ការអនុវត្តខ្សែស្រឡាយ អ្វីផ្សេងទៀត។ កុំប្រញាប់ប្រញាល់រីករាយ / រន្ធត់ (គូសបន្ទាត់ពីក្រោមតាមការសមរម្យ) នៅពេលអនាគតនៃការទំនាក់ទំនងជាមួយ Autoconf - តាមពិត configure QEMU ទំនងជាសរសេរដោយខ្លួនឯង ហើយមិនត្រូវបានបង្កើតពីអ្វីនោះទេ។

WebAssembly ។

ដូច្នេះតើអ្វីទៅដែលហៅថា WebAssembly (ហៅកាត់ថា WASM)? នេះគឺជាការជំនួសសម្រាប់ Asm.js លែងធ្វើពុតជាកូដ JavaScript ត្រឹមត្រូវ។ ផ្ទុយទៅវិញ វាគឺជាប្រព័ន្ធគោលពីរសុទ្ធសាធ និងធ្វើឱ្យប្រសើរ ហើយសូម្បីតែគ្រាន់តែសរសេរចំនួនគត់ទៅក្នុងវាមិនសាមញ្ញបំផុតនោះទេ៖ សម្រាប់ការបង្រួម វាត្រូវបានរក្សាទុកក្នុងទម្រង់ ឡេប ៨.

អ្នកប្រហែលជាធ្លាប់បានលឺអំពីក្បួនដោះស្រាយការបង្វិលឡើងវិញសម្រាប់ Asm.js - នេះគឺជាការស្ដារឡើងវិញនូវការណែនាំអំពីការគ្រប់គ្រងលំហូរ "កម្រិតខ្ពស់" (នោះគឺប្រសិនបើ - បន្ទាប់មក - ផ្សេងទៀត រង្វិលជុំ។ ល។ ) ដែលម៉ាស៊ីន JS ត្រូវបានរចនាឡើងពី LLVM IR កម្រិតទាប ខិតទៅជិតលេខកូដម៉ាស៊ីនដែលដំណើរការដោយខួរក្បាល។ តាមធម្មជាតិ តំណាងកម្រិតមធ្យមនៃ QEMU គឺខិតទៅជិតទីពីរ។ វាហាក់ដូចជាថានៅទីនេះវាគឺជា bytecode ចុងបញ្ចប់នៃការធ្វើទារុណកម្ម... ហើយបន្ទាប់មកមានប្លុក ប្រសិនបើ-បន្ទាប់មក-ផ្សេងទៀត និងរង្វិលជុំ!..

ហើយនេះគឺជាហេតុផលមួយផ្សេងទៀតដែល Binaryen មានប្រយោជន៍: វាអាចទទួលយកប្លុកកម្រិតខ្ពស់ដោយធម្មជាតិនៅជិតអ្វីដែលនឹងត្រូវបានរក្សាទុកនៅក្នុង WASM ។ ប៉ុន្តែវាក៏អាចបង្កើតកូដពីក្រាហ្វនៃប្លុកមូលដ្ឋាន និងការផ្លាស់ប្តូររវាងពួកវាផងដែរ។ ជាការប្រសើរណាស់, ខ្ញុំបាននិយាយរួចហើយថាវាលាក់ទ្រង់ទ្រាយផ្ទុក WebAssembly នៅពីក្រោយ C/C ++ API ដែលងាយស្រួល។

TCG (ម៉ាស៊ីនបង្កើតកូដតូច)

ស៊ីជីជី ដើមឡើយ ផ្នែកខាងក្រោយសម្រាប់កម្មវិធីចងក្រង C ។ បន្ទាប់មក ជាក់ស្តែង វាមិនអាចទប់ទល់នឹងការប្រកួតប្រជែងជាមួយ GCC បានទេ ប៉ុន្តែនៅទីបញ្ចប់វាបានរកឃើញកន្លែងរបស់វានៅក្នុង QEMU ជាយន្តការបង្កើតកូដសម្រាប់វេទិកាម៉ាស៊ីន។ វាក៏មាន backend TCG ដែលបង្កើត abstract bytecode មួយចំនួន ដែលត្រូវបានប្រតិបត្តិភ្លាមៗដោយអ្នកបកប្រែ ប៉ុន្តែខ្ញុំបានសម្រេចចិត្តជៀសវាងការប្រើវានៅពេលនេះ។ ទោះជាយ៉ាងណាក៏ដោយការពិតដែលថានៅក្នុង QEMU វាអាចទៅរួចរួចហើយក្នុងការបើកការផ្លាស់ប្តូរទៅជាជំងឺរបេងដែលបានបង្កើតតាមរយៈមុខងារ tcg_qemu_tb_execវាបានប្រែទៅជាមានប្រយោជន៍ខ្លាំងណាស់សម្រាប់ខ្ញុំ។

ដើម្បីបន្ថែមផ្នែកខាងក្រោយ TCG ថ្មីទៅ QEMU អ្នកត្រូវបង្កើតថតរង tcg/<имя архитектуры> (ក្នុងករណី​នេះ, tcg/binaryen) ហើយវាមានឯកសារពីរ៖ tcg-target.h и tcg-target.inc.c и ចុះឈ្មោះ វាទាំងអស់អំពី configure. អ្នកអាចដាក់ឯកសារផ្សេងទៀតនៅទីនោះ ប៉ុន្តែដូចដែលអ្នកអាចទាយបានពីឈ្មោះទាំងពីរនេះ ពួកវាទាំងពីរនឹងត្រូវបានរួមបញ្ចូលនៅកន្លែងណាមួយ៖ មួយជាឯកសារបឋមកថាធម្មតា (វាត្រូវបានរួមបញ្ចូលនៅក្នុង tcg/tcg.hហើយឯកសារនោះមានរួចហើយនៅក្នុងឯកសារផ្សេងទៀតនៅក្នុងថត tcg, accel និងមិនត្រឹមតែប៉ុណ្ណោះ) មួយទៀត - គ្រាន់តែជាព័ត៌មានសង្ខេបនៅក្នុង tcg/tcg.cប៉ុន្តែវាមានសិទ្ធិចូលប្រើមុខងារឋិតិវន្តរបស់វា។

ដោយសម្រេចចិត្តថាខ្ញុំនឹងចំណាយពេលច្រើនពេកលើការស៊ើបអង្កេតលម្អិតអំពីរបៀបដែលវាដំណើរការ ខ្ញុំគ្រាន់តែចម្លង "គ្រោងឆ្អឹង" នៃឯកសារទាំងពីរនេះពីការអនុវត្តផ្នែកខាងក្រោយមួយផ្សេងទៀត ដោយបង្ហាញដោយស្មោះត្រង់នៅក្នុងបឋមកថាអាជ្ញាប័ណ្ណ។

ឯកសារ tcg-target.h មានការកំណត់ជាចម្បងនៅក្នុងទម្រង់ #define-s៖

• តើមានការចុះឈ្មោះប៉ុន្មាន និងទទឹងប៉ុន្មាននៅលើស្ថាបត្យកម្មគោលដៅ (យើងមានច្រើនតាមដែលយើងចង់បាន ច្រើនតាមដែលយើងចង់បាន - សំណួរគឺបន្ថែមអំពីអ្វីដែលនឹងត្រូវបានបង្កើតទៅជាកូដដែលមានប្រសិទ្ធភាពជាងមុនដោយកម្មវិធីរុករកតាមអ៊ីនធឺណិតលើស្ថាបត្យកម្ម "គោលដៅទាំងស្រុង" ...)
• ការតម្រឹមនៃការណែនាំរបស់ម៉ាស៊ីន៖ នៅលើ x86 និងសូម្បីតែនៅក្នុង TCI ការណែនាំមិនត្រូវបានតម្រឹមទាល់តែសោះ ប៉ុន្តែខ្ញុំនឹងដាក់នៅក្នុងសតិបណ្ដោះអាសន្នកូដមិនមែនជាការណែនាំទាល់តែសោះ ប៉ុន្តែចង្អុលទៅរចនាសម្ព័ន្ធបណ្ណាល័យ Binaryen ដូច្នេះខ្ញុំនឹងនិយាយថា៖ 4 បៃ
• ការណែនាំជាជម្រើសអ្វីដែលកម្មវិធីខាងក្រោយអាចបង្កើតបាន - យើងរួមបញ្ចូលអ្វីគ្រប់យ៉ាងដែលយើងរកឃើញនៅក្នុង Binaryen អនុញ្ញាតឱ្យឧបករណ៍បង្កើនល្បឿនបំបែកផ្នែកដែលនៅសល់ទៅជាសាមញ្ញជាងដោយខ្លួនវាផ្ទាល់។
• តើទំហំប្រហាក់ប្រហែលនៃឃ្លាំងសម្ងាត់ TLB ដែលស្នើសុំដោយផ្នែកខាងក្រោយ។ ការពិតគឺថានៅក្នុង QEMU អ្វីគ្រប់យ៉ាងគឺធ្ងន់ធ្ងរ: ទោះបីជាមានមុខងារជំនួយដែលអនុវត្តការផ្ទុក / ហាងដោយគិតពី MMU ភ្ញៀវ (តើយើងនឹងនៅឯណាដោយគ្មានវាឥឡូវនេះ?) ពួកគេរក្សាទុកឃ្លាំងសម្ងាត់ការបកប្រែរបស់ពួកគេក្នុងទម្រង់ជារចនាសម្ព័ន្ធ។ ដំណើរការដែលងាយស្រួលបង្កប់ដោយផ្ទាល់ទៅក្នុងប្លុកផ្សាយ។ សំណួរគឺថាតើអ្វីទៅជាអុហ្វសិតនៅក្នុងរចនាសម្ព័ន្ធនេះត្រូវបានដំណើរការប្រកបដោយប្រសិទ្ធភាពបំផុតដោយលំដាប់តូច និងលឿននៃពាក្យបញ្ជា?
• នៅទីនេះអ្នកអាចកែប្រែគោលបំណងនៃការចុះឈ្មោះដែលបានបម្រុងទុកមួយ ឬពីរ បើកការហៅ TB តាមរយៈមុខងារមួយ និងពណ៌នាជាជម្រើសពីរបីតូច។ inline- មុខងារដូចជា flush_icache_range (ប៉ុន្តែនេះមិនមែនជាករណីរបស់យើងទេ)

ឯកសារ tcg-target.inc.cជាការពិតណាស់ ជាធម្មតាមានទំហំធំជាង និងមានមុខងារចាំបាច់ជាច្រើន៖

• ការចាប់ផ្តើម រួមទាំងការរឹតបន្តឹងលើការណែនាំដែលអាចដំណើរការលើ operands ណាមួយ។ ចម្លងដោយខ្ញុំពីផ្នែកខាងក្រោយមួយទៀត
• អនុគមន៍​ដែល​ទទួល​យក​ការណែនាំ​កូដ​បៃ​ខាងក្នុង​មួយ​
• អ្នកក៏អាចដាក់មុខងារជំនួយនៅទីនេះ ហើយអ្នកក៏អាចប្រើមុខងារឋិតិវន្តពី tcg/tcg.c

សម្រាប់ខ្លួនខ្ញុំផ្ទាល់ ខ្ញុំបានជ្រើសរើសយុទ្ធសាស្ត្រដូចខាងក្រោម៖ នៅក្នុងពាក្យដំបូងនៃប្លុកបកប្រែបន្ទាប់ ខ្ញុំបានសរសេរចង្អុលចំនួនបួន៖ សញ្ញាចាប់ផ្តើម (តម្លៃជាក់លាក់មួយនៅក្នុងតំបន់ជុំវិញ។ 0xFFFFFFFFដែលកំណត់ស្ថានភាពបច្ចុប្បន្ននៃជំងឺរបេង) បរិបទ ម៉ូឌុលដែលបានបង្កើត និងលេខវេទមន្តសម្រាប់បំបាត់កំហុស។ ដំបូងគេដាក់សញ្ញាសម្គាល់ 0xFFFFFFFF - nដែលជាកន្លែង n - ចំនួនវិជ្ជមានតិចតួច ហើយរាល់ពេលដែលវាត្រូវបានប្រតិបត្តិតាមរយៈអ្នកបកប្រែ វាកើនឡើង 1. នៅពេលដែលវាឈានដល់ 0xFFFFFFFEការចងក្រងបានកើតឡើង ម៉ូឌុលត្រូវបានរក្សាទុកក្នុងតារាងមុខងារ នាំចូលទៅក្នុង "កម្មវិធីបើកដំណើរការ" តូចមួយ ដែលការប្រតិបត្តិបានមកពី tcg_qemu_tb_execហើយម៉ូឌុលត្រូវបានដកចេញពីអង្គចងចាំ QEMU ។

ដើម្បីបកស្រាយរឿងបុរាណ "ឈើច្រត់ តើមានទំនាក់ទំនងគ្នាប៉ុន្មានក្នុងសំឡេងនេះសម្រាប់បេះដូងរបស់ប្រូហ្គឺ..."។ ទោះយ៉ាងណាក៏ដោយ ការចងចាំបានលេចធ្លាយនៅកន្លែងណាមួយ។ លើសពីនេះទៅទៀត វាត្រូវបានគ្រប់គ្រងដោយ QEMU! ខ្ញុំ​មាន​កូដ​ដែល​ពេល​សរសេរ​ការ​ណែនាំ​បន្ទាប់ (នោះ​គឺ​ជា​ទ្រនិច) បាន​លុប​តំណ​ដែល​មាន​នៅ​កន្លែង​នេះ​មុន​នេះ ប៉ុន្តែ​វា​មិន​បាន​ជួយ​ទេ។ តាមពិតក្នុងករណីសាមញ្ញបំផុត QEMU បែងចែកអង្គចងចាំនៅពេលចាប់ផ្តើម ហើយសរសេរកូដដែលបានបង្កើតនៅទីនោះ។ នៅពេលដែលសតិបណ្ដោះអាសន្នអស់ លេខកូដត្រូវបានបោះចោល ហើយលេខបន្ទាប់នឹងចាប់ផ្តើមសរសេរនៅកន្លែងរបស់វា។

បន្ទាប់ពីសិក្សាកូដ ខ្ញុំបានដឹងថាល្បិចជាមួយលេខវេទមន្តបានអនុញ្ញាតឱ្យខ្ញុំមិនបរាជ័យលើការបំផ្លិចបំផ្លាញបណ្តុំដោយដោះលែងអ្វីមួយខុសនៅលើបណ្តុំដែលមិនទាន់បានកំណត់នៅលើការឆ្លងកាត់ដំបូង។ ប៉ុន្តែតើអ្នកណាជាអ្នកសរសេរសតិបណ្ដោះអាសន្នដើម្បីរំលងមុខងាររបស់ខ្ញុំនៅពេលក្រោយ? ដូចដែលអ្នកអភិវឌ្ឍន៍ Emscripten ណែនាំ នៅពេលដែលខ្ញុំជួបបញ្ហា ខ្ញុំបានបញ្ជូនកូដលទ្ធផលត្រឡប់ទៅកម្មវិធីដើមវិញ កំណត់ Mozilla Record-Replay នៅលើវា... ជាទូទៅ នៅទីបញ្ចប់ខ្ញុំបានដឹងពីរឿងសាមញ្ញមួយ៖ សម្រាប់ប្លុកនីមួយៗ។ ក struct TranslationBlock ជាមួយនឹងការពិពណ៌នារបស់វា។ ទាយទៅណា... ត្រឹមត្រូវហើយ នៅមុនប្លុកខាងស្តាំនៅក្នុងបណ្តុំ។ ដោយដឹងរឿងនេះ ខ្ញុំបានសម្រេចចិត្តឈប់ប្រើឈើច្រត់ (យ៉ាងហោចណាស់ខ្លះ) ហើយគ្រាន់តែបោះចោលលេខវេទមន្ត ហើយផ្ទេរពាក្យដែលនៅសល់ទៅ struct TranslationBlockបង្កើតបញ្ជីភ្ជាប់តែមួយដែលអាចឆ្លងកាត់បានយ៉ាងលឿននៅពេលដែលឃ្លាំងសម្ងាត់ការបកប្រែត្រូវបានកំណត់ឡើងវិញ និងបង្កើនអង្គចងចាំ។

ឈើច្រត់ខ្លះនៅសល់៖ ឧទាហរណ៍ ចង្អុលសម្គាល់នៅក្នុងសតិបណ្ដោះអាសន្នកូដ - ខ្លះគឺសាមញ្ញ BinaryenExpressionRefនោះគឺពួកគេមើលកន្សោមដែលចាំបាច់ត្រូវដាក់ជាលីនេអ៊ែរទៅក្នុងប្លុកមូលដ្ឋានដែលបានបង្កើត ផ្នែកគឺជាលក្ខខណ្ឌសម្រាប់ការផ្លាស់ប្តូររវាង BBs ផ្នែកគឺជាកន្លែងដែលត្រូវទៅ។ ជាការប្រសើរណាស់, មានប្លុកដែលបានរៀបចំរួចហើយសម្រាប់ Relooper ដែលចាំបាច់ត្រូវភ្ជាប់តាមលក្ខខណ្ឌ។ ដើម្បីសម្គាល់ពួកវា ការសន្មត់ត្រូវបានប្រើថាពួកវាទាំងអស់ត្រូវបានតម្រឹមដោយយ៉ាងហោចណាស់បួនបៃ ដូច្នេះអ្នកអាចប្រើប៊ីតពីរយ៉ាងតិចបំផុតសម្រាប់ស្លាកដោយសុវត្ថិភាព អ្នកគ្រាន់តែចាំថាត្រូវយកវាចេញប្រសិនបើចាំបាច់។ ដោយវិធីនេះ ស្លាកបែបនេះត្រូវបានប្រើរួចហើយនៅក្នុង QEMU ដើម្បីបង្ហាញពីហេតុផលសម្រាប់ការចាកចេញពីរង្វិលជុំ TCG ។

ការប្រើប្រាស់ Binaryen

ម៉ូឌុលនៅក្នុង WebAssembly មានមុខងារ ដែលនីមួយៗមានតួ ដែលជាកន្សោម។ កន្សោម​គឺ​ជា​ប្រតិបត្តិការ unary និង binary ប្លុក​ដែល​មាន​បញ្ជី​កន្សោម​ផ្សេង​ទៀត លំហូរ​វត្ថុ​បញ្ជា។ល។ ដូចដែលខ្ញុំបាននិយាយរួចមកហើយ លំហូរការគ្រប់គ្រងនៅទីនេះត្រូវបានរៀបចំយ៉ាងជាក់លាក់ដូចជាសាខាកម្រិតខ្ពស់ រង្វិលជុំ ការហៅមុខងារជាដើម។ អាគុយម៉ង់​ទៅ​មុខងារ​មិន​ត្រូវ​បាន​បញ្ជូន​ទៅ​លើ​ជង់​នោះ​ទេ ប៉ុន្តែ​ច្បាស់​ណាស់ ដូច​ជា​នៅ​ក្នុង JS ដែរ។ វាក៏មានអថេរសកលដែរ ប៉ុន្តែខ្ញុំមិនបានប្រើវាទេ ដូច្នេះខ្ញុំនឹងមិនប្រាប់អ្នកអំពីពួកវាទេ។

អនុគមន៍​ក៏​មាន​អថេរ​មូលដ្ឋាន​ដែល​មាន​លេខ​ពី​សូន្យ​នៃ​ប្រភេទ៖ int32 / int64 / float / double ។ ក្នុងករណីនេះ អថេរ n មូលដ្ឋានដំបូងគឺជាអាគុយម៉ង់ដែលបានបញ្ជូនទៅអនុគមន៍។ សូមចំណាំថា ទោះបីជាអ្វីៗនៅទីនេះមិនមានកម្រិតទាបទាំងស្រុងនៅក្នុងលក្ខខណ្ឌនៃលំហូរការគ្រប់គ្រងក៏ដោយ ចំនួនគត់នៅតែមិនអនុវត្តគុណលក្ខណៈ "ចុះហត្ថលេខា/មិនបានចុះហត្ថលេខា"៖ របៀបដែលលេខមានឥរិយាបទអាស្រ័យលើលេខកូដប្រតិបត្តិការ។

និយាយជាទូទៅ Binaryen ផ្តល់ C-API សាមញ្ញ៖ អ្នកបង្កើតម៉ូឌុលមួយ នៅក្នុងគាត់ បង្កើតកន្សោម - unary, binary, blocks ពី expressions ផ្សេងទៀត, control flow ។ល។ បន្ទាប់​មក​អ្នក​បង្កើត​អនុគមន៍​មួយ​ដែល​មាន​កន្សោម​ជា​តួ​របស់​វា។ ប្រសិនបើអ្នកដូចខ្ញុំដែរ មានក្រាហ្វការផ្លាស់ប្តូរកម្រិតទាប សមាសធាតុ relooper នឹងជួយអ្នក។ តាមដែលខ្ញុំយល់ វាអាចប្រើការគ្រប់គ្រងកម្រិតខ្ពស់នៃលំហូរប្រតិបត្តិក្នុងប្លុកមួយ ដរាបណាវាមិនហួសពីព្រំដែននៃប្លុក - នោះគឺវាអាចធ្វើទៅបានដើម្បីធ្វើឱ្យផ្លូវខាងក្នុងលឿន / យឺត។ ផ្លូវបំបែកនៅខាងក្នុងកូដដំណើរការឃ្លាំងសម្ងាត់ TLB ដែលភ្ជាប់មកជាមួយ ប៉ុន្តែមិនមែនដើម្បីជ្រៀតជ្រែកជាមួយលំហូរត្រួតពិនិត្យ "ខាងក្រៅ" នោះទេ។ នៅពេលដែលអ្នកដោះលែង relooper ប្លុករបស់វាត្រូវបានដោះលែង នៅពេលអ្នកដោះលែងម៉ូឌុល កន្សោម មុខងារ។ល។ ដែលត្រូវបានបែងចែកទៅវាបាត់។ សង្វៀន.

ទោះយ៉ាងណាក៏ដោយ ប្រសិនបើអ្នកចង់បកស្រាយកូដភ្លាមៗដោយមិនចាំបាច់បង្កើត និងលុបឧទាហរណ៍អ្នកបកប្រែ វាសមហេតុផលក្នុងការដាក់តក្កវិជ្ជានេះទៅក្នុងឯកសារ C++ ហើយពីទីនោះដោយផ្ទាល់គ្រប់គ្រង C++ API ទាំងមូលនៃបណ្ណាល័យ ដោយរំលងរួចរាល់- បានធ្វើរុំ។

ដូច្នេះដើម្បីបង្កើតកូដដែលអ្នកត្រូវការ

// настроить глобальные параметры (можно поменять потом)
BinaryenSetAPITracing(0);

BinaryenSetOptimizeLevel(3);
BinaryenSetShrinkLevel(2);

// создать модуль
BinaryenModuleRef MODULE = BinaryenModuleCreate();

// описать типы функций (как создаваемых, так и вызываемых)
helper_type  BinaryenAddFunctionType(MODULE, "helper-func", BinaryenTypeInt32(), int32_helper_args, ARRAY_SIZE(int32_helper_args));
// (int23_helper_args приоб^Wсоздаются отдельно)

// сконструировать супер-мега выражение
// ... ну тут уж вы как-нибудь сами :)

// потом создать функцию
BinaryenAddFunction(MODULE, "tb_fun", tb_func_type, func_locals, FUNC_LOCALS_COUNT, expr);
BinaryenAddFunctionExport(MODULE, "tb_fun", "tb_fun");
...
BinaryenSetMemory(MODULE, (1 << 15) - 1, -1, NULL, NULL, NULL, NULL, NULL, 0, 0);
BinaryenAddMemoryImport(MODULE, NULL, "env", "memory", 0);
BinaryenAddTableImport(MODULE, NULL, "env", "tb_funcs");

// запросить валидацию и оптимизацию при желании
assert (BinaryenModuleValidate(MODULE));
BinaryenModuleOptimize(MODULE);

... បើខ្ញុំភ្លេចអ្វីមួយ សូមអភ័យទោស នេះគ្រាន់តែជាការបង្ហាញខ្នាតប៉ុណ្ណោះ ហើយព័ត៌មានលម្អិតមាននៅក្នុងឯកសារ។

ហើយឥឡូវនេះ crack-fex-pex ចាប់ផ្តើម, អ្វីមួយដូចនេះ:

static char buf[1 << 20];
BinaryenModuleOptimize(MODULE);
BinaryenSetMemory(MODULE, 0, -1, NULL, NULL, NULL, NULL, NULL, 0, 0);
int sz = BinaryenModuleWrite(MODULE, buf, sizeof(buf));
BinaryenModuleDispose(MODULE);
EM_ASM({
  var module = new WebAssembly.Module(new Uint8Array(wasmMemory.buffer, $0, $1));
  var fptr = $2;
  var instance = new WebAssembly.Instance(module, {
      'env': {
          'memory': wasmMemory,
          // ...
      }
  );
  // и вот уже у вас есть instance!
}, buf, sz);

ដើម្បីភ្ជាប់ពិភពលោកនៃ QEMU និង JS ហើយក្នុងពេលតែមួយអាចចូលប្រើមុខងារដែលបានចងក្រងបានយ៉ាងឆាប់រហ័ស អារេមួយត្រូវបានបង្កើតឡើង (តារាងមុខងារសម្រាប់បញ្ចូលទៅក្នុង launcher) ហើយមុខងារដែលបានបង្កើតត្រូវបានដាក់នៅទីនោះ។ ដើម្បីគណនាលិបិក្រមយ៉ាងឆាប់រហ័ស លិបិក្រមនៃប្លុកបកប្រែពាក្យសូន្យត្រូវបានប្រើប្រាស់ដំបូងជាវា ប៉ុន្តែបន្ទាប់មកលិបិក្រមដែលបានគណនាដោយប្រើរូបមន្តនេះបានចាប់ផ្តើមសមទៅនឹងវាលនៅក្នុង struct TranslationBlock.

ដោយវិធីនេះ, ការបង្ហាញ (បច្ចុប្បន្នមានអាជ្ញាប័ណ្ណស្រពិចស្រពិល) ដំណើរការល្អតែនៅក្នុង Firefox ប៉ុណ្ណោះ។ អ្នកអភិវឌ្ឍន៍ Chrome ដូចម្ដេចដែលមិនទាន់រួចរាល់ ចំពោះការពិតដែលថានរណាម្នាក់ចង់បង្កើតម៉ូឌុល WebAssembly ច្រើនជាងមួយពាន់ដូច្នេះពួកគេគ្រាន់តែបែងចែកទំហំអាសយដ្ឋាននិម្មិតមួយជីហ្គាបៃសម្រាប់នីមួយៗ ...

នោះហើយជាទាំងអស់សម្រាប់ពេលនេះ។ ប្រហែលជានឹងមានអត្ថបទមួយទៀតប្រសិនបើអ្នកណាម្នាក់ចាប់អារម្មណ៍។ ពោលគឺយ៉ាងហោចណាស់នៅសល់ តែប៉ុណ្ណោះ ធ្វើឱ្យឧបករណ៍ប្លុកដំណើរការ។ វាក៏ប្រហែលជាសមហេតុផលផងដែរក្នុងការធ្វើឱ្យការចងក្រងនៃម៉ូឌុល WebAssembly មានភាពអសមកាល ដូចទម្លាប់នៅក្នុងពិភព JS ចាប់តាំងពីនៅតែមានអ្នកបកប្រែដែលអាចធ្វើអ្វីៗទាំងអស់នេះបានរហូតដល់ម៉ូឌុលដើមរួចរាល់។

ជា​ចុង​ក្រោយ​មាន​ការ​យល់​ច្រឡំ​មួយ​: អ្នកបានចងក្រងប្រព័ន្ធគោលពីរនៅលើស្ថាបត្យកម្ម 32 ប៊ីត ប៉ុន្តែកូដតាមរយៈប្រតិបត្តិការអង្គចងចាំ ឡើងពី Binaryen កន្លែងណាមួយនៅលើជង់ ឬកន្លែងផ្សេងទៀតនៅផ្នែកខាងលើ 2 GB នៃទំហំអាសយដ្ឋាន 32 ប៊ីត។ បញ្ហាគឺថាតាមទស្សនៈរបស់ Binaryen នេះកំពុងចូលប្រើអាសយដ្ឋានលទ្ធផលធំពេក។ តើធ្វើដូចម្តេចដើម្បីទទួលបាននៅជុំវិញនេះ?

តាមវិធីរបស់admin

ខ្ញុំមិនបានបញ្ចប់ការសាកល្បងនេះទេ ប៉ុន្តែគំនិតដំបូងរបស់ខ្ញុំគឺ "ចុះបើខ្ញុំដំឡើងលីនុច 32 ប៊ីត?" បន្ទាប់មកផ្នែកខាងលើនៃទំហំអាសយដ្ឋាននឹងត្រូវបានកាន់កាប់ដោយខឺណែល។ សំណួរតែមួយគត់គឺថាតើចំនួនប៉ុន្មាននឹងត្រូវបានកាន់កាប់: 1 ឬ 2 Gb ។

នៅក្នុងវិធីរបស់អ្នកសរសេរកម្មវិធី (ជម្រើសសម្រាប់អ្នកអនុវត្ត)

តោះផ្លុំពពុះមួយនៅផ្នែកខាងលើនៃកន្លែងអាសយដ្ឋាន។ ខ្ញុំ​ផ្ទាល់​មិន​យល់​ថា​ហេតុ​អ្វី​បាន​ជា​វា​ធ្វើ​ការ - នៅ​ទីនោះ​ រួចទៅហើយ ត្រូវតែមានជង់មួយ។ ប៉ុន្តែ "យើងជាអ្នកអនុវត្ត៖ អ្វីៗដំណើរការសម្រាប់យើង ប៉ុន្តែគ្មាននរណាម្នាក់ដឹងពីមូលហេតុ..."

// 2gbubble.c
// Usage: LD_PRELOAD=2gbubble.so <program>

#include <sys/mman.h>
#include <assert.h>

void __attribute__((constructor)) constr(void)
{
  assert(MAP_FAILED != mmap(1u >> 31, (1u >> 31) - (1u >> 20), PROT_NONE, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0));
}

... វា​ជា​ការ​ពិត​ដែល​វា​មិន​ត្រូវ​គ្នា​ជាមួយ Valgrind ប៉ុន្តែ​ជា​សំណាង​ល្អ Valgrind ខ្លួន​វា​បាន​ជំរុញ​អ្នក​រាល់​គ្នា​ចេញ​ពី​ទីនោះ​យ៉ាង​មាន​ប្រសិទ្ធភាព :)

ប្រហែល​ជា​មាន​នរណា​ម្នាក់​នឹង​ផ្តល់​ការ​ពន្យល់​កាន់​តែ​ប្រសើរ​អំពី​របៀប​ដែល​កូដ​របស់​ខ្ញុំ​នេះ​ដំណើរការ...

ប្រភព: www.habr.com