Llst आंतरिक उपकरण, भाग 3. JIT का जादू, या किसी वर्चुअल मशीन को 50 बार कैसे गति दें

पिछले लेख में , हंबग और मैंने दिखाया कि कैसे कम्प्यूटेशनल गति को अलग-अलग तरीके से निष्पादित किया जाता है और इसकी सामग्री के आधार पर भिन्न हो सकते हैं। अब हम एक आभासी मशीन के हुड के नीचे देख सकते हैं और समझ सकते हैं कि यह कैसे और क्यों होता है।

इससे पहले हम स्मॉलटाक भाषा से परिचित हुए, या लिटिल स्मॉलटॉक के सूक्ष्म कार्यान्वयन से। हमने भाषा के सिंटैक्स, मेमोरी में ऑब्जेक्ट्स का प्रतिनिधित्व करने के लिए प्रारूप और बुनियादी निर्देशों का एक सेट तैयार किया। अब हम स्मॉलटाक और एलएलवीएम के बीच बातचीत के मुद्दों के करीब आते हैं (इसके लिए, लेखों की पूरी श्रृंखला की कल्पना की गई थी)।

अब हमारे जेआईटी कंपाइलर में वास्तव में क्या किया गया है, यह समझने के लिए हमारे पास सभी आवश्यक ज्ञान आधार हैं। इस लेख में, हम सीखेंगे कि स्मॉलटाक बाईटेकोड्स को एलएलवीएम आईआर कोड में कैसे परिवर्तित किया जाता है, कोड को कैसे संकलित और निष्पादित किया जाता है, और यह प्रोग्रामेटिक व्याख्या की तुलना में तेजी से क्यों काम करता है। सबसे अधीर संख्या और रेंगने वाली लाइनों के साथ शेलकास्ट ( एक बार और दो बार ) देख सकता है (स्क्रॉल करने की संभावना के बारे में मत भूलना)।

परिचय

TRIZ और सामान्य ज्ञान दोनों के सामान्य विचार हमें बताते हैं कि:

• सबसे तेज़ तरीका यह साबित करके कुछ करना है कि यह आवश्यक नहीं है;
• जल्दी से कुछ करने के बजाय, आप बुखार को खराब नहीं कर सकते हैं, लेकिन इसे पहले से करने की कोशिश करें;
• एक ही काम को दो बार करने की आवश्यकता नहीं है (खासकर यदि आप इसे बिल्कुल नहीं कर सकते हैं)।

ये सिद्धांत मानवीय रिश्तों से बहुत आगे निकल जाते हैं और विभिन्न प्रकार के क्षेत्रों में आवेदन पाते हैं। जिसमें कंप्यूटर साइंस भी शामिल है। कई लोग कैश का उपयोग करने के लाभों को समझते हैं । कुछ ने आलसी कंप्यूटिंग के बारे में सुना है। लेकिन एक अर्थहीन, भयावह नौकरशाही के समय के विरोध में एक प्रतिशोध के साथ, हर कोई भर आया।

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

एक आभासी मशीन और एक वास्तविक प्रोसेसर के बीच अंतर

स्मालटाक वर्चुअल मशीन स्टैक-ओरिएंटेड है:

1. संचालन करते समय, ऑपरेंड को स्टैक पर धकेल दिया जाता है;
2. निष्पादित ऑपरेशन स्टैक से ऑपरेंड की आवश्यक संख्या को हटा देता है;
3. परिणाम स्टैक के शीर्ष पर वापस धकेल दिया जाता है और अगले ऑपरेशन के लिए एक ऑपरेंड के रूप में इस्तेमाल किया जा सकता है।

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

बेशक, यह सब एक कारण के लिए किया जाता है। मशीन का स्टैक्ड संगठन जटिल कार्यों को शुरू किए बिना कार्यों के अनुक्रम रिकॉर्ड करना बहुत आसान बनाता है। उदाहरण के लिए, कोष्ठक के साथ अंकगणितीय अभिव्यक्तियों की गणना करते समय, स्टैक का उपयोग मध्यवर्ती मूल्यों के अस्थायी भंडारण के रूप में किया जाता है। पुराने समय से, इंजीनियरिंग कैलकुलेटर को इन सिद्धांतों के अनुसार डिजाइन किया गया है, रिवर्स पोलिश नोटेशन का उपयोग करते हुए।

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

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

