Tracing just-in-time compilation
જસ્ટ-ઇન-ટાઇમ સંકલનને ટ્રેસ કરવું એ વર્ચ્યુઅલ મશીનો દ્વારા રનટાઇમ પર પ્રોગ્રામના અમલને શ્રેષ્ઠ બનાવવા માટે ઉપયોગમાં લેવાતી તકનીક છે. આ વારંવાર ચલાવવામાં આવતી કામગીરીઓના રેખીય ક્રમને રેકોર્ડ કરીને, તેમને મૂળ મશીન કોડમાં સંકલિત કરીને અને તેમને અમલમાં મૂકીને કરવામાં આવે છે. આ પરંપરાગત જસ્ટ-ઇન-ટાઇમ (જેઆઇટી) કમ્પાઇલર્સનો વિરોધ કરે છે જે પદ્ધતિ દીઠ કામ કરે છે. જસ્ટ-ઇન-ટાઇમ સંકલન એ રનટાઇમ પર મશીન કોડમાં પ્રોગ્રામના ભાગોનું સંકલન કરીને પ્રોગ્રામ્સની અમલની ઝડપ વધારવાની એક તકનીક છે. વિવિધ જે. આઈ. ટી. સંકલનકારોને વર્ગીકૃત કરવાની એક રીત તેમના સંકલન અવકાશ દ્વારા છે. જ્યારે પદ્ધતિ-આધારિત જેઆઇટી કમ્પાઇલર્સ એક સમયે એક પદ્ધતિને મશીન કોડમાં અનુવાદિત કરે છે, ત્યારે જેઆઇટી ટ્રેસિંગ તેમના સંકલનના એકમ તરીકે વારંવાર ચલાવવામાં આવતી લૂપ્સનો ઉપયોગ કરે છે. ટ્રેસિંગ જેઆઇટી એ ધારણાઓ પર આધારિત છે કે પ્રોગ્રામ્સ તેમનો મોટાભાગનો સમય પ્રોગ્રામના કેટલાક લૂપ્સ ("હોટ લૂપ્સ") માં વિતાવે છે અને અનુગામી લૂપ પુનરાવર્તનો ઘણીવાર સમાન માર્ગો લે છે. ટ્રેસિંગ જેઆઇટી ધરાવતા વર્ચ્યુઅલ મશીનો ઘણીવાર મિશ્ર-મોડ એક્ઝેક્યુશન વાતાવરણ હોય છે, જેનો અર્થ છે કે તેમની પાસે ટ્રેસિંગ જેઆઇટી ઉપરાંત દુભાષિયો અથવા મેથડ કમ્પાઇલર હોય છે. તકનીકી વિગતો ટ્રેસિંગ JIT કમ્પાઇલર રનટાઇમ પર વિવિધ તબક્કાઓમાંથી પસાર થાય છે. પ્રથમ, લૂપ્સ માટે રૂપરેખા માહિતી એકત્રિત કરવામાં આવે છે. હોટ લૂપની ઓળખ થયા પછી, એક વિશેષ ટ્રેસિંગ તબક્કો દાખલ કરવામાં આવે છે, જે તે લૂપની તમામ ચલાવવામાં આવેલી કામગીરીને રેકોર્ડ કરે છે. કામગીરીના આ ક્રમને ટ્રેસ કહેવામાં આવે છે. ટ્રેસને પછી ઓપ્ટિમાઇઝ કરવામાં આવે છે અને મશીન કોડ (ટ્રેસ) માં સંકલિત કરવામાં આવે છે. જ્યારે આ લૂપ ફરીથી ચલાવવામાં આવે છે, ત્યારે સંકલિત ટ્રેસને પ્રોગ્રામ પ્રતિરૂપને બદલે કહેવામાં આવે છે. આ પગલાંઓ નીચે વિગતવાર સમજાવવામાં આવ્યા છેઃ રૂપરેખા બનાવવાનો તબક્કો રૂપરેખા બનાવવાનો ધ્યેય ગરમ લૂપ્સને ઓળખવાનો છે. આ ઘણીવાર દરેક લૂપ માટે પુનરાવર્તનોની સંખ્યાની ગણતરી કરીને કરવામાં આવે છે. લૂપની ગણતરી ચોક્કસ મર્યાદા ઓળંગી જાય તે પછી, લૂપને ગરમ માનવામાં આવે છે, અને ટ્રેસિંગ તબક્કો દાખલ કરવામાં આવે છે. ટ્રેસિંગ તબક્કો ટ્રેસિંગ તબક્કામાં લૂપનો અમલ સામાન્ય રીતે આગળ વધે છે, પરંતુ વધુમાં દરેક ચલાવવામાં આવેલી કામગીરીને ટ્રેસમાં રેકોર્ડ કરવામાં આવે છે. નોંધાયેલ કામગીરીઓ સામાન્ય રીતે ટ્રેસ ટ્રીમાં સંગ્રહિત થાય છે, ઘણીવાર મધ્યવર્તી રજૂઆત (IR) માં. ટ્રેસિંગ ફંક્શન કૉલ્સને અનુસરે છે, જે તેમને ટ્રેસમાં ઇનલાઇન થવા તરફ દોરી જાય છે. જ્યાં સુધી લૂપ તેના અંત સુધી પહોંચે નહીં અને શરૂઆતમાં પાછા કૂદી ન જાય ત્યાં સુધી ટ્રેસિંગ ચાલુ રહે છે. લૂપના એક નક્કર એક્ઝેક્યુશન પાથને અનુસરીને ટ્રેસ રેકોર્ડ કરવામાં આવે છે, તેથી તે ટ્રેસના પછીના એક્ઝેક્યુશન તે પાથથી અલગ થઈ શકે છે. તે ક્યાં થઈ શકે છે તે સ્થાનોને ઓળખવા માટે, ખાસ રક્ષક સૂચનાઓ ટ્રેસમાં દાખલ કરવામાં આવે છે. આવા સ્થળનું એક ઉદાહરણ છે 'ઇફ્ સ્ટેટમેન્ટ્સ ". ગાર્ડ એ નક્કી કરવા માટે ઝડપી તપાસ છે કે મૂળ સ્થિતિ હજુ પણ સાચી છે કે નહીં. જો રક્ષક નિષ્ફળ જાય, તો ટ્રેસની અમલવારી રદ કરવામાં આવે છે. ટ્રેસિંગ એક્ઝેક્યુશન દરમિયાન કરવામાં આવે છે, તેથી ટ્રેસને રનટાઇમ માહિતી (દા. ત.) સમાવવા માટે બનાવી શકાય છે. પ્રકારની માહિતી). આ માહિતીનો ઉપયોગ પછીથી કોડ કાર્યક્ષમતા વધારવા માટે ઓપ્ટિમાઇઝેશન તબક્કામાં થઈ શકે છે. ઓપ્ટિમાઇઝેશન અને કોડ-જનરેશન ફેઝ ટ્રેસિસને ઓપ્ટિમાઇઝ કરવું સરળ છે, કારણ કે તેઓ માત્ર એક જ એક્ઝેક્યુશન પાથને રજૂ કરે છે, જેનો અર્થ છે કે કોઈ નિયંત્રણ પ્રવાહ અસ્તિત્વમાં નથી અને તેને કોઈ હેન્ડલિંગની જરૂર નથી. લાક્ષણિક ઓપ્ટિમાઇઝેશનમાં કોન્સ્ટન્ટ-સબએક્સપ્રેશન નાબૂદી, ડેડ કોડ નાબૂદી, રજિસ્ટર ફાળવણી, અપરિવર્તનશીલ-કોડ ગતિ, કોન્સ્ટન્ટ ફોલ્ડિંગ અને એસ્કેપ વિશ્લેષણનો સમાવેશ થાય છે. ઓપ્ટિમાઇઝેશન પછી, ટ્રેસને મશીન કોડમાં ફેરવવામાં આવે છે. એ જ રીતે ઓપ્ટિમાઇઝેશન માટે, ટ્રેસની રેખીય પ્રકૃતિને કારણે આ સરળ છે. અમલ ટ્રેસને મશીન કોડમાં સંકલિત કર્યા પછી, તેને લૂપના અનુગામી પુનરાવર્તનોમાં ચલાવી શકાય છે. જ્યાં સુધી રક્ષક નિષ્ફળ ન થાય ત્યાં સુધી ટ્રેસ અમલ ચાલુ રહે છે. ઇતિહાસ જ્યારે કે જે. આઈ. ટી. નો વિચાર 1960ના દાયકા સુધી પહોંચે છે, ત્યારે જે. આઈ. ટી. ને શોધી કાઢવાનો ઉપયોગ તાજેતરમાં જ વધુ થાય છે. જે. આઈ. ટી. ને શોધવાના આજના વિચાર સમાન વિચારનો પ્રથમ ઉલ્લેખ 1970માં થયો હતો. એવું જોવામાં આવ્યું હતું કે સંકલિત કોડ ફક્ત અર્થઘટન દરમિયાન કરવામાં આવેલી ક્રિયાઓને સંગ્રહિત કરીને રન-ટાઇમ પર દુભાષિયા પાસેથી મેળવી શકાય છે. ટ્રેસિંગનું પ્રથમ અમલીકરણ ડાયનેમો છે, "એક સોફ્ટવેર ડાયનેમિક ઓપ્ટિમાઇઝેશન સિસ્ટમ જે મૂળ સૂચના પ્રવાહની કામગીરીને પારદર્શક રીતે સુધારવામાં સક્ષમ છે કારણ કે તે પ્રોસેસર પર અમલ કરે છે". આવું કરવા માટે, જ્યાં સુધી "ગરમ" સૂચના ક્રમ ન મળે ત્યાં સુધી મૂળ સૂચના પ્રવાહનું અર્થઘટન કરવામાં આવે છે. આ ક્રમ માટે એક ઓપ્ટિમાઇઝ્ડ વર્ઝન જનરેટ કરવામાં આવે છે, કેશ કરવામાં આવે છે અને ચલાવવામાં આવે છે. ડાયનેમોનું વિસ્તરણ પાછળથી ડાયનેમોરિયો સુધી કરવામાં આવ્યું હતું. એક ડાયનામોરિયો-આધારિત પ્રોજેક્ટ દુભાષિયાના નિર્માણ માટેનું એક માળખું હતું જે ટ્રેસિંગ અને આંશિક મૂલ્યાંકનને જોડે છે. તેનો ઉપયોગ "ભાષાના અમલીકરણમાંથી દુભાષિયાના ઓવરહેડને ગતિશીલ રીતે દૂર કરવા" માટે થતો હતો. 2006 માં, હોટપાથવીએમ, ઉચ્ચ-સ્તરની ભાષા માટે પ્રથમ ટ્રેસિંગ જેઆઇટી કમ્પાઇલર વિકસાવવામાં આવ્યું હતું. આ વી. એમ. વારંવાર ચલાવવામાં આવતી બાઈટકોડ સૂચનાઓને ગતિશીલ રીતે ઓળખવામાં સક્ષમ હતી, જેને શોધી કાઢવામાં આવે છે અને પછી સ્ટેટિક સિંગલ અસાઇનમેન્ટ (એસએસએ) બાંધકામનો ઉપયોગ કરીને મશીન કોડમાં સંકલિત કરવામાં આવે છે. હોટપાથ વી. એમ. માટે પ્રેરણા સંસાધન મર્યાદિત મોબાઇલ ઉપકરણો માટે કાર્યક્ષમ જેવીએમ હોવાની હતી. ટ્રેસિંગ જેઆઇટીનું બીજું ઉદાહરણ ટ્રેસમોંકી છે, જે ફાયરફોક્સ (2009) માટે મોઝિલાના જાવાસ્ક્રિપ્ટ અમલીકરણમાંથી એક છે. ટ્રેસમોંકી રન-ટાઇમ પર ગતિશીલ ભાષા જાવાસ્ક્રિપ્ટમાં વારંવાર ચલાવવામાં આવતા લૂપ ટ્રેસને સંકલિત કરે છે અને દરેક પાથ પર બનતા વાસ્તવિક ગતિશીલ પ્રકારો માટે જનરેટ કરેલા કોડને નિષ્ણાત બનાવે છે. જેઆઇટી ટ્રેસિંગનો ઉપયોગ કરતી અન્ય એક યોજના પાયપાઈ છે. તે ભાષાના અમલીકરણ માટે ટ્રેસિંગ જેઆઇટીના ઉપયોગને સક્ષમ કરે છે જે પાયપીના અનુવાદ ટૂલચેન સાથે લખવામાં આવ્યા હતા, આમ તે દુભાષિયાનો ઉપયોગ કરીને ચલાવવામાં આવતા કોઈપણ પ્રોગ્રામની કામગીરીમાં સુધારો થાય છે. દુભાષિયા દ્વારા ચલાવવામાં આવતા પ્રોગ્રામને બદલે દુભાષિયાને જ શોધીને આ શક્ય બને છે. માઇક્રોસોફ્ટ દ્વારા તેમના કોમન ઇન્ટરમીડિયેટ લેંગ્વેજ (સી. આઈ. એલ.) માટે એસ. પી. યુ. આર. પ્રોજેક્ટમાં ટ્રેસિંગ જે. આઈ. ટી. ની પણ શોધ કરવામાં આવી છે. એસ. પી. યુ. આર. એ સી. આઇ. એલ. માટે સામાન્ય ટ્રેસર છે, જેનો ઉપયોગ જાવાસ્ક્રિપ્ટ અમલીકરણ દ્વારા પણ શોધી શકાય છે. ટ્રેસનું ઉદાહરણ નીચેના પાયથોન પ્રોગ્રામને ધ્યાનમાં લો જે ક્રમિક સંપૂર્ણ સંખ્યાઓના વર્ગના સરવાળાની ગણતરી કરે છે જ્યાં સુધી તે સરવાળો 100000 કરતાં વધી ન જાયઃ ડિફ સ્ક્વેર (x): રીટર્ન x * x i = 0 y = 0 જ્યારે સાચુંઃ y + = સ્ક્વેર (i) જો y> 100000: બ્રેક i = i + 1 આ પ્રોગ્રામ માટે ટ્રેસ કંઈક આવું દેખાઈ શકે છેઃ લૂપસ્ટાર્ટ (i1, y1) i2 = int _ mul (i1, i1) #x * x y2 = int _ add (y1, i2) #y + = i * i b1 = int _ gt (y2,100000) ગાર્ડ _ ફોલ્સ (b1) i3 = int _ add (i1 કોડ જનરેશન ડાલ્વિક હોટસ્પોટ ઇન્ટરપ્રિટર પ્રોફાઇલ-માર્ગદર્શિત ઓપ્ટિમાઇઝેશન RPython સિમેન્ટીક ડિક્શનરી એન્કોડિંગ સંદર્ભો બાહ્ય લિંક્સ લુએજેઆઈટી કમ્પાઇલર કન્સ્ટ્રક્શન સોફ્ટવેર ઓપ્ટિમાઇઝેશનની સત્તાવાર વેબસાઇટ ઉદાહરણ તરીકે પાયથોન (પ્રોગ્રામિંગ લેંગ્વેજ) કોડ સાથેના લેખો જુઓ.