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

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

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

1. सामग्री

2. परिचय

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

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

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

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

नोट: संकलक विभिन्न प्रोसेसर आर्किटेक्चर के लिए एक उच्च स्तरीय भाषा का संकलन करके ऐसी समस्याओं को हल करता है। VM एक मानक CPU आर्किटेक्चर बनाता है जो विभिन्न हार्डवेयर उपकरणों पर सिम्युलेटेड है। कंपाइलर के फायदों में से एक यह है कि वीएम जैसा कोई रन-टाइम ओवरहेड नहीं है। यद्यपि संकलक अच्छी तरह से काम करते हैं, कई प्लेटफार्मों के लिए एक नया संकलक लिखना बहुत मुश्किल है, इसलिए वीएम अभी भी उपयोगी हैं। वास्तव में, विभिन्न स्तरों पर, VM और संकलक दोनों का एक साथ उपयोग किया जाता है।

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

एक वीएम को समान लाभ प्रदान करने के लिए बड़ा या सर्वव्यापी होने की आवश्यकता नहीं है। पुराने वीडियो गेम अक्सर सरल स्क्रिप्टिंग सिस्टम बनाने के लिए छोटे VMs का उपयोग करते थे ।

वीएम सुरक्षित रूप से अलग-थलग कार्यक्रमों के लिए भी उपयोगी होते हैं। एक आवेदन कचरा संग्रह है। सी या सी ++ के शीर्ष पर स्वचालित कचरा संग्रह को लागू करने के लिए कोई तुच्छ तरीका नहीं है , क्योंकि कार्यक्रम अपने स्वयं के ढेर या चर नहीं देख सकता है। हालाँकि, VM रनिंग प्रोग्राम "बाहर" है और स्टैक पर मेमोरी सेल्स के सभी संदर्भों का अवलोकन कर सकता है।

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

3. आर्किटेक्चर एलसी -3

हमारा VM LC-3 नामक एक काल्पनिक कंप्यूटर का अनुकरण करेगा। यह छात्रों के असेंबलर को पढ़ाने के लिए लोकप्रिय है। यहां, x86 की तुलना में कमांड का एक सरलीकृत सेट है, लेकिन आधुनिक सीपीयू में उपयोग की जाने वाली सभी बुनियादी अवधारणाओं को बरकरार रखता है।

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

स्मृति

LC-3 में 65,536 मेमोरी सेल (2 ¹⁶ ) हैं, जिनमें से प्रत्येक में 16-बिट मान है। इसका मतलब है कि यह केवल 128 KB स्टोर कर सकता है - जो आप उपयोग कर रहे हैं उससे बहुत कम! हमारे कार्यक्रम में, यह मेमोरी एक साधारण सरणी में संग्रहीत है:

/* 65536 locations */ uint16_t memory[UINT16_MAX];

रजिस्टरों

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

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

8 सामान्य प्रयोजन रजिस्टर ( R0-R7 )
टीमों के काउंटर का 1 रजिस्टर ( PC )
1 शर्त झंडा रजिस्टर ( COND )

किसी भी सॉफ्टवेयर की गणना करने के लिए सामान्य प्रयोजन रजिस्टर का उपयोग किया जा सकता है। निर्देश काउंटर एक अहस्ताक्षरित पूर्णांक है जिसे निष्पादित करने के लिए अगले निर्देश का मेमोरी पता है। हालत के झंडे हमें पिछली गणना के बारे में जानकारी देते हैं।

 enum { R_R0 = 0, R_R1, R_R2, R_R3, R_R4, R_R5, R_R6, R_R7, R_PC, /* program counter */ R_COND, R_COUNT };

स्मृति की तरह, हम रजिस्टरों को एक सरणी में संग्रहीत करेंगे:

 uint16_t reg[R_COUNT];

निर्देश सेट

एक निर्देश एक कमांड है जो प्रोसेसर को कुछ प्रकार के मौलिक कार्य करने के लिए कहता है, उदाहरण के लिए, दो नंबर जोड़ें। निर्देश में एक ओपकोड (ऑपरेशन कोड) होता है जो कार्य के प्रकार को दर्शाता है, साथ ही साथ मापदंडों का एक सेट जो कार्य के लिए इनपुट प्रदान करता है।

प्रत्येक ओपकोड एक कार्य का प्रतिनिधित्व करता है जिसे प्रोसेसर "जानता है" कैसे प्रदर्शन करना है। एलसी -3 में 16 ऑपकोड हैं। एक कंप्यूटर केवल इन सरल निर्देशों के अनुक्रम की गणना कर सकता है। प्रत्येक निर्देश की लंबाई 16 बिट्स है, और बाएं 4 बिट्स ऑपरेशन कोड को स्टोर करते हैं। बाकी का उपयोग मापदंडों को स्टोर करने के लिए किया जाता है।

बाद में हम विस्तार से चर्चा करेंगे कि प्रत्येक निर्देश क्या करता है। इस समय निम्नलिखित ऑपकोड को परिभाषित करें। सुनिश्चित करें कि आप सही एनम मान प्राप्त करने के लिए इस आदेश को रखें:

 enum { OP_BR = 0, /* branch */ OP_ADD, /* add */ OP_LD, /* load */ OP_ST, /* store */ OP_JSR, /* jump register */ OP_AND, /* bitwise and */ OP_LDR, /* load register */ OP_STR, /* store register */ OP_RTI, /* unused */ OP_NOT, /* bitwise not */ OP_LDI, /* load indirect */ OP_STI, /* store indirect */ OP_JMP, /* jump */ OP_RES, /* reserved (unused) */ OP_LEA, /* load effective address */ OP_TRAP /* execute trap */ };

