लिटिल मैन कंप्यूटर

From Vigyanwiki

लिटिल मैन कंप्यूटर (एलएमसी) कंप्यूटर का एक निर्देशात्मक मॉडल है, जिसे 1965 में डॉ. स्टुअर्ट मैडनिक द्वारा बनाया गया था।[1] एलएमसी का उपयोग सामान्यतः छात्रों को पढ़ाने के लिए किया जाता है क्योंकि यह एक साधारण वॉन न्यूमैन आर्किटेक्चर कंप्यूटर का मॉडल है, जिसमें आधुनिक कंप्यूटर की सभी मुख्य विशेषताएं हैं। इसके प्रोग्रामों को मशीन कोड (यद्यपि बाइनरी के अतिरिक्त डेसीमल में) या असेंबली कोड में किया जा सकता है।[2][3][4]

एलएमसी मॉडल एक क्लोज्ड मेल-रूम में क्लोज्ड लिटिल मैन कंप्यूटर की अवधारणा पर आधारित है। क्लोज्ड मेल-रूम के एक भाग मे 100 मेलबॉक्स होते हैं सामान्यतः जिनकी संख्या 0 से 99 मे मध्य होती है। जिनमें से प्रत्येक में 3 डिजिट का डेटा (000 से 999 तक) हो सकता है। इसके अतिरिक्त दूसरे भाग पर इनबॉक्स और आउटबॉक्स लेबल (प्रोग्रामिंग लैंग्वेज) वाले दो मेलबॉक्स हैं जिनका उपयोग डेटा प्राप्त करने और आउटपुट करने के लिए किया जाता है। क्लोज्ड मेल-रूम के सेंटर में एक कार्य क्षेत्र है जिसमें साधारण दो फ़ंक्शन (+) और (-) होते है जिसे एक्युमुलेटर के रूप में जाना जाता है। एक रीसेट करने योग्य काउंटर है जिसे प्रोग्राम काउंटर के रूप में जाना जाता है। प्रोग्राम काउंटर में लिटिल मैन कंप्यूटर द्वारा किए जाने वाले अगले इंस्ट्रक्शन का एड्रेस होता है। प्रत्येक इंस्ट्रक्शन के निष्पादित होने के बाद इस प्रोग्राम काउंटर को सामान्यतः 1 से बढ़ा दिया जाता है, जिससे लिटिल मैन को एक फ़ंक्शन के रूप मे प्रोग्राम के माध्यम से कार्य करने की स्वीकृति प्राप्त होती है जो ब्रांच इंस्ट्रक्शन इटेरशन (लूप) और कंडीशनल प्रोग्रामिंग संरचनाओं को एक प्रोग्राम में सम्मिलित करने की स्वीकृति देते हैं। यदि कोई विशेष कंडीशनल (सामान्यतः एक्यूमुलेटर में संग्रहीत मान शून्य या धनात्मक होता है) पूरी हो जाती है तो प्रोग्राम काउंटर को नॉन-कंडीशनल मेमोरी एड्रेस पर प्रयुक्त करके प्राप्त किया जाता है।

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

कार्यान्वयन साइकल

See also: इंस्ट्रक्शन

किसी प्रोग्राम को निष्पादित करने के लिए लिटिल मैन कंप्यूटर इन नियमो का अनुसरण करता है:

  1. मेलबॉक्स संख्या के लिए प्रोग्राम काउंटर की जांच करें जिसमें प्रोग्राम इंस्ट्रक्शन सम्मिलित होते है।
  2. उस संख्या वाले मेलबॉक्स से इंस्ट्रक्शन प्राप्त करें जिसमे प्रत्येक इंस्ट्रक्शन के दो फ़ील्ड ऑपकोड (संचालन करने के लिए ऑपरेशन को इंगित करता है) और एड्रेस फ़ील्ड (यह दर्शाता है कि ऑपरेशन करने के लिए डेटा कहां है) होते हैं।
  3. प्रोग्राम काउंटर बढ़ाएँ जिसमे अगले इंस्ट्रक्शन की मेलबॉक्स संख्या सम्मिलित होती है।
  4. इंस्ट्रक्शन को डिकोड करें। यदि इंस्ट्रक्शन किसी अन्य मेलबॉक्स में संग्रहीत डेटा का उपयोग करता है तो उस डेटा के लिए मेलबॉक्स संख्या को खोजने के लिए एड्रेस फ़ील्ड का उपयोग करें जिस पर यह कार्य किया जा सकता है। उदाहरण के लिए 'मेलबॉक्स संख्या 42 से डेटा प्राप्त करें।
  5. फेच संख्या 4 में निर्धारित एड्रेस के साथ इनपुट एक्यूमुलेटर या मेलबॉक्स से डेटा प्राप्त करें।
  6. दिए गए ऑपकोड के आधार पर इंस्ट्रक्शन को कार्यान्वित करें।
  7. फेच संख्या 4 में निर्धारित एड्रेस के साथ परिणाम को आउटपुट, एक्यूमुलेटर या मेलबॉक्स में संग्रहीत करें।
  8. साइकल या हाल्ट को दोहराने के लिए प्रोग्राम काउंटर पर वापस जाए।

