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

लेकिन यह तकनीक, मेरी राय में, लगभग सार्वभौमिक है, और दुभाषिया विकास के बुनियादी सिद्धांतों को समझना न केवल TIOBE के अनुसार "भाषा की वर्ष" शीर्षक के लिए अगले चैलेंजर के निर्माता के लिए उपयोगी है , बल्कि सामान्य रूप से किसी भी प्रोग्रामर के लिए उपयोगी है ।

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

भाग एक, परिचयात्मक (वर्तमान)
भाग दो, अनुकूलन
भाग तीन, लागू

प्रागितिहास

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

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

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

प्रोग्रामिंग भाषाओं में बाइट कोड कहां गए?

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

कोड के मध्यवर्ती प्रतिनिधित्व के रूप में आभासी निर्देश सेट की लोकप्रियता तीन कारणों से होती है:

बाइटकोड कार्यक्रमों को आसानी से नए प्लेटफार्मों पर पोर्ट किया जाता है।
बाइटकोड व्याख्याकार कोड के वाक्यविन्यास वृक्ष के दुभाषियों की तुलना में तेज़ हैं।
आप कुछ ही घंटों में एक साधारण वर्चुअल मशीन विकसित कर सकते हैं।

आइए कुछ सरल सी आभासी मशीनें बनाते हैं और आभासी मशीनों को लागू करने के मुख्य तकनीकी पहलुओं को उजागर करने के लिए इन उदाहरणों का उपयोग करते हैं।

पूर्ण नमूना कोड GitHub पर उपलब्ध हैं। उदाहरणों को किसी भी अपेक्षाकृत ताजा जीसीसी के साथ संकलित किया जा सकता है:

gcc interpreter-basic-switch.c -o interpreter ./interpreter

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

दुनिया का सबसे आसान बायोटेक दुभाषिया

जैसा कि मैंने कहा, सरलतम दुभाषिया बनाना बहुत आसान है। टिप्पणियाँ लिस्टिंग के पीछे हैं, लेकिन कोड के साथ सीधे शुरू करते हैं:

 struct { uint8_t *ip; uint64_t accumulator; } vm; typedef enum { /* increment the register */ OP_INC, /* decrement the register */ OP_DEC, /* stop execution */ OP_DONE } opcode; typedef enum interpret_result { SUCCESS, ERROR_UNKNOWN_OPCODE, } interpret_result; void vm_reset(void) { puts("Reset vm state"); vm = (typeof(vm)) { NULL }; } interpret_result vm_interpret(uint8_t *bytecode) { vm_reset(); puts("Start interpreting"); vm.ip = bytecode; for (;;) { uint8_t instruction = *vm.ip++; switch (instruction) { case OP_INC: { vm.accumulator++; break; } case OP_DEC: { vm.accumulator--; break; } case OP_DONE: { return SUCCESS; } default: return ERROR_UNKNOWN_OPCODE; } } return SUCCESS; }

सौ से कम लाइनें हैं, लेकिन एक आभासी मशीन की सभी विशिष्ट विशेषताओं का प्रतिनिधित्व किया जाता है। मशीन में एक एकल रजिस्टर ( vm.accumulator ), तीन ऑपरेशन (रजिस्टर वेतन वृद्धि, रजिस्टर में वृद्धि और कार्यक्रम निष्पादन के पूरा होने) और वर्तमान निर्देश ( vm.ip ) के लिए एक संकेतक है।

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

परिचालन को बाइट्स के एक सरणी के रूप में vm_interpret फंक्शन पर स्थानांतरित किया जाता है - एक बाइटकोड (Eng। बाइटकोड ) - और क्रमिक रूप से तब तक निष्पादित किया जाता है जब तक OP_DONE वर्चुअल मशीन ( OP_DONE ) को OP_DONE का ऑपरेशन OP_DONE ।

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

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

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

और इसके विपरीत: उच्च-स्तरीय आभासी मशीनों का संचालन बायोटेक में संकलित एक विशेष प्रोग्रामिंग भाषा के शब्दार्थ को बारीकी से दर्शाता है। इसलिए, उदाहरण के लिए, SQLite, Gawk और Prolog के कई संस्करणों के लिए काम करें।

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

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

