QEMU.js: अब गंभीरता से और WASM के साथ

एक बार हँसी के लिए, मैंने प्रक्रिया की उलटफेर को साबित करने और मशीन कोड से जावास्क्रिप्ट (या यों कहें, Asm.js) उत्पन्न करने का तरीका जानने का फैसला किया। QEMU को प्रयोग के लिए चुना गया था, कुछ समय बाद हैबर पर एक लेख लिखा गया था। टिप्पणियों में, मुझे WebAssembly पर परियोजना को रीमेक करने की सलाह दी गई थी, और मुझे स्वयं ऐसा महसूस नहीं हुआ था कि लगभग समाप्त हो चुकी परियोजना को स्वयं छोड़ रहा हूं ... काम चल गया, लेकिन बहुत धीरे-धीरे, और अब, उस लेख में, "यह कैसे समाप्त हुआ?" विषय पर एक टिप्पणी दिखाई दी। मेरे विस्तृत जवाब के लिए, मैंने सुना "यह एक लेख पर खींचता है।" खैर, अगर यह खींचता है, तो एक लेख होगा। शायद कोई काम आएगा। इससे, पाठक डिवाइस के बारे में कुछ तथ्यों को सीखता है, क्यूईएमयू कोड पीढ़ी का समर्थन करता है, साथ ही साथ वेब एप्लिकेशन के लिए जस्ट-इन-टाइम कंपाइलर कैसे लिखता है।

कार्य

चूंकि मैंने पहले ही जान लिया था कि किसी तरह से QEMU को जावास्क्रिप्ट में कैसे पोर्ट किया जाता है, इसलिए इस बार इसे बुद्धिमानी से करने और पुरानी गलतियों को न दोहराने का निर्णय लिया गया।

समय की त्रुटि संख्या: बिंदु रिलीज से शाखा

मेरी पहली गलती अपस्ट्रीम संस्करण 2.4.1 से मेरे संस्करण को शाखा देना था। तब यह मेरे लिए एक अच्छा विचार था: यदि बिंदु रिलीज़ मौजूद है, तो यह संभवतः एक साधारण 2.4 की तुलना में अधिक स्थिर है, और इससे भी अधिक master शाखा है। और जब से मैं अपने कीड़े की उचित मात्रा में जोड़ने की योजना बना रहा था, मुझे अजनबी की बिल्कुल भी जरूरत नहीं थी। तो शायद ऐसा ही हुआ। लेकिन यहाँ बुरा भाग्य है: QEMU अभी भी खड़ा नहीं है, और कुछ बिंदु पर वे भी 10. द्वारा उत्पन्न प्रतिशत कोड के अनुकूलन की घोषणा की "हाँ, अब मैं ठंड हूँ," मैंने सोचा और टूट गया । यहां हमें एक विषयांतर करना चाहिए: QEMU.js के एकल-थ्रेडेड प्रकृति और इस तथ्य के कारण कि मूल QEMU मल्टीथ्रेडिंग की अनुपस्थिति को लागू नहीं करता है (अर्थात, यह एक ही समय में असंबंधित कोड पथों को संचालित करने में सक्षम होने के लिए महत्वपूर्ण है, और न केवल "सभी कर्नेल प्लग करें"), मुख्य कार्य बाहर से कॉल की संभावना के लिए "बाहर बारी" करना पड़ा। इससे कुछ प्राकृतिक विलय की समस्याएं पैदा हुईं। हालांकि, यह तथ्य कि master शाखा से कुछ बदलाव, जिनके साथ मैंने अपने कोड को मर्ज करने की कोशिश की थी, को भी पॉइंट रिलीज़ में चेरी चुना गया था (और, इसलिए, मेरी शाखा में), शायद, सुविधा नहीं जोड़ेंगे।

सामान्य तौर पर, मैंने फैसला किया कि वैसे भी प्रोटोटाइप समझ में आता है बाहर फेंक दो भागों के लिए जुदा और कुछ नया और अब master से आधारित खरोंच से एक नया संस्करण का निर्माण।