नोट: Intel x86 आर्किटेक्चर में सैकड़ों निर्देश हैं, जबकि अन्य आर्किटेक्चर जैसे ARM और LC-3 बहुत कम हैं। छोटे निर्देश सेट को RISC कहा जाता है, जबकि बड़े को CISC कहा जाता है। बड़े अनुदेश सेट, एक नियम के रूप में, मौलिक रूप से नई सुविधाएँ प्रदान नहीं करते हैं, लेकिन अक्सर कोडांतरक कोड के लेखन को सरल बनाते हैं । CISC का एक निर्देश कई RISC निर्देशों को बदल सकता है। हालांकि, CISC प्रोसेसर डिजाइन और निर्माण के लिए अधिक जटिल और महंगे हैं। यह और अन्य व्यापार-बंद "इष्टतम" डिज़ाइन को कॉल करने की अनुमति नहीं देते हैं ।

हालत झंडे

R_COND रजिस्टर उन कंडीशन फ्लैग को स्टोर करता है जो अंतिम गणना के बारे में जानकारी प्रदान करते हैं। यह प्रोग्राम को तार्किक स्थितियों की जांच करने की अनुमति देता है, जैसे if (x > 0) { ... } ।

प्रत्येक प्रोसेसर में विभिन्न स्थितियों को इंगित करने के लिए कई स्टेटस फ्लैग होते हैं। LC-3 केवल तीन कंडीशन फ़्लैग का उपयोग करता है जो पिछली गणना का संकेत दिखाते हैं।

 enum { FL_POS = 1 << 0, /* P */ FL_ZRO = 1 << 1, /* Z */ FL_NEG = 1 << 2, /* N */ };

नोट: (चरित्र << को लेफ्ट शिफ्ट ऑपरेटर कहा जाता है । (n << k) बिट्स n k स्थानों के द्वारा बाईं ओर शिफ्ट करता है। इस प्रकार, 1 << 2 बराबर 4 यहां पढ़ें यदि आप अवधारणा से परिचित नहीं हैं तो यह बहुत महत्वपूर्ण होगा)।

हमने अपने वर्चुअल मशीन के हार्डवेयर घटकों को कॉन्फ़िगर करना समाप्त कर दिया है! मानक समावेशन जोड़ने के बाद (ऊपर लिंक देखें), आपकी फ़ाइल कुछ इस तरह दिखनी चाहिए:

 {Includes, 12} {Registers, 3} {Opcodes, 3} {Condition Flags, 3}

यहां लेख के गिने हुए खंडों के लिंक दिए गए हैं, जहां से संबंधित कोड के टुकड़े आते हैं। संपूर्ण सूची के लिए, कार्य कार्यक्रम देखें - लगभग। प्रति।

4. असेंबलर उदाहरण

अब, LC-3 कोडांतरक कार्यक्रम को देखने के लिए आइए देखें कि वर्चुअल मशीन वास्तव में क्या करती है। आपको यह जानने की आवश्यकता नहीं है कि कोडांतरक में कैसे प्रोग्राम किया जाए, या यहां सब कुछ समझें। बस एक सामान्य विचार प्राप्त करने की कोशिश करें कि क्या हो रहा है। यहाँ एक सरल "हैलो वर्ल्ड" है:

 .ORIG x3000 ; this is the address in memory where the program will be loaded LEA R0, HELLO_STR ; load the address of the HELLO_STR string into R0 PUTs ; output the string pointed to by R0 to the console HALT ; halt the program HELLO_STR .STRINGZ "Hello World!" ; store this string here in the program .END ; mark the end of the file

सी में के रूप में, कार्यक्रम ऊपर से नीचे तक एक बयान को निष्पादित करता है। लेकिन सी के विपरीत, कोई नस्टेड क्षेत्र नहीं हैं {} या नियंत्रण संरचनाएं जैसे कि if या while ; बस ऑपरेटरों की एक सरल सूची। इसलिए, प्रदर्शन करना बहुत आसान है।

कृपया ध्यान दें कि कुछ ऑपरेटरों के नाम उन opcodes के अनुरूप हैं जिन्हें हमने पहले परिभाषित किया था। हम जानते हैं कि निर्देश 16 बिट्स हैं, लेकिन प्रत्येक पंक्ति अलग-अलग संख्या में वर्णों की तरह दिखती है। ऐसा बेमेल विवाह कैसे संभव है?

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

नोट: हालांकि संकलक और कोडांतरक विकास में समान भूमिका निभाते हैं, लेकिन वे समान नहीं हैं। कोडांतरक केवल यह बताता है कि प्रोग्रामर ने पाठ में क्या लिखा है, पात्रों को उनके बाइनरी प्रतिनिधित्व के साथ बदल दिया और उन्हें निर्देश में पैक किया।

.ORIG और .STRINGZ निर्देश की तरह दिखते हैं, लेकिन नहीं। ये कोडांतरक निर्देश हैं जो कोड या डेटा का हिस्सा उत्पन्न करते हैं। उदाहरण के लिए, .STRINGZ एक बाइनरी प्रोग्राम में एक निर्दिष्ट स्थान पर वर्णों की एक स्ट्रिंग सम्मिलित करता है।