Bytecode अनुदेश तर्क

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

हम निर्देशों (OP_ADDI, OP_SUBI) को प्रस्तुत करके उदाहरण का विस्तार करेंगे जो एक तर्क को बाइट के रूप में तुरंत opcode के बाद लेते हैं:

 struct { uint8_t *ip; uint64_t accumulator; } vm; typedef enum { /* increment the register */ OP_INC, /* decrement the register */ OP_DEC, /* add the immediate argument to the register */ OP_ADDI, /* subtract the immediate argument from the register */ OP_SUBI, /* stop execution */ OP_DONE } opcode; typedef enum interpret_result { SUCCESS, ERROR_UNKNOWN_OPCODE, } interpret_result; void vm_reset(void) { puts("Reset vm state"); vm = (typeof(vm)) { NULL }; } interpret_result vm_interpret(uint8_t *bytecode) { vm_reset(); puts("Start interpreting"); vm.ip = bytecode; for (;;) { uint8_t instruction = *vm.ip++; switch (instruction) { case OP_INC: { vm.accumulator++; break; } case OP_DEC: { vm.accumulator--; break; } case OP_ADDI: { /* get the argument */ uint8_t arg = *vm.ip++; vm.accumulator += arg; break; } case OP_SUBI: { /* get the argument */ uint8_t arg = *vm.ip++; vm.accumulator -= arg; break; } case OP_DONE: { return SUCCESS; } default: return ERROR_UNKNOWN_OPCODE; } } return SUCCESS; }

नए निर्देश ( vm_interpret फ़ंक्शन देखें) ने अपने तर्क को बाइटकोड से पढ़ा और इसे रजिस्टर में जोड़ा / रजिस्टर से घटाया।

इस तरह के तर्क को एक तात्कालिक तर्क कहा जाता है , क्योंकि यह सीधे opcode सरणी में स्थित है। हमारे कार्यान्वयन में मुख्य सीमा यह है कि तर्क एक एकल बाइट है और केवल 256 मान ले सकता है।

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

स्टैक मशीन

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

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

 #define STACK_MAX 256 struct { uint8_t *ip; /* Fixed-size stack */ uint64_t stack[STACK_MAX]; uint64_t *stack_top; /* A single register containing the result */ uint64_t result; } vm; typedef enum { /* push the immediate argument onto the stack */ OP_PUSHI, /* pop 2 values from the stack, add and push the result onto the stack */ OP_ADD, /* pop 2 values from the stack, subtract and push the result onto the stack */ OP_SUB, /* pop 2 values from the stack, divide and push the result onto the stack */ OP_DIV, /* pop 2 values from the stack, multiply and push the result onto the stack */ OP_MUL, /* pop the top of the stack and set it as execution result */ OP_POP_RES, /* stop execution */ OP_DONE, } opcode; typedef enum interpret_result { SUCCESS, ERROR_DIVISION_BY_ZERO, ERROR_UNKNOWN_OPCODE, } interpret_result; void vm_reset(void) { puts("Reset vm state"); vm = (typeof(vm)) { NULL }; vm.stack_top = vm.stack; } void vm_stack_push(uint64_t value) { *vm.stack_top = value; vm.stack_top++; } uint64_t vm_stack_pop(void) { vm.stack_top--; return *vm.stack_top; } interpret_result vm_interpret(uint8_t *bytecode) { vm_reset(); puts("Start interpreting"); vm.ip = bytecode; for (;;) { uint8_t instruction = *vm.ip++; switch (instruction) { case OP_PUSHI: { /* get the argument, push it onto stack */ uint8_t arg = *vm.ip++; vm_stack_push(arg); break; } case OP_ADD: { /* Pop 2 values, add 'em, push the result back to the stack */ uint64_t arg_right = vm_stack_pop(); uint64_t arg_left = vm_stack_pop(); uint64_t res = arg_left + arg_right; vm_stack_push(res); break; } case OP_SUB: { /* Pop 2 values, subtract 'em, push the result back to the stack */ uint64_t arg_right = vm_stack_pop(); uint64_t arg_left = vm_stack_pop(); uint64_t res = arg_left - arg_right; vm_stack_push(res); break; } case OP_DIV: { /* Pop 2 values, divide 'em, push the result back to the stack */ uint64_t arg_right = vm_stack_pop(); /* Don't forget to handle the div by zero error */ if (arg_right == 0) return ERROR_DIVISION_BY_ZERO; uint64_t arg_left = vm_stack_pop(); uint64_t res = arg_left / arg_right; vm_stack_push(res); break; } case OP_MUL: { /* Pop 2 values, multiply 'em, push the result back to the stack */ uint64_t arg_right = vm_stack_pop(); uint64_t arg_left = vm_stack_pop(); uint64_t res = arg_left * arg_right; vm_stack_push(res); break; } case OP_POP_RES: { /* Pop the top of the stack, set it as a result value */ uint64_t res = vm_stack_pop(); vm.result = res; break; } case OP_DONE: { return SUCCESS; } default: return ERROR_UNKNOWN_OPCODE; } } return SUCCESS; }