गलती नंबर दो: टीएलपी पद्धति

वास्तव में, यह एक गलती नहीं है, सामान्य रूप से - यह "जहां और कैसे स्थानांतरित करना है?" की पूरी गलतफहमी की स्थिति में एक परियोजना बनाने की एक विशेषता है, और सामान्य रूप से "क्या हम वहां पहुंचेंगे?" इन शर्तों के तहत, प्रोग्रामिंग एक उचित विकल्प था, लेकिन, निश्चित रूप से, मैं इसे अनावश्यक रूप से दोहराना नहीं चाहता था। इस बार मैं इसे बुद्धिमानी से करना चाहता था: परमाणु कमिट, जानबूझकर कोड में बदलाव (और "वर्णों के साथ यादृच्छिक वर्णों को एक साथ संकलित नहीं करता है जब तक कि यह (चेतावनियों के साथ)", जैसा कि लिनुस टॉर्वाल्ड्स ने एक बार किसी के बारे में कहा था, यदि आप विकिटनी को मानते हैं), आदि।

गलती नंबर तीन: पानी में चढ़ने का कांटा नहीं जानना

मैंने अभी तक पूरी तरह से इससे छुटकारा नहीं पाया है, लेकिन अब मैंने कम से कम प्रतिरोध के मार्ग का पालन नहीं करने का फैसला किया, और इसे "एक वयस्क तरीके से" करने के लिए, अर्थात्, खरोंच से अपने टीसीजी बैकेंड को लिखें, ताकि मैं बाद में यह न कहूं, "हां, यह बेशक, धीरे-धीरे, लेकिन मैं सब कुछ नियंत्रित नहीं कर सकता - टीसीआई इस तरह लिखा है ... "। इसके अलावा, शुरू में यह एक स्पष्ट समाधान की तरह लग रहा था , क्योंकि मैं बाइनरी कोड उत्पन्न कर रहा था । जैसा कि कहा जाता है, "मैंने गेन्ट एकत्र किया, लेकिन यह नहीं कि एक": कोड बेशक, बाइनरी है, लेकिन नियंत्रण को इस तरह से स्थानांतरित नहीं किया जा सकता है - इसे संकलन के लिए ब्राउज़र में स्पष्ट रूप से धकेलने की आवश्यकता है, जिसके परिणामस्वरूप जेएस दुनिया से एक निश्चित वस्तु है, जो अभी भी कहीं न कहीं बचाने की जरूरत है। हालाँकि, पर साधारण RISC आर्किटेक्चर के लिए, जैसा कि मैं इसे समझता हूं, एक विशिष्ट स्थिति को पुनर्निर्मित कोड के लिए अनुदेश कैश को स्पष्ट रूप से फ्लश करने की आवश्यकता है - यदि यह वह नहीं है जो हमें चाहिए, तो कम से कम यह करीब है। इसके अलावा, अपने आखिरी प्रयास से, मैंने सीखा कि नियंत्रण को अनुवाद ब्लॉक के मध्य में स्थानांतरित नहीं किया जाता है, इसलिए, हमें वास्तव में किसी भी ऑफसेट से व्याख्या किए गए बाईटेकोड की आवश्यकता नहीं है, और हम बस टीबी पर फ़ंक्शन द्वारा उत्पन्न कर सकते हैं।

आकर लात मारी

