🧔🏾 👩🏽‍🤝‍👩🏻 🤽🏻 ObjectScript 0.99-vm3 के लिए बड़ा अपडेट। भाग 1: रजिस्टर वर्चुअल मशीन 🈯️ 🆒 👴🏾

ObjectScript एक नया एम्बेड करने योग्य और बहुत हल्का ऑब्जेक्ट-ओरिएंटेड ओपन सोर्स प्रोग्रामिंग लैंग्वेज है। ObjectScript जावास्क्रिप्ट, लुआ, रूबी, और PHP जैसी भाषाओं की क्षमताओं का विस्तार करता है। आप इस लेख में मूल भाषा वाक्य रचना पढ़ सकते हैं।

ObjectScript 0.99-vm3 - एक नई तेज़ वर्चुअल मशीन और नई सुविधाएँ।

कुछ ऑपरेटरों को clone, numberof जाता clone, numberof , उदाहरण के लिए, clone, numberof , आदि को कार्यों द्वारा प्रतिस्थापित किया जाता है। फ़ंक्शन में अंतिम मान स्वचालित रूप से वापस आ जाता है। ऑब्जेक्ट के सदस्यों तक पहुंचने के लिए एक छोटी प्रविष्टि जोड़ी गई - @varname , फ़ंक्शन और अधिक की घोषणा के लिए एक नया लघु वाक्यविन्यास। एट अल।

भाग 1. रजिस्टर ऑब्जेक्टस्क्रिप्ट वर्चुअल मशीन

परंपरागत रूप से, प्रोग्रामिंग भाषाएं स्टैक्ड वर्चुअल मशीन (जावा, .Net, एक्शनस्क्रिप्ट और कुछ अन्य) का उपयोग करती हैं। ऐसे VMs स्टैक में मान जोड़ने के लिए push, pop कमांड का उपयोग करते हैं और यदि आवश्यक हो तो इसे हटा देते हैं। गणितीय क्रियाओं की गणना करते समय, ढेर के शीर्ष पर स्थित दो मानों का उपयोग तर्कों के रूप में किया जाता है, और ऑपरेशन के परिणाम तर्कों को प्रतिस्थापित करते हैं। उदाहरण के लिए, निम्न कोड:

  i = j + k

स्टैक पर VM को कमांड में संकलित किया जाएगा:

  push_local j -     push_local k -     operator + -     set_local i -       pop -

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

  add i, j, k

डिबगिंग जानकारी में ऑब्जेक्ट इस आदेश को निम्नानुसार दिखाता है:

  var i = var j [operator +] var k

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

चर में बदलते मूल्यों के साथ उदाहरण:

  i, j = j, i

ObjectScript इस कोड को तीन कमांड में संकलित करता है:

  move: # = var j move: var j = var i move: var i = #

जहाँ # का अर्थ है अस्थायी चर के तहत केस का उपयोग करना। यदि आप कमांडों को देखते हैं, तो आप देखेंगे कि चर के मूल्यों में परिवर्तन एक इष्टतम तरीके से होता है और निम्नलिखित कोड के पूरी तरह से बराबर है:

  temp = j j = i i = temp

रजिस्टर वर्चुअल मशीन क्या है?

एक रजिस्टर वर्चुअल मशीन मूल्यों के ढेर के साथ काम नहीं करता है, लेकिन रजिस्टरों में मूल्यों के साथ। एक रजिस्टर एक अस्थायी स्थानीय चर है जो हर समय मौजूद होता है जब उस तक पहुंच संभव है।

यह रजिस्टर VM के पहले हाइलाइट को छुपाता है। रजिस्टर हमेशा पढ़ने और लिखने के लिए तैयार है, वीएम को इस तरह के एक चर (रजिस्टर) के अस्तित्व, इसके आवंटन और विनाश के लिए अनावश्यक जांच करने की आवश्यकता नहीं है।

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

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

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

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

