🧝🏾 ⬜️ 💱 [अनुवाद] ग्रेगल - जावा जेवीएम जेवीएम कंपाइलर कैसे काम करता है 👂🏽 🤴🏾 🍰

नमस्कार, हेब्र! मैं आपको लेख " अंडरस्टैंडिंग हाउ ग्रेवल वर्क्स - जावा जेआईटी कम्पाइलर जावा में लिखा " का अनुवाद प्रस्तुत करता हूं।

परिचय

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

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

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

यदि आप जानते हैं कि एक जेवीएम क्या है; आम तौर पर समझते हैं कि शब्दों के बाइटकोड और मशीन कोड का क्या मतलब है; और जावा में लिखा कोड पढ़ने में सक्षम है, तो मुझे आशा है कि प्रस्तुत सामग्री को समझने के लिए यह पर्याप्त होगा।

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

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

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

जेआईटी कंपाइलर क्या है?

मुझे यकीन है कि आप में से बहुत से लोग जानते हैं कि एक जेआईटी कंपाइलर क्या है, लेकिन फिर भी मैं मूल बातों पर स्पर्श करूंगा ताकि कोई भी इस मुख्य प्रश्न को पूछने से डरकर यहां न बैठे।

जब आप IDE में javac या compile-on-save कमांड चलाते हैं, तो आपका Java प्रोग्राम जावा कोड से JVM बायटेकोड पर संकलित होता है, जो प्रोग्राम का बाइनरी प्रतिनिधित्व है। यह जावा स्रोत कोड की तुलना में अधिक कॉम्पैक्ट और सरल है। हालाँकि, आपके लैपटॉप या सर्वर का नियमित प्रोसेसर सिर्फ JVM बायटेकोड को निष्पादित नहीं कर सकता है।

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

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

जावा में JIT कंपाइलर क्यों लिखें?

तिथि करने के लिए, ओपन जेडीके नामक एक जेवीएम कार्यान्वयन में दो मुख्य जेआईटी संकलक शामिल हैं। क्लाइंट कंपाइलर, जिसे C1 के रूप में जाना जाता है, को तेज संचालन के लिए डिज़ाइन किया गया है, लेकिन एक ही समय में कम अनुकूलित कोड का उत्पादन करता है। सर्वर कंपाइलर, जिसे ऑप्टो या सी 2 के रूप में जाना जाता है, को काम करने के लिए थोड़ा अधिक समय की आवश्यकता होती है, लेकिन अधिक अनुकूलित कोड का उत्पादन करता है।

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

आज उन्हें जोड़ा जा सकता है ताकि कोड को पहले C1 द्वारा संकलित किया जाए, और फिर, अगर इसे गहन रूप से निष्पादित किया जाता है और यह अतिरिक्त समय बिताने के लिए समझ में आता है, - C2। इसे tiered संकलन कहते हैं।

चलो C2 पर स्थित है, सर्वर कंपाइलर जो अधिक अनुकूलन करता है।

हम OpenJDK को GitHub पर दर्पण से क्लोन कर सकते हैं, या साइट पर प्रोजेक्ट ट्री खोल सकते हैं।

 $ git clone https://github.com/dmlloyd/openjdk.git

C2 कोड Openjdk / hotspot / src / share / vm / opto में है ।

स्रोत कोड C2

सबसे पहले, यह ध्यान देने योग्य है कि C2 C ++ में लिखा गया है । बेशक, यह कुछ बुरा नहीं है, लेकिन कुछ नुकसान भी हैं। C ++ एक असुरक्षित भाषा है। इसका अर्थ है कि C ++ में त्रुटियां VM को क्रैश कर सकती हैं। इसका कारण शायद कोड की उम्र है, लेकिन C2 C ++ कोड को बनाए रखना और विकसित करना बहुत मुश्किल हो गया है।

C2 संकलक के पीछे के प्रमुख आंकड़ों में से एक, Cliff Click ने कहा कि वह C ++ में फिर से कभी भी VM नहीं लिखेगा, और हमने ट्विटर JVM टीम को यह कहते सुना कि C2 स्थिर है और इसे एक कारण के लिए प्रतिस्थापित करने की आवश्यकता है आगे के विकास की कठिनाइयों।