हालांकि मैंने जुलाई में कोड को फिर से लिखना शुरू कर दिया, जादुई पेंडेल क्रेप नहीं आया: आमतौर पर गीथहब के पत्र इश्यू और पुल अनुरोधों की प्रतिक्रियाओं की सूचना के रूप में आते हैं, और फिर, अचानक , संदर्भ में quu बैकेंड के रूप में द्विआधारी कहते हैं , "यहाँ यह है- उन्होंने ऐसा कुछ किया, शायद वह कुछ कहेंगे। ” यह WASM JIT बनाने के लिए Emscripten से संबंधित बाइनरी लाइब्रेरी का उपयोग करने के बारे में था। खैर, मैंने कहा कि आपके पास वहां अपाचे 2.0 लाइसेंस है, और क्यूईएमयू को GPLv2 के तहत वितरित किया गया है, और वे बहुत संगत नहीं हैं। यह अचानक पता चला कि लाइसेंस को किसी तरह ठीक किया जा सकता है (मुझे नहीं पता: हो सकता है, बदल जाए, डबल लाइसेंस हो सकता है, शायद कुछ और ...)। यह, निश्चित रूप से, मुझे खुश कर दिया, क्योंकि मैं पहले से ही उस समय तक कई बार बाइनरी प्रारूप WebAssembly को देख चुका था, और किसी तरह मेरे लिए दुखी और समझ से बाहर था। यहाँ एक पुस्तकालय था जो संक्रमण ग्राफ के साथ बुनियादी ब्लॉकों को ऊपर उठाएगा, और बायटेकोड जारी करेगा, और यदि आवश्यक हो तो दुभाषिया में इसे लॉन्च भी कर सकता है।

तब क्यूईएमयू मेलिंग सूची पर एक पत्र भी था, लेकिन इस सवाल की अधिक संभावना है, "इसे किसकी आवश्यकता है?" और यह, अचानक , आवश्यक था। कम से कम, आप ऐसे उपयोग मामलों को एक साथ परिमार्जन कर सकते हैं यदि यह अधिक या कम स्मार्ट तरीके से काम करता है:

• बिना किसी इंस्टॉलेशन के कुछ भी शिक्षण शुरू करना
• iOS पर वर्चुअलाइजेशन, जहां केवल अफवाहों के अनुसार मक्खी पर कोड पीढ़ी का अधिकार रखने वाला एकमात्र आवेदन JS इंजन है (क्या यह सच है?)
• मिनी-ओएस प्रदर्शन - एकल-डिस्क, अंतर्निहित, फर्मवेयर के सभी प्रकार, आदि ...

ब्राउज़र रनटाइम की विशेषताएं

जैसा कि मैंने कहा, क्यूईएमयू मल्टीथ्रेडिंग से बंधा है, लेकिन यह ब्राउज़र में नहीं है। खैर, यह है कि नहीं की तरह ... पहले तो यह बिल्कुल भी नहीं था, फिर वेबवर्कर्स दिखाई दिए - जैसा कि मैं इसे समझता हूं, यह पारस्परिक रूप से परिवर्तनशील चर के बिना संदेश के आधार पर मल्टीथ्रेडिंग है। स्वाभाविक रूप से, यह एक साझा मेमोरी मॉडल के आधार पर मौजूदा कोड को पोर्ट करते समय महत्वपूर्ण समस्याएं पैदा करता है। फिर, जनता के दबाव में, इसे SharedArrayBuffers नाम से लागू किया गया। उन्होंने धीरे-धीरे इसे पेश किया, अलग-अलग ब्राउज़रों में इसके लॉन्च का जश्न मनाया, फिर नए साल का जश्न मनाया, और फिर मेल्टडाउन ... जिसके बाद वे इस नतीजे पर पहुंचे कि असभ्य, समय मापने में अशिष्टता न करें, लेकिन साझा स्मृति और काउंटर को बढ़ाने वाले प्रवाह की मदद से, यह अभी भी बहुत सटीक है । इसलिए उन्होंने साझा स्मृति के साथ मल्टीथ्रेडिंग को बंद कर दिया। ऐसा लगता है कि उन्होंने बाद में इसे वापस कर दिया, लेकिन, जैसा कि पहले प्रयोग से स्पष्ट हो गया है, इसके बिना जीवन है, और यदि ऐसा है, तो हम इसे मल्टीथ्रेडिंग पर भरोसा किए बिना करने की कोशिश करेंगे।