इस प्रकार, प्रोसेसर पर स्मॉलटाक कोड को कुशलतापूर्वक निष्पादित करने के लिए, आपको रजिस्टर करने के लिए स्टैक लॉजिक को बदलने का एक तरीका खोजने की आवश्यकता है।

कंपाइलर जेआईटी वैल्यू स्टैक

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

चलो पहले दिए गए छँटाई विधि से left चर को शुरू करने के लिए आवश्यक स्मालटाक बाइटकोड पर एक बार फिर से अपना ध्यान आकर्षित करते हैं:

 "left <- List new" 0023 PushLiteral 4 0024 MarkArguments 1 0025 SendMessage new 0026 AssignTemporary 0 0027 DoSpecial popTop 

एक और उदाहरण, एक ही विधि से एक ब्लॉक की शुरुआत:

 0037 PushArgument 1 "criteria" 0038 PushTemporary 3 "x" 0039 PushTemporary 2 "mediane" 0040 MarkArguments 3 0041 SendMessage value:value: "  " 0042 DoSpecial branchIfFalse 52 

और दोनों मामलों में यह स्पष्ट है कि बड़ी संख्या में सरल मेमोरी ऑपरेशन किए जाते हैं। बेसिक पुश निर्देशों को युग्मक निर्देशों की एक जोड़ी में बदला जा सकता है। आपको केवल एक मेमोरी क्षेत्र से दूसरे के क्षेत्र में चर के शीर्ष के सूचकांक को स्थानांतरित करके एक मेमोरी क्षेत्र से सूचक (और हम केवल ऑब्जेक्ट संरचनाओं के लिए पॉइंटर्स के साथ काम करते हैं) को कॉपी करने की आवश्यकता है।

आईआर कोड में उपरोक्त विचारों का कार्यान्वयन "हेड-ऑन" कुछ इस तरह हो सकता है:

 define void @pushValueToStack(%TContext* %context, i32 %index, %TObject* %value) { %stackPointer = getelementptr inbounds %TContext* %context, i32 0, i32 4 %stack = load %TObjectArray** %stackPointer %stackObject = bitcast %TObjectArray* %stack to %TObject* call %TObject** @setObjectField(%TObject* %stackObject, i32 %index, %TObject* %value) ret void } define %TObject** @setObjectField(%TObject* %object, i32 %index, %TObject* %value) { %fieldPointer = call %TObject** @getObjectFieldPtr(%TObject* %object, i32 %index) store %TObject* %value, %TObject** %fieldPointer ret %TObject** %fieldPointer } define %TObject** @getObjectFieldPtr(%TObject* %object, i32 %index) { %fields = getelementptr inbounds %TObject* %object, i32 0, i32 2 %fieldPointer = getelementptr inbounds [0 x %TObject*]* %fields, i32 0, i32 %index ret %TObject** %fieldPointer } 

हां, यह काम करेगा और, देशी कोड में परिवर्तित हो जाएगा, दुभाषिया के लिए समान कार्यान्वयन से तेज होगा। लेकिन ऐसे JIT VM का समग्र प्रदर्शन आश्चर्यजनक रूप से कम होगा। बात यह है कि मेमोरी ऑपरेशन स्वयं दूर नहीं हुए हैं। हमने सॉफ्टवेयर वीएम के "रैपर" से छुटकारा पाकर, उन्हें केवल निम्न-स्तरीय कोड में पोर्ट किया।

आभासी मशीन को वास्तव में गति देने के लिए, आपको हमें प्रदान की जाने वाली एलएलवीएम सुविधाओं का उपयोग करने की आवश्यकता है, अर्थात् एसएसए, साथ में अनुकूलन पास का एक समृद्ध सेट।

यदि हम पुश और मार्कशीट निर्देशों के उद्देश्य को याद करते हैं, तो यह स्पष्ट हो जाता है कि यहाँ स्टैक का उपयोग केवल एक निश्चित मान (तर्क, शाब्दिक, स्थिर या अस्थायी चर) को संबद्ध सेल के तर्कों के साथ करने के लिए किया जाता है, जो संबंधित पुश निर्देश की स्थिति से निर्धारित होता है।

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

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