माइनस यह है कि कमांड का हिस्सा अभी भी एक बाइट के साथ एन्कोड करना असंभव है, उदाहरण के लिए, push_double, jump , आदि। ऐसे कमांड के लिए अतिरिक्त तर्क की आवश्यकता होती है, push_double एक डबल-सटीक संख्या डबल (8 बाइट्स) है, jump एक ऑफसेट है (उदाहरण के लिए, 4) संक्रमण के लिए बाइट - int32)। क्योंकि स्टैक वीएम में कमांड एक-दूसरे का पालन करते हैं, वे किसी भी तरह से संरेखित नहीं होते हैं, इसलिए डबल नंबर या ऑफसेट इंट 32 किसी भी पते पर मेमोरी में हो सकता है, जिसमें एक विषम और सामान्य रूप से शामिल है। जो लोग प्रोसेसर की वास्तुकला से परिचित हैं, वे तुरंत इस पर ध्यान देंगे, क्योंकि इस तरह के तर्कों को एक प्रोसेसर आदेश के साथ नहीं पढ़ा जा सकता है। यदि आप ऐसा करने की कोशिश करते हैं, उदाहरण के लिए, स्मृति में एक विषम पते पर dword को पढ़ें, तो एआरएम आर्किटेक्चर पर एक अपवाद होगा और प्रोग्राम एक त्रुटि के साथ बंद हो जाएगा। विभिन्न वास्तुकारों के पास या तो त्रुटियां हो सकती हैं या प्रदर्शन में एक भयावह गिरावट आ सकती है। इसलिए, बाइट्स की एक धारा से इस तरह के मल्टीबाइट तर्कों को पढ़ने के लिए, आपको केवल बाइट-बाय-बिट की आवश्यकता होती है और अंतिम तर्क बनाने के लिए ऑफ़सेट के बिटवाइज़ संचालन का उपयोग करते हैं। यह वीएम की गति को थोड़ा कम करता है।

एक रजिस्टर वीएम में, कई आदेशों में तीन तर्क होते हैं और कब्जे (तर्कों के साथ) 4 बाइट्स होते हैं। ऊपर वर्णित समस्याओं को खत्म करने के लिए, ऑब्जेक्टस्क्रिप्ट में सभी कमांड्स गठबंधन किए गए हैं और हमेशा 4 बाइट्स पर कब्जा कर लेते हैं, भले ही कुछ बिट्स वास्तव में उपयोग नहीं किए जाते हों। उदाहरण के लिए, ObjectScript में move कमांड के दो तर्क हैं। लेकिन इस मामले में भी, ऑब्जेक्टस्क्रिप्ट निम्नानुसार है। बहुत बार, move कमांड एक दूसरे का अनुसरण करते हैं और लगातार दो रजिस्टर भरते हैं। इस स्थिति में, ObjectScript (ऑप्टिमाइज़ेशन स्टेज पर) दो move बजाय एक move2 कमांड उत्पन्न करता है:

  move2 R, A, B

जिसे दो move कमांड के रूप में निष्पादित किया जाता है:

  move R, A move R+1, B

इस स्थिति में, move2 में तीन तर्क हैं और 4 बाइट्स का पूरी तरह से उपयोग करता है। आदेशों का संरेखण उन्हें एक प्रोसेसर कमांड के साथ पढ़ना संभव बनाता है, जिससे वीएम की गति बढ़ जाती है।

अन्य प्लस के साथ संयोजन में, नए रजिस्टर VM3 के साथ ऑब्जेक्टस्क्रिप्ट अब पिछले स्टैक VM2 की तुलना में तीसरा तेज है।

रजिस्टर वीएम कैसे काम करता है और रजिस्टर कहां से आते हैं

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

उदाहरण के लिए, निम्न कोड:

  k = i - j*k / (x + y - z*i / j) + i

ObjectScript संकलन:

  # (59) = var j (5) [operator *] var k (6) # (60) = var x (7) [operator +] var y (8) # (61) = var z (9) [operator *] var i (4) # (61) = # (61) [operator /] var j (5) # (60) = # (60) [operator -] # (61) # (59) = # (59) [operator /] # (60) # (58) = var i (4) [operator -] # (59) var k (10) = # (58) [operator +] var i (4)

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

रजिस्टर VM में फ़ंक्शन कॉल

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

  func(i, k - x*y * (z + i), j*k)

