👨‍👨‍👧 🖐🏽 💇🏼 Llst आंतरिक भाग 2 या लिटिल स्मॉलटॉक + LLVM = ♥ 👩🏿‍🤝‍👨🏽 🏇 👩🏼‍🌾

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

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

हालाँकि, पहले चीजें पहले ...

संस्करण 0.2 में नया

पिछले लेख में वर्णित पिछले संस्करण की तुलना में बहुत सारे बदलाव हैं:

सूची दिखाएं

हमने रीडलाइन लाइब्रेरी को कनेक्ट किया । अब आप आसानी से कमांड लाइन को संपादित कर सकते हैं; टैब कुंजी पर पहले दर्ज कमांड (Ctrl + R) और स्वतः पूर्णता का इतिहास था। सामान्य तौर पर, सब कुछ किसी भी सामान्य शेल के समान ही होता है।
फ़ाइलों के साथ काम करने के आदिम जोड़े जाते हैं और छवि डिस्क पर लिखी जाती है। अब आप मूल के साथ नए वीएम के साथ लगभग ऐसा ही कर सकते हैं।
शेड्यूलर वर्ग पर आधारित आदिम मल्टीटास्किंग (हरे धागे) को लागू किया। योजनाएं - पूर्ण मल्टीथ्रेडिंग।
टेस्ट मूल वस्तुओं के लिए लिखे गए थे जो बाद के डिबगिंग को बहुत सरल करते थे। टेस्ट कमाल के हैं!
ऑब्जेक्ट्स hptr<> करने के लिए hptr<> पॉइंटर्स। पहले, वे बाहरी सूचियों का उपयोग करते थे std::list<> , अब सूची को स्टैक स्पेस में बनाए रखा गया है। यह अकेले सॉफ्टवेयर VM को दो बार त्वरित करता है।
शाखा 37 में , नेटिव एपीआई स्केच बनाए गए हैं, जो भविष्य में आपको रैपर और अन्य बैसाखी के बिना आसानी से देशी तरीकों को लिखने की अनुमति देगा। विधियों को "उसी स्थान पर" उन्हीं वर्गों में लागू किया जाता है जो स्मॉलटाक से समकक्ष संस्थाओं की संरचना का वर्णन करते हैं। उदाहरण यहां , यहां और यहां देखे जा सकते हैं ।
मौजूदा बेकर के आधार पर जनरेशनल जीसी को लागू करने का प्रयास किया गया था। वास्तव में, सभी अंतर ढेर के हिस्सों की भूमिका में है और पीढ़ियों के बीच लिंक की सूची का भंडारण है। इस प्रकार, जब जल्दी से इकट्ठे होते हैं, तो केवल युवा पीढ़ी पर जाने और वहां से उन वस्तुओं को लेने के लिए आवश्यक है जो पुरानी पीढ़ियों से संदर्भित हैं। कोड लिखा है, लेकिन अभी तक डिबग नहीं किया गया है।
Flex / Bison का उपयोग करके ImageBuilder को फिर से लिखने पर काम शुरू हो गया है। विरासत में मिली उपयोगिता में कई समस्याएं हैं: आप मापदंडों को पारित नहीं कर सकते हैं, कोई सामान्य त्रुटि आउटपुट नहीं है, छवि कोड में वर्णों की एक जोड़ी को बदलते समय "रहस्यमय" क्रैश हो जाता है; हटाते समय समान "रहस्यमय" जीवन, उदाहरण के लिए, एक टिप्पणी, आदि इसके अलावा, कुछ मामलों में उपयोगिता गलत बायोटेक उत्पन्न करती है। बेशक, इस तरह से रहना असंभव है, इसलिए हमने इसका रीमेक बनाने का फैसला किया। फिलहाल, लिटिल स्मालटाक का व्याकरण पूरी तरह से वर्णित है; भाषा स्वयं के निर्माण के अलावा, नियंत्रण कमांड भी हैं जो प्राथमिक बूटस्ट्रैप छवि बनाने के लिए उपयोग की जाती हैं।
हमें एक डोमेन नाम मिला और GitHub में स्थानांतरित कर दिया गया । अब रिपॉजिटरी llst.org पर उपलब्ध है। ट्रैकर पर भी ध्यान दें।

खैर, अब, सबसे दिलचस्प:

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

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

यह कैसा दिखता है

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

चलो बेंचमार्क के साथ शुरू करते हैं:

 loopBenchmark | sum | sum <- 0. 1 to: 100000 do: [ :x | sum <- sum + 1 ]. ^sum

यह "सरल" कोड चर सौ से थोड़ा एक सौ हजार बार जोड़ता है। बेशक, बाहर निकलने पर हमें वही एक लाख मिलना चाहिए (या हमारे वीएम कचरे में जा सकते हैं)।

और यहाँ रन का परिणाम है:

कई बीचेस

 $ ./llst Image read complete. Loaded 5442 objects Soft run: 60 Cold jit run: 46 Hot jit run: 28 JIT Runtime stat: Messages dispatched: 200006 Objects allocated: 200004 Blocks invoked: 200002 Block cache hits: 199999 misses 3 ratio 100.00 % Message cache hits: 400004 misses 6 ratio 100.00 % Hot methods: Hit count Method name 200000 Block>>value: (0 sites) 2 Number>>to:do: (1 sites) value: (index 20, offset 109) class hits: (Block 200000) 2 Undefined>>loopBenchmark (1 sites) to:do: (index 15, offset 73) class hits: (SmallInt 2) 2 Block>>value (0 sites) Patching active methods that have hot call sites Recompiling method for patching: Number>>to:do: Patching Number>>to:do: ...done. Verifying ...done. Recompiling method for patching: Undefined>>loopBenchmark Patching Undefined>>loopBenchmark ...done. Verifying ...done. Optimizing Number>>to:do: ...done. Verifying ...done. Optimizing Undefined>>loopBenchmark ...done. Verifying ...done. Compiling machine code for Number>>to:do: ...done. Compiling machine code for Undefined>>loopBenchmark ...done. All is done. Patched cold jit run: 12 Patched hot jit run: 9 JIT Runtime stat: Messages dispatched: 200010 Objects allocated: 400008 Blocks invoked: 400004 Block cache hits: 399998 misses 6 ratio 100.00 % Message cache hits: 400006 misses 10 ratio 100.00 % Hot methods: Hit count Method name 200000 Block>>value: (0 sites) 4 Block>>value (0 sites) 2 Undefined>>loopBenchmark (0 sites) 2 Number>>to:do: (1 sites) value: (index 20, offset 109) class hits: (Block 200000) 2 Undefined>>loopBenchmark (1 sites) to:do: (index 15, offset 73) class hits: (SmallInt 2) ===-------------------------------------------------------------------------=== ... Statistics Collected ... ===-------------------------------------------------------------------------=== 2 adce - Number of instructions removed 2 branchfolding - Number of block tails merged 2 branchfolding - Number of dead blocks removed 1 cgscc-passmgr - Maximum CGSCCPassMgr iterations on one SCC 31 codegen-dce - Number of dead instructions deleted 63 codegenprepare - Number of GEPs converted to casts 9 codegenprepare - Number of blocks eliminated 114 codegenprepare - Number of memory instructions whose address computations were sunk 47 codegenprepare - Number of uses of Cast expressions replaced with uses of sunken Casts 313 dagcombine - Number of dag nodes combined 0 dse - Number of other instrs removed 12 dse - Number of stores deleted 54 gvn - Number of blocks merged 2 gvn - Number of instructions PRE'd 125 gvn - Number of instructions deleted 2 gvn - Number of loads PRE'd 37 gvn - Number of loads deleted 265 inline - Number of functions inlined 271 inline-cost - Number of call sites analyzed 263 instcombine - Number of dead inst eliminated 1 instcombine - Number of dead stores eliminated 67 instcombine - Number of instructions sunk 492 instcombine - Number of insts combined 159 isel - Number of blocks selected using DAG 7667 isel - Number of times dag isel has to try another path 101 jit - Number of bytes of global vars initialized 5310 jit - Number of bytes of machine code compiled 12 jit - Number of global vars initialized 239 jit - Number of relocations applied 3 jit - Number of slabs of memory allocated by the JIT 1 loop-simplify - Number of pre-header or exit blocks inserted 3 machine-licm - Number of hoisted machine instructions CSEed 11 machine-licm - Number of machine instructions hoisted out of loops 73 machine-sink - Number of machine instructions sunk 6 memdep - Number of block queries that were completely cached 11 memdep - Number of fully cached non-local ptr responses 43 memdep - Number of uncached non-local ptr responses 784 pei - Number of bytes used for stack in all functions 1 phi-opt - Number of dead PHI cycles 15 phielim - Number of atomic phis lowered 31 pre-RA-sched - Number of loads clustered together 48 reassociate - Number of insts reassociated 29 regalloc - Number of cross class joins performed 251 regalloc - Number of identity moves eliminated after coalescing 92 regalloc - Number of identity moves eliminated after rewriting 7 regalloc - Number of instructions deleted by DCE 4 regalloc - Number of instructions re-materialized 1 regalloc - Number of interferences evicted 251 regalloc - Number of interval joins performed 11 regalloc - Number of new live ranges queued 683 regalloc - Number of original intervals 369 regalloc - Number of registers assigned 1 regalloc - Number of registers unassigned 3 regalloc - Number of rematerialized defs for spilling 4 regalloc - Number of rematerialized defs for splitting 3 regalloc - Number of spilled live ranges 2 regalloc - Number of splits finished 4 simplifycfg - Number of blocks simplified 2 twoaddrinstr - Number of instructions aggressively commuted 2 twoaddrinstr - Number of instructions commuted to coalesce 4 twoaddrinstr - Number of instructions promoted to 3-address 30 twoaddrinstr - Number of two-address instructions 14 x86-codegen - Number of floating point instructions 1414 x86-emitter - Number of machine instructions emitted ->

यहाँ पाँच लाइनें महत्वपूर्ण हैं:

 Soft run: 60 Cold jit run: 46 Hot jit run: 28 Patched cold jit run: 12 Patched hot jit run: 9

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

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

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

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

पांचवीं पंक्ति पैचेड और अनुकूलित विधि का हॉट रन है। फिर, बस बिना किसी चाल के ऐसा कर रहा था।

