दिलचस्प पोस्ट
एंड्रॉइड रिसाइक्लर आइटमों को जोड़ने और हटाने कैसे एक unordered सूची आइटम से indentation को दूर करने के लिए? $ .jax की सफलता और .done () विधि के बीच अंतर क्या है सप्ताहांत को छोड़कर दो तिथियों के बीच दिनांक सीमा प्राप्त करें दृश्य स्टूडियो – त्रुटि प्राप्त "मेटाडेटा फ़ाइल 'XYZ' को संपादित नहीं किया जा सकता है" इकाई-विशेषता-मान तालिका डिजाइन कैसे गतिशील जोड़ा तत्व के लिए fancybox बाध्य करने के लिए? स्ट्रिंग तुलना में उच्चारण किए गए अक्षरों को अनदेखा कर रहा है एंड्रॉइड पर एनडीके-जीडीबी कैसे काम करना है? स्किकिट में प्रीप्रोसिंग सीखना – एकल नमूना – मूल्यह्रास चेतावनी अजाक्स फ़ंक्शन ऑनबीयरइनलोड करने के लिए कैसे करें? UIButton टच और होल्ड पायथन में raw_input फ़ंक्शन कार्यक्रम को सी ++ में समय संकलित करने पर स्थैतिक एरेज़ बनाएँ मॉडल के पूरे सेट को फ़ॉर्मडाटा में कैसे जोड़ें और इसे एमवीसी में प्राप्त करें

एक अभी-अभी-समय (जेआईटी) कंपाइलर क्या करता है?

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

Solutions Collecting From Web of "एक अभी-अभी-समय (जेआईटी) कंपाइलर क्या करता है?"

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

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

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

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

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

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

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

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

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

जेट परिदृश्य:

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

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

जीआईटी बनाम गैर-जेआईटी की तुलना:

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

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

जेट उदाहरण:

  1. जावा में जेआईटी जेवीएम (जावा आभासी मशीन) में है
  2. सी # में सीएलआर (सामान्य भाषा रनटाइम) में है
  3. एंड्रॉइड में यह नए संस्करणों में डीवीएम (डलविक वर्चुअल मशीन) या एआरटी (एंड्रॉइड रनटाइम) में है।

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

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

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

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

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

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

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

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

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

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

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

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

उपरोक्त लूप कोड 10 गुना के लिए चलता है यदि i का मान 0 है

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

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

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

इसे पढ़ने के लिए जेएटी को समझने के लिए ओरेकल दस्तावेज़ीकरण देखें।

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

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

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

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

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

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

निम्नलिखित कोड उदाहरण बताते हैं कि जेआईटी जावा कोड को कैसे अनुकूलित करता है

अनुकूलन से पहले कोड

  class A { B b; public void newMethod() { y = b.get(); ...do stuff... z = b.get(); sum = y + z; } } class B { int value; final int get() { return value; } } 

अनुकूलन के बाद कोड

 class A { B b; public void newMethod() { y = b.value; ...do stuff... sum = y + y; } } class B { int value; final int get() { return value; } } 

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

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

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

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