कमांड

एलएमसी बाइनरी प्रोसेसर की वास्तविक कार्यप्रणाली को दर्शाता है। जिसकी डेसीमल संख्याओं की सरलता को उन छात्रों के लिए कॉम्प्लेक्सिटी समस्या को कम करने के लिए चुना गया था जो बाइनरी/हेक्साडेसिमल में कार्य करने में सहज (कम्फ़र्टेबल) नहीं हो सकते थे।

निर्देश (इंस्ट्रक्शन)

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

नीचे दी गई तालिका एक विशिष्ट न्यूमेरिक इंस्ट्रक्शन कोड और एक्विवलेंट मनेमोनिक कोड प्रदर्शित करती है।

इंस्ट्रक्शन
न्यूमेरिक कोड मनेमोनिक कोड इंस्ट्रक्शन विवरण
1xx एडीडी एडीडी मेलबॉक्स xx में संग्रहीत मान को वर्तमान में एक्यूमुलेटर मान से जोड़ें।
ध्यान दें: मेलबॉक्स का डेटा परिवर्तित नही किया जाता है और एक्यूमुलेटर की गतिविधियों को उन इंस्ट्रक्शन मे जोड़ने के लिए परिभाषित नहीं किया जाता है, जो 3 डिजिट से बड़े योग का कारण बनते हैं। सबट्रैक्ट के समान कोई ओवरफ्लो पर ऋणात्मक फ्लैग प्रयुक्त कर सकता है।
2xx एसयूबी सब्ट्रैक्ट एक्यूमुलेटर पर वर्तमान में जो भी मान है, उसमें से मेलबॉक्स xx में संग्रहीत मान घटाएँ।
ध्यान दें: मेलबॉक्स का डेटा परिवर्तित नही किया गया है और एक्यूमुलेटर के एक्शन को ऋणात्मक परिणामों का कारण बनने वाले सबट्रैक्ट इंस्ट्रक्शन के लिए परिभाषित नहीं किया गया है। हालांकि एक ऋणात्मक ऋणात्मक फ्लैग प्रयुक्त कर सकता है। ताकि 7xx (बीआरजेड) और 8xx (बीआरपी) का उपयोग किया जा सके।
3xx एसटीए स्टोर एक्यूमुलेटर के डेटा को मेलबॉक्स xx (डेस्ट्रकटिव) में संग्रहीत करें।
ध्यान दें: एक्यूमुलेटर का डेटा (नॉन-डेस्ट्रकटिव) परिवर्तित नही किया जाता है लेकिन मेमेलबॉक्स का डेटा परिवर्तित किया जाता है फिर चाहे उसमें कुछ भी डेस्ट्रकटिव डेटा स्थित हो।
5xx एलडीए लोड मेलबॉक्स xx (नॉन-डेस्ट्रकटिव) से मान लोड करें और इसे एक्यूमुलेटर (डेस्ट्रकटिव) में प्रस्तुत करें।
6xx बीआरए ब्रांच (अनकंडीशनल) प्रोग्राम काउंटर को दिए गए एड्रेस (मान xx) पर प्रयुक्त करें। अर्थात् मेलबॉक्स xx में यही मान अगला निष्पादित इंस्ट्रक्शन होगा।
7xx बीआरजेड यदि ब्रांच शून्य (कंडीशनल) यदि एक्यूमुलेटर में मान 000 है, तो प्रोग्राम काउंटर का मान xx प्रयुक्त करें अन्यथा कुछ न करें शून्य रहने दे। ऋणात्मक फ्लैग को ध्यान में रखा गया है या नहीं यह अपरिभाषित है। जब एक सब्ट्रैक्ट एक्यूमुलेटर को अंडरफ्लो करता है, तो यह ऋणात्मक फ्लैग प्रयुक्त किया जाता है जिसके बाद एक्यूमुलेटर अपरिभाषित होता है या संभावित रूप से शून्य होता है, जिससे अंडरफ्लो पर बीआरजेड का कार्य अपरिभाषित हो जाता है। यदि एक्यूमुलेटर शून्य है और ऋणात्मक फ्लैग प्रयुक्त नहीं है तो प्रयुक्त किया गया डेटा ब्रांच में होता है।
ध्यान दें: चूंकि प्रोग्राम मेमोरी में संग्रहीत होता है। इसलिए डेटा और प्रोग्राम इंस्ट्रक्शन का एड्रेस फॉर्मेट के समान होता है।
8xx बीआरपी यदि ब्रांच धनात्मक (कंडीशनल) यदि एक्यूमुलेटर 0 या धनात्मक है, तो प्रोग्राम काउंटर को मान को xx पर प्रयुक्त करें अन्यथा कुछ न करें शून्य रहने दे। चूँकि एलएमसी मेमोरी सेल केवल 0 और 999 के बीच मान रख सकते हैं। यह इंस्ट्रक्शन पूरी तरह से सब्ट्रैक्ट पर अंडरफ्लो द्वारा निर्धारित ऋणात्मक फ्लैग और संभावित रूप से एडीडी (अपरिभाषित) ओवरफ्लो पर निर्भर करता है।
ध्यान दें: चूंकि प्रोग्राम मेमोरी में संग्रहीत होता है। इसलिए डेटा और प्रोग्राम इंस्ट्रक्शन का एड्रेस फॉर्मेट के समान होता है।
901 आईएनपी इनपुट इनबॉक्स पर जाएं, उपयोगकर्ता से डेटा प्राप्त करें और इसे एक्यूमुलेटर में इनपुट करे।
ध्यान दें: यह एक्यूमुलेटर में जो भी डेटा होता है उसे डेस्ट्रकटिव कर देता है।
902 ओयूटी आउटपुट एक्यूमुलेटर से डेटा को आउटबॉक्स में कॉपी करें।
ध्यान दें: एक्यूमुलेटर का डेटा (नॉन-डेस्ट्रकटिव) परिवर्तित नही किया जाता है।
000 एचएलटी/सीओबी हॉल्ट/कॉफी ब्रेक कार्य करना बंद करें/प्रोग्राम समाप्त करें।
डीएटी डाटा यह एक असेंबलर इंस्ट्रक्शन है जो बस-डेटा को अगले उपलब्ध मेलबॉक्स में लोड करता है। वैरिएबल घोषित करने के लिए डीएटी का उपयोग लेबल के संयोजन में भी किया जा सकता है। उदाहरण के लिए डीएटी 984 मान 984 को डीएटी इंस्ट्रक्शन के एड्रेस पर एक मेलबॉक्स में संग्रहीत करता है।