इस प्रकार, हम अनुकूलित संदेश भेजने के लिए निम्नलिखित एल्गोरिथ्म प्राप्त करते हैं:

1. ऑब्जेक्ट को स्टैक के संदर्भ ( पुश ) पर धकेलने के बजाय, हम मेमोरी से वैल्यू को वेरिएबल ( लोड ) में लोड करते हैं और इसे कंपाइलर वैल्यू स्टैक पर डालते हैं;
2. MarkArguments स्टेटमेंट को संसाधित करते हुए , हम तर्कों का एक ऑब्जेक्ट बनाते हैं, और फिर क्रमिक रूप से वैल्यू स्टैक से तत्वों को निकालते हैं और उन्हें एक पंक्ति में तर्कों के बनाए हुए ऐरो के स्लॉट में स्टोर करते हैं;
3. हम SendMessage हैंडलर स्टब कहते हैं ।

यह पता चला है कि चार मेमोरी ऑपरेशन ( लोड मान, स्टैक पर स्टोर मान, स्टैक से लोड मान और तर्क सरणी के क्षेत्र में स्टोर) के बजाय, हमने केवल दो ( लोड मान और सरणी में स्टोर ) छोड़ दिए हैं।

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

तरीके और कार्य

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

संदेश भेजना

जैसा कि हम पिछले लेख से याद करते हैं, एक आभासी मशीन को संदेश भेजने के लिए, आपको आवश्यकता है:

1. स्टैक से मान निकालें और तर्कों की एक सरणी बनाएं ( markArguments में एक अलग चरण के रूप में किया गया);
2. संदेश को संसाधित करने वाले पदानुक्रम में विधि खोजें;
3. एक संदर्भ वस्तु तैयार करें और खेतों में भरें;
4. नए संदर्भ के निष्पादन के लिए स्विच करें।

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

सॉफ्टवेयर VM केवल ढेर पर सभी ऑब्जेक्ट्स बनाता है, क्योंकि इसमें कोई अन्य मेमोरी नहीं है। JIT VM के मामले में, हम कुछ वस्तुओं को स्टैक पर रखकर मेमोरी ओवरहेड को काफी कम कर सकते हैं। ऐसी वस्तुएं हैं:

• तर्कों की सरणी
• प्रसंग वस्तु;
• अस्थायी चर की सरणी।

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

आंकड़े

JIT कंपाइलर के आदर्श अंतिम परिणाम को निम्नानुसार दर्शाया जा सकता है:

• सभी शामिल Smalltalk विधियाँ कार्य में परिवर्तित हो गईं
• भेजे गए प्रत्येक संदेश को डायरेक्ट फंक्शन कॉल में बदला जाता है (सर्च स्टब नहीं)
• चूंकि प्रत्यक्ष कॉल होते हैं, इसलिए ब्लॉक और छोटे कार्यों का कोड इसके उपयोग के स्थान पर भेजा जाता है

RBI को प्राप्त करने के रास्ते में मुख्य समस्या कॉल से कॉल पर वस्तु के प्रकार की अनिश्चितता है। एक बार फिर संग्रह पर विचार करें >> क्रमबद्ध विधि जिसे हम पहले से जानते हैं:

 sort: criteria | left right mediane | (self size < 32) ifTrue: [ ^ self insertSort: criteria ]. mediane <- self popFirst. left <- List new. right <- List new. self do: [ :x | (criteria value: x value: mediane) ifTrue: [ left add: x ] ifFalse: [ right add: x ] ]. left <- left sort: criteria. right <- right sort: criteria. right add: mediane. ^ left appendList: right 

चर के प्रकारों के बारे में क्या उपयोग किया जाता है? निष्पादन के संदर्भ और कॉलिंग कोड के बिना, कुछ भी निश्चित नहीं कहा जा सकता है। यह स्मॉलटाकल की ताकत और कमजोरी दोनों है। मजबूत क्योंकि यह कोड वंश के वर्ग की परवाह किए बिना समान रूप से कुशलतापूर्वक काम करेगा। यह सूची और सरणी दोनों को समान रूप से क्रमबद्ध करेगा। कमजोर, चूंकि हम संकलन चरण में अनुकूलन नहीं कर सकते हैं, जो वस्तु प्रकारों के ज्ञान पर निर्भर है।