गोटो जैसे बयान का उपयोग करके लूप और शर्तों को निष्पादित किया जाता है। यहां एक और उदाहरण है जो 10 तक गिना जाता है।

 AND R0, R0, 0 ; clear R0 LOOP ; label at the top of our loop ADD R0, R0, 1 ; add 1 to R0 and store back in R0 ADD R1, R0, -10 ; subtract 10 from R0 and store back in R1 BRn LOOP ; go back to LOOP if the result was negative ... ; R0 is now 10!

नोट: इस ट्यूटोरियल में असेंबली सीखने की ज़रूरत नहीं है। लेकिन अगर आप रुचि रखते हैं, तो आप LC-3 टूल्स का उपयोग करके अपने खुद के LC-3 प्रोग्राम लिख और बना सकते हैं।

5. कार्यक्रम का निष्पादन

एक बार फिर, पिछले उदाहरणों से यह पता चलता है कि VM क्या करता है। एक वीएम लिखने के लिए, आपको असेंबलर की पूरी समझ की आवश्यकता नहीं है। जब तक आप निर्देशों को पढ़ने और निष्पादित करने के लिए उचित प्रक्रिया का पालन करते हैं, तब तक कोई भी LC-3 प्रोग्राम सही ढंग से काम करेगा, चाहे इसकी जटिलता कितनी भी हो। सिद्धांत रूप में, एक वीएम भी एक ब्राउज़र या लिनक्स की तरह एक ऑपरेटिंग सिस्टम चला सकता है!

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

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

प्रक्रिया

लिखने की प्रक्रिया का सटीक विवरण इस प्रकार है:

PC रजिस्टर के पते पर मेमोरी से एक निर्देश डाउनलोड करें।
PC रजिस्टर बढ़ाएँ।
यह निर्धारित करने के लिए कि किस प्रकार के निर्देशों का पालन करने के लिए opcode देखें।
इसके मापदंडों का उपयोग करते हुए निर्देशों का पालन करें।
चरण 1 पर लौटें।

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

हम मुख्य चक्र के उदाहरण के रूप में इस प्रक्रिया का अध्ययन शुरू करते हैं:

 int main(int argc, const char* argv[]) { {Load Arguments, 12} {Setup, 12} /* set the PC to starting position */ /* 0x3000 is the default */ enum { PC_START = 0x3000 }; reg[R_PC] = PC_START; int running = 1; while (running) { /* FETCH */ uint16_t instr = mem_read(reg[R_PC]++); uint16_t op = instr >> 12; switch (op) { case OP_ADD: {ADD, 6} break; case OP_AND: {AND, 7} break; case OP_NOT: {NOT, 7} break; case OP_BR: {BR, 7} break; case OP_JMP: {JMP, 7} break; case OP_JSR: {JSR, 7} break; case OP_LD: {LD, 7} break; case OP_LDI: {LDI, 6} break; case OP_LDR: {LDR, 7} break; case OP_LEA: {LEA, 7} break; case OP_ST: {ST, 7} break; case OP_STI: {STI, 7} break; case OP_STR: {STR, 7} break; case OP_TRAP: {TRAP, 8} break; case OP_RES: case OP_RTI: default: {BAD OPCODE, 7} break; } } {Shutdown, 12} }

6. निर्देशों का कार्यान्वयन

अब आपका कार्य प्रत्येक ओपकोड के लिए सही कार्यान्वयन करना है। प्रत्येक निर्देश का एक विस्तृत विनिर्देश परियोजना प्रलेखन में निहित है। विनिर्देश से आपको यह पता लगाने की आवश्यकता है कि प्रत्येक निर्देश कैसे काम करता है और एक कार्यान्वयन लिखता है। यह जितना लगता है उससे कहीं ज्यादा आसान है। यहाँ मैं प्रदर्शित करूँगा कि उनमें से दो को कैसे लागू किया जाए। बाकी के लिए कोड अगले भाग में पाया जा सकता है।

जोड़ें

ADD निर्देश दो नंबर लेता है, उन्हें जोड़ता है और परिणाम को एक रजिस्टर में संग्रहीत करता है। विनिर्देश पृष्ठ 526 के दस्तावेज़ीकरण में है। प्रत्येक ADD अनुदेश इस प्रकार है:

आरेख में दो लाइनें हैं, क्योंकि इस निर्देश के लिए दो अलग-अलग "मोड" हैं। इससे पहले कि मैं विधाओं की व्याख्या करूं, आइए उनके बीच समानताएं खोजने की कोशिश करें। दोनों चार समान बिट्स 0001 शुरू होते हैं। यह OP_ADD लिए opcode मूल्य है। अगले तीन बिट्स आउटपुट रजिस्टर के लिए DR चिह्नित हैं। आउटपुट रजिस्टर वह स्थान होता है जहाँ राशि जमा होती है। निम्नलिखित तीन बिट्स हैं: SR1 । यह एक रजिस्टर है जिसमें पहले नंबर को जोड़ा जाना है।

इस प्रकार, हम जानते हैं कि परिणाम को कहाँ सहेजना है, और हम जोड़ने के लिए पहली संख्या जानते हैं। इसके अलावा केवल दूसरे नंबर का पता लगाना बाकी है। यहां दोनों रेखाएं अलग-अलग होने लगती हैं। ध्यान दें कि 5 वीं बिट शीर्ष पर 0 है और 1. सबसे नीचे है। यह बिट या तो सीधे मोड या रजिस्टर मोड से मेल खाती है । रजिस्टर मोड में, दूसरा नंबर पहले की तरह रजिस्टर में संग्रहीत किया जाता है। इसे SR2 के रूप में चिह्नित किया गया है और यह शून्य के माध्यम से बिट्स दो में निहित है। बिट्स 3 और 4 का उपयोग नहीं किया जाता है। कोडांतरक में, इसे इस तरह लिखा जाएगा:

 ADD R2 R0 R1 ; add the contents of R0 to R1 and store in R2.