इस उदाहरण में पहले से ही अधिक संचालन हैं, और उनमें से लगभग सभी केवल स्टैक के साथ काम करते हैं। OP_PUSHI स्टैक पर अपना तत्काल तर्क देता है। निर्देश OP_ADD, OP_SUB, OP_DIV, OP_MUL मानों के ढेर से पॉपअप होते हैं, परिणाम की गणना करते हैं, और इसे वापस स्टैक पर धकेलते हैं। OP_POP_RES स्टैक से मान निकालता है और इसे परिणाम रजिस्टर में रखता है, जिसका उद्देश्य वर्चुअल मशीन के परिणामों के लिए है।

विभाजन ऑपरेशन (OP_DIV) के लिए, शून्य त्रुटि वाला एक विभाजन पकड़ा जाता है, जो वर्चुअल मशीन को रोकता है।

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

रजिस्टर मशीन

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

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

इस बीच, प्रत्येक अतिरिक्त निर्देश का निष्पादन शेड्यूलिंग की लागत को दर्शाता है, अर्थात ओपकोड को डिकोड करना और निर्देशों के शरीर पर स्विच करना।

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

 #define REGISTER_NUM 16 struct { uint16_t *ip; /* Register array */ uint64_t reg[REGISTER_NUM]; /* A single register containing the result */ uint64_t result; } vm; typedef enum { /* Load an immediate value into r0 */ OP_LOADI, /* Add values in r0,r1 registers and put them into r2 */ OP_ADD, /* Subtract values in r0,r1 registers and put them into r2 */ OP_SUB, /* Divide values in r0,r1 registers and put them into r2 */ OP_DIV, /* Multiply values in r0,r1 registers and put them into r2 */ OP_MUL, /* Move a value from r0 register into the result register */ OP_MOV_RES, /* stop execution */ OP_DONE, } opcode; typedef enum interpret_result { SUCCESS, ERROR_DIVISION_BY_ZERO, ERROR_UNKNOWN_OPCODE, } interpret_result; void vm_reset(void) { puts("Reset vm state"); vm = (typeof(vm)) { NULL }; } void decode(uint16_t instruction, uint8_t *op, uint8_t *reg0, uint8_t *reg1, uint8_t *reg2, uint8_t *imm) { *op = (instruction & 0xF000) >> 12; *reg0 = (instruction & 0x0F00) >> 8; *reg1 = (instruction & 0x00F0) >> 4; *reg2 = (instruction & 0x000F); *imm = (instruction & 0x00FF); } interpret_result vm_interpret(uint16_t *bytecode) { vm_reset(); puts("Start interpreting"); vm.ip = bytecode; uint8_t op, r0, r1, r2, immediate; for (;;) { /* fetch the instruction */ uint16_t instruction = *vm.ip++; /* decode it */ decode(instruction, &op, &r0, &r1, &r2, &immediate); /* dispatch */ switch (op) { case OP_LOADI: { vm.reg[r0] = immediate; break; } case OP_ADD: { vm.reg[r2] = vm.reg[r0] + vm.reg[r1]; break; } case OP_SUB: { vm.reg[r2] = vm.reg[r0] - vm.reg[r1]; break; } case OP_DIV: { /* Don't forget to handle the div by zero error */ if (vm.reg[r1] == 0) return ERROR_DIVISION_BY_ZERO; vm.reg[r2] = vm.reg[r0] / vm.reg[r1]; break; } case OP_MUL: { vm.reg[r2] = vm.reg[r0] * vm.reg[r1]; break; } case OP_MOV_RES: { vm.result = vm.reg[r0]; break; } case OP_DONE: { return SUCCESS; } default: return ERROR_UNKNOWN_OPCODE; } } return SUCCESS; }