उदाहरण

न्यूमेरिक इंस्ट्रक्शन कोड का उपयोग करना

यह प्रोग्राम (इंस्ट्रक्शन 901 से इंस्ट्रक्शन 000 तक) केवल न्यूमेरिक कोड का उपयोग करके लिखा गया है। प्रोग्राम इनपुट के रूप में दो संख्या लेता है और आउटपुट देता है। ध्यान दें कि यह कार्यान्वयन मेलबॉक्स 00 पर प्रारम्भ होता है और मेलबॉक्स 07 पर समाप्त होता है। न्यूमेरिक इंस्ट्रक्शन कोड का उपयोग करके एलएमसी प्रोग्रामिंग मे होने वाली कमी पर नीचे चर्चा की गई है।

मेलबॉक्स न्यूमेरिक कोड ऑपरेशन टिप्पणी
00 901 एक्यूमुलेटर = इनबॉक्स पहली संख्या को कैलकुलेटर में प्रस्तुत करें (वहां जो कुछ भी था उसे मिटा दें)
01 308 मेलबॉक्स 08 = एक्यूमुलेटर कैलकुलेटर का वर्तमान मान संग्रहीत करें (अगले चरण की तैयारी के लिए...)
02 901 एक्यूमुलेटर = इनबॉक्स दूसरी संख्या को कैलकुलेटर में प्रस्तुत करें (वहां जो कुछ भी था उसे मिटा दें)
03 309 मेलबॉक्स 09 = एक्यूमुलेटर कैलकुलेटर का वर्तमान मान संग्रहीत करें (फिर से, अगले चरण की तैयारी के लिए...)
04 508 एक्यूमुलेटर = मेलबॉक्स 08 (अब दोनों इनपुट मान मेलबॉक्स 08 और 09 में संग्रहीत हैं...)