तत्काल मोड में, रजिस्टर की सामग्री को जोड़ने के बजाय, तत्काल मूल्य निर्देश में ही एम्बेडेड है। यह सुविधाजनक है क्योंकि प्रोग्राम को इस संख्या को मेमोरी से रजिस्टर में लोड करने के लिए अतिरिक्त निर्देशों की आवश्यकता नहीं है। इसके बजाय, यह पहले से ही अनुदेश के अंदर है जब हमें इसकी आवश्यकता होती है। व्यापार-बंद यह है कि केवल छोटी संख्या को वहां संग्रहीत किया जा सकता है। सटीक होने के लिए, अधिकतम 2 ⁵ = 32। यह काउंटरों या मूल्यों को बढ़ाने के लिए सबसे उपयोगी है। कोडांतरक में, आप इस तरह लिख सकते हैं:

 ADD R0 R0 1 ; add 1 to R0 and store back in R0

यहाँ विनिर्देश से एक अंश है:

यदि बिट [5] 0 है, तो SR2 से दूसरा स्रोत ऑपरेंड प्राप्त किया जाता है। यदि बिट [5] 1 है, तो दूसरे स्रोत ऑपरेंड को imm5 से 16 बिट तक विस्तारित करके प्राप्त किया जाता है। दोनों ही मामलों में, SR1 की सामग्री में दूसरा स्रोत ऑपरेंड जोड़ा जाता है, और परिणाम DR में संग्रहीत किया जाता है। (पृष्ठ ५२६)

यह वही है जो हमने चर्चा की थी। लेकिन "अर्थ का विस्तार" क्या है? हालांकि प्रत्यक्ष मोड में मूल्य में केवल 5 बिट्स हैं, इसे 16-बिट संख्या के साथ जोड़ने की आवश्यकता है। इन 5 बिट्स को दूसरे नंबर के अनुरूप करने के लिए 16 तक विस्तारित किया जाना चाहिए। सकारात्मक संख्याओं के लिए, हम शून्य के साथ लापता बिट्स को भर सकते हैं और समान मूल्य प्राप्त कर सकते हैं। हालांकि, नकारात्मक संख्याओं के लिए यह काम नहीं करता है। उदाहरण के लिए, पांच बिट्स में 1 1111 । यदि आप इसे शून्य से भरते हैं, तो हमें 0000 0000 0001 1111 मिलता है, जो कि 32 है! मूल्य का विस्तार सकारात्मक संख्याओं के लिए शून्य और नकारात्मक संख्याओं के लिए बिट्स को भरकर इस समस्या को रोकता है।

 uint16_t sign_extend(uint16_t x, int bit_count) { if ((x >> (bit_count - 1)) & 1) { x |= (0xFFFF << bit_count); } return x; }

नोट: यदि आप बाइनरी नकारात्मक संख्याओं में रुचि रखते हैं, तो आप अतिरिक्त कोड के बारे में पढ़ सकते हैं। लेकिन यह जरूरी नहीं है। बस ऊपर दिए गए कोड को कॉपी करें और इसका उपयोग तब करें जब विनिर्देश मान का विस्तार करने के लिए कहता है।

विनिर्देशन का अंतिम वाक्य है:

परिणाम कोड नकारात्मक, शून्य या सकारात्मक के आधार पर निर्धारित किए जाते हैं। (पृष्ठ ५२६)

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

 void update_flags(uint16_t r) { if (reg[r] == 0) { reg[R_COND] = FL_ZRO; } else if (reg[r] >> 15) /* a 1 in the left-most bit indicates negative */ { reg[R_COND] = FL_NEG; } else { reg[R_COND] = FL_POS; } }

अब हम ADD के लिए कोड लिखने के लिए तैयार हैं:

 { /* destination register (DR) */ uint16_t r0 = (instr >> 9) & 0x7; /* first operand (SR1) */ uint16_t r1 = (instr >> 6) & 0x7; /* whether we are in immediate mode */ uint16_t imm_flag = (instr >> 5) & 0x1; if (imm_flag) { uint16_t imm5 = sign_extend(instr & 0x1F, 5); reg[r0] = reg[r1] + imm5; } else { uint16_t r2 = instr & 0x7; reg[r0] = reg[r1] + reg[r2]; } update_flags(r0); }

इस खंड में बहुत सारी जानकारी है, तो आइए संक्षेप में बताते हैं।

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

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

LDI

LDI का अर्थ है "अप्रत्यक्ष" या "अप्रत्यक्ष" लोडिंग (अप्रत्यक्ष)। इस निर्देश का उपयोग मेमोरी लोकेशन के मान को रजिस्टर में लोड करने के लिए किया जाता है। पृष्ठ 532 पर विशिष्टता।

यहाँ बाइनरी लेआउट कैसा दिखता है:

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

पते की गणना मूल्य के बिट्स [8:0] को 16 बिट तक बढ़ाकर और इस मान को बढ़े हुए PC जोड़कर की जाती है। इस पते पर मेमोरी में क्या संग्रहित किया गया है, उस डेटा का पता है जिसे DR में लोड किया जाएगा। (पृष्ठ ५३२)