उदाहरण 16 रजिस्टरों के साथ एक रजिस्टर मशीन दिखाता है। निर्देश 16 बिट्स पर कब्जा कर लेते हैं और तीन तरीकों से इनकोड किए जाते हैं:

4 बिट प्रति ओपकोड + 4 बिट्स प्रति रजिस्टर नाम + 8 बिट्स प्रति तर्क।
4 बिट प्रति ओपकोड + तीन बार 4 बिट्स प्रति रजिस्टर नाम।
4 बिट प्रति ओपकोड + 4 बिट्स प्रति एकल रजिस्टर नाम + 8 अप्रयुक्त बिट्स।

हमारी छोटी आभासी मशीन में बहुत कम ऑपरेशन होते हैं, इसलिए प्रति ओपेक चार बिट्स (या 16 संभव संचालन) काफी पर्याप्त हैं। ऑपरेशन यह निर्धारित करता है कि निर्देश के शेष टुकड़े वास्तव में क्या दर्शाते हैं।

OP_LOADI ऑपरेशन के साथ रजिस्टर में डेटा लोड करने के लिए पहले प्रकार की कोडिंग (4 + 4 + 8) की आवश्यकता होती है। दूसरे प्रकार (4 + 4 + 4 + 4) का उपयोग अंकगणितीय परिचालनों के लिए किया जाता है, जो यह जानना चाहिए कि कहां पर एक दलील लेनी है और कहां पर गणना परिणाम जोड़ना है। और अंत में, अंतिम रूप (4 + 4 + 8 अनावश्यक बिट्स) का उपयोग एक तर्क के रूप में एकल रजिस्टर के निर्देशों के लिए किया जाता है, हमारे मामले में यह OP_MOV_RES है।

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

मुख्य विशेषताएं: रजिस्टर मशीनों के बायटेकोड में कम निर्देश होते हैं, व्यक्तिगत निर्देश व्यापक होते हैं, ऐसे बायटेकोड में संकलन अधिक कठिन होता है - कंपाइलर को यह तय करना होता है कि उपलब्ध रजिस्टरों का उपयोग कैसे किया जाए।

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

स्टैक और रजिस्टर मशीनें, तुलना

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

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

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

किस वास्तुकला के बारे में बहस अभी भी खत्म नहीं हुई है। यदि हम जावा संकलक के बारे में बात करते हैं, तो Dalvik VM बाईटेकोड, जो हाल ही में हर एंड्रॉइड डिवाइस पर काम करने तक पंजीकृत था; लेकिन शीर्षक JVM ने निर्देशों के ढेर को बनाए रखा है। लुआ वर्चुअल मशीन एक रजिस्टर मशीन का उपयोग करती है, लेकिन पायथन वीएम अभी भी स्टैकेबल है। और इसी तरह।

बाइटकोड नियमित अभिव्यक्ति दुभाषियों में

