जस्ट-इन-टाइम (JIT) कंपाइलर क्या करता है?

Question

जेआईटी संकलक विशेष रूप से गैर-जेआईटी संकलक के विपरीत क्या करता है? क्या कोई वर्णन को समझने के लिए एक सहज और आसान दे सकता है?

Comments

ibm.com/support/knowledgecenter/SSYKE2_7.1.0/...

— TechDog

अपडेटेड लिंक

— आकाश नारायण

मुझे उपयोगी होने के लिए youtube.com/watch?v=yQ27DjKnxwo मिला ।

— एडम ज़र्नर

Answer 1

JIT कंपाइलर प्रोग्राम शुरू होने के बाद चलता है और मक्खी पर (या बस-इन-टाइम, जैसा कि इसे कहा जाता है) कोड (आमतौर पर बाईटेकोड या किसी प्रकार के वीएम निर्देशों) को संकलित करता है, जो आमतौर पर तेजी से होता है, आमतौर पर होस्ट CPU के मूल में होता है निर्देश समुच्चय। JIT में डायनेमिक रनटाइम जानकारी तक पहुँच होती है जबकि एक मानक संकलक ऐसा नहीं करता है और बार-बार उपयोग किए जाने वाले कार्यों की तरह बेहतर अनुकूलन कर सकता है।

यह एक पारंपरिक संकलक कि संकलित के विपरीत है सब मशीन भाषा के लिए कोड से पहले कार्यक्रम पहली बार चलाने है।

Paraphrase के लिए, पारंपरिक कंपाइलर पूरे प्रोग्राम को EXE फ़ाइल के रूप में बनाते हैं, जब आप इसे चलाते हैं तो पहली बार। नए शैली के कार्यक्रमों के लिए, एक विधानसभा pseudocode (पी-कोड) के साथ उत्पन्न होती है। केवल आपके द्वारा OS पर प्रोग्राम को निष्पादित किया जाता है (जैसे, उसके आइकन पर डबल-क्लिक करके) होगा (JIT) कंपाइलर में मशीन कोड (m-code) उत्पन्न होता है जिसे इंटेल-आधारित प्रोसेसर या जो भी समझेगा।

Comments

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

— हारून

एक JIT को अक्सर मशीन भाषा में बदलने के लिए व्याख्या किए गए कोड के साथ उपयोग किया जाता है लेकिन हां, विशुद्ध रूप से व्याख्या किया गया कोड (बिना किसी JITting के) धीमा है। यहां तक ​​कि एक JITter के बिना जावा बाइटकोड वास्तव में धीमा है।

— मार्क सिडेड

लक्ष्य को मशीन कोड नहीं होना चाहिए, हालांकि। JRuby के पास एक JIT कंपाइलर है, जो एक-दो इनवॉइस के बाद Ruby sourcecode को Java bytecode में संकलित करेगा। फिर, एक और जोड़ी के इनवोकेशन के बाद, JVM JIT कंपाइलर मूल कोड को बायटेकोड में किक करता है।

— जोर्ग डब्ल्यू मित्तग

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

— एडम जास्किविकेज़

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

— सुपरकाट

Answer 2

शुरुआत में, एक संकलक वस्तु कोड (मशीन निर्देशों) में एक उच्च-स्तरीय भाषा (असेंबलर से उच्च स्तर के रूप में परिभाषित) को चालू करने के लिए जिम्मेदार था, जिसे तब एक निष्पादनकर्ता में (लिंकर द्वारा) जोड़ा जाएगा।

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

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

Comments

हालाँकि यह वाक्यांश "जस्ट-इन-टाइम (JIT) संकलक रन-टाइम दुभाषिया की एक विशेषता है" भ्रम का कारण बनता है; जैसे - stackoverflow.com/questions/16439512/…

— स्टीफन सी

वास्तव में, JIT एक ऐड-ऑन था, और आप अभी भी इसे -Xint पैरामीटर का उपयोग करके जावा में अक्षम कर सकते हैं, इसलिए यह सिर्फ एक विशेषता है।

— क्रेग ट्रेडर

मैं पूरी तरह से सहमत नहीं हूँ। जेआईटी विकास नहीं है - यह क्लासिक संकलक का विकल्प है।

— --६

JIT हार्ड-वायरिंग मैकेनिकल स्विच से विकासवादी पथ पर एक कदम है जो आपके स्मार्ट फोन को "OK Google" कहकर खोज मानदंड को निर्दिष्ट करता है। जावा 7/8 के भाग के रूप में उपलब्ध वर्तमान जेआईटी जावा 2 के भाग के रूप में जो कुछ भी उपलब्ध था उससे परे छलांग और सीमा है - जो कि विकास है।

— क्रेग ट्रेडर

@ i486 - Sun / Oracle ने (AFAIK) ने जावा के लिए कभी भी क्लासिकल ("समय से आगे") संकलक नहीं भेजा है जो कि मूल कोड उत्पन्न करता है। यह तर्क है कि जेआईटी एक विकल्प है ... जब वे बात करते हैं तो यह माना जाता है कि इसे कभी नहीं भेजा गया था। (मैं GCJ AOT कंपाइलर को छूट देता हूं क्योंकि इसका Sun / Oracle से कोई लेना-देना नहीं था, और यह पूर्ण समाधान भी नहीं था। यह निश्चित रूप से अब व्यवहार्य नहीं है।)