पहले की तरह, आपको इस 9-बिट मान का विस्तार करने की आवश्यकता है, लेकिन इस बार इसे वर्तमान PC जोड़ें। (यदि आप निष्पादन चक्र को देखते हैं, तो इस निर्देश को लोड करने के तुरंत बाद PC बढ़ गया)। परिणामी योग मेमोरी में स्थान का पता है, और इस पते में एक और मूल्य है, जो लोड मूल्य का पता है।

यह स्मृति से पढ़ने के लिए एक गोल चक्कर की तरह लग सकता है, लेकिन यह आवश्यक है। LD निर्देश 9 बिट्स के एक पते ऑफ़सेट तक सीमित है, जबकि मेमोरी में 16 बिट्स के पते की आवश्यकता होती है। LDI उन मूल्यों को लोड करने के लिए उपयोगी है जो वर्तमान कंप्यूटर के बाहर कहीं संग्रहीत हैं, लेकिन उनका उपयोग करने के लिए, अंतिम स्थान का पता पास में संग्रहीत किया जाना चाहिए। आप इसे C में एक स्थानीय चर के रूप में सोच सकते हैं, जो कुछ डेटा के लिए एक संकेतक है:

 // the value of far_data is an address // of course far_data itself (the location in memory containing the address) has an address char* far_data = "apple"; // In memory it may be layed out like this: // Address Label Value // 0x123: far_data = 0x456 // ... // 0x456: string = 'a' // if PC was at 0x100 // LDI R0 0x023 // would load 'a' into R0

पहले की तरह, DR को मान लिखने के बाद, झंडे को अपडेट किया जाना चाहिए:

परिणाम कोड नकारात्मक, शून्य या सकारात्मक के आधार पर निर्धारित किए जाते हैं। (पृष्ठ ५३२)

यहाँ इस मामले के लिए कोड है: ( mem_read अगले भाग में चर्चा की mem_read ):

 { /* destination register (DR) */ uint16_t r0 = (instr >> 9) & 0x7; /* PCoffset 9*/ uint16_t pc_offset = sign_extend(instr & 0x1ff, 9); /* add pc_offset to the current PC, look at that memory location to get the final address */ reg[r0] = mem_read(mem_read(reg[R_PC] + pc_offset)); update_flags(r0); }

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

अब आपको बाकी निर्देशों को लागू करने की आवश्यकता है। विनिर्देशों का पालन करें और पहले से लिखे गए कोड का उपयोग करें। सभी निर्देशों के लिए कोड लेख के अंत में दिया गया है। पहले बताए गए दो OP_RTI जरूरत नहीं होगी: OP_RTI और OP_RES । आप उन्हें अनदेखा कर सकते हैं या एक त्रुटि दे सकते हैं यदि उन्हें बुलाया जाता है। जब किया जाता है, तो आपके वीएम का थोक पूरा माना जा सकता है!

7. निर्देशों के अनुसार पालना

यदि आप अटके हुए हैं तो इस खंड में शेष निर्देशों का पूरा कार्यान्वयन है।

आरटीआई और आरईएस

(इस्तेमाल नहीं किया गया)

 abort();

बिट "और"

 { uint16_t r0 = (instr >> 9) & 0x7; uint16_t r1 = (instr >> 6) & 0x7; uint16_t imm_flag = (instr >> 5) & 0x1; if (imm_flag) { uint16_t imm5 = sign_extend(instr & 0x1F, 5); reg[r0] = reg[r1] & imm5; } else { uint16_t r2 = instr & 0x7; reg[r0] = reg[r1] & reg[r2]; } update_flags(r0); }

बिटवाइज़ नहीं

 { uint16_t r0 = (instr >> 9) & 0x7; uint16_t r1 = (instr >> 6) & 0x7; reg[r0] = ~reg[r1]; update_flags(r0); }

शाखा

 { uint16_t pc_offset = sign_extend((instr) & 0x1ff, 9); uint16_t cond_flag = (instr >> 9) & 0x7; if (cond_flag & reg[R_COND]) { reg[R_PC] += pc_offset; } }

कूद

RET को विनिर्देश में एक अलग निर्देश के रूप में इंगित किया गया है, क्योंकि यह कोडांतरक में एक और कमांड है। यह वास्तव में JMP का एक विशेष मामला है। जब भी R1 7 होता है तो RET होता है।

 { /* Also handles RET */ uint16_t r1 = (instr >> 6) & 0x7; reg[R_PC] = reg[r1]; }

कूद रजिस्टर

 { uint16_t r1 = (instr >> 6) & 0x7; uint16_t long_pc_offset = sign_extend(instr & 0x7ff, 11); uint16_t long_flag = (instr >> 11) & 1; reg[R_R7] = reg[R_PC]; if (long_flag) { reg[R_PC] += long_pc_offset; /* JSR */ } else { reg[R_PC] = reg[r1]; /* JSRR */ } break; }

भार

 { uint16_t r0 = (instr >> 9) & 0x7; uint16_t pc_offset = sign_extend(instr & 0x1ff, 9); reg[r0] = mem_read(reg[R_PC] + pc_offset); update_flags(r0); }

लोड रजिस्टर

 { uint16_t r0 = (instr >> 9) & 0x7; uint16_t r1 = (instr >> 6) & 0x7; uint16_t offset = sign_extend(instr & 0x3F, 6); reg[r0] = mem_read(reg[r1] + offset); update_flags(r0); }

प्रभावी लोड पता

 { uint16_t r0 = (instr >> 9) & 0x7; uint16_t pc_offset = sign_extend(instr & 0x1ff, 9); reg[r0] = reg[R_PC] + pc_offset; update_flags(r0); }