हमारे पास एक मुश्किल योजना है जो आपको इष्टतम के करीब परिणाम प्राप्त करने की अनुमति देती है। और उसका नाम कॉल सांख्यिकी है। जैसे ही कार्यक्रम चलता है, SendMessage हैंडलर कहा जाता है, जो अपने मुख्य काम के अलावा, यह भी बताता है कि संदेश भेजने में कौन सी कक्षाएं शामिल हैं।

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

इसलिए, यहां तक ​​कि कॉल आंकड़े होने पर, हम इस चरण में अधिकतम कर सकते हैं प्रत्यक्ष कॉल सम्मिलित करना , बशर्ते कि चर का प्रकार हमारे लिए ज्ञात में से एक हो। वास्तव में, यह इस तथ्य की ओर जाता है कि पैचर आवेषण ब्लॉक को स्विच करता है जो ऑब्जेक्ट के वर्ग की जांच करता है और संबंधित फ़ंक्शन पर नियंत्रण स्थानांतरित करता है।

प्रकार का अनुमान

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

उदाहरण के लिए, Collection>>sort: ऊपर वर्णित विधि को देखते हुए, एक चौकस पाठक यह नोटिस कर सकता है कि List वर्ग के उदाहरणों से left और right हमेशा आरंभीकृत right । वर्चुअल मशीन निम्नलिखित विचारों से इसे समझ सकती है:

1. left चर को List new अभिव्यक्ति के परिणाम के लिए आरंभीकृत किया गया है।
2. अभिव्यक्ति List new कोई पैरामीटर नहीं लेता है और एक निश्चित कार्रवाई ऑब्जेक्ट ( List ) है
3. List ऑब्जेक्ट के लिए #new संदेश भेजना List>>new द्वारा संभाला जाता है
4. List>>new विधि अभिव्यक्ति के परिणाम को super new लौटाती है
5. वर्तमान संदर्भ में, यह List super यानी Collection
6. एक Collection वस्तु के लिए #new संदेश भेजना Object>>new द्वारा संभाला जाता है
7. Object>>new विधि में आदिम 7 शामिल है, जो हमेशा एक ज्ञात वर्ग (स्वयंसिद्ध) की वस्तु देता है

इसके अलावा, अभिव्यक्तियां उल्टे क्रम में ढह जाती हैं, जो बयान की ओर ले जाती हैं: " left चर List वर्ग के ऑब्जेक्ट द्वारा आरंभीकृत किया जाता है"।

left और right चर के वर्ग को जानकर, शेष विधि को भी अनुकूलित किया जा सकता है। ऑपरेशन #add: #sort: और #appendList: अतिरिक्त शर्तों के बिना प्रत्यक्ष विधि कॉल का उपयोग करके संकलित किए जाते हैं।

वास्तव में, प्रकारों का गहन उल्लेख हमारे लिए वांछनीय है, लेकिन आवश्यक नहीं है। यह जानना पर्याप्त है कि चर का प्रकार कॉल से कॉल में नहीं बदलता है। और हम यह पता लगा लेंगे कि जब हम पहली बार संदेश भेजते हैं तो यह वास्तव में क्या होगा। सभी एक साथ, आप प्रोग्राम निष्पादन के दौरान टाइप चेक को समाप्त कर सकते हैं, कोड की मात्रा कम कर सकते हैं और ऑप्टिमाइज़र के हाथों को खोल सकते हैं।

संकलन

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

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

हमारा कार्य विधि के बाइटकोड को पढ़ना और आईआर कोड में इसे फिर से बनाना, संक्रमण तर्क को संरक्षित करना और अंत में एक कार्यात्मक समकक्ष प्राप्त करना है। बेशक, इसका मतलब यह नहीं है कि हमें शब्द के लिए बाइट कोड शब्द से संचालन को दोहराना चाहिए, लेकिन हमें शुद्धता सुनिश्चित करने की आवश्यकता है।

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

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

उदाहरण के लिए, यदि हमारे पास बाइटकोड में था:

 "left <- List new" 0023 PushLiteral 4 0024 MarkArguments 1 0025 SendMessage new 0026 AssignTemporary 0 0027 DoSpecial popTop 