पहले मान को वापस कैलकुलेटर में लोड करें (वहां जो कुछ भी था उसे मिटा दें)

05 209 एक्यूमुलेटर = एक्यूमुलेटर - मेलबॉक्स 09 कैलकुलेटर के वर्तमान मान से दूसरी संख्या घटाएं (जो कि पहली संख्या पर मान प्रयुक्त किया गया था)
06 902 आउटबॉक्स = एक्यूमुलेटर कैलकुलेटर के परिणाम को आउटबॉक्स में आउटपुट करें।
07 000 हॉल्ट एचएएलटी एलएमसी

मनेमोनिक्स और लेबल लैंग्वेज का उपयोग करना

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

INP
STA FIRST
INP
STA SECOND
LDA FIRST
SUB SECOND
OUT
HLT
FIRST DAT
SECOND DAT

लेबल (प्रोग्रामिंग लैंग्वेज)

लेबल प्रोग्रामिंग लैंग्वेज के बिना प्रोग्रामर को मेलबॉक्स (मेमोरी) एड्रेसों की मैन्युअल रूप से गणना करने की आवश्यकता होती है। न्यूमेरिक कोड उदाहरण में यदि अंतिम एचएलटी इंस्ट्रक्शन से पहले एक नया इंस्ट्रक्शन डाला जाना था तो वह एचएलटी इंस्ट्रक्शन एड्रेस 07 से एड्रेस 08 पर चला जाता है जिससे एड्रेस लेबल एड्रेस 00 पर प्रारम्भ होता है। मान लीजिए कि उपयोगकर्ता ने पहले इनपुट के रूप में 600 प्रस्तुत किया है तब इंस्ट्रक्शन 308 का अर्थ यह होगा कि यह मान एड्रेस 08 पर संग्रहीत किया जाएगा और 000 (एचएलटी) इंस्ट्रक्शन को डेस्ट्रकटिव कर दिया जाएगा। चूँकि 600 का अर्थ है कि ब्रांच से मेलबॉक्स एड्रेस 00 प्रोग्राम क्लोज्ड होने के आतिरिक्त एक इंडलेस लूप स्टैक हो सकता है।

इस समस्या को हल करने के लिए अधिकांश असेंबली लैंग्वेज (एलएमसी सहित) मनेमोनिक्स को लेबल (प्रोग्रामिंग लैंग्वेज) के साथ जोड़ती हैं। लेबल प्रोग्रामिंग लैंग्वेज एक ऐसा शब्द है जिसका उपयोग एक मेमोरी एड्रेस को नाम देने के लिए किया जाता है जहां एक इंस्ट्रक्शन या डेटा संग्रहीत किया जाता है या एक इंस्ट्रक्शन में उस एड्रेस को संदर्भित करने के लिए उपयोग किया जाता है।

जब कोई प्रोग्राम असेंबल किया जाता है:

  • इंस्ट्रक्शन निमोनिक के बाईं ओर एक लेबल प्रोग्रामिंग लैंग्वेज को मेमोरी एड्रेस में परिवर्तित किया जाता है जिसमे इंस्ट्रक्शन या डेटा को लूपस्टार्ट आईएनपी पर संग्रहीत किया जाता है।
  • इंस्ट्रक्शन निमोनिक के दाईं ओर एक लेबल प्रोग्रामिंग लैंग्वेज ऊपर उल्लिखित मेमोरी एड्रेस अर्थात बीआरए लूपस्टार्ट का मान लेता है।
  • डीएटी स्टेटमेंट के साथ संयुक्त लेबल प्रोग्रामिंग लैंग्वेज एक वेरिएबल के रूप में करता करती है। यह मेमोरी एड्रेस को लेबल प्रोग्रामिंग लैंग्वेज प्रयुक्त करता है क्योकि डेटा डीएटी 1 या संख्या 1 डीएटी पर संग्रहीत है।