दुकान

 { uint16_t r0 = (instr >> 9) & 0x7; uint16_t pc_offset = sign_extend(instr & 0x1ff, 9); mem_write(reg[R_PC] + pc_offset, reg[r0]); }

दुकान अप्रत्यक्ष

 { uint16_t r0 = (instr >> 9) & 0x7; uint16_t pc_offset = sign_extend(instr & 0x1ff, 9); mem_write(mem_read(reg[R_PC] + pc_offset), reg[r0]); }

स्टोर रजिस्टर

 { uint16_t r0 = (instr >> 9) & 0x7; uint16_t r1 = (instr >> 6) & 0x7; uint16_t offset = sign_extend(instr & 0x3F, 6); mem_write(reg[r1] + offset, reg[r0]); }

8. बाधित हैंडलिंग प्रक्रिया

LC-3 आम कार्यों और I / O उपकरणों के साथ बातचीत करने के लिए कई पूर्वनिर्धारित दिनचर्या प्रदान करता है। उदाहरण के लिए, कीबोर्ड इनपुट और कंसोल के लिए आउटपुट लाइनें प्राप्त करने की प्रक्रियाएं हैं। उन्हें ट्रैप रूटीन कहा जाता है, जिसे आप LC-3 के लिए ऑपरेटिंग सिस्टम या API के रूप में सोच सकते हैं। प्रत्येक उपप्रोग्राम को एक बाधा कोड (ट्रैप कोड) सौंपा गया है जो इसे पहचानता है (ओपोड के समान)।इसे निष्पादित करने के लिए, TRAPवांछित सबप्रोग्राम के कोड के साथ एक निर्देश कहा जाता है ।

प्रत्येक बाधा कोड के लिए enum सेट करें:

 enum { TRAP_GETC = 0x20, /* get character from keyboard */ TRAP_OUT = 0x21, /* output a character */ TRAP_PUTS = 0x22, /* output a word string */ TRAP_IN = 0x23, /* input a string */ TRAP_PUTSP = 0x24, /* output a byte string */ TRAP_HALT = 0x25 /* halt the program */ };

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

: 0x3000 0x0 . , .

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

यद्यपि प्रक्रियाओं को कोडांतरक में लिखा जा सकता है और भौतिक कंप्यूटर LC-3 ऐसा होगा, यह VM के लिए सबसे अच्छा विकल्प नहीं है। अपने स्वयं के आदिम इनपुट-आउटपुट प्रक्रियाओं को लिखने के बजाय, आप उन का उपयोग कर सकते हैं जो हमारे ओएस पर उपलब्ध हैं। यह हमारे कंप्यूटर पर वर्चुअल मशीन में सुधार करेगा, कोड को सरल करेगा और पोर्टेबिलिटी के लिए उच्च स्तर की अमूर्तता प्रदान करेगा।

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

Opcode के लिए बहु-विकल्प ऑपरेटर में, TRAPएक और स्विच जोड़ें:

 switch (instr & 0xFF) { case TRAP_GETC: {TRAP GETC, 9} break; case TRAP_OUT: {TRAP OUT, 9} break; case TRAP_PUTS: {TRAP PUTS, 8} break; case TRAP_IN: {TRAP IN, 9} break; case TRAP_PUTSP: {TRAP PUTSP, 9} break; case TRAP_HALT: {TRAP HALT, 9} break; }

निर्देशों के अनुसार, मैं आपको दिखाऊंगा कि कैसे एक प्रक्रिया को लागू करना है, और बाकी को खुद करना है।

डालता है

इंटरप्ट कोड PUTSएक टर्मिनेटिंग जीरो (इसी तरह printfC) के साथ एक स्ट्रिंग को वापस करने के लिए उपयोग किया जाता है । पृष्ठ 543 पर विशिष्टता।

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

विनिर्देशन से:

कंसोल डिस्प्ले में ASCII वर्ण स्ट्रिंग प्रदर्शित करें। वर्ण लगातार मेमोरी सेल में निहित होते हैं, प्रति सेल एक वर्ण, निर्दिष्ट पते पर शुरू होता है R0। आउटपुट तब समाप्त होता है जब मेमोरी में कोई मूल्य सामने आता है x0000। (पृष्ठ ५४३)

ध्यान दें कि सी स्ट्रिंग्स के विपरीत, यहां वर्ण एक बाइट में नहीं, बल्कि स्मृति में एक स्थान पर संग्रहीत किए जाते हैं । LC-3 की मेमोरी लोकेशन 16 बिट्स है, इसलिए स्ट्रिंग में प्रत्येक कैरेक्टर 16 बिट्स है। सी फ़ंक्शन में इसे प्रदर्शित करने के लिए, आपको प्रत्येक मान को एक चरित्र में बदलने और उन्हें अलग से प्रिंट करने की आवश्यकता है।

 { /* one char per word */ uint16_t* c = memory + reg[R_R0]; while (*c) { putc((char)*c, stdout); ++c; } fflush(stdout); }

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

9. बाधित दिनचर्या के लिए धोखा शीट

इस खंड में शेष व्यवधान दिनचर्या के पूर्ण कार्यान्वयन शामिल हैं।

चरित्र प्रविष्टि

 /* read a single ASCII char */ reg[R_R0] = (uint16_t)getchar();

चरित्र उत्पादन

 putc((char)reg[R_R0], stdout); fflush(stdout);

चरित्र इनपुट अनुरोध

 printf("Enter a character: "); reg[R_R0] = (uint16_t)getchar();