... तो इस टुकड़े को संकलित करते समय, क्रियाओं का क्रम निम्नानुसार होगा:

1. एक स्थगित ऑपरेशन बनाएं "स्टैक पर चौथा शाब्दिक डालें।"
2. MarkArguments स्टेटमेंट को स्टैक से मान खींचने की आवश्यकता होती है। यह लंबित ऑपरेशन के निष्पादन की ओर जाता है: lit0 नाम का lit0 , जिसमें हम lit0 के सरणी से चौथे तत्व को पढ़ने के संचालन को संलग्न करते हैं। हमने यह नाम मौजूदा आधार इकाई के मूल्यों के ढेर पर रखा है।
3. हम एक तत्व की एक सरणी बनाते हैं, इसे args0 नाम से args0 । . , , ( lit0 ). , : args0[0] = lit0 .
4. sendMessage, args0 . ( , ).
5. temp0, . temp0 .
6. ( popTop ).

पहली नज़र में यह डरावना है, लेकिन वास्तव में, यह सब कुछ ही कोडांतरक निर्देशों में एक साथ आएगा। विशेष रूप से, जब तर्कों की एक सरणी बनाते हैं, तो हम केवल आवश्यक मेमोरी ऑपरेशन छोड़ देते हैं: एक शाब्दिक पढ़ें, इसे एक सरणी में लिखें, एक संदेश भेजें और एक अस्थायी चर के लिए परिणाम लिखें।

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

हमारे देश में, ढेर पर भी तर्कों का एक सरणी नहीं बनाया जाता है, लेकिन कॉल के वास्तविक स्टैक से स्ट्रीम तक स्थित है। इसलिए, सरणी को आवंटित करना और भरना जल्दी होता है। सबसे महत्वपूर्ण बात, एलएलवीएम, आईआर पर काम कर रहा है, सभी प्रकार के अनुकूलन करने के लिए स्वतंत्र है जिसे हम सीधे नहीं देखते हैं, लेकिन इसे उपयुक्त मानते हैं।

उदाहरण के लिए, ऐसा हो सकता है कि एक ही अस्थायी मूल्य का उपयोग पंक्ति में दो बार किया जाए। फिर, मान को फिर से पढ़ने के बजाय, एलएलवीएम पिछले नाम (यदि यह परिणाम को प्रभावित नहीं करता है) का उपयोग कर सकता है। और इस तरह के trifles का एक पूरा गुच्छा हैं।

... हमने उस विकल्प पर विचार किया है जिसमें कंपाइलर मूल्य स्टैक स्थानीय रूप से उपयोग किया जाता है। जब संक्रमण ऑपरेशन चलन में आता है तो चीजें बहुत अधिक जटिल हो जाती हैं।

सभी पुश ऑपरेशनवर्तमान बेस यूनिट के मूल्यों के स्थानीय ढेर पर प्रदर्शन किया। स्टैक संचालन गैर-स्थानीय हो सकता है। इस स्थिति में, मान ब्लॉक से उच्चतर संक्रमण पदानुक्रम में निकाल दिया जाता है। उदाहरण के लिए: दो बुनियादी ब्लॉक हैं एक्स और वाई। ब्लॉक एक्स में ऑपरेशन होते हैं pushTemporary 0औरbranch , Y. , Y markArguments 1 , . , Y . , Y X, . .

Y X 1 ..X n , φ- , SSA. X i , , . , .

, MethodCompiler::TJitContext::popValue() JITCompilation.txt .


, , « ». , , . Collection>>sort: , . , , .

, . , , . , .

, . , 10% , , — . , :

branch , Y. , Y markArguments 1 , . , Y . , Y X, . .

Y X 1 ..X n , φ- , SSA. X i , , . , .

, MethodCompiler::TJitContext::popValue() JITCompilation.txt .


, , « ». , , . Collection>>sort: , . , , .

, . , , . , .

, . , 10% , , — . , :

branch , Y. , Y markArguments 1 , . , Y . , Y X, . .

Y X 1 ..X n , φ- , SSA. X i , , . , .

, MethodCompiler::TJitContext::popValue() JITCompilation.txt .


, , « ». , , . Collection>>sort: , . , , .

, . , , . , .

, . , 10% , , — . , :