अंत में, निम्न-स्तरीय आभासी मशीनों से खुद को विचलित करने के लिए, आइए एक विशेष दुभाषिया पर नज़र डालें जो नियमित अभिव्यक्ति के मिलान के लिए तार की जाँच करता है:

 typedef enum { /* match a single char to an immediate argument from the string and advance ip and cp, or * abort*/ OP_CHAR, /* jump to and match either left expression or the right one, abort if nothing matches*/ OP_OR, /* do an absolute jump to an offset in the immediate argument */ OP_JUMP, /* stop execution and report a successful match */ OP_MATCH, } opcode; typedef enum match_result { MATCH_OK, MATCH_FAIL, MATCH_ERROR, } match_result; match_result vm_match_recur(uint8_t *bytecode, uint8_t *ip, char *sp) { for (;;) { uint8_t instruction = *ip++; switch (instruction) { case OP_CHAR:{ char cur_c = *sp; char arg_c = (char)*ip ; /* no match? FAILed to match */ if (arg_c != cur_c) return MATCH_FAIL; /* advance both current instruction and character pointers */ ip++; sp++; continue; } case OP_JUMP:{ /* read the offset and jump to the instruction */ uint8_t offset = *ip; ip = bytecode + offset; continue; } case OP_OR:{ /* get both branch offsets */ uint8_t left_offset = *ip++; uint8_t right_offset = *ip; /* check if following the first offset get a match */ uint8_t *left_ip = bytecode + left_offset; if (vm_match_recur(bytecode, left_ip, sp) == MATCH_OK) return MATCH_OK; /* no match? Check the second branch */ ip = bytecode + right_offset; continue; } case OP_MATCH:{ /* success */ return MATCH_OK; } } return MATCH_ERROR; } } match_result vm_match(uint8_t *bytecode, char *str) { printf("Start matching a string: %s\n", str); return vm_match_recur(bytecode, bytecode, str); }

मुख्य निर्देश OP_CHAR है। वह अपना तात्कालिक तर्क लेती है और स्ट्रिंग ( char *sp ) में वर्तमान चरित्र से इसकी तुलना करती है। लाइन में अपेक्षित और वर्तमान पात्रों के संयोग के मामले में, अगले निर्देश और अगले चरित्र के लिए संक्रमण होता है।

मशीन जंप ऑपरेशन (OP_JUMP) को भी समझती है, जो एक एकल तर्क देता है। तर्क का अर्थ है कि बाइटकोड में निरपेक्ष ऑफसेट, जहां से गणना जारी रखना है।

अंतिम महत्वपूर्ण ऑपरेशन OP_OR है। वह दो ऑफसेट लेती है, उनमें से पहले पर कोड लागू करने की कोशिश कर रही है, फिर, एक त्रुटि के मामले में, दूसरा। वह एक पुनरावर्ती कॉल के साथ ऐसा करती है, अर्थात्, निर्देश नियमित अभिव्यक्ति के सभी संभावित वेरिएंट्स के पेड़ की गहराई में चलता है।

हैरानी की बात है, कोड के चार opcodes और सत्तर पंक्तियाँ "abc", "a; bc", "(ab | bc) d", "a * bc" जैसे नियमित भावों को व्यक्त करने के लिए पर्याप्त हैं। इस वर्चुअल मशीन में एक स्पष्ट स्थिति भी नहीं है, क्योंकि आपको जो कुछ भी ज़रूरत है - निर्देश स्ट्रीम की शुरुआत के लिए संकेत, वर्तमान निर्देश और वर्तमान चरित्र - पुनरावर्ती फ़ंक्शन के तर्क के रूप में पारित किया गया है।

यदि आप नियमित अभिव्यक्ति इंजनों के काम के विवरण में रुचि रखते हैं, तो आप पहले Google RE2 से नियमित अभिव्यक्ति इंजन के लेखक, रस कॉक्स द्वारा लेखों की एक श्रृंखला पढ़ सकते हैं।

परिणाम

आइए संक्षेप में बताते हैं।

सामान्य-प्रयोजन प्रोग्रामिंग भाषाओं के लिए, एक नियम के रूप में, दो आर्किटेक्चर का उपयोग किया जाता है: स्टैक और रजिस्टर।

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

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

दूसरी ओर, उच्च स्तरीय निर्देश लोकप्रिय आभासी मशीनों में एक बड़ी भूमिका निभाते हैं। जावा में, उदाहरण के लिए, ये पॉलीमॉर्फिक फ़ंक्शन कॉल, ऑब्जेक्ट आवंटन और कचरा संग्रह के लिए निर्देश हैं।

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

व्यावहारिक सिफारिशें:

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

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

DIY बाइटकोड व्याख्याकार