लाइन आउटपुट

 { /* one char per byte (two bytes per word) here we need to swap back to big endian format */ uint16_t* c = memory + reg[R_R0]; while (*c) { char char1 = (*c) & 0xFF; putc(char1, stdout); char char2 = (*c) >> 8; if (char2) putc(char2, stdout); ++c; } fflush(stdout); }

कार्यक्रम समाप्ति

 puts("HALT"); fflush(stdout); running = 0;

10. प्रोग्राम डाउनलोड करना

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

प्रोग्राम फ़ाइल के पहले 16 बिट्स स्मृति में पते को इंगित करते हैं जहां कार्यक्रम शुरू होना चाहिए। इस पते को मूल कहा जाता है । इसे पहले पढ़ा जाना चाहिए, इसके बाद फ़ाइल से शेष डेटा को मेमोरी में पढ़ा जाता है।

यहाँ प्रोग्राम को LC-3 मेमोरी में लोड करने का कोड है:

 void read_image_file(FILE* file) { /* the origin tells us where in memory to place the image */ uint16_t origin; fread(&origin, sizeof(origin), 1, file); origin = swap16(origin); /* we know the maximum file size so we only need one fread */ uint16_t max_read = UINT16_MAX - origin; uint16_t* p = memory + origin; size_t read = fread(p, sizeof(uint16_t), max_read, file); /* swap to little endian */ while (read-- > 0) { *p = swap16(*p); ++p; } }

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

 uint16_t swap16(uint16_t x) { return (x << 8) | (x >> 8); }

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

इसके लिए एक सुविधाजनक फ़ंक्शन भी जोड़ें read_image_file, जो स्ट्रिंग के लिए पथ लेता है:

 int read_image(const char* image_path) { FILE* file = fopen(image_path, "rb"); if (!file) { return 0; }; read_image_file(file); fclose(file); return 1; }

11. मैप किए गए रजिस्टर

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

हमारे LC-3 के लिए, हमें दो अनुपयोगी रजिस्टर लागू करने की आवश्यकता है। यह कीबोर्ड स्टेटस रजिस्टर ( KBSR) और कीबोर्ड डेटा रजिस्टर ( KBDR) है। पहला इंगित करता है कि क्या कुंजी दबाया गया है, और दूसरा यह निर्धारित करता है कि किस कुंजी को दबाया गया है।

यद्यपि कीबोर्ड इनपुट का उपयोग करके अनुरोध किया जा सकता है GETC, यह इनपुट प्राप्त होने तक निष्पादन को अवरुद्ध करता है। KBSRऔर KBDRअनुमति देंप्रोग्राम को चलाते समय डिवाइस की स्थिति पर पूछताछ करें , ताकि इनपुट की प्रतीक्षा करते समय यह उत्तरदायी रहे।

 enum { MR_KBSR = 0xFE00, /* keyboard status */ MR_KBDR = 0xFE02 /* keyboard data */ };

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

 void mem_write(uint16_t address, uint16_t val) { memory[address] = val; } uint16_t mem_read(uint16_t address) { if (address == MR_KBSR) { if (check_key()) { memory[MR_KBSR] = (1 << 15); memory[MR_KBDR] = getchar(); } else { memory[MR_KBSR] = 0; } } return memory[address]; }

यह एक वर्चुअल मशीन का अंतिम घटक है! यदि आपने शेष व्यवधान दिनचर्या और निर्देशों को लागू किया है, तो आप इसे आज़माने के लिए तैयार हैं!

निम्न क्रम में सी फ़ाइल में लिखा गया सब कुछ जोड़ा जाना चाहिए:

 {Memory Mapped Registers, 11} {TRAP Codes, 8} {Memory Storage, 3} {Register Storage, 3} {Functions, 12} {Main Loop, 5}

12. प्लेटफ़ॉर्म सुविधाएँ

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

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

 uint16_t check_key() { fd_set readfds; FD_ZERO(&readfds); FD_SET(STDIN_FILENO, &readfds); struct timeval timeout; timeout.tv_sec = 0; timeout.tv_usec = 0; return select(1, &readfds, NULL, NULL, &timeout) != 0; }

प्रोग्राम के तर्कों से रास्ता निकालने के लिए कोड और यदि वे गायब हैं तो उपयोग उदाहरण का उत्पादन करें।

 if (argc < 2) { /* show usage string */ printf("lc3 [image-file1] ...\n"); exit(2); } for (int j = 1; j < argc; ++j) { if (!read_image(argv[j])) { printf("failed to load image: %s\n", argv[j]); exit(1); } }

यूनिक्स-विशिष्ट टर्मिनल इनपुट कॉन्फ़िगरेशन कोड।

 struct termios original_tio; void disable_input_buffering() { tcgetattr(STDIN_FILENO, &original_tio); struct termios new_tio = original_tio; new_tio.c_lflag &= ~ICANON & ~ECHO; tcsetattr(STDIN_FILENO, TCSANOW, &new_tio); } void restore_input_buffering() { tcsetattr(STDIN_FILENO, TCSANOW, &original_tio); }

जब कार्यक्रम बाधित होता है, तो हम कंसोल को उसकी सामान्य सेटिंग्स पर लौटना चाहते हैं।

 void handle_interrupt(int signal) { restore_input_buffering(); printf("\n"); exit(-2); }

 signal(SIGINT, handle_interrupt); disable_input_buffering();

 restore_input_buffering();

 {Sign Extend, 6} {Swap, 10} {Update Flags, 6} {Read Image File, 10} {Read Image, 10} {Check Key, 12} {Memory Access, 11} {Input Buffering, 12} {Handle Interrupt, 12}

 #include <stdio.h> #include <stdlib.h> #include <stdint.h> #include <string.h> #include <signal.h> #include <unistd.h> #include <fcntl.h> #include <sys/time.h> #include <sys/types.h> #include <sys/termios.h> #include <sys/mman.h>