असेंबली लैंग्वेज मनेमोनिक्स और लेबल प्रोग्रामिंग लैंग्वेज का उपयोग करती है। यदि अंतिम एचएलटी इंस्ट्रक्शन से पहले एक नया इंस्ट्रक्शन डाला गया था तो FIRST इंस्ट्रक्शन वाला एड्रेस अब 08 की अतिरिक्त मेमोरी एड्रेस 09 पर होगा और जब प्रोग्राम को असेंबल किया जाएगा तब STA FIRST इंस्ट्रक्शन 309 (एसटीए) या 308 (एसटीए 08) में परिवर्तित हो जाएगा।

इसलिए लेबल प्रोग्रामिंग लैंग्वेज का उपयोग किया जाता है:

  • किसी ब्रांच इंस्ट्रक्शन के लक्ष्य के रूप में किसी विशेष इंस्ट्रक्शन की पहचान करें।
  • नामित वेरिएबल के रूप में एक मेमोरी एड्रेस की पहचान करें (डीएटी का उपयोग करके) और प्रोग्राम द्वारा उपयोग के लिए असेंबली टाइम पर प्रोग्राम में वैकल्पिक रूप से डेटा लोड करें। सामान्यतः यह उपयोग तब तक स्पष्ट नहीं है जब तक कोई यह नहीं मानता कि काउंटर में 1 जोड़ने का कोई तरीका नहीं है। कोई उपयोगकर्ता प्रारम्भ में इनपुट 1 के लिए कह सकता है। लेकिन इसे असेंबली टाइम डीएटी 1 का उपयोग करके लोड किया जा सकता है।

उदाहरण

नीचे दिया गया प्रोग्राम उपयोगकर्ता से इनपुट लेगा और शून्य होने तक गणना करेगा। 

 INP
     OUT      // Initialize output 
LOOP BRZ QUIT // Label this memory address as LOOP. If the accumulator value is 0, jump to the memory address labeled QUIT
     SUB ONE  // Subtract the value stored at address ONE from the accumulator
     OUT
     BRA LOOP // Jump (unconditionally) to the memory address labeled LOOP
QUIT HLT      // Label this memory address as QUIT
ONE  DAT 1    // Store the value 1 in this memory address, and label it ONE (variable declaration)

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

START   LDA ZERO     // Initialize for multiple program run
        STA RESULT
        STA COUNT
        INP          // User provided input
        BRZ END      // Branch to program END if input = 0
        STA VALUE    // Store input as VALUE
LOOP    LDA RESULT   // Load the RESULT
        ADD VALUE    // Add VALUE, the user provided input, to RESULT
        STA RESULT   // Store the new RESULT
        LDA COUNT    // Load the COUNT
        ADD ONE      // Add ONE to the COUNT
        STA COUNT    // Store the new COUNT
        SUB VALUE    // Subtract the user provided input VALUE from COUNT
        BRZ ENDLOOP  // If zero (VALUE has been added to RESULT by VALUE times), branch to ENDLOOP
        BRA LOOP     // Branch to LOOP to continue adding VALUE to RESULT
ENDLOOP LDA RESULT   // Load RESULT
        OUT          // Output RESULT
        BRA START    // Branch to the START to initialize and get another input VALUE
END     HLT          // HALT - a zero was entered so done!
RESULT  DAT          // Computed result (defaults to 0)
COUNT   DAT          // Counter (defaults to 0)
ONE     DAT 1        // Constant, value of 1
VALUE   DAT          // User provided input, the value to be squared (defaults to 0)
ZERO    DAT          // Constant, value of 0 (defaults to 0)

ध्यान दें: यदि डीएटी स्टेटमेंट के बाद कोई डेटा नहीं है तो डिफ़ॉल्ट मान 0 मेमोरी एड्रेस में संग्रहीत होता है। उपरोक्त उदाहरण में BRZ_ENDLOOP अपरिभाषित होता है, क्योंकि COUNT-VALUE ऋणात्मक हो सकती है, जिसके बाद एक्यूमुलेटर मान अपरिभाषित होता है। जिसके परिणामस्वरूप BRZ शाखाबद्ध और एक्यूमुलेटर शून्य हो सकता है। जिससे कोड को स्पेसिफिकेशन के लिए कम्पेटिबल या परिवर्तित किया जा सकता है। 

        LDA COUNT    // Load the COUNT
        ADD ONE      // Add ONE to the COUNT
        STA COUNT    // Store the new COUNT
        SUB VALUE    // Subtract the user provided input VALUE from COUNT
        BRZ ENDLOOP  // If zero (VALUE has been added to RESULT by VALUE times), branch to ENDLOOP
        ...