— स्टीफन C

Answer 3

जेआईटी-बस समय में शब्द ही कहता है कि कब इसकी जरूरत है (मांग पर)

विशिष्ट परिदृश्य:

स्रोत कोड पूरी तरह से मशीन कोड में परिवर्तित हो जाता है

JIT परिदृश्य:

स्रोत कोड विधानसभा भाषा में संरचना की तरह बदल जाएगा [पूर्व आईएल (मध्यवर्ती भाषा) के लिए सी # के लिए, बाइटकोड के लिए जावा]।

मध्यवर्ती कोड को केवल मशीन भाषा में परिवर्तित किया जाता है, जब आवेदन की आवश्यकता है कि आवश्यक कोड केवल मशीन कोड में परिवर्तित हो जाते हैं।

JIT बनाम गैर-JIT तुलना:

• JIT में सभी कोड मशीन कोड में परिवर्तित नहीं होते हैं, पहले जो कोड आवश्यक है उसका एक हिस्सा मशीन कोड में परिवर्तित हो जाएगा, अगर कोई विधि या कार्यक्षमता जिसे मशीन में नहीं है तो उसे मशीन कोड में बदल दिया जाएगा ... यह कम कर देता है सीपीयू पर बोझ।

• चूँकि मशीन कोड रन टाइम पर उत्पन्न होगा .... JIT कंपाइलर मशीन कोड का उत्पादन करेगा जो मशीन के CPU आर्किटेक्चर को चलाने के लिए अनुकूलित है।

JIT के उदाहरण:

1. जावा JIT में JVM (Java Virtual Machine) है
2. C # में यह CLR (सामान्य भाषा रनटाइम) में है
3. Android में यह DVM (Dalvik Virtual Machine), या ART (Android RunTime) नए संस्करणों में है।

Comments

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

— सुपरकैट

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

— नवजाल

आप कह रहे हैं कि जावा में JIT JVM है। हालाँकि हम पहले से ही JVM को संकलित कोड प्रदान करते हैं, है ना? तो यह फिर से आप इसका मतलब संकलन?

— कोरे तुगे

@KorayTugay - हम JVM को JTEM को बाइटकोड प्रदान करते हैं और JVM उस हिस्से को मशीन कोड में परिवर्तित कर देगा।

— दुरई अमुथन

जावा में JIT JVM नहीं है। यह उसका एक हिस्सा मात्र है।

— happs

Answer 4

जैसा कि अन्य ने उल्लेख किया है

JIT का मतलब जस्ट-इन-टाइम होता है जिसका मतलब है कि कोड जरूरत पड़ने पर संकलित हो जाता है, रनटाइम से पहले नहीं।

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

साथ ही अगली बार इस फ़ंक्शन की गणना की जाती है समान संकलित कोड को सामान्य व्याख्या के विपरीत फिर से निष्पादित किया जाता है जिसमें कोड को फिर से लाइन द्वारा व्याख्या की जाती है। इससे निष्पादन तेजी से होता है।

Answer 5

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

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

स्रोत

Comments

JIT की मेरी व्याख्या यह है कि यह संस्मरण की तरह कार्य करता है, जहाँ अक्सर उपयोग किए जाने वाले कार्य 'संग्रहीत' होते हैं और जावा बाईटेकोड से देशी ISA-निर्भर कोड के संकलन का खर्च बायपास हो जाता है। यदि यह सही है, तो जावा शुरू से ही पूरी तरह से देशी कोड का संकलन क्यों नहीं करता है? यह किसी भी प्रकार के रन-टाइम संकलन को कम कर देगा और मशीन को जावा 'मूल' बना देगा?

— माइकल चोई

Answer 6

JIT का मतलब जस्ट-इन-टाइम होता है जिसका मतलब है कि कोड जरूरत पड़ने पर संकलित हो जाता है, रनटाइम से पहले नहीं।

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

Comments

उपयोगकर्ता के कंप्यूटर में कहीं भी संकलित कोड संकलित क्यों नहीं किए जाते हैं, तो अगली बार आवेदन को चलाने के लिए JIT को उन्हें फिर से स्थापित करने की आवश्यकता नहीं है?

— omerfarukdogan

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

— ब्रायन लाइटल ने

Answer 7

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

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

JIT कंपाइलर केवल रन टाइम के दौरान काम करता है, इसलिए हमारे पास कोई बाइनरी आउटपुट नहीं है।

Comments

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

— यव बोके

Answer 8

जस्ट इन टाइम कंपाइलर (JIT):
यह जावा बायटेकोड्स को उस विशिष्ट सीपीयू के मशीन निर्देशों में संकलित करता है।

उदाहरण के लिए, यदि हमारे जावा कोड में एक लूप स्टेटमेंट है:

while(i<10){
    // ...
    a=a+i;
    // ...
 }

उपरोक्त लूप कोड 10 बार चलता है यदि i का मान 0 है।

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

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

JIT कंपाइलर मशीन कोड के सभी कोड को संकलित नहीं करता है। यह कोड को संकलित करता है जिसमें रन टाइम पर एक समान पैटर्न होता है।

अधिक पढ़ने के लिए JIT को समझें इस Oracle दस्तावेज को देखें ।

Comments

"बार-बार 10 बार के लिए बायटेकोड को संकलित करना आवश्यक नहीं है क्योंकि एक ही निर्देश 10 बार निष्पादित करने जा रहा है" - एक नियमित संकलक के बारे में क्या? क्या यह इस टुकड़े को कई बार संकलित करता है?

— TT_

Answer 9

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

Comments

आपका क्या मतलब है "विधि स्तर"?

— कोरे तुगे

Answer 10

मुझे पता है कि यह एक पुराना धागा है, लेकिन रनटाइम ऑप्टिमाइज़ेशन JIT संकलन का एक और महत्वपूर्ण हिस्सा है जो यहाँ चर्चा में नहीं लगता है। मूल रूप से, जेआईटी संकलक कार्यक्रम की निगरानी कर सकता है क्योंकि यह निष्पादन में सुधार के तरीके निर्धारित करने के लिए चलता है। फिर, यह मक्खी पर उन परिवर्तनों को कर सकता है - रनटाइम के दौरान। Google JIT ऑप्टिमाइज़ेशन (javaworld में इसके बारे में बहुत अच्छा लेख है। )

Answer 11

बस एक समय संकलक (JIT) सॉफ्टवेयर का एक टुकड़ा है जो एक गैर निष्पादन योग्य इनपुट प्राप्त करता है और निष्पादित होने के लिए उपयुक्त मशीन कोड देता है। उदाहरण के लिए:

Intermediate representation    JIT    Native machine code for the current CPU architecture

     Java bytecode            --->        machine code
     Javascript (run with V8) --->        machine code

इसका परिणाम यह है कि एक निश्चित सीपीयू वास्तुकला के लिए उपयुक्त जेआईटी कंपाइलर को स्थापित किया जाना चाहिए।

अंतर संकलक, दुभाषिया, और जेआईटी

हालांकि सामान्य रूप से अपवाद हो सकते हैं जब हम स्रोत कोड को मशीन कोड में बदलना चाहते हैं जिसका हम उपयोग कर सकते हैं:

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

Answer 12

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

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

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

Answer 13

जस्ट-इन-टाइम (JIT) संकलन, (गतिशील अनुवाद या रन-टाइम संकलन), a है कंप्यूटर कोड को निष्पादित करने तरीका है जिसमें प्रोग्राम के निष्पादन के दौरान संकलन शामिल होता है - रन टाइम पर - निष्पादन से पहले ।

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

आइए, जेवीएम में प्रयुक्त जेआईटी पर विचार करें,

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

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

ट्रेस ट्री एक डेटा संरचना है जिसका उपयोग प्रोग्रामिंग कोड के रनटाइम संकलन में किया जाता है। ट्रेस पेड़ों का उपयोग एक प्रकार के in जस्ट इन टाइम कंपाइलर ’में किया जाता है जो हॉटस्पॉट्स के दौरान कोड निष्पादित करता है और इसे संकलित करता है। देखें इस ।

देखें:

• http://www.oracle.com/webfolder/technetwork/tutorials/obe/java/gc01/index.html
• https://en.wikipedia.org/wiki/Just-in-time_compilation

Answer 14

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

Answer 15

20% बाइट कोड का 80% समय उपयोग किया जाता है। JIT कंपाइलर को ये आँकड़े मिलते हैं और यह 20% बाइट कोड को इनलाइन विधियों, अप्रयुक्त तालों को हटाने आदि को जोड़कर और उस मशीन के लिए विशेष रूप से बाइटकोड बनाने के द्वारा तेजी से चलाने के लिए अनुकूलित करता है। मैं इस लेख से उद्धृत कर रहा हूं, मैंने पाया कि यह आसान था। http://java.dzone.com/articles/just-time-compiler-jit-hotspot

Comments

निश्चित नहीं है कि यह क्यों चिह्नित किया गया था -1। मुझे लगता है कि यहाँ बिंदु यह है कि रन टाइम आँकड़े का उपयोग अनुकूलन में मदद करने के लिए किया जाता है।

— Eze

हां, लेकिन जवाब में ऐसा नहीं था। वास्तव में, JIT कोड के सबसे गर्म 20% का अनुकूलन नहीं करता है।

— शुभम

Answer 16

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

Comments

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

— zapl

Answer 17

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

Answer 18

जस्ट इन टाइम कंपाइलर को जावा में प्रदर्शन सुधार के लिए जेआईटी कंपाइलर के रूप में भी जाना जाता है। इसे बाई दिफ़ौल्ट मर्थकृत किया गया है। यह पहले के बजाय निष्पादन समय पर किया गया संकलन है। जावा ने JVM में शामिल करके JIT कंपाइलर के उपयोग को लोकप्रिय बनाया है।