दूसरी विशेषता स्टैक के साथ निम्न-स्तरीय जोड़तोड़ की असंभवता है: आप बस ले नहीं सकते, वर्तमान संदर्भ को बचा सकते हैं और एक नए स्टैक के साथ एक नए पर स्विच कर सकते हैं। कॉल स्टैक को जेएस वर्चुअल मशीन द्वारा प्रबंधित किया जाता है। ऐसा लगता है, क्या समस्या है, क्योंकि हमने अभी भी पूर्व प्रवाह को पूरी तरह से मैन्युअल रूप से प्रबंधित करने का निर्णय लिया है? तथ्य यह है कि QEMU में ब्लॉक इनपुट-आउटपुट को कोरटाइन के माध्यम से लागू किया गया है, और यहां निम्न-स्तरीय स्टैक जोड़तोड़ हमारे लिए उपयोगी होगी। सौभाग्य से, एम्सिप्टेन में पहले से ही अतुल्यकालिक संचालन के लिए एक तंत्र शामिल है, यहां तक ​​कि दो: Asyncify और Emterpreter । पहला उत्पन्न जावास्क्रिप्ट कोड के महत्वपूर्ण ब्लॉटिंग के माध्यम से काम करता है और अब समर्थित नहीं है। दूसरा वर्तमान "सही तरीका" है और अपने स्वयं के दुभाषिया के लिए बाइटकोड की पीढ़ी के माध्यम से काम करता है। यह धीरे-धीरे काम करता है, लेकिन यह कोड को नहीं बढ़ाता है। सच है, इस तंत्र के लिए कोरटाइन समर्थन को इसके लिए जिम्मेदार ठहराया गया था (पहले से ही Asyncify के तहत लिखे गए coroutines थे और Emterpreter के लिए लगभग एक ही एपीआई का कार्यान्वयन था, आपको बस उन्हें कनेक्ट करना था)।

फिलहाल, मैं अभी तक WASM में संकलित कोड को विभाजित करने में कामयाब नहीं हुआ हूं और एम्टरपेटर का उपयोग करके व्याख्या की गई है, इसलिए ब्लॉक डिवाइस अभी तक काम नहीं करते हैं (अगली श्रृंखला देखें, जैसा कि वे कहते हैं ...)। यही है, अंत में, आपको ऐसी मज़ेदार स्तरित चीज़ मिलनी चाहिए:

• व्याख्या की गई ब्लॉक I / O ठीक है, क्या, क्या आपने वास्तव में एक देशी NVMe के प्रदर्शन की उम्मीद की थी? :)
• सांख्यिकीय रूप से संकलित मुख्य QEMU कोड (अनुवादक, अन्य उत्सर्जित उपकरण, आदि)
• WASM गतिशील रूप से संकलित अतिथि कोड

QEMU स्रोतों की विशेषताएं

जैसा कि आप शायद पहले से ही अनुमान लगा चुके हैं, अतिथि आर्किटेक्चर के लिए इम्यूलेशन कोड और क्यूईएमयू से मेजबान मशीन निर्देश उत्पन्न करने के लिए कोड अलग-अलग हैं। वास्तव में, थोड़ा पेचीदा मामला भी है:

• गेस्ट आर्किटेक्चर हैं
• लिनक्स पर हार्डवेयर वर्चुअलाइजेशन (संगत अतिथि और मेजबान सिस्टम के लिए) केवीएम, कहीं भी त्वरक हैं , जेआईटी कोड पीढ़ी के लिए टीसीजी कहीं भी। QEMU 2.9 के साथ शुरू, विंडोज पर HAXM हार्डवेयर वर्चुअलाइजेशन मानक के लिए समर्थन दिखाई दिया ( विवरण )
• यदि टीसीजी का उपयोग किया जाता है, और हार्डवेयर वर्चुअलाइजेशन नहीं है, तो इसमें प्रत्येक मेजबान वास्तुकला के लिए कोड पीढ़ी के लिए अलग समर्थन है, साथ ही एक सार्वभौमिक व्याख्याकार के लिए
• ... और इसके चारों ओर - बाह्य परिधीय, यूजर इंटरफेस, माइग्रेशन, रिकॉर्ड-रिप्ले आदि।