ये पीज़ हैं ... मानों को बढ़ाते हुए, हम पाते हैं कि मेरी मशीन पर प्रति सेकंड लगभग 12 मिलियन ब्लॉक संसाधित होते हैं। इस स्थिरांक से आप संसाधित संदेशों की संख्या का अनुमान प्राप्त कर सकते हैं। JIT कोड में Number>>to:do: विधि के अनुसार, तीन ऑपरेशन किए जाते हैं जो निम्नलिखित संदेश भेजने के बराबर होते हैं:

#to:do: अंदर < काउंटर ऑब्जेक्ट भेजना #to:do: (लूप कंडीशन);
#value: बनाना #value: एक ब्लॉक ऑब्जेक्ट (ब्लॉक कॉल);
sum ऑब्जेक्ट (लूप बॉडी) को + भेजना।

हमें लगातार 36 मिलियन मिलते हैं, जिसे प्रति सेकंड भेजे गए संदेशों की संख्या के ऊपर से एक मोटे अनुमान के रूप में माना जा सकता है।

इसी समय, यह गति सीमा से दूर है। उदाहरण के लिए, यदि हम समय- whileTrue: निर्माण का उपयोग करते हुए बेंचमार्क के शरीर को फिर से whileTrue:

 loopBenchmark | sum | sum <- 0. [ sum < 1000000 ] whileTrue: [ sum <- sum + 1 ]. ^sum

फिर एक लाख पर रन के परिणाम (एक सौ हजार के बजाय, निरंतर पर ध्यान दें) निम्नानुसार होंगे:

 Soft run: 197 Cold jit run: 13 Hot jit run: 4

इस स्थिति में, हमें प्रति सेकंड case 8.1 messages 10 ⁸ संदेशों के बराबर या 197/4, का त्वरण 50 गुना मिलता है। ऐसा इसलिए है क्योंकि अब संकलित संस्करण में संदेश भेजने का कोई वास्तविक संचालन नहीं है। whileTrue: संक्रमण के साथ निर्देशों के एक रैखिक सेट में फैलता है; सभी ऑपरेशन उन संख्याओं पर होते हैं, जिनके लिए निष्पादन की अलग-अलग शाखाएं होती हैं, जिसमें सीधे अंकगणितीय ऑपरेशन शामिल होते हैं।

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

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

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

छंटनी परीक्षण अधिक मामूली परिणाम दिखाता है:

 Soft run: 48 Cold jit run: 140 Hot jit run: 25 Patched cold jit run: 7 Patched hot jit run: 6