क्लिफ क्लिक प्रेजेंटेशन

क्या क्लिफ क्लिक फिर से करना नहीं चाहता है

https://www.youtube.com/watch?v=Hqw57GJSrac

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

आप सोच सकते हैं : मैं जावा जेआईटी संकलक जैसा कुछ कैसे लिख सकता हूं? , और यह केवल C ++ जैसी निम्न-स्तरीय सिस्टम प्रोग्रामिंग भाषा में ही संभव है। इस प्रस्तुति में, मैं आपको विश्वास दिलाता हूं कि यह बिल्कुल भी नहीं है! अनिवार्य रूप से, जेआईटी कंपाइलर को जेवीएम बायटेकोड को स्वीकार करना चाहिए और मशीन कोड देना चाहिए - आप इसे इनपुट पर byte[] देते हैं, और आप भी byte[] पाना चाहते हैं। ऐसा करने के लिए बहुत सारे जटिल काम लगते हैं, लेकिन यह सिस्टम स्तर को प्रभावित नहीं करता है, और इसलिए सिस्टम भाषा जैसे कि C या C ++ की आवश्यकता नहीं होती है।

ग्रेगल सेटअप

पहली चीज जो हमें चाहिए वह है जावा 9. जेआरएमसीआई नामक ग्रेवल इंटरफेस, जिसे जेईपी 243 जावा-लेवल जेवीएम कंपाइलर इंटरफेस के हिस्से के रूप में जावा में जोड़ा गया था और पहले संस्करण में यह जावा 9 शामिल है। मैं 9 + 181 का उपयोग करता हूं। किसी विशेष आवश्यकताओं के मामले में, जावा 8 के लिए पोर्ट (बैकपोर्ट) हैं।

 $ export JAVA_HOME=`pwd`/jdk9 $ export PATH=$JAVA_HOME/bin:$PATH $ java -version java version "9" Java(TM) SE Runtime Environment (build 9+181) Java HotSpot(TM) 64-Bit Server VM (build 9+181, mixed mode)

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

आप GitHub के साथ mx क्लोन कर सकते हैं। मैं #7353064 कमिट का उपयोग कर रहा #7353064 । अब केवल निष्पादन योग्य को पथ में जोड़ें।

 $ git clone https://github.com/graalvm/mx.git $ cd mx; git checkout 7353064 $ export PATH=`pwd`/mx:$PATH

अब हमें खुद ग्रैल को क्लोन करना होगा। मैं एक वितरण का उपयोग कर रहा हूँ जिसका नाम है ग्रेवलम संस्करण ०.२ ..२ ।

 $ git clone https://github.com/graalvm/graal.git --branch vm-enterprise-0.28.2

इस रिपॉजिटरी में अन्य परियोजनाएं शामिल हैं, जिनमें हमें कोई दिलचस्पी नहीं है, इसलिए हम सिर्फ कंपाइलर सबप्रोजेक्ट में जाते हैं, जो कि ग्रेगल जेआईटी कंपाइलर है, और इसे mx का उपयोग करके संकलित करते हैं।

 $ cd graal/compiler $ mx build

ग्रेगल कोड के साथ काम करने के लिए मैं ग्रहण आईडीई का उपयोग करूंगा। मैं ग्रहण 4.7.1 का उपयोग कर रहा हूं। mx हमारे लिए ग्रहण प्रोजेक्ट फाइल तैयार कर सकता है।

 $ mx eclipseinit

कार्यक्षेत्र के रूप में ग्रेवल निर्देशिका को खोलने के लिए , आपको फ़ाइल, आयात ..., सामान्य, मौजूदा परियोजनाओं को निष्पादित करने और फिर से ग्रेवल निर्देशिका का चयन करने की आवश्यकता है। यदि आपने जावा 9 पर ग्रहण नहीं चलाया है, तो आपको JDK स्रोतों को भी संलग्न करना पड़ सकता है।

चर्म में

सब ठीक है। अब जब सब कुछ तैयार है, तो आइए देखें कि यह कैसे काम करता है। हम इस बहुत ही सरल कोड का उपयोग करेंगे।

 class Demo { public static void main(String[] args) { while (true) { workload(14, 2); } } private static int workload(int a, int b) { return a + b; } }