वैसे, क्या आप जानते हैं: QEMU न केवल पूरे कंप्यूटर का अनुकरण कर सकता है, बल्कि मेजबान कर्नेल में एक अलग उपयोगकर्ता प्रक्रिया के लिए प्रोसेसर, जिसका उपयोग किया जाता है, उदाहरण के लिए, बायलर के इंस्ट्रूमेंटेशन के लिए AFL फ़ज़र द्वारा। हो सकता है कि कोई इस QEMU मोड को संचालन के लिए JS में पोर्ट करना चाहता हो? ;)

सबसे लंबे समय तक मुफ़्त कार्यक्रमों की तरह, QEMU को configure और make लिए कॉल के माध्यम से बनाया गया है। मान लीजिए कि आप कुछ जोड़ने का फैसला करते हैं: एक टीसीजी बैकएंड, एक धागा कार्यान्वयन, कुछ और। आनन्दित होने के लिए जल्दी मत करो / भयभीत हो (आवश्यक के रूप में रेखांकित करें) ऑटोकॉन्फ़ के साथ संवाद करने की संभावना - वास्तव में, क्यूईएमयू पर configure स्वयं-लिखित प्रतीत होता है और इससे उत्पन्न होने वाली कोई बात नहीं है।

WebAssembly

तो यह क्या चीज है - WebAssembly (उर्फ WASM)? यह Asm.js के लिए एक प्रतिस्थापन है, अब मान्य जावास्क्रिप्ट कोड होने का दिखावा नहीं करता है। इसके विपरीत, यह विशुद्ध रूप से द्विआधारी और अनुकूलित है, और यहां तक ​​कि इसमें केवल एक पूर्णांक लिखना बहुत सरल नहीं है: यह कॉम्पैक्टनेस के लिए LEB128 प्रारूप में संग्रहीत है।

आपने Asm.js के लिए पुनर्जन्म एल्गोरिथ्म के बारे में सुना होगा - यह "उच्च-स्तरीय" निष्पादन प्रवाह नियंत्रण निर्देशों (यानी, यदि-तब-अन्यथा, लूप, आदि) की बहाली है, जिसके तहत जेएस इंजन को निम्न-स्तर के एलएलवीएम आईआर से ट्यून किया गया है। प्रोसेसर द्वारा निष्पादित मशीन कोड के करीब। स्वाभाविक रूप से, QEMU का मध्यवर्ती प्रतिनिधित्व दूसरे के करीब है। ऐसा लगता है कि यहाँ यह है, bytecode, पीड़ा का अंत ... और फिर ब्लॉक, अगर-तब-और लूप! ..!

और यह एक और कारण है कि बाइनरीन उपयोगी है: यह, निश्चित रूप से, उच्च-स्तरीय ब्लॉकों को पास कर सकता है जो WASM में संग्रहीत होंगे। लेकिन यह बेस ब्लॉक और उनके बीच बदलाव के ग्राफ से भी कोड का उत्पादन कर सकता है। खैर, मैंने पहले ही कहा था कि यह WebAssembly भंडारण प्रारूप को सुविधाजनक C / C ++ API के पीछे छिपा देता है।

टीसीजी (टिनी कोड जेनरेटर)