पूर्ण निष्कर्ष

 Preparing test data ...done Soft run: 48 Cold jit run: 140 Hot jit run: 25 JIT Runtime stat: Messages dispatched: 210613 Objects allocated: 17746 Blocks invoked: 43006 Block cache hits: 43001 misses 5 ratio 99.99 % Message cache hits: 369520 misses 51704 ratio 87.73 % Hot methods: Hit count Method name 44061 Link>>next (0 sites) 35102 MetaObject>>in:at:put: (0 sites) 27775 Link>>value (0 sites) 25778 Block>>value:value: (0 sites) 17746 Class>>new (0 sites) 17356 MetaLink>>value:next: (3 sites) new (index 3, offset 7) class hits: (MetaLink 17356) in:at:put: (index 11, offset 31) class hits: (MetaLink 17356) in:at:put: (index 18, offset 72) class hits: (MetaLink 17356) 17226 Block>>value: (0 sites) 15619 List>>add: (1 sites) value:next: (index 5, offset 13) class hits: (MetaLink 15619) 1999 List>>isEmpty (1 sites) = (index 4, offset 9) class hits: (SmallInt 1999) 1999 SmallInt>>= (0 sites) 1867 List>>insert:onCondition: (10 sites) isEmpty (index 3, offset 7) class hits: (List 1867) add: (index 10, offset 27) class hits: (List 130) value (index 33, offset 166) class hits: (Link 10419) value:value: (index 40, offset 210) class hits: (Block 10419) next (index 48, offset 268) class hits: (Link 1481) value:next: (index 50, offset 286) class hits: (MetaLink 1481) value:next: (index 57, offset 21) class hits: (Link 1481) next (index 68, offset 8) class hits: (Link 8938) value:next: (index 81, offset 24) class hits: (MetaLink 256) next: (index 83, offset 9) class hits: (Link 256) 1481 Link>>value:next: (0 sites) 392 List>>size (0 sites) 390 MetaList>>new (2 sites) new (index 4, offset 9) class hits: (MetaCollection 390) in:at:put: (index 12, offset 34) class hits: (MetaList 390) 384 Link>>next: (0 sites) 262 Collection>>sort: (13 sites) size (index 3, offset 7) class hits: (List 262) insertSort: (index 12, offset 34) class hits: (List 132) popFirst (index 21, offset 88) class hits: (List 130) new (index 26, offset 126) class hits: (MetaList 130) new (index 31, offset 158) class hits: (MetaList 130) value:value: (index 42, offset 219) class hits: (Block 15359) add: (index 49, offset 279) class hits: (List 8207) add: (index 56, offset 12) class hits: (List 7152) do: (index 59, offset 31) class hits: (List 130) sort: (index 64, offset 64) class hits: (List 130) sort: (index 70, offset 19) class hits: (List 130) add: (index 76, offset 4) class hits: (List 130) appendList: (index 81, offset 24) class hits: (List 130) 260 Link>>do: (2 sites) value (index 18, offset 72) class hits: (Link 260) value: (index 20, offset 82) class hits: (Block 260) 260 List>>do: (1 sites) do: (index 9, offset 25) class hits: (Link 260) 132 Collection>>insertSort: (4 sites) isEmpty (index 3, offset 7) class hits: (List 132) new (index 16, offset 55) class hits: (MetaList 130) insert:onCondition: (index 27, offset 130) class hits: (List 1867) do: (index 30, offset 143) class hits: (List 130) 130 List>>popFirst (3 sites) value (index 14, offset 43) class hits: (Link 130) next (index 19, offset 76) class hits: (Link 130) - (index 25, offset 111) class hits: (SmallInt 130) 130 SmallInt>>- (0 sites) 130 List>>appendList: (7 sites) firstLink (index 8, offset 21) class hits: (List 2) size (index 13, offset 40) class hits: (List 2) next (index 36, offset 181) class hits: (Link 8207) next (index 43, offset 234) class hits: (Link 8079) firstLink (index 54, offset 3) class hits: (List 128) next: (index 56, offset 12) class hits: (Link 128) size (index 61, offset 49) class hits: (List 128) 130 List>>firstLink (0 sites) 2 Collection>>sort (1 sites) sort: (index 10, offset 27) class hits: (List 2) 2 Block>>value (0 sites) ===-------------------------------------------------------------------------=== ... Statistics Collected ... ===-------------------------------------------------------------------------=== 2 adce - Number of instructions removed 14 branchfolding - Number of block tails merged 6 branchfolding - Number of branches optimized 5 branchfolding - Number of dead blocks removed 1 cgscc-passmgr - Maximum CGSCCPassMgr iterations on one SCC 38 codegen-dce - Number of dead instructions deleted 220 codegenprepare - Number of GEPs converted to casts 2 codegenprepare - Number of blocks eliminated 151 codegenprepare - Number of memory instructions whose address computations were sunk 123 codegenprepare - Number of uses of Cast expressions replaced with uses of sunken Casts 854 dagcombine - Number of dag nodes combined 250 dce - Number of insts removed 194 dse - Number of other instrs removed 158 dse - Number of stores deleted 51 gvn - Number of blocks merged 353 gvn - Number of instructions deleted 6 gvn - Number of loads PRE'd 277 gvn - Number of loads deleted 862 inline - Number of functions inlined 862 inline-cost - Number of call sites analyzed 1085 instcombine - Number of dead inst eliminated 69 instcombine - Number of instructions sunk 2540 instcombine - Number of insts combined 194 isel - Number of blocks selected using DAG 18193 isel - Number of times dag isel has to try another path 461 jit - Number of bytes of global vars initialized 12042 jit - Number of bytes of machine code compiled 25 jit - Number of global vars initialized 375 jit - Number of relocations applied 2 jit - Number of slabs of memory allocated by the JIT 15 llst - Number of removed loads from gc.root protected pointers <<<<<< 222 llst - Number of removed roots <<<<<< 4 machine-cse - Number of common subexpression eliminated 1 machine-licm - Number of hoisted machine instructions CSEed 14 machine-licm - Number of machine instructions hoisted out of loops 71 machine-sink - Number of machine instructions sunk 10 memdep - Number of block queries that were completely cached 81 memdep - Number of fully cached non-local ptr responses 84 memdep - Number of uncached non-local ptr responses 2792 pei - Number of bytes used for stack in all functions 9 phielim - Number of atomic phis lowered 2 phielim - Number of critical edges split 36 pre-RA-sched - Number of loads clustered together 23 reassociate - Number of insts reassociated 21 regalloc - Number of cross class joins performed 250 regalloc - Number of identity moves eliminated after coalescing 124 regalloc - Number of identity moves eliminated after rewriting 6 regalloc - Number of instructions deleted by DCE 1 regalloc - Number of interferences evicted 248 regalloc - Number of interval joins performed 21 regalloc - Number of new live ranges queued 1240 regalloc - Number of original intervals 891 regalloc - Number of registers assigned 1 regalloc - Number of registers unassigned 6 regalloc - Number of rematerialized defs for spilling 4 regalloc - Number of rematerialized defs for splitting 6 regalloc - Number of spilled live ranges 4 regalloc - Number of splits finished 13 simplifycfg - Number of blocks simplified 3 twoaddrinstr - Number of instructions re-materialized 43 twoaddrinstr - Number of two-address instructions 40 x86-codegen - Number of floating point instructions 2697 x86-emitter - Number of machine instructions emitted Patching active methods that have hot call sites Recompiling method for patching: MetaLink>>value:next: Patching MetaLink>>value:next: ...done. Verifying ...done. Recompiling method for patching: List>>add: Patching List>>add: ...done. Verifying ...done. Recompiling method for patching: List>>isEmpty Patching List>>isEmpty ...done. Verifying ...done. Recompiling method for patching: List>>insert:onCondition: Patching List>>insert:onCondition: ...done. Verifying ...done. Recompiling method for patching: MetaList>>new Patching MetaList>>new ...done. Verifying ...done. Recompiling method for patching: Collection>>sort: Patching Collection>>sort: ...done. Verifying ...done. Recompiling method for patching: Link>>do: Patching Link>>do: ...done. Verifying ...done. Recompiling method for patching: List>>do: Patching List>>do: ...done. Verifying ...done. Recompiling method for patching: Collection>>insertSort: Patching Collection>>insertSort: ...done. Verifying ...done. Recompiling method for patching: List>>popFirst Patching List>>popFirst ...done. Verifying ...done. Recompiling method for patching: List>>appendList: Patching List>>appendList: ...done. Verifying ...done. Recompiling method for patching: Collection>>sort Patching Collection>>sort ...done. Verifying ...done. Optimizing MetaLink>>value:next: ...done. Verifying ...done. Optimizing List>>add: ...done. Verifying ...done. Optimizing List>>isEmpty ...done. Verifying ...done. Optimizing List>>insert:onCondition: ...done. Verifying ...done. Optimizing MetaList>>new ...done. Verifying ...done. Optimizing Collection>>sort: ...done. Verifying ...done. Optimizing Link>>do: ...done. Verifying ...done. Optimizing List>>do: ...done. Verifying ...done. Optimizing Collection>>insertSort: ...done. Verifying ...done. Optimizing List>>popFirst ...done. Verifying ...done. Optimizing List>>appendList: ...done. Verifying ...done. Optimizing Collection>>sort ...done. Verifying ...done. Compiling machine code for MetaLink>>value:next: ...done. Compiling machine code for List>>add: ...done. Compiling machine code for List>>isEmpty ...done. Compiling machine code for List>>insert:onCondition: ...done. Compiling machine code for MetaList>>new ...done. Compiling machine code for Collection>>sort: ...done. Compiling machine code for Link>>do: ...done. Compiling machine code for List>>do: ...done. Compiling machine code for Collection>>insertSort: ...done. Compiling machine code for List>>popFirst ...done. Compiling machine code for List>>appendList: ...done. Compiling machine code for Collection>>sort ...done. All is done. Patched cold jit run: 7 Patched hot jit run: 6

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

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