निम्नलिखित संस्करण के साथ COUNT-VALUE के अतिरिक्त VALUE-COUNT का मूल्यांकन किया जाता है क्योकि यह सुनिश्चित करता है कि एक्यूमुलेटर कभी भी अंडरफ्लो न हो: 

   	...
        LDA COUNT    // Load the COUNT
        ADD ONE      // Add ONE to the COUNT
        STA COUNT    // Store the new COUNT
        LDA VALUE    // Load the VALUE
        SUB COUNT    // Subtract COUNT from the user provided input VALUE
        BRZ ENDLOOP  // If zero (VALUE has been added to RESULT by VALUE times), branch to ENDLOOP
        ...

इसका एक अन्य उदाहरण क्विन (कंप्यूटिंग) है, जो अपने स्वयं के मशीन कोड को प्रिंट कर करता है। प्रिंट-सोर्स असंभव होता है क्योंकि टेक्स्ट को आउटपुट नहीं किया जा सकता है: 

LOAD LDA 0     // Load position 0 into the accumulator. This line will be modified on each loop to load the next lines into the accumulator
     OUT       // Output the accumulator's value. The accumulator's value will be the line that was just loaded
     SUB ONE   // Subtract 1 from the value in the accumulator. This is so we can do the BRZ in the next step to see if we are on the last line in the program
     BRZ ONE   // If the previous subtraction has made the accumulator 0 (which means we had the value 001 in the accumulator), then branch to position ONE
     LDA LOAD  // Load the LOAD position into the accumulator, this is in preparation to increment the address digits for this position
     ADD ONE   // Increment the position digits for the LOAD line. The value currently in the accumulator would, if read as an instruction, load the next line into the accumulator, compared to the last line loaded
     STA LOAD  // Store the newly incremented LOAD line back in the LOAD position
     BRA LOAD  // Return to the beginning of the loop
ONE  DAT 1     // The variable ONE. If read as an instruction, this will be interpreted as HLT/COB and will end the program

यह क्विन एसएमसी का उपयोग करके कार्य करता है क्योकि 0 को प्रत्येक इटेरशन में 1 से बढ़ाया जाता है और उस लाइन के कोड का आउटपुट किया जाता है जब तक कि वह जो कोड आउटपुट कर रहा है वह 1 न जाए और जिस पॉइंट पर मान 1 स्थिति होता है। वहाँ 1 का मान ऑपकोड के रूप में 0 होता है। इसलिए इसे HALT/COB इंस्ट्रक्शन के रूप में समझा जाता है।

यह भी देखें

संदर्भ

  1. ↑ "लिटिल मैन कंप्यूटर". Illinois State University. May 1, 2000. Archived from the original on February 27, 2009. Retrieved March 8, 2009.
  2. ↑ Yurcik, W.; Osborne, H. (2001). "A crowd of Little Man Computers: Visual computer simulator teaching tools". Proceedings of the 2001 Winter Simulation Conference (Cat. No.01CH37304). Vol. 2. p. 1632. doi:10.1109/WSC.2001.977496. ISBN 0-7803-7307-3. S2CID 18907923.
  3. ↑ Yurcik, W.; Brumbaugh, L. (2001). "A web-based little man computer simulator". कंप्यूटर विज्ञान शिक्षा पर बत्तीसवें SIGCSE तकनीकी संगोष्ठी की कार्यवाही - SIGCSE '01. p. 204. doi:10.1145/364447.364585. ISBN 1581133294. S2CID 14794750.
  4. ↑ Osborne, H.; Yurcik, W. (2002). "The educational range of visual simulations of the Little Man Computer architecture paradigm". 32nd Annual Frontiers in Education. pp. S4G–S19. doi:10.1109/FIE.2002.1158742. ISBN 0-7803-7444-4. S2CID 10324295.


बाहरी संबंध

सिमुलेटर

ऑनलाइन


श्रेणी:उदाहरण कोड वाले लेख श्रेणी:शैक्षिक सार मशीनें श्रेणी:1965 में कंप्यूटर से संबंधित परिचय

Retrieved from ‘https://www.vigyanwiki.in/index.php?title=लिटिल_मैन_कंप्यूटर&oldid=252269’