वर्चुअल मशीन स्टार्टअप

अब आप LC-3 वर्चुअल मशीन बना और चला सकते हैं!

अपने पसंदीदा कंपाइलर के साथ प्रोग्राम को संकलित करें ।
2048 या दुष्ट का संकलित संस्करण डाउनलोड करें ।
एक तर्क के रूप में obj फ़ाइल के साथ कार्यक्रम चलाएँ:
lc3-vm path/to/2048.obj
2048 में खेलें!

 Control the game using WASD keys. Are you on an ANSI terminal (y/n)? y +--------------------------+ | | | | | | | 2 | | | | 2 | | | | | | | +--------------------------+

डिबगिंग

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

14. C ++ में वैकल्पिक विधि

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

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

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

निर्देश को चरणों के अनुक्रम के रूप में देखते हुए, हम देखते हैं कि प्रत्येक निर्देश कई छोटे चरणों का एक पुनर्व्यवस्था है। हम इंगित करने के लिए बिट फ्लैग का उपयोग करेंगे कि प्रत्येक निर्देश के लिए कौन से चरणों का पालन करें। 1निर्देश संख्या बिट में मान इंगित करता है कि इस निर्देश के लिए संकलक को कोड के इस खंड को शामिल करना चाहिए।

 template <unsigned op> void ins(uint16_t instr) { uint16_t r0, r1, r2, imm5, imm_flag; uint16_t pc_plus_off, base_plus_off; uint16_t opbit = (1 << op); if (0x4EEE & opbit) { r0 = (instr >> 9) & 0x7; } if (0x12E3 & opbit) { r1 = (instr >> 6) & 0x7; } if (0x0022 & opbit) { r2 = instr & 0x7; imm_flag = (instr >> 5) & 0x1; imm5 = sign_extend((instr) & 0x1F, 5); } if (0x00C0 & opbit) { // Base + offset base_plus_off = reg[r1] + sign_extend(instr & 0x3f, 6); } if (0x4C0D & opbit) { // Indirect address pc_plus_off = reg[R_PC] + sign_extend(instr & 0x1ff, 9); } if (0x0001 & opbit) { // BR uint16_t cond = (instr >> 9) & 0x7; if (cond & reg[R_COND]) { reg[R_PC] = pc_plus_off; } } if (0x0002 & opbit) // ADD { if (imm_flag) { reg[r0] = reg[r1] + imm5; } else { reg[r0] = reg[r1] + reg[r2]; } } if (0x0020 & opbit) // AND { if (imm_flag) { reg[r0] = reg[r1] & imm5; } else { reg[r0] = reg[r1] & reg[r2]; } } if (0x0200 & opbit) { reg[r0] = ~reg[r1]; } // NOT if (0x1000 & opbit) { reg[R_PC] = reg[r1]; } // JMP if (0x0010 & opbit) // JSR { uint16_t long_flag = (instr >> 11) & 1; pc_plus_off = reg[R_PC] + sign_extend(instr & 0x7ff, 11); reg[R_R7] = reg[R_PC]; if (long_flag) { reg[R_PC] = pc_plus_off; } else { reg[R_PC] = reg[r1]; } } if (0x0004 & opbit) { reg[r0] = mem_read(pc_plus_off); } // LD if (0x0400 & opbit) { reg[r0] = mem_read(mem_read(pc_plus_off)); } // LDI if (0x0040 & opbit) { reg[r0] = mem_read(base_plus_off); } // LDR if (0x4000 & opbit) { reg[r0] = pc_plus_off; } // LEA if (0x0008 & opbit) { mem_write(pc_plus_off, reg[r0]); } // ST if (0x0800 & opbit) { mem_write(mem_read(pc_plus_off), reg[r0]); } // STI if (0x0080 & opbit) { mem_write(base_plus_off, reg[r0]); } // STR if (0x8000 & opbit) // TRAP { {TRAP, 8} } //if (0x0100 & opbit) { } // RTI if (0x4666 & opbit) { update_flags(r0); } }

 static void (*op_table[16])(uint16_t) = { ins<0>, ins<1>, ins<2>, ins<3>, ins<4>, ins<5>, ins<6>, ins<7>, NULL, ins<9>, ins<10>, ins<11>, ins<12>, NULL, ins<14>, ins<15> };

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

C ++ के अन्य संस्करण पहले से लिखे गए कोड का उपयोग करते हैं। पूर्ण संस्करण यहाँ ।

 {Includes, 12} {Registers, 3} {Condition Flags, 3} {Opcodes, 3} {Memory Mapped Registers, 11} {TRAP Codes, 8} {Memory Storage, 3} {Register Storage, 3} {Functions, 12} int running = 1; {Instruction C++, 14} {Op Table, 14} int main(int argc, const char* argv[]) { {Load Arguments, 12} {Setup, 12} enum { PC_START = 0x3000 }; reg[R_PC] = PC_START; while (running) { uint16_t instr = mem_read(reg[R_PC]++); uint16_t op = instr >> 12; op_table[op](instr); } {Shutdown, 12} }

हम अपनी खुद की वर्चुअल मशीन लिखते हैं