स्मालटाक वर्चुअल मशीन

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

यह समझने के लिए कि एक मशीन कैसे करती है, सबसे पहले समझना चाहिए कि स्मॉलटाक ऑब्जेक्ट क्या है।

वस्तुएं

निम्नलिखित संरचना द्वारा किसी भी वस्तु को सरल बनाया जा सकता है:

 struct TObject { TSize size; TClass* klass; union { TObject* fields[0]; uint8_t bytes[0]; }; };

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

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

इस प्रकार, 30 बिट ऑब्जेक्ट के आकार के लिए बने रहते हैं। साधारण वस्तुओं के लिए, आकार की गणना खेतों में (4 बाइट्स की एक बहु), बाइनरी के लिए - बाइट्स में की जाती है। चूंकि दोनों वस्तुओं में समान, प्रसिद्ध शीर्षक है, इसलिए इसका आकार कुल राशि में नहीं लिया जाता है।

sMALLINT

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

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

यह छोटी चाल काफी खपत की गई मेमोरी को कम कर सकती है, क्योंकि इसके बाइनरी प्रतिनिधित्व की तुलना में संख्या लिखने के लिए केवल 1 बिट का उपयोग किया जाता है। यदि बॉक्सिंग का उपयोग किया जाता है , तो प्रत्येक संख्या के लिए, ऑब्जेक्ट पॉइंटर के 4 बाइट्स के अलावा, हेडर के 8 बाइट्स और वास्तविक डेटा के 4 और बाइट्स संग्रहीत किए जाएंगे। सबसे अच्छा विकल्प नहीं है, यह मुझे लगता है।

संदेशों

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

एक संदेश भेजना एक वर्ग के पदानुक्रम में एक खोज से शुरू होता है जो संदेश को संभाल सकता है। खोज वस्तु के तात्कालिक वर्ग से, पदानुक्रम तक, तक की जाती हैObject। मुझे कहना होगा कि यह एक महंगा ऑपरेशन है, क्योंकि आपको बड़ी संख्या में मेमोरी एक्सेस करनी होती है। इसलिए, खोज परिणाम कैश किए जाते हैं। इस प्रकार, एक पूर्ण खोज केवल एक बार ही की जानी है। विधि कैश केवल दो मामलों में फ़्लश किया जाता है - अगले कचरा संग्रह के दौरान (विधि ऑब्जेक्ट्स स्थानांतरित हो सकते हैं) और जब अगला तरीका जोड़ा गया / हटाया गया (यह पदानुक्रम को प्रभावित कर सकता है)। यहां तक कि कचरा संग्रह के दौरान कैश की नियमित सफाई को ध्यान में रखते हुए, हिट का प्रतिशत बहुत अधिक (लगभग 99%) रहता है, ताकि किसी विधि को खोजने में बिताया गया समय औसत रूप से महत्वहीन माना जा सके।

आइए देखें कि किसी वस्तु 'Hello world'(वर्ग उदाहरण String) को संदेश भेजने के मामले में खोज कैसे होती है #isNil।