सबसे पहले, हम इस javac कोड को संकलित करते हैं, और फिर JVM चलाते हैं। सबसे पहले, मैं आपको दिखाता हूँ कि मानक C2 JIT कंपाइलर कैसे काम करता है। ऐसा करने के लिए, हम कई झंडे निर्दिष्ट -XX:+PrintCompilation : -XX:+PrintCompilation , जो JVM के लिए एक विधि को संकलित करते समय लॉग लिखना आवश्यक है, और -XX:CompileOnly=Demo::workload , ताकि केवल यह संकलन संकलित हो। यदि हम नहीं करते हैं, तो बहुत अधिक जानकारी प्रदर्शित की जाएगी, और जेवीएम हमारी आवश्यकता से अधिक स्मार्ट होगा, और उस कोड को अनुकूलित करेगा जिसे हम देखना चाहते हैं।

 $ javac Demo.java $ java \ -XX:+PrintCompilation \ -XX:CompileOnly=Demo::workload \ Demo ... 113 1 3 Demo::workload (4 bytes) ...

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

अब, हमारे जावा 9 जेवीएम के जेआईटी संकलक के रूप में, हम ताजा संकलित ग्रेगल का उपयोग करते हैं। ऐसा करने के लिए, कुछ और झंडे जोड़ें।

--module-path=... और - --upgrade-module-path=... जोड़ें। आपको याद दिलाता हूं कि जावा मॉड्यूल आरा मॉड्यूल सिस्टम के हिस्से के रूप में मॉड्यूल 9 में दिखाई दिया था, और हमारे उद्देश्यों के लिए हम इसे क्लासपैथ के साथ समानता से विचार कर सकते हैं।

इस संस्करण में जेवीएमसीआई (ग्रेगल द्वारा इस्तेमाल किया जाने वाला इंटरफ़ेस) इस तथ्य के कारण हमें -XX:+UnlockExperimentalVMOptions की आवश्यकता है।

ध्वज -XX:+EnableJVMCI कहने की आवश्यकता है कि हम JVMCI, और -XX:+UseJVMCICompiler का उपयोग करना चाहते हैं - एक नया JIT संकलक सक्षम और स्थापित करने के लिए।

उदाहरण को जटिल नहीं करने के लिए, और, J1MCI के साथ संयोजन के रूप में C1 का उपयोग करने के बजाय, केवल JVMCI संकलक है, ध्वज को निर्दिष्ट करें -XX:-TieredCompilation , जो -XX:-TieredCompilation संकलन को अक्षम कर देगा।

पहले की तरह, हम झंडे निर्दिष्ट करते हैं -XX:+PrintCompilation और -XX:CompileOnly=Demo::workload ।

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

 $ java \ --module-path=graal/sdk/mxbuild/modules/org.graalvm.graal_sdk.jar:graal/truffle/mxbuild/modules/com.oracle.truffle.truffle_api.jar \ --upgrade-module-path=graal/compiler/mxbuild/modules/jdk.internal.vm.compiler.jar \ -XX:+UnlockExperimentalVMOptions \ -XX:+EnableJVMCI \ -XX:+UseJVMCICompiler \ -XX:-TieredCompilation \ -XX:+PrintCompilation \ -XX:CompileOnly=Demo::workload \ Demo ... 583 25 Demo::workload (4 bytes) ...

जेवीएम कंपाइलर इंटरफ़ेस

क्या आपको नहीं लगता कि हमने कुछ असामान्य किया? हमारे पास एक स्थापित जेवीएम है, और हमने जेवीएम में कुछ भी बदले बिना सिर्फ एक नए संकलित के साथ जेआईटी कंपाइलर को बदल दिया। यह सुविधा JVMCI नामक एक नए JVM इंटरफ़ेस द्वारा प्रदान की गई है, JVM संकलक इंटरफ़ेस , जैसा कि मैंने ऊपर कहा था, JEP 243 था और जावा 9 में आया था।

यह विचार कुछ अन्य मौजूदा जेवीएम तकनीकों के समान है।

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

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

जेवीएमसीआई का विचार समान है। यह आपको जावा में लिखे गए अपने स्वयं के जावा JIT संकलक को जोड़ने की अनुमति देता है।

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

