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

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

कार्य

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

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

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

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

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

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

गलती नंबर तीन: घाट को जाने बिना पानी में उतरना

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

उन्होंने आकर लात मारी

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

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

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

ब्राउज़र रनटाइम सुविधाएँ

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

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

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

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

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

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

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

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

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

WebAssembly

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

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

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

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

TCG मूलरूप से था सी कंपाइलर के लिए बैकएंड। फिर, जाहिरा तौर पर, यह जीसीसी के साथ प्रतिस्पर्धा का सामना नहीं कर सका, लेकिन अंत में इसे होस्ट प्लेटफॉर्म के लिए कोड जनरेशन तंत्र के रूप में क्यूईएमयू में अपनी जगह मिल गई। एक टीसीजी बैकएंड भी है जो कुछ अमूर्त बाइटकोड उत्पन्न करता है, जिसे दुभाषिया द्वारा तुरंत निष्पादित किया जाता है, लेकिन मैंने इस बार इसका उपयोग करने से बचने का फैसला किया है। हालाँकि, तथ्य यह है कि 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-एस:

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

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

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

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

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

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

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

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

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

फ़ंक्शंस में स्थानीय चर भी होते हैं, जो शून्य से क्रमांकित होते हैं, प्रकार: int32 / int64 / फ़्लोट / डबल। इस मामले में, पहले 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 की दुनिया को जोड़ने और साथ ही संकलित कार्यों तक शीघ्रता से पहुंचने के लिए, एक सरणी बनाई गई (लॉन्चर में आयात के लिए कार्यों की एक तालिका), और उत्पन्न कार्यों को वहां रखा गया था। सूचकांक की त्वरित गणना करने के लिए, शुरुआत में शून्य शब्द अनुवाद ब्लॉक के सूचकांक का उपयोग किया गया था, लेकिन फिर इस सूत्र का उपयोग करके गणना की गई सूचकांक बस फ़ील्ड में फिट होने लगी struct TranslationBlock.

संयोग से, डेमो (वर्तमान में एक संदिग्ध लाइसेंस के साथ) केवल फ़ायरफ़ॉक्स में ठीक काम करता है। क्रोम डेवलपर्स थे किसी तरह तैयार नहीं इस तथ्य से कि कोई व्यक्ति WebAssembly मॉड्यूल के एक हजार से अधिक उदाहरण बनाना चाहेगा, इसलिए उन्होंने प्रत्येक के लिए वर्चुअल एड्रेस स्पेस की एक गीगाबाइट आवंटित की...

अभी के लिए इतना ही। यदि किसी की रुचि हो तो शायद एक और लेख होगा। अर्थात्, कम से कम वहाँ रहता है केवल ब्लॉक डिवाइस को कार्यशील बनाएं। WebAssembly मॉड्यूल के संकलन को एसिंक्रोनस बनाना भी उचित हो सकता है, जैसा कि JS दुनिया में प्रथागत है, क्योंकि अभी भी एक दुभाषिया है जो मूल मॉड्यूल तैयार होने तक यह सब कर सकता है।

अंत में एक पहेली: आपने 32-बिट आर्किटेक्चर पर एक बाइनरी संकलित की है, लेकिन कोड, मेमोरी ऑपरेशंस के माध्यम से, बाइनरीन से चढ़ता है, कहीं स्टैक पर, या कहीं और 2-बिट एड्रेस स्पेस के ऊपरी 32 जीबी में। समस्या यह है कि बाइनरीन के दृष्टिकोण से यह बहुत बड़े परिणामी पते तक पहुंच है। इससे कैसे निपटें?

एडमिन के तरीके से

मैंने इसका परीक्षण समाप्त नहीं किया, लेकिन मेरा पहला विचार यह था कि "क्या होगा यदि मैं 32-बिट लिनक्स स्थापित करूं?" फिर पता स्थान का ऊपरी भाग कर्नेल द्वारा कब्जा कर लिया जाएगा। एकमात्र सवाल यह है कि कितना खर्च किया जाएगा: 1 या 2 जीबी।

प्रोग्रामर के तरीके से (अभ्यासियों के लिए विकल्प)

आइए पता स्थान के शीर्ष पर एक बुलबुला उड़ाएँ। मैं स्वयं नहीं समझता कि यह वहां क्यों काम करता है पहले ही वहाँ एक ढेर होना चाहिए. लेकिन "हम अभ्यासी हैं: सब कुछ हमारे लिए काम करता है, लेकिन कोई नहीं जानता कि क्यों..."

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

... यह सच है कि यह वालग्रिंड के साथ संगत नहीं है, लेकिन, सौभाग्य से, वालग्रिंड स्वयं बहुत प्रभावी ढंग से सभी को वहां से बाहर धकेल देता है :)

शायद कोई बेहतर स्पष्टीकरण देगा कि मेरा यह कोड कैसे काम करता है...

स्रोत: www.habr.com