खोज इस प्रकार की जाएगी:

hash(String, #isNil);
, ;
, String :
methods , ( Dictionary ) .
: ;
;
;
, , , ; ;
, :
( nil ), 4;
, .

यदि विधि श्रेणी पदानुक्रम में कभी नहीं मिली, तो वर्चुअल मशीन उस ऑब्जेक्ट को एक संदेश भेजती #doesNotUnderstand:है जिसे संसाधित होने की गारंटी दी जाएगी (कम से कम वास्तविक में Object)। कुछ मामलों में, कक्षाएं विशिष्ट लक्ष्यों को प्राप्त करने के लिए जानबूझकर इस संदेश को रोकती हैं। उदाहरण के लिए, प्रॉक्सी ऑब्जेक्ट ऐसा कर सकते हैं, जो तब एक वैध पते पर संदेश पहुंचाते हैं।

उपरोक्त संदेश के लिए, String>>isNilखोज श्रृंखला होगी:
String→ Array→ Collection→ Magnitude→ → Object।

विधि पाए जाने के बाद, वर्चुअल मशीन संदर्भ ऑब्जेक्ट बनाता है और पॉप्युलेट करता है, और फिर विधि के लिए आगे बढ़ता है।

प्रसंग

संदर्भ की अवधारणा एक संदेश भेजने के संचालन के लिए अटूट रूप से जुड़ी हुई है।

X86 जैसे पारंपरिक प्रोसेसर आर्किटेक्चर में, कॉल स्टैक की अवधारणा मौजूद है । जब फ़ंक्शन को कॉल किया जाता है, तो रिटर्न एड्रेस के साथ पास किए गए पैरामीटर को स्टैक पर धकेल दिया जाता है, जिसके बाद फ़ंक्शन बॉडी में संक्रमण किया जाता है। जब आप फ़ंक्शन से बाहर निकलते हैं, तो क्रमशः स्टैक के शीर्ष से रिटर्न एड्रेस हटा दिया जाता है। यह पता चलता है कि स्टैक पर प्रत्येक फ़ंक्शन के लिए वर्तमान फ़ंक्शन कॉल में थ्रेड प्रारंभ होने के क्षणों से संक्रमण का संपूर्ण "पदानुक्रम" निहित है।

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

 struct TContext : public TObject { TMethod* method; TObjectArray* arguments; TObjectArray* temporaries; TObjectArray* stack; TInteger bytePointer; TInteger stackTop; TContext* previousContext; };

विधि - इस संदेश को संसाधित करने वाली पहले से प्राप्त विधि ऑब्जेक्ट के लिए एक संकेतक यहां रखा गया है।
तर्क - द्रव्यमान (उदाहरण Array) के सूचक को यहां संग्रहीत किया जाता है , जहां पारित तर्क सहेजे जाते हैं।
अस्थायी - अस्थायी विधि चर का भंडारण। विशेष रूप से, वे जो | |विधि शीर्षलेख में वर्णों के बीच लिखे गए हैं ।
stack — . . . , . .
bytePointer — ; IP . . .
stackTop — .
पिछला कॉन्टेक्स्ट - और यहाँ अभिभावक प्रसंग को केवल संग्रहित किया गया है, जिस विधि से संदेश भेजा गया था। जब आप वर्तमान विधि से एक मान लौटाते हैं, तो इसे मूल स्टैक के ऊपर रखा जाएगा।

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

तरीकों

विधियों का प्रतिनिधित्व निम्न रूप की वस्तुओं द्वारा किया जाता है:

 struct TMethod : public TObject { TSymbol* name; TByteObject* byteCodes; TSymbolArray* literals; TInteger stackSize; TInteger temporarySize; TClass* klass; TString* text; TObject* package; };

नाम - विधि का वास्तविक नाम, या इस नाम के प्रतीक के लिए एक संकेतक।
byteCodes — ByteArray , - .
literals — . : , , . , .
stackSize — (. TContext::stack), .
temporarySize — , . .
klass — , .
text — .
पैकेज इस विधि की श्रेणी है। उपयोगकर्ता इंटरफ़ेस में प्रदर्शित विधियों की सूचियों को फ़िल्टर करने के लिए डिज़ाइन किया गया है। वर्तमान में उपयोग नहीं किया गया।

विधि ऑब्जेक्ट तब बनते हैं जब प्राथमिक छवि स्रोत ImageSource.st से ImageBuilder का उपयोग करके संकलित की जाती है, और फिर परिणामी छवि फ़ाइल में सहेजी जाती है। साथ ही, कमांड लाइन से कमांड निष्पादित होने पर एक बार का तरीका बनाया जाता है। वास्तव में, कमांड लाइन पाठ की व्याख्या विधि के निकाय के रूप में की जाती है, जिसे बाद में संकलित किया जाता है और सामान्य तरीके से बुलाया जाता है।

यह इस तरह किया जाता है। विधि के शरीर में Undefined>>mainकोड है :

 [ command <- String readline: '->'. command notNil ] whileTrue: [ command isEmpty ifFalse: [ command doIt printNl ] ]

सबसे पहले, रीडलाइन लाइब्रेरी का उपयोग करके, हमें कमांड लाइन मिलती है। फिर एक संदेश स्ट्रिंग ऑब्जेक्ट को भेजा जाता है #doIt, जिसका परिणाम स्क्रीन पर प्रदर्शित होता है। विधि #doItइस प्रकार है:

 doIt | method | method <- Undefined parseMethod: 'doItCommand ^ ' + self. ^ method notNil ifTrue: [ ^ Context new perform: method withArguments: (Array new: 1) ]

सभी मैजिक एक ऐसी विधि से बनाया गया है जो इमेज टेक्स्ट में यहां लागू कंपाइलर का उपयोग करके Undefined>>parseMethod:सोर्स टेक्स्ट #doItCommandसे मेथड ऑब्जेक्ट बनाता है । यह पता चला है कि स्मॉलटाक खुद स्मॉलटाक में लिखे गए कंपाइलर का उपयोग करके अपने स्वयं के तरीकों का संकलन करता है, जो छवि का एक अभिन्न अंग है। मुझे यह पल काफी मजेदार लगता है।

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

वर्चुअल मशीन निर्देश

एक वर्चुअल मशीन केवल तरीकों के ढांचे के भीतर निर्देशों को निष्पादित कर सकती है। बाहर कोड के तरीके मौजूद नहीं हैं। निर्देश वर्ग उदाहरण के बाइटकोड्स फ़ील्ड में संग्रहीत किए जाते हैं Method। उदाहरण में, इसके अतिरिक्त, अतिरिक्त जानकारी होती है, जिसका उपयोग संदर्भ ऑब्जेक्ट को प्रारंभ करते समय भी किया जाता है (ऊपर देखें)।

चूंकि लेख पहले ही बहुत बढ़ चुका है, इसलिए मैं यहां बाईटकोड का प्रतिनिधित्व करने के प्रारूप के बारे में विस्तार से वर्णन नहीं करूंगा। मैं केवल यह ध्यान देता हूं कि एक निर्देश एक या दो बाइट्स पर कब्जा कर सकता है।

मूल्य ढेर निर्देश

ऑब्जेक्ट स्टैक के शीर्ष पर किसी एक ऑब्जेक्ट को पुश करने के निर्देश भी हैं । निर्देश कोड के साथ, एक पूर्णांक पैरामीटर भी निर्दिष्ट किया जाता है, जिसे संबंधित डेटा संरचना से एक वस्तु का चयन करने के लिए एक सूचकांक के रूप में व्याख्या की जाती है:

pushArgument - वर्तमान संदर्भ के तर्कों के एक तर्क से एक तर्क।
pushInstance - वर्तमान वस्तु का क्षेत्र।
pushTemporary - वर्तमान संदर्भ के चर की एक सरणी से एक अस्थायी चर।
pushLiteral - इस पद्धति के एक निरंतर सरणी से एक शाब्दिक।

दो अन्य विशेष पुश निर्देश हैं जो थोड़ा अलग तरीके से काम करते हैं:

pushConstant — : SmallInt , 0-9 , nil , true false , Undefined , True False .
pushBlock — Block , - , . bytePointer .

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

असाइनमेंट - वर्तमान ऑब्जेक्ट फ़ील्ड के मान को स्टैक के शीर्ष पर असाइन करता है।
असाइनमेंट - एक अस्थायी चर को एक मान देता है जो स्टैक के शीर्ष पर स्थित है।

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

संक्रमण निर्देश

बेशक, संक्रमण निर्देश हैं:

branchIfTrue — bytePointer , true .
branchIfFalse — , false .
branch — .

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

संदेश भेजते समय, तर्क स्टैक पर धकेल दिए जाते हैं, जिसके बाद markArguments N स्टेटमेंट कहा जाता है । यह स्टैक से एन मान निकालता है और उनसे एक ऑब्जेक्ट बनाता है Array। इसके बाद, इस ऑब्जेक्ट का पॉइंटर स्टैक के शीर्ष पर लौटता है, जिसका उपयोग निर्मित संदर्भ ऑब्जेक्ट के तर्कों के क्षेत्र को शुरू करते समय किया जाएगा ।

वापसी के निर्देश

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

स्मॉलटाक में एक मनमाना मूल्य वापस करने के अलावा , परिणाम के रूप में स्व- वापसी करना बहुत बार आवश्यक होता है। इसलिए, इस तरह के ऑपरेशन के लिए एक अलग आत्म- बयान बयान प्रदान किया जाता है ।

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

यह एक उदाहरण के साथ दिखाना सबसे आसान है। यह विधि पाठ है।Collection>>at:ifAbsent:

 at: value ifAbsent: exceptionBlock self do: [ :element | element = value ifTrue: [ ^element ] ]. ^exceptionBlock value

^elementनेस्टेड ब्लॉक में एक अभिव्यक्ति को ब्लॉकरटर्न स्टेटमेंट का उपयोग करके संकलित किया जाएगा । यह आवश्यक है क्योंकि वास्तव में, ब्लॉक को वर्तमान विधि में निष्पादित नहीं किया जाएगा, लेकिन बहुत गहरा है। विधि विधि को Collection>>at:ifAbsent:कॉल करती है Collection>>do:, बाहरी ब्लॉक को एक पैरामीटर के रूप में पारित करती है। विधि, Collection>>do:बदले में, Block>>value:संग्रह के प्रत्येक तत्व को कॉल करेगी , इसे ब्लॉक के पैरामीटर के रूप में पास करेगी । और केवल अंदर ही Block>>value:आदिम संख्या 8 है, जो पहले से ही ब्लॉक कोड के निष्पादन को बढ़ावा देगा। इसलिए, कोड ब्लॉक यह तय करेगा कि मूल्य को वापस करना आवश्यक है element, यह ब्लॉक-रीट अनुदेश का उपयोग करके ऐसा करेगा , जो नियंत्रण को बहुत ऊपर, बाहर तक स्थानांतरित करेगाCollection>>at:ifAbsent:संदेश के परिणाम के रूप में वांछित मान लौटाते हुए।

यह ध्यान देने योग्य है कि ^ब्लॉक के निकाय में खड़े प्रत्येक ऑपरेटर को ब्लॉकटर्न विवरण में परिवर्तित नहीं किया जाएगा । जब भी संभव हो, संकलक कोड को सरल निर्देशों में विघटित करने की कोशिश करता है: निष्पादन विधि के शरीर में ब्लॉक एम्बेड करें और सरल निर्देश संक्रमण के साथ ब्लॉक की कॉल को बदलें। इस स्थिति में, ब्लॉक रीटर्न को स्टैकरटर्न या सेल्फटर्न से भी बदल दिया जाएगा ।

विशेष निर्देश

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

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

विधि निष्पादन

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

हम पहले से ही पिछले लेख से परिचित संग्रह छँटाई विधि के आधार पर विधि के निष्पादन और JIT संकलक के कार्य को ट्रैक करेंगे:

 ->Collection viewMethod: #sort: 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

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

 ->Collection methods at: #sort:; disassemble "  " 0000 PushArgument 0 "    self" 0001 MarkArguments 1 0002 SendMessage size 0003 PushLiteral 1 "  1        32" 0004 SendBinary < " " 0005 DoSpecial branchIfFalse 16 "     " "  :" 0008 PushArgument 0 0009 PushArgument 1 0010 MarkArguments 2 0011 SendMessage insertSort: 0012 DoSpecial stackReturn 0013 DoSpecial branch 17 "   :" 0016 PushConstant nil " " 0017 DoSpecial popTop "mediane <- self popFirst" 0018 PushArgument 0 0019 MarkArguments 1 0020 SendMessage popFirst 0021 AssignTemporary 2 0022 DoSpecial popTop "left <- List new" 0023 PushLiteral 4 0024 MarkArguments 1 0025 SendMessage new 0026 AssignTemporary 0 0027 DoSpecial popTop "right <- List new" 0028 PushLiteral 6 0029 MarkArguments 1 0030 SendMessage new 0031 AssignTemporary 1 0032 DoSpecial popTop "self do: ..." 0033 PushArgument 0 0034 PushBlock " " 0037 PushArgument 1 "criteria" 0038 PushTemporary 3 "x" 0039 PushTemporary 2 "mediane" 0040 MarkArguments 3 0041 SendMessage value:value: "  " 0042 DoSpecial branchIfFalse 52 "left add: x" 0045 PushTemporary 0 0046 PushTemporary 3 0047 MarkArguments 2 0048 SendMessage add: 0049 DoSpecial branch 56 "right add: x" 0052 PushTemporary 1 0053 PushTemporary 3 0054 MarkArguments 2 0055 SendMessage add: 0056 DoSpecial stackReturn 0057 MarkArguments 2 0058 SendMessage do: 0059 DoSpecial popTop "  left" 0060 PushTemporary 0 0061 PushArgument 1 0062 MarkArguments 2 0063 SendMessage sort: 0064 AssignTemporary 0 0065 DoSpecial popTop "  right" 0066 PushTemporary 1 0067 PushArgument 1 0068 MarkArguments 2 0069 SendMessage sort: 0070 AssignTemporary 1 0071 DoSpecial popTop "right add: mediane" 0072 PushTemporary 1 0073 PushTemporary 2 0074 MarkArguments 2 0075 SendMessage add: 0076 DoSpecial popTop "  " 0077 PushTemporary 0 0078 PushTemporary 1 0079 MarkArguments 2 0080 SendMessage appendList: " " 0081 DoSpecial stackReturn "( )" 0082 DoSpecial popTop 0083 DoSpecial selfReturn

निष्कर्ष

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

हमने सीखा कि वस्तुएं एक स्मालटाक छवि में कैसे दिखती हैं, संख्याओं का प्रतिनिधित्व कैसे किया जाता है, एक संदेश भेजने और एक उपयुक्त वर्ग की खोज के लिए एल्गोरिथ्म का पता लगाया, और सीखा कि एक संदर्भ वस्तु क्या है; अंत में, हम वर्चुअल मशीन के मूल निर्देशों से परिचित हो गए, पहले से ही ज्ञात छँटाई विधि के कोड की जांच की और उन निर्देशों को जिसमें यह संकलक द्वारा अनुवादित किया गया है।

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

अंत में, एक छोटा सा सर्वेक्षण:

Llst आंतरिक भाग 2 या लिटिल स्मॉलटॉक + LLVM = ♥