अब से, मैं इस राय को दूर करना शुरू करता हूं कि आपके पास हो सकता है कि जेआईटी कंपाइलर बहुत जटिल हो।

जेआईटी संकलक इनपुट के लिए क्या स्वीकार करता है? यह संकलित की जाने वाली विधि के बायटेकोड को स्वीकार करता है। और बाइटकोड, जैसा कि नाम से पता चलता है, केवल बाइट्स की एक सरणी है।

परिणामस्वरूप JIT कंपाइलर क्या उत्पन्न करता है? यह विधि का मशीन कोड देता है। मशीन कोड भी केवल बाइट्स की एक सरणी है।

नतीजतन, यह इंटरफ़ेस जिसे जेवीएम में एम्बेड करने के लिए एक नया जेआईटी कंपाइलर लिखते समय लागू किया जाना चाहिए, कुछ इस तरह दिखाई देगा।

 interface JVMCICompiler { byte[] compileMethod(byte[] bytecode); }

इसलिए, यदि आप कल्पना नहीं कर सकते कि जावा मशीन कोड में जेआईटी संकलन के रूप में निम्न-स्तर के रूप में कुछ कैसे कर सकता है, तो अब आप देख सकते हैं कि यह इतना निम्न-स्तर का काम नहीं है। सच? यह byte[] से केवल एक फ़ंक्शन है।

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

 interface JVMCICompiler { void compileMethod(CompilationRequest request); } interface CompilationRequest { JavaMethod getMethod(); } interface JavaMethod { byte[] getCode(); int getMaxLocals(); int getMaxStackSize(); ProfilingInfo getProfilingInfo(); ... }

साथ ही, इंटरफ़ेस को संकलित कोड की वापसी की आवश्यकता नहीं है। इसके बजाय, एक और एपीआई का उपयोग जेवीएम में मशीन कोड को स्थापित करने के लिए किया जाता है।

 HotSpot.installCode(targetCode);

अब, JVM के लिए एक नया JIT कंपाइलर लिखने के लिए, आपको बस इस इंटरफ़ेस को लागू करने की आवश्यकता है। हमें उस विधि के बारे में जानकारी मिलती है जिसे संकलित करने की आवश्यकता है, और हमें इसे मशीन कोड में संकलित करना चाहिए और installCode कॉल करना installCode ।

 class GraalCompiler implements JVMCICompiler { void compileMethod(CompilationRequest request) { HotSpot.installCode(...); } }

आइए ग्रेगल के साथ ग्रहण आईडीई पर जाएं और कुछ वास्तविक इंटरफेस और कक्षाओं पर एक नज़र डालें। जैसा कि पहले उल्लेख किया गया है, वे कुछ अधिक जटिल होंगे, लेकिन बहुत अधिक नहीं।

JVMCICompiler

HotSpotGraalCompiler

compileMethod

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

 class HotSpotGraalCompiler implements JVMCICompiler { CompilationRequestResult compileMethod(CompilationRequest request) { System.err.println("Going to compile " + request.getMethod().getName()); ... } }

संकलन

अभी के लिए, हॉटस्पॉट में संकलन लॉगिंग को अक्षम करें। अब हम अपने संदेश को संकलक के संशोधित संस्करण से देख सकते हैं।

 $ java \ --module-path=graal/sdk/mxbuild/modules/org.graalvm.graal_sdk.jar:graal/truffle/mxbuild/modules/com.oracle.truffle.truffle_api.jar \ --upgrade-module-path=graal/compiler/mxbuild/modules/jdk.internal.vm.compiler.jar \ -XX:+UnlockExperimentalVMOptions \ -XX:+EnableJVMCI \ -XX:+UseJVMCICompiler \ -XX:-TieredCompilation \ -XX:CompileOnly=Demo::workload \ Demo Going to compile workload

यदि आप इसे स्वयं दोहराने की कोशिश करते हैं, तो आप देखेंगे कि आपको हमारी बिल्ड सिस्टम - mx build को चलाने की आवश्यकता नहीं है। पर्याप्त, ग्रहण के लिए सामान्य, बचाने पर संकलित करें । और निश्चित रूप से हमें स्वयं जेवीएम के पुनर्निर्माण की आवश्यकता नहीं है। हम केवल मौजूदा JVM में संशोधित संकलक को एम्बेड करते हैं।