टीसीजी मूल रूप से सी कंपाइलर के लिए एक बैकएंड था । फिर, जाहिरा तौर पर, यह जीसीसी के साथ प्रतिस्पर्धा नहीं खड़ा कर सका, लेकिन अंत में इसे मेजबान मंच के लिए कोड पीढ़ी तंत्र के रूप में क्यूईएमयू में अपनी जगह मिली। एक टीसीजी बैकएंड भी है जो कुछ अमूर्त बाईटेकोड उत्पन्न करता है, जिसे तुरंत दुभाषिया द्वारा निष्पादित किया जाता है, लेकिन मैंने इस बार इस समय को छोड़ने का फैसला किया। हालाँकि, यह तथ्य कि QEMU में पहले से ही tcg_qemu_tb_exec फ़ंक्शन के माध्यम से उत्पन्न टीबी के लिए संक्रमण को सक्षम करने की क्षमता है, मेरे लिए बहुत उपयोगी था।

QEMU में एक नया TCG बैकएंड जोड़ने के लिए, आपको एक 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 पर, और टीसीआई में, निर्देश बिल्कुल भी संरेखित नहीं करते हैं, लेकिन मैं कोड बफर में डालने का निर्देश बिल्कुल नहीं दे रहा हूं, लेकिन बाइनरीन लाइब्रेरी की संरचनाओं को इंगित करता है, इसलिए मैं कहता हूं: 4 बाइट्स
• बैकएंड उत्पन्न करने वाले वैकल्पिक निर्देश क्या कर सकते हैं - बाइनरी में जो कुछ भी हम पाते हैं उसे चालू करें, एक्सीलरेटर को बाकी हिस्सों को सरल बनाने दें
• टीएलबी कैश का अनुमानित आकार बैकएंड द्वारा अनुरोध किया गया है। तथ्य यह है कि QEMU में सब कुछ गंभीर है: यद्यपि सहायक कार्य हैं जो अतिथि MMU (और अब इसके बिना?) को ध्यान में रखते हुए लोड / स्टोर करते हैं, वे एक संरचना के रूप में अपने अनुवाद कैश को सहेजते हैं, जिसके प्रसंस्करण को एम्बेड करना सुविधाजनक होता है? सीधे अनुवाद ब्लॉक में। सवाल यह है कि इस संरचना में कौन सी ऑफसेट सबसे कुशलता से कमान के एक छोटे और तेज अनुक्रम द्वारा नियंत्रित की जाती है
• यहां आप एक या दो आरक्षित रजिस्टरों के उद्देश्य को मोड़ सकते हैं, एक फ़ंक्शन के माध्यम से टीबी कॉल को सक्षम कर सकते हैं और वैकल्पिक रूप से flush_icache_range जैसे छोटे inline कार्यों के एक जोड़े का वर्णन कर flush_icache_range (लेकिन यह हमारा मामला नहीं है)

बेशक, tcg-target.inc.c आमतौर पर बहुत बड़ी होती है और इसमें कई आवश्यक कार्य होते हैं:

• आरंभीकरण, संकेत करना, अन्य बातों के साथ-साथ उस निर्देश पर प्रतिबंध जिसके साथ ऑपरेंड काम कर सकते हैं। एक और बैकएंड से मेरे द्वारा नकल की गई
• आंतरिक बाइटकोड के एक निर्देश को स्वीकार करने वाला कार्य
• यहाँ आप सहायक कार्य कर सकते हैं, और यहाँ भी आप tcg/tcg.c से स्थैतिक कार्यों का उपयोग कर सकते हैं

खुद के लिए, मैंने निम्नलिखित रणनीति चुनी: अगले अनुवाद ब्लॉक के पहले शब्दों में, मैंने चार पॉइंटर्स लिखे: स्टार्ट मार्क ( 0xFFFFFFFF के आसपास के क्षेत्र में एक निश्चित मूल्य, जिसने टीबी की वर्तमान स्थिति निर्धारित की), संदर्भ, उत्पन्न मॉड्यूल, और डीबगिंग के लिए जादू की संख्या। सबसे पहले, लेबल को 0xFFFFFFFF - n सेट किया गया था, जहां n एक छोटी धनात्मक संख्या है, और हर बार दुभाषिया के माध्यम से यह 1 से बढ़ जाता है। जब यह 0xFFFFFFFE तक पहुंच गया, संकलन हुआ, तो मॉड्यूल एक छोटे "लॉन्चर" में आयात किया गया था, जो फ़ंक्शन तालिका में संग्रहीत किया गया था, जिसमें निष्पादन बाएं tcg_qemu_tb_exec , और मॉड्यूल QEMU मेमोरी से हटा दिया गया था।