ObjectScript संकलन:

  begin call move: # (59) = var func (11) move: # (60) = const null (-1) move: # (61) = var i (4) # (63) = var x (7) [operator *] var y (8) # (64) = var z (9) [operator +] var i (4) # (63) = # (63) [operator *] # (64) # (62) = var k (10) [operator -] # (63) # (63) = var j (5) [operator *] var k (10) end call: start 59, params 5

यह फ़ंक्शन पाँच मानों के अनुक्रम से शुरू होता है, जो सूचकांक 59 पर शुरू होता है। पहले दो मूल्य उपयोगिता पैरामीटर हैं, अर्थात् 59 - फ़ंक्शन स्वयं, 60 - यह फ़ंक्शन के लिए (इस मामले में शून्य):

  move: # (59) = var func (11) move: # (60) = const null (-1)

अगला, पैरामीटर स्वयं स्थानांतरित किए जाते हैं, वे 61 से 63 में पंजीकृत होते हैं। पहला पैरामीटर सिर्फ i चर है, यह 61 रजिस्टर करने के लिए कॉपी किया गया है:

  move: # (61) = var i (4)

दूसरा पैरामीटर गणितीय संचालन k - x*y * (z + i) , इसे रजिस्टर 62 में संग्रहीत किया जाता है:

  # (63) = var x (7) [operator *] var y (8) # (64) = var z (9) [operator +] var i (4) # (63) = # (63) [operator *] # (64) # (62) = var k (10) [operator -] # (63)

तीसरा पैरामीटर ( j*k ) रजिस्टर 63 में संग्रहीत है:

  # (63) = var j (5) [operator *] var k (10)

अब अनुक्रम पूरी तरह से तैयार है और फ़ंक्शन को बुलाया जा सकता है।

और कहाँ रजिस्टर वर्चुअल मशीन का उपयोग किया जाता है

रजिस्टर VM का उपयोग Lua 5.0 और उच्चतर में भी किया जाता है, quecec में (भूकंप 1 और कई पोर्ट के लिए इस तरह की एक स्क्रिप्टिंग प्रोग्रामिंग भाषा थी), Java (उदाहरण के लिए, Dalvik VM) के लिए रजिस्टर VMs हैं। औपचारिक रूप से, C ++ / C और अन्य भाषाओं में मशीन कोड में संकलित कोई भी प्रोग्राम आंतरिक संचालन के लिए एक रजिस्टर मॉडल और कॉलिंग फ़ंक्शन के लिए एक स्टैक का उपयोग करता है।

कुल मिलाकर

नया रजिस्टर ऑब्जेक्टस्क्रिप्ट वर्चुअल मशीन (VM3) पिछले स्टैक VM2 के एक तिहाई से तेज है और इसमें कम कमांड हैं, VM2 में केवल 36 बनाम 111। बहुत कम टीमें वीएम को सरल बनाती हैं और यदि आवश्यक हो तो जेआईटी को लागू करने की संभावना बढ़ाती हैं।

स्टैक का उपयोग स्थानीय फ़ंक्शन चर के लिए किया जाता है, एक पुनरावर्ती कॉल की संभावना प्रदान करता है। आवश्यक स्टैक आकार को एक बार आरक्षित किया जाता है जब फ़ंक्शन कहा जाता है, VM3 खुद को स्टैक लागू नहीं करता है।

कस्टम कोड के साथ एकीकरण को आसान बनाने के लिए ObjectScript API में स्टैक का भी उपयोग किया जाता है। ऑब्जेक्टस्क्रिप्ट API अपरिवर्तित रहा और पिछले संस्करण के साथ पूरी तरह से संगत है।

विस्तार

अगले भाग में, हम अन्य नवाचारों के बारे में बात करेंगे जो ऑब्जेक्टस्क्रिप्ट में दिखाई दिए, उदाहरण के लिए, फैक्टरियल फ़ंक्शन को इस तरह लिखा जा सकता है:

 print "factorial(10) = " .. {|a| a <= 1 ? 1 : a * _F(a-1)}(10)

उत्पादन होगा:

 factorial(10) = 3628800

और कई अन्य एट अल।

ObjectScript के बारे में अन्य प्रासंगिक लेख:

ObjectScript 0.99-vm3 के लिए बड़ा अपडेट। भाग 1: रजिस्टर वर्चुअल मशीन