गिनती के गाल

वैसे, हम जानते हैं कि ग्रेगल एक byte[] को दूसरे byte[] परिवर्तित करता है। अब आइए सिद्धांत और डेटा संरचनाओं के बारे में बात करते हैं जो वह उपयोग करता है, क्योंकि वे संकलक के लिए भी थोड़े असामान्य हैं।

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

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

इसे कभी-कभी प्रोग्राम डिपेंडेंसी ग्राफ कहा जाता है।

प्रपत्र x + y की अभिव्यक्ति होने पर x + y हम स्थानीय चर x और y , और उनकी राशि का एक नोड प्राप्त करते हैं।

डेटा प्रवाह ग्राफ

इस ग्राफ में नीले किनारे स्थानीय चर को पढ़ने से लेकर सारांश तक डेटा प्रवाह की दिशा दिखाते हैं।

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

नियंत्रण प्रवाह ग्राफ

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

ग्रेगल ग्राफ को देखने के लिए, आप एक उपकरण का उपयोग कर सकते हैं, जिसे आइडियलग्राफ विजुअललाइज़र या आईजीवी कहा जाता है। mx igv का उपयोग करके स्टार्टअप का प्रदर्शन किया जाता है।

IdealGraphVisualiser

उसके बाद, JVM को -Dgraal.Dump फ्लैग के साथ -Dgraal.Dump ।

एक साधारण डेटा स्ट्रीम को एक सरल अभिव्यक्ति लिखकर देखा जा सकता है।

 int average(int a, int b) { return (a + b) / 2; }

अंकगणित का अर्थ igv है

