DIY वर्चुअल मशीन

कभी-कभी एक विचार मन में आता है जिससे छुटकारा पाना बहुत मुश्किल है। मेरे साथ ऐसा हुआ।

मैंने एक वर्चुअल मशीन (वीएम) बनाने का फैसला किया, यह देखते हुए कि उस समय मेरे पास कोई विचार नहीं था, मुझे यह प्रतीत हुआ कि यह एक महान विचार है। यदि आप रुचि रखते हैं, तो कट पर जाएं!

सिद्धांत

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

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

VM का मेरा संस्करण JVM से कुछ हद तक समान होगा क्योंकि यह एक शक्तिशाली VM बनाने के उद्देश्य से अधिक प्रशिक्षण परियोजना है।

स्मृति

तो, अब चलो स्मृति का पता लगाते हैं। मेमोरी बनाने के लिए, मैंने एक अहस्ताक्षरित इंट सरणी का उपयोग करने का निर्णय लिया। सरणी का आकार एक मैक्रो का उपयोग करके निर्धारित किया जाता है, मेरे संस्करण में मेमोरी का आकार 4096 बाइट्स है (सरणी में 1024 तत्व हैं, और चूंकि अधिकांश प्लेटफार्मों पर 4 बाइट्स को अहस्ताक्षरित अंतर डेटा के लिए आवंटित किया जाता है, तो 1024 * 4 = 4096), अन्य चीजों के साथ, हम 8 रजिस्टरों को परिभाषित करेंगे। प्रत्येक में 8 सेल पहले से ही 256 बाइट्स (8 * 8 * 4 = 256) होंगे। यह इस तरह दिखता है:

#define MEMSIZE 1024 unsigned int memory[MEMSIZE]; unsigned int reg[8][8]; 

प्रोग्रामिंग

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

 enum commands { /*   / List of commands */ CRG = 1, /* Change ReGister -   [1] */ CRC, /* Change Register Cell [2] */ PRG, /* Put in ReGister -       [3] */ PRC /* Put Register Cell     [4] */ }; 

प्रत्येक टीम का अपना झंडा होता है जो कुछ अतिरिक्त मापदंडों को परिभाषित करता है।
हम झंडे का वर्णन करेंगे:

 enum flags { /*   / List of flags */ STDI = 1, /*   / Standard flag */ STDA /*   / Address flag */ }; 

मानक कमांड का रूप है: [कमांड] [फ्लैग] [डेटा] (कुछ कमांड की उपस्थिति भिन्न हो सकती है), इसके आधार पर हम एक साधारण दुभाषिया लिखेंगे:

 if (memory[cell] == CRG && memory[cell + 1] == STDI) { indxX = memory[cell + 2]; cell++; } else if (memory[cell] == CRC && memory[cell + 1] == STDI) { indxY = memory[cell + 2]; cell++; } else if (memory[cell] == PRG && memory[cell + 1] == STDI) { reg[indxX][0] = memory[cell + 2]; cell++; } else if (memory[cell] == PRC && memory[cell + 1] == STDI) { reg[indxX][indxY] = memory[cell + 2]; cell++; } 

indxX और indxY वैरिएबल हैं जो रेजिस्टर में वर्तमान कर्सर स्थिति को स्टोर करते हैं।
सेल एक चर है जो मेमोरी एरे में वर्तमान कर्सर स्थिति को संग्रहीत करता है।

लेकिन संख्याओं के साथ प्रोग्रामिंग बहुत सुविधाजनक नहीं है, इसलिए सी प्रीप्रोसेसर का उपयोग करके हम अपने कोडांतरक का वर्णन करेंगे। मैं समझता हूं कि मैक्रों के साथ एएसएम लिखना बहुत अच्छा नहीं है, लेकिन यह समाधान अस्थायी है।

हमारा asm कोड इस तरह दिखता है:

 /*  */ #define $CRG {memory[memIndx++] = CRG;} #define $CRC {memory[memIndx++] = CRC;} #define $PRG {memory[memIndx++] = PRG;} #define $PRC {memory[memIndx++] = PRC;} /*  */ #define _$STDI {memory[memIndx++] = STDI;} #define _$STDA {memory[memIndx++] = STDA;} /*  */ #define _$DATA memory[memIndx++] = 

memIndx एक चर है जो मेमोरी एरे में वर्तमान कर्सर स्थिति को संग्रहीत करता है।

और यहाँ हमारे asm पर कोड है जो पते में रजिस्टर में 123 डाल रहा है [1] [0] (पहला रजिस्टर, शून्य सेल):

 $CRG /*   */ _$STDI /*   STDI */ _$DATA 1; /*   */ $CRC /*   */ _$STDI _$DATA 0; $PRC /*   */ _$STDI _$DATA 123; 

बधाई हो, अब हमारे पास अपनी कार के लिए asm की एक झलक है!

कार्यक्रम शुरू करें

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

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

शब्दों से कर्मों की ओर बढ़ते हैं:

कोड पढ़ना और इसे एक फ़ाइल में लिखना:

 if (memory[i] == CRG && memory[i + 1] == STDI) { fprintf(code, "%d %d ", CRG, STDI); i++; } else if (memory[i] == CRC && memory[i + 1] == STDI) { fprintf(code, "%d %d ", CRC, STDI); i++; } else if (memory[i] == PRG && memory[i + 1] == STDI) { fprintf(code, "%d %d ", PRG, STDI); i++; } else if (memory[i] == PRC && memory[i + 1] == STDI) { fprintf(code, "%d %d ", PRC, STDI); i++; } 

कोड ncpGen () फ़ंक्शन के अंग का हिस्सा है।

फ़ाइल पढ़ना और उसका निष्पादन:

 if (prog != NULL) { fread(txt, 1, len, prog); tok = strtok(txt, " "); while (tok != NULL) { memory[i] = atoi(tok); tok = strtok(NULL, " "); if (argc == 3 && strcmp(argv[2], "-m") == 0) { printf("%d\n", memory[i]); } i++; } memInter(); } else { perror("Fail"); } 

अब, एक मैक्रो को परिभाषित करते हैं ताकि asm की व्याख्या करने के बजाय, कोड .ncp में बदल जाए:

 #define _toNCP(name) {strcpy(filename, name);} {ncpGen();} 

यदि कुछ भी है, तो लेख सभी कोड प्रस्तुत नहीं करता है, लेकिन इसका केवल एक छोटा सा हिस्सा है!

पूरा कोड प्रोजेक्ट रिपॉजिटरी में है ।

पढ़ने के लिए बहुत बहुत धन्यवाद!