क्लासिक्स को पैराफ़ेज़ करने के लिए, "क्रच, दिल के लिए इस ध्वनि में कितना प्रोग्रैस्ट इंटरवेट किया गया है ..."। हालाँकि, स्मृति कहीं लीक हो रही थी। और यह QEMU द्वारा प्रबंधित एक मेमोरी थी! मेरे पास एक कोड था जो कि अगले निर्देश (अच्छी तरह से, एक सूचक) को लिखते समय, उस लिंक को हटा देता था जो पहले इस जगह पर था, लेकिन इससे कोई फायदा नहीं हुआ। दरअसल, सरलतम मामले में, क्यूईएमयू स्टार्टअप पर मेमोरी आवंटित करता है और वहां उत्पन्न कोड लिखता है। जब बफर समाप्त होता है, तो कोड को बाहर फेंक दिया जाता है, और अगले को उसके स्थान पर लिखा जाना शुरू होता है।

कोड का अध्ययन करने के बाद, मुझे एहसास हुआ कि जादू की संख्या के साथ बैसाखी ने हमें ढेर के विनाश पर नहीं पड़ने दिया, पहले पास पर अनइंस्टॉल किए गए बफर पर कुछ गलत किया। लेकिन बाद में मेरे कार्य को दरकिनार करते हुए बफर को कौन लिखता है? जैसा कि Emscripten डेवलपर्स ने सलाह दी, एक समस्या में चलाने के बाद, मैंने परिणामी कोड को मूल एप्लिकेशन पर वापस पोर्ट किया, उस पर मोज़िला रिकॉर्ड-रीप्ले सेट किया ... सामान्य तौर पर, मुझे एक साधारण बात का एहसास हुआ: प्रत्येक विवरण के साथ एक struct TranslationBlock प्रत्येक ब्लॉक के लिए आवंटित किया गया है। अनुमान करें कि ... यह सही है, ब्लॉक के ठीक सामने बफर में है। यह महसूस करने के बाद, मैंने इसे बैसाखी (कम से कम कुछ) के साथ टाई करने का फैसला किया, और बस मैजिक नंबर को फेंक दिया, और शेष शब्दों को struct TranslationBlock स्थानांतरित कर दिया, एक एकल-लिंक की गई सूची बनाई जिससे आप जल्दी से अनुवाद कैश को रीसेट कर सकते हैं और मेमोरी को मुक्त कर सकते हैं।

कुछ बैसाखी बनी हुई है: उदाहरण के लिए, कोड बफ़र में चिह्नित संकेत - उनमें से कुछ बस BinaryenExpressionRef , अर्थात, वे उन अभिव्यक्तियों को देखते हैं जिन्हें उत्पन्न आधार इकाई में रैखिक रूप से रखा जाना चाहिए, भाग - डब्ल्यूबी के बीच संक्रमण स्थिति, भाग - जहां जाना है। खैर, रीलोपर के लिए पहले से ही तैयार ब्लॉक हैं, जिन्हें शर्तों के अनुसार जोड़ा जाना चाहिए। उनके बीच अंतर करने के लिए, धारणा का उपयोग किया जाता है कि वे सभी कम से कम चार बाइट्स संरेखित हैं, इसलिए आप सुरक्षित रूप से लेबल के दो बिट्स का उपयोग कर सकते हैं, आपको केवल आवश्यक होने पर इसे हटाने के लिए याद रखना होगा। वैसे, टीसीजी चक्र से बाहर निकलने के कारण को इंगित करने के लिए ऐसे लेबल पहले से ही क्यूईएमयू में उपयोग किए जाते हैं।

बाइनरीन का उपयोग करना

WebAssembly में मॉड्यूल में फ़ंक्शन होते हैं, जिनमें से प्रत्येक में एक अभिव्यक्ति का प्रतिनिधित्व करने वाला एक शरीर होता है। अभिव्यक्तियां एकात्मक और द्विआधारी संचालन हैं, ब्लॉक जिसमें अन्य अभिव्यक्तियों की सूची शामिल है, नियंत्रण प्रवाह, आदि। जैसा कि मैंने पहले ही कहा था, यहाँ नियंत्रण प्रवाह उच्च-स्तरीय शाखाओं, लूप, फ़ंक्शन कॉल आदि के रूप में ठीक-ठीक आयोजित किया जाता है। कार्यों के तर्क ढेर पर नहीं, बल्कि स्पष्ट रूप से पारित किए जाते हैं, जैसा कि जेएस में है। वैश्विक चर हैं, लेकिन मैंने उनका उपयोग नहीं किया, इसलिए मैंने उनके बारे में बात नहीं की।

फ़ंक्शंस में स्थानीय चर भी होते हैं, जिन्हें स्क्रैच से टाइप किया जाता है: int32 / int64 / float / double। पहले n स्थानीय चर फ़ंक्शन के लिए दिए गए तर्क हैं। कृपया ध्यान दें कि यद्यपि यहां सब कुछ नियंत्रण प्रवाह के मामले में पूरी तरह से निम्न-स्तर का नहीं है, फिर भी पूर्णांक साइन / साइनलेस साइन को नहीं ले जाते हैं: संख्या कैसे व्यवहार करेगी यह ऑपरेशन कोड पर निर्भर करता है।

आमतौर पर, बाइनरीन एक सरल सी-एपीआई प्रदान करता है: आप एक मॉड्यूल बनाते हैं, इसमें आप अभिव्यक्ति बनाते हैं - एकात्मक, बाइनरी, अन्य भावों से ब्लॉक, नियंत्रण प्रवाह, आदि। फिर आप एक फ़ंक्शन बनाते हैं, जिसका शरीर आपको एक अभिव्यक्ति निर्दिष्ट करने की आवश्यकता है। यदि आप, मेरी तरह, एक निम्न-स्तरीय संक्रमण ग्राफ रखते हैं, तो रिलॉपर घटक आपकी सहायता करेगा। जहां तक ​​मैं समझता हूं, ब्लॉक में निष्पादन के प्रवाह के उच्च-स्तरीय नियंत्रण का उपयोग करना संभव है, जब तक कि यह ब्लॉक की सीमा से परे नहीं जाता है - अर्थात, अंतर्निहित टीएलबी कैश प्रोसेसिंग कोड के अंदर एक आंतरिक फास्ट पथ / धीमी पथ शाखा बनाना संभव है, लेकिन कोई हस्तक्षेप नहीं है । जब आप रीलॉपर जारी करते हैं, तो इसके ब्लॉक जारी होते हैं, जब आप एक मॉड्यूल, भाव, कार्य आदि जारी करते हैं, तो इसके क्षेत्र में गायब हो जाते हैं।

हालाँकि, यदि आप इंटरप्रेटर उदाहरण के अनावश्यक निर्माण और विलोपन के बिना चलते-चलते कोड की व्याख्या करना चाहते हैं, तो इस तर्क को 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); 

… — , , — .

--, :

 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 , ( ), . , translation block, , struct TranslationBlock .

, ( ) Firefox. Chrome - , - WebAssembly, ...

. , , - . , . , WebAssembly , JS, , , .

: 32- , Binaryen, - - 2 32- . , Binaryen . ?

 // 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)); }