आप देख सकते हैं कि पैरामीटर 0 ( P(0 ) और 1 ( P(1) ) इसके अतिरिक्त ऑपरेशन के इनपुट पर कैसे जाता है, जो, निरंतर 2 ( C(2) ) के साथ डिवीजन ऑपरेशन के इनपुट पर जाता है, जिसके बाद यह मान वापस आ जाता है।

डेटा और नियंत्रण के अधिक जटिल प्रवाह को देखने के लिए, हम एक चक्र शुरू करते हैं।

 int average(int[] values) { int sum = 0; for (int n = 0; n < values.length; n++) { sum += values[n]; } return sum / values.length; }

अंकगणित का अर्थ है चक्र के साथ इगव

लूप के साथ अंकगणित मध्यम विस्तृत आइवरी

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

अब आप देख सकते हैं कि क्यों इस डेटा संरचना को कभी-कभी नोड्स का समुद्र या सूप कहा जाता है।

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

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

Bytecode से मशीन कोड तक

आइए देखें कि ये विचार व्यवहार में कैसे दिखते हैं, और संकलन प्रक्रिया के कुछ चरणों का पालन करें।

बाईटेकोड प्राप्त करना

संकलन बायटेकोड से शुरू होता है। आइए अपने छोटे से सारांश उदाहरण पर वापस आते हैं।

 int workload(int a, int b) { return a + b; }

हम संकलन शुरू होने से ठीक पहले इनपुट पर प्राप्त बाइटकोड को आउटपुट करेंगे।

 class HotSpotGraalCompiler implements JVMCICompiler { CompilationRequestResult compileMethod(CompilationRequest request) { System.err.println(request.getMethod().getName() + " bytecode: " + Arrays.toString(request.getMethod().getCode())); ... } }

 workload bytecode: [26, 27, 96, -84]

जैसा कि आप देख सकते हैं, संकलक का इनपुट बायटेकोड है।

बाइटकोड पार्सर और ग्राफ बिल्डर

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

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

AddNode

कॉल जोड़ें AddNode.create

पार्सर

यह देखा जा सकता है कि वे बाइटकोड पार्सर द्वारा बनाए गए हैं, और इसने हमें IADD प्रोसेसिंग IADD ( 96 , जिसे हमने मुद्रित इनपुट ऐरे में देखा था) तक ले गए।

 private void genArithmeticOp(JavaKind kind, int opcode) { ValueNode y = frameState.pop(kind); ValueNode x = frameState.pop(kind); ValueNode v; switch (opcode) { ... case LADD: v = genIntegerAdd(x, y); break; ... } frameState.push(kind, append(v)); }

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

इस प्रकार ग्राफ ग्रेगल बनाया गया है।

मशीन कोड प्राप्त करना

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

 void generate(Generator gen) { gen.emitAdd(a, b); }

मैं दोहराता हूं, यहां हम बहुत उच्च स्तर पर काम करते हैं। हमारे पास एक वर्ग है जिसके साथ हम मशीन कोड के निर्देशों को जारी करते हैं, यह विवरण दिए बिना कि यह कैसे काम करता है।

emitAdd , , , , . .

 int workload(int a) { return a + 1; }

, .

 void incl(Register dst) { int encode = prefixAndEncode(dst.encoding); emitByte(0xFF); emitByte(0xC0 | encode); } void emitByte(int b) { data.put((byte) (b & 0xFF)); }

असेंबलर में विधानसभा निर्देश

बाइट आउटपुट

, , ByteBuffer — .

— .

 class HotSpotGraalCompiler implements JVMCICompiler { CompilationResult compileHelper(...) { ... System.err.println(method.getName() + " machine code: " + Arrays.toString(result.getTargetCode())); ... } }

प्रिंटिंग मशीन कोड

. HotSpot. . OpenJDK, , -, JVM, .

 $ cd openjdk/hotspot/src/share/tools/hsdis $ curl -O http://ftp.heanet.ie/mirrors/gnu/binutils/binutils-2.24.tar.gz $ tar -xzf binutils-2.24.tar.gz $ make BINUTILS=binutils-2.24 ARCH=amd64 CFLAGS=-Wno-error $ cp build/macosx-amd64/hsdis-amd64.dylib ../../../../../..

: -XX:+UnlockDiagnosticVMOptions -XX:+PrintAssembly .

 $ java \ --module-path=graal/sdk/mxbuild/modules/org.graalvm.graal_sdk.jar:graal/truffle/mxbuild/modules/com.oracle.truffle.truffle_api.jar \ --upgrade-module-path=graal/compiler/mxbuild/modules/jdk.internal.vm.compiler.jar \ -XX:+UnlockExperimentalVMOptions \ -XX:+EnableJVMCI \ -XX:+UseJVMCICompiler \ -XX:-TieredCompilation \ -XX:+PrintCompilation \ -XX:+UnlockDiagnosticVMOptions \ -XX:+PrintAssembly \ -XX:CompileOnly=Demo::workload \ Demo

 workload machine code: [15, 31, 68, 0, 0, 3, -14, -117, -58, -123, 5, ...] ... 0x000000010f71cda0: nopl 0x0(%rax,%rax,1) 0x000000010f71cda5: add %edx,%esi ;\*iadd {reexecute=0 rethrow=0 return_oop=0} ; - Demo::workload@2 (line 10) 0x000000010f71cda7: mov %esi,%eax ;\*ireturn {reexecute=0 rethrow=0 return_oop=0} ; - Demo::workload@3 (line 10) 0x000000010f71cda9: test %eax,-0xcba8da9(%rip) # 0x0000000102b74006 ; {poll_return} 0x000000010f71cdaf: vzeroupper 0x000000010f71cdb2: retq

. , . generate , .

 class AddNode { void generate(...) { ... gen.emitSub(op1, op2, false) ... // changed from emitAdd } }

AddNode निर्देश जारी करना

, , , .

 workload mechine code: [15, 31, 68, 0, 0, 43, -14, -117, -58, -123, 5, ...] 0x0000000107f451a0: nopl 0x0(%rax,%rax,1) 0x0000000107f451a5: sub %edx,%esi ;\*iadd {reexecute=0 rethrow=0 return_oop=0} ; - Demo::workload@2 (line 10) 0x0000000107f451a7: mov %esi,%eax ;\*ireturn {reexecute=0 rethrow=0 return_oop=0} ; - Demo::workload@3 (line 10) 0x0000000107f451a9: test %eax,-0x1db81a9(%rip) # 0x000000010618d006 ; {poll_return} 0x0000000107f451af: vzeroupper 0x0000000107f451b2: retq

, ? Graal ; ; ; . , Graal.

 [26, 27, 96, -84] → [15, 31, 68, 0, 0, 43, -14, -117, -58, -123, 5, ...]

, , . Graal , .

— . .

 interface Phase { void run(Graph graph); }

(canonicalisation)

. , , ( constant folding ) .

— canonical .

 interface Node { Node canonical(); }

, , , . — . -(-x) x .

 class NegateNode implements Node { Node canonical() { if (value instanceof NegateNode) { return ((NegateNode) value).getValue(); } else { return this; } } }

NegateNode में खोज नाम

Graal . , .

Java, canonical .

Global value numbering

Global value numbering (GVN) — . a + b , — .

 int workload(int a, int b) { return (a + b) * (a + b); }

Graal . — . GVN . hash map , , .

वैश्विक मूल्य संख्या

वैश्विक मूल्य क्रमांकन ग्राफ

, — , , - . , , , , — .

 int workload() { return (getA() + getB()) * (getA() + getB()); }

ऐसा ग्राफ़ जो वैश्विक मान नहीं हो सकता है

(lock coarsening)

. . , , , ( inlining ).

 void workload() { synchronized (monitor) { counter++; } synchronized (monitor) { counter++; } }

, , , , .

 void workload() { monitor.enter(); counter++; monitor.exit(); monitor.enter(); counter++; monitor.exit(); }

. .

 void workload() { monitor.enter(); counter++; counter++; monitor.exit(); }

Graal LockEliminationPhase . run , . , , .

 void run(StructuredGraph graph) { for (monitorExitNode monitorExitNode : graph.getNodes(MonitorExitNode.class)) { FixedNode next = monitorExitNode.next(); if (next instanceof monitorEnterNode) { AccessmonitorNode monitorEnterNode = (AccessmonitorNode) next; if (monitorEnterNode.object() ## monitorExitNode.object()) { monitorExitNode.remove(); monitorEnterNode.remove(); } } } }

सरलीकरण बंद करो

, , , , 2 .

 void workload() { monitor.enter(); counter += 2; monitor.exit(); }

IGV . , , \ , , , 2 .

ताले को सरल करें

Graal , , , . , , , .

Graal , , , , , , .

Graal , , . ? , ?

, , . . , , , , . , , , , , .

( register allocation ). Graal , JIT-, — ( linear scan algorithm ).

, , , - , .

, , , , (.. ), . , , .

( graph scheduling ). . , . , , , .

, .

Graal?

, , , Graal — , Oracle . , Graal?

(final-tier compiler)

C JVMCI Graal HotSpot — , . ( HotSpot) Graal , .

Twitter Graal , Java 9 . : -XX:+UseJVMCICompiler .

JVMCI , Graal JVM. (deploy) - JVM, Graal. Java-, Graal, JVM.

OpenJDK Metropolis JVM Java. Graal .

महानगर परियोजना

http://cr.openjdk.java.net/\~jrose/metropolis/Metropolis-Proposal.html

Graal . Graal JVM, Graal . , Graal . , - , , JNI.

Charles Nutter JRuby Graal Ruby. , - .

AOT (ahead-of-time)

Graal — Java. JVMCI , Graal, , , Graal . , Graal , JIT-.

JIT- AOT- , Graal . AOT Graal.

Java 9 JIT-, . JVM, .

AOT Java 9 Graal, Linux. , , .

. SubstrateVM — AOT-, Java- JVM . , - (statically linked) . JVM , . SubstrateVM Graal. ( just-in-time ) SubstrateVM, , Graal . Graal AOT- .

 $ javac Hello.java $ graalvm-0.28.2/bin/native-image Hello classlist: 966.44 ms (cap): 804.46 ms setup: 1,514.31 ms (typeflow): 2,580.70 ms (objects): 719.04 ms (features): 16.27 ms analysis: 3,422.58 ms universe: 262.09 ms (parse): 528.44 ms (inline): 1,259.94 ms (compile): 6,716.20 ms compile: 8,817.97 ms image: 1,070.29 ms debuginfo: 672.64 ms write: 1,797.45 ms [total]: 17,907.56 ms $ ls -lh hello -rwxr-xr-x 1 chrisseaton staff 6.6M 4 Oct 18:35 hello $ file ./hello ./hellojava: Mach-O 64-bit executable x86_64 $ time ./hello Hello! real 0m0.010s user 0m0.003s sys 0m0.003s