लिटिल मैन कंप्यूटर: Difference between revisions

From Vigyanwiki
No edit summary
No edit summary
Line 1: Line 1:
{{Short description|Instructional model of a computer}}
{{Short description|Instructional model of a computer}}
'''लिटिल मैन कंप्यूटर''' (एलएमसी) [[कंप्यूटर]] का एक निर्देशात्मक मॉडल है, जिसे 1965 में डॉ. [[स्टुअर्ट मैडनिक]] द्वारा बनाया गया था।<ref>{{cite web|title=लिटिल मैन कंप्यूटर|url=http://www.acs.ilstu.edu/faculty/javila/lmc/ |date=May 1, 2000 |publisher=[[Illinois State University]] |access-date=March 8, 2009 |url-status=dead |archive-url=https://web.archive.org/web/20090227005033/http://www.acs.ilstu.edu/faculty/javila/lmc/ |archive-date=February 27, 2009 }}</ref> एलएमसी का उपयोग आम तौर पर छात्रों को पढ़ाने के लिए किया जाता है, क्योंकि यह एक साधारण [[वॉन न्यूमैन वास्तुकला|वॉन न्यूमैन]] आर्किटेक्चर कंप्यूटर का मॉडल बनाता है - जिसमें आधुनिक कंप्यूटर की सभी बुनियादी विशेषताएं हैं। इसे मशीन कोड (यद्यपि बाइनरी के बजाय दशमलव में) या असेंबली कोड में प्रोग्राम किया जा सकता है।<ref>{{Cite book | doi = 10.1109/WSC.2001.977496| chapter = A crowd of Little Man Computers: Visual computer simulator teaching tools| title = Proceedings of the 2001 Winter Simulation Conference (Cat. No.01CH37304)| volume = 2| pages = 1632| year = 2001| last1 = Yurcik | first1 = W.| last2 = Osborne | first2 = H.| isbn = 0-7803-7307-3| s2cid = 18907923}}</ref><ref>{{Cite book | doi = 10.1145/364447.364585| chapter = A web-based little man computer simulator| title = कंप्यूटर विज्ञान शिक्षा पर बत्तीसवें SIGCSE तकनीकी संगोष्ठी की कार्यवाही - SIGCSE '01| pages = 204| year = 2001| last1 = Yurcik | first1 = W. | last2 = Brumbaugh | first2 = L. | isbn = 1581133294| s2cid = 14794750}}</ref><ref>{{Cite book | doi = 10.1109/FIE.2002.1158742| chapter = The educational range of visual simulations of the Little Man Computer architecture paradigm| title = 32nd Annual Frontiers in Education| pages = S4G–S19| year = 2002| last1 = Osborne | first1 = H.| last2 = Yurcik | first2 = W.| isbn = 0-7803-7444-4| s2cid = 10324295}}</ref>
'''लिटिल मैन कंप्यूटर''' (एलएमसी) [[कंप्यूटर]] का एक निर्देशात्मक मॉडल है, जिसे 1965 में डॉ. [[स्टुअर्ट मैडनिक]] द्वारा बनाया गया था।<ref>{{cite web|title=लिटिल मैन कंप्यूटर|url=http://www.acs.ilstu.edu/faculty/javila/lmc/ |date=May 1, 2000 |publisher=[[Illinois State University]] |access-date=March 8, 2009 |url-status=dead |archive-url=https://web.archive.org/web/20090227005033/http://www.acs.ilstu.edu/faculty/javila/lmc/ |archive-date=February 27, 2009 }}</ref> एलएमसी का उपयोग सामान्यतः छात्रों को पढ़ाने के लिए किया जाता है क्योंकि यह एक साधारण [[वॉन न्यूमैन वास्तुकला|वॉन न्यूमैन]] आर्किटेक्वेरिएबल कंप्यूटर का मॉडल है, जिसमें आधुनिक कंप्यूटर की सभी मुख्य विशेषताएं हैं। इसके प्रोग्रामों को मशीन कोड (यद्यपि बाइनरी के अतिरिक्त डेसीमल में) या असेंबली कोड में किया जा सकता है।<ref>{{Cite book | doi = 10.1109/WSC.2001.977496| chapter = A crowd of Little Man Computers: Visual computer simulator teaching tools| title = Proceedings of the 2001 Winter Simulation Conference (Cat. No.01CH37304)| volume = 2| pages = 1632| year = 2001| last1 = Yurcik | first1 = W.| last2 = Osborne | first2 = H.| isbn = 0-7803-7307-3| s2cid = 18907923}}</ref><ref>{{Cite book | doi = 10.1145/364447.364585| chapter = A web-based little man computer simulator| title = कंप्यूटर विज्ञान शिक्षा पर बत्तीसवें SIGCSE तकनीकी संगोष्ठी की कार्यवाही - SIGCSE '01| pages = 204| year = 2001| last1 = Yurcik | first1 = W. | last2 = Brumbaugh | first2 = L. | isbn = 1581133294| s2cid = 14794750}}</ref><ref>{{Cite book | doi = 10.1109/FIE.2002.1158742| chapter = The educational range of visual simulations of the Little Man Computer architecture paradigm| title = 32nd Annual Frontiers in Education| pages = S4G–S19| year = 2002| last1 = Osborne | first1 = H.| last2 = Yurcik | first2 = W.| isbn = 0-7803-7444-4| s2cid = 10324295}}</ref>


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


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


== निष्पादन चक्र ==
== कार्यान्वयन साइकल ==
{{See also|Instruction cycle}}
{{See also|इंस्ट्रक्शन}}


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


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


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


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


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


{| class="wikitable"
{| class="wikitable"
|+ निर्देश
|+ इंस्ट्रक्शन
|-
|-
! न्यूमेरिक कोड
! न्यूमेरिक कोड
!मनेमोनिक कोड
!मनेमोनिक कोड
!निर्देश
!इंस्ट्रक्शन
! विवरण
! विवरण
|-
|-
| 1xx || ADD || ADD
| 1xx || एडीडी || एडीडी
| मेलबॉक्स xx में संग्रहीत मान को वर्तमान में संचायक (कैलकुलेटर) पर जो भी मान है, उसमें जोड़ें।
| मेलबॉक्स xx में संग्रहीत मान को वर्तमान में एक्यूमुलेटर पर जो भी मान है, उसमें जोड़ें।
: ध्यान दें: मेलबॉक्स की सामग्री नहीं बदली जाती है, और संचायक (कैलकुलेटर) की गतिविधियों को उन निर्देशों को जोड़ने के लिए परिभाषित नहीं किया जाता है जो 3 अंकों से बड़े योग का कारण बनते हैं। सबट्रैक्ट के समान, कोई ओवरफ्लो पर नकारात्मक ध्वज सेट कर सकता है।
: ध्यान दें: मेलबॉक्स का डेटा परिवर्तित नही किया जाता है और एक्यूमुलेटर की गतिविधियों को उन इंस्ट्रक्शन मे जोड़ने के लिए परिभाषित नहीं किया जाता है, जो 3 डिजिट से बड़े योग का कारण बनते हैं। सबट्रैक्ट के समान कोई ओवरफ्लो पर ऋणात्मक फ्लैग प्रयुक्त कर सकता है।
|-
|-
| 2xx || SUB || SUBTRACT
| 2xx || एसयूबी || सब्ट्रैक्ट
| संचायक (कैलकुलेटर) पर वर्तमान में जो भी मान है, उसमें से मेलबॉक्स xx में संग्रहीत मान घटाएँ।
| एक्यूमुलेटर पर वर्तमान में जो भी मान है, उसमें से मेलबॉक्स xx में संग्रहीत मान घटाएँ।
: ध्यान दें: मेलबॉक्स की सामग्री नहीं बदली गई है, और संचायक की क्रियाओं को नकारात्मक परिणामों का कारण बनने वाले घटाव निर्देशों के लिए परिभाषित नहीं किया गया है - हालांकि, एक नकारात्मक ध्वज सेट किया जाएगा ताकि 7xx (BRZ) और 8xx (BRP) का उपयोग किया जा सके अच्छी तरह से।
: ध्यान दें: मेलबॉक्स का डेटा परिवर्तित नही किया गया है और एक्यूमुलेटर के एक्शन को ऋणात्मक परिणामों का कारण बनने वाले सबट्रैक्ट इंस्ट्रक्शन के लिए परिभाषित नहीं किया गया है। हालांकि एक ऋणात्मक ऋणात्मक फ्लैग प्रयुक्त कर सकता है। ताकि 7xx (बीआरजेड) और 8xx (बीआरपी) का उपयोग किया जा सके।
|-
|-
| 3xx || STA || STORE
| 3xx || एसटीए || स्टोर
| संचायक की सामग्री को मेलबॉक्स xx (विनाशकारी) में संग्रहीत करें।
| एक्यूमुलेटर के डेटा को मेलबॉक्स xx (डेस्ट्रकटिव) में संग्रहीत करें।
: ध्यान दें: संचायक (कैलकुलेटर) की सामग्री नहीं बदली जाती (गैर-विनाशकारी) लेकिन मेलबॉक्स की सामग्री बदल दी जाती है, चाहे उसमें कुछ भी हो (विनाशकारी)
: ध्यान दें: एक्यूमुलेटर का डेटा (नॉन-डेस्ट्रकटिव) परिवर्तित नही किया जाता है लेकिन मेमेलबॉक्स का डेटा परिवर्तित किया जाता है फिर चाहे उसमें कुछ भी डेस्ट्रकटिव डेटा स्थित हो।
|-
|-
| 5xx || LDA || LOAD
| 5xx || एलडीए || लोड
| मेलबॉक्स xx (गैर-विनाशकारी) से मान लोड करें और इसे संचायक (विनाशकारी) में दर्ज करें।
| मेलबॉक्स xx (नॉन-डेस्ट्रकटिव) से मान लोड करें और इसे एक्यूमुलेटर (डेस्ट्रकटिव) में प्रस्तुत करें।
|-
|-
| 6xx || BRA || [[branch (computer science)|BRANCH]] (unconditional)
| 6xx || बीआरए || [[branch (computer science)|ब्रांच]] (अनकंडीशनल)
| प्रोग्राम काउंटर को दिए गए पते (मान xx) पर सेट करें। अर्थात्, मेलबॉक्स xx में मान अगला निष्पादित निर्देश होगा।
| प्रोग्राम काउंटर को दिए गए एड्रेस (मान xx) पर प्रयुक्त करें। अर्थात् मेलबॉक्स xx में यही मान अगला निष्पादित इंस्ट्रक्शन होगा।
|-
|-
| 7xx || BRZ || BRANCH IF ZERO ([[conditional (programming)|conditional]])
| 7xx || बीआरजेड || यदि ब्रांच शून्य ([[conditional (programming)|कंडीशनल]])
| यदि संचायक (कैलकुलेटर) में मान 000 है, तो प्रोग्राम काउंटर को मान xx पर सेट करें। अन्यथा, कुछ न करें. नकारात्मक ध्वज को ध्यान में रखा गया है या नहीं यह अपरिभाषित है। जब एक SUBTRACT संचायक को अंडरफ्लो करता है, तो यह ध्वज सेट किया जाता है, जिसके बाद संचायक अपरिभाषित होता है, संभावित रूप से शून्य होता है, जिससे अंडरफ्लो पर BRZ का व्यवहार अपरिभाषित हो जाता है। यदि संचायक शून्य है और नकारात्मक ध्वज सेट नहीं है तो सुझाया गया व्यवहार शाखा में होगा।
| यदि एक्यूमुलेटर में मान 000 है, तो प्रोग्राम काउंटर का मान xx प्रयुक्त करें अन्यथा कुछ न करें शून्य रहने दे। ऋणात्मक फ्लैग को ध्यान में रखा गया है या नहीं यह अपरिभाषित है। जब एक सब्ट्रैक्ट एक्यूमुलेटर को अंडरफ्लो करता है, तो यह ऋणात्मक फ्लैग प्रयुक्त किया जाता है जिसके बाद एक्यूमुलेटर अपरिभाषित होता है या संभावित रूप से शून्य होता है, जिससे अंडरफ्लो पर बीआरजेड का कार्य अपरिभाषित हो जाता है। यदि एक्यूमुलेटर शून्य है और ऋणात्मक फ्लैग प्रयुक्त नहीं है तो प्रयुक्त किया गया डेटा ब्रांच में होता है।
: नोट: चूंकि प्रोग्राम मेमोरी में संग्रहीत होता है, इसलिए डेटा और प्रोग्राम निर्देशों का पता/स्थान प्रारूप समान होता है।
: ध्यान दें: चूंकि प्रोग्राम मेमोरी में संग्रहीत होता है। इसलिए डेटा और प्रोग्राम इंस्ट्रक्शन का एड्रेस फॉर्मेट के समान होता है।
|-
|-
| 8xx || BRP || BRANCH IF POSITIVE (conditional)
| 8xx || बीआरपी || यदि ब्रांच धनात्मक (कंडीशनल)
| यदि संचायक (कैलकुलेटर) 0 या सकारात्मक है, तो प्रोग्राम काउंटर को मान xx पर सेट करें। अन्यथा, कुछ न करें. चूँकि LMC मेमोरी सेल केवल 0 और 999 के बीच मान रख सकते हैं, यह निर्देश पूरी तरह से SUBTRACT पर अंडरफ्लो द्वारा निर्धारित नकारात्मक ध्वज और संभावित रूप से ADD (अपरिभाषित) पर ओवरफ्लो पर निर्भर करता है।
| यदि एक्यूमुलेटर 0 या धनात्मक है, तो प्रोग्राम काउंटर को मान को xx पर प्रयुक्त करें अन्यथा कुछ न करें शून्य रहने दे। चूँकि एलएमसी मेमोरी सेल केवल 0 और 999 के बीच मान रख सकते हैं। यह इंस्ट्रक्शन पूरी तरह से सब्ट्रैक्ट पर अंडरफ्लो द्वारा निर्धारित ऋणात्मक फ्लैग और संभावित रूप से एडीडी (अपरिभाषित) ओवरफ्लो पर निर्भर करता है।
: नोट: चूंकि प्रोग्राम मेमोरी में संग्रहीत होता है, इसलिए डेटा और प्रोग्राम निर्देशों का पता/स्थान प्रारूप समान होता है।
: ध्यान दें: चूंकि प्रोग्राम मेमोरी में संग्रहीत होता है। इसलिए डेटा और प्रोग्राम इंस्ट्रक्शन का एड्रेस फॉर्मेट के समान होता है।
|-
|-
| 901 || INP || INPUT
| 901 || आईएनपी || इनपुट
| इनबॉक्स पर जाएं, उपयोगकर्ता से मूल्य प्राप्त करें, और इसे संचायक (कैलकुलेटर) में डालें
| इनबॉक्स पर जाएं, उपयोगकर्ता से डेटा प्राप्त करें और इसे एक्यूमुलेटर में इनपुट करे।
: नोट: यह संचायक में जो भी मूल्य था उसे अधिलेखित कर देगा (विनाशकारी)
: ध्यान दें: यह एक्यूमुलेटर में जो भी डेटा होता है उसे डेस्ट्रकटिव कर देता है।
|-
|-
| 902 || OUT || OUTPUT
| 902 || ओयूटी || आउटपुट
| संचायक (कैलकुलेटर) से मान को आउटबॉक्स में कॉपी करें।
| एक्यूमुलेटर से डेटा को आउटबॉक्स में कॉपी करें।
: ध्यान दें: संचायक की सामग्री बदली नहीं जाती (गैर-विनाशकारी)।
: ध्यान दें: एक्यूमुलेटर का डेटा (नॉन-डेस्ट्रकटिव) परिवर्तित नही किया जाता है।
|-
|-
| 000 || HLT/COB || HALT/COFFEE BREAK
| 000 || एचएलटी/सीओबी || हॉल्ट/कॉफी ब्रेक
| काम करना बंद करें/कार्यक्रम समाप्त करें।
| कार्य करना बंद करें/प्रोग्राम समाप्त करें।
|-
|-
|    || DAT || DATA || यह एक असेंबलर निर्देश है जो बस मान को अगले उपलब्ध मेलबॉक्स में लोड करता है। वैरिएबल घोषित करने के लिए DAT का उपयोग लेबल के संयोजन में भी किया जा सकता है। उदाहरण के लिए, DAT 984 मान 984 को DAT निर्देश के पते पर एक मेलबॉक्स में संग्रहीत करेगा।
|    || डीएटी || डाटा || यह एक असेंबलर इंस्ट्रक्शन है जो बस-डेटा को अगले उपलब्ध मेलबॉक्स में लोड करता है। वैरिएबल घोषित करने के लिए डीएटी का उपयोग लेबल के संयोजन में भी किया जा सकता है। उदाहरण के लिए डीएटी 984 मान 984 को डीएटी इंस्ट्रक्शन के एड्रेस पर एक मेलबॉक्स में संग्रहीत करता है।
|}
|}
=== उदाहरण ===
=== उदाहरण ===


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


{| class="wikitable"
{| class="wikitable"
! Mailbox
! मेलबॉक्स
! Numeric code
! न्यूमेरिक कोड
!ऑपरेशन
!ऑपरेशन
! टिप्पणी
! टिप्पणी
Line 88: Line 88:
| 00
| 00
| '''901'''
| '''901'''
| Accumulator = इनबॉक्स
| एक्यूमुलेटर = इनबॉक्स
|पहला नंबर दर्ज करें, कैलकुलेटर में दर्ज करें (वहां जो कुछ भी था उसे मिटा दें)
|पहली संख्या को कैलकुलेटर में प्रस्तुत करें (वहां जो कुछ भी था उसे मिटा दें)
|-
|-
| 01
| 01
| '''308'''
| '''308'''
| Mailbox 08 = Accumulator
| मेलबॉक्स 08 = एक्यूमुलेटर
|कैलकुलेटर का वर्तमान मान संग्रहीत करें (अगले चरण की तैयारी के लिए...)
|कैलकुलेटर का वर्तमान मान संग्रहीत करें (अगले वेरिएबलण की तैयारी के लिए...)
|-
|-
| 02
| 02
| '''901'''
| '''901'''
| Accumulator = इनबॉक्स
| एक्यूमुलेटर = इनबॉक्स
|दूसरा नंबर दर्ज करें, कैलकुलेटर में दर्ज करें (वहां जो कुछ भी था उसे मिटा दें)
|दूसरी संख्या को कैलकुलेटर में प्रस्तुत करें (वहां जो कुछ भी था उसे मिटा दें)
|-
|-
| 03
| 03
| '''309'''
| '''309'''
| Mailbox 09 = Accumulator
| मेलबॉक्स 09 = एक्यूमुलेटर
|कैलकुलेटर का वर्तमान मान संग्रहीत करें (फिर से, अगले चरण की तैयारी के लिए...)
|कैलकुलेटर का वर्तमान मान संग्रहीत करें (फिर से, अगले वेरिएबलण की तैयारी के लिए...)
|-
|-
| 04
| 04
| '''508'''
| '''508'''
| Accumulator = Mailbox 08
| एक्यूमुलेटर = मेलबॉक्स 08
|(अब दोनों इनपुट मान मेलबॉक्स 08 और 09 में संग्रहीत हैं...)  
|(अब दोनों इनपुट मान मेलबॉक्स 08 और 09 में संग्रहीत हैं...)  


Line 115: Line 115:
| 05
| 05
| '''209'''
| '''209'''
| Accumulator = Accumulator - Mailbox 09
| एक्यूमुलेटर = एक्यूमुलेटर - मेलबॉक्स 09
|कैलकुलेटर के वर्तमान मान से दूसरा नंबर घटाएं (जो कि पहले नंबर पर सेट किया गया था)
|कैलकुलेटर के वर्तमान मान से दूसरी संख्या घटाएं (जो कि पहली संख्या पर मान प्रयुक्त किया गया था)
|-
|-
| 06
| 06
| '''902'''
| '''902'''
| आउटबॉक्स = Accumulator
| आउटबॉक्स = एक्यूमुलेटर
|कैलकुलेटर के परिणाम को आउटबॉक्स में आउटपुट करें
|कैलकुलेटर के परिणाम को आउटबॉक्स में आउटपुट करें।
|-
|-
| 07
| 07
| '''000'''
| '''000'''
| Halt
| हॉल्ट
| एचएएलटी एलएमसी
| एचएएलटी एलएमसी
|}
|}
==== [[स्मृति सहायक]]्स और लेबल का उपयोग करना ====
==== मनेमोनिक्स और लेबल का उपयोग करना ====
असेंबली भाषा एक निम्न-स्तरीय प्रोग्रामिंग भाषा है जो संख्यात्मक निर्देश कोड के बजाय निमोनिक्स और लेबल का उपयोग करती है। यद्यपि एलएमसी केवल निमोनिक्स के एक सीमित सेट का उपयोग करता है, प्रत्येक निर्देश के लिए एक निमोनिक का उपयोग करने की सुविधा नीचे दिखाए गए उसी प्रोग्राम की असेंबली भाषा से स्पष्ट होती है - प्रोग्रामर को अब अज्ञात संख्यात्मक कोड का एक सेट याद रखने की आवश्यकता नहीं है और वह कर सकता है अब अधिक यादगार स्मरणीय कोड के एक सेट के साथ कार्यक्रम। यदि निमोनिक एक निर्देश है जिसमें मेमोरी एड्रेस (या तो एक शाखा निर्देश या डेटा लोड/सेव करना) शामिल है तो मेमोरी एड्रेस को नाम देने के लिए एक लेबल का उपयोग किया जाता है।
असेंबली लैंग्वेज एक निम्न-स्तरीय प्रोग्रामिंग लैंग्वेज है जो न्यूमेरिक इंस्ट्रक्शन कोड के अतिरिक्त मनेमोनिक्स और लेबल का उपयोग करती है। यद्यपि लिटिल मैन कंप्यूटर केवल मनेमोनिक्स के एक सीमित समूह का उपयोग करता है तो प्रत्येक इंस्ट्रक्शन के लिए एक मनेमोनिक्स कोड का उपयोग करने की सुविधा नीचे दिखाए गए उसी प्रोग्राम की असेंबली लैंग्वेज से स्पष्ट होती है। जिससे प्रोग्रामर को अब अज्ञात न्यूमेरिक कोड को याद रखने की आवश्यकता नहीं है और वह कर सकता है अब अधिक मनेमोनिक्स कोड को एक प्रोग्राम कोड के साथ प्रयोग किया जा सकता है। यदि मनेमोनिक्स एक इंस्ट्रक्शन है जिसमें मेमोरी एड्रेस (या तो एक ब्रांच इंस्ट्रक्शन या डेटा लोड) सम्मिलित है तो मेमोरी एड्रेस को नाम देने के लिए एक लेबल का उपयोग किया जाता है।
  INP
  INP
  STA FIRST
  STA FIRST
Line 141: Line 141:
  SECOND DAT
  SECOND DAT


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


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


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


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


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


=== उदाहरण ===
=== उदाहरण ===
नीचे दिया गया प्रोग्राम उपयोगकर्ता इनपुट लेगा, और शून्य तक उल्टी गिनती करेगा।
नीचे दिया गया प्रोग्राम उपयोगकर्ता से इनपुट लेगा और शून्य तक गणना करेगा।
   INP
   INP
       OUT      // Initialize output
       OUT      // Initialize आउटपुट
  LOOP BRZ QUIT // Label this memory address as LOOP. If the accumulator value is 0, jump to the memory address labeled QUIT
  LOOP बीआरजेड QUIT // Label this memory एडीडीress as LOOP. If the एक्यूमुलेटर value is 0, jump to the memory एडीडीress labeled QUIT
       SUB ONE  // Subtract the value stored at address ONE from the accumulator
       एसयूबी ONE  // सब्ट्रैक्ट the value स्टोरd at एडीडीress ONE from the एक्यूमुलेटर
       OUT
       OUT
       BRA LOOP // Jump (unconditionally) to the memory address labeled LOOP
       BRA LOOP // Jump (unकंडीशनलly) to the memory एडीडीress labeled LOOP
  QUIT HLT      // Label this memory address as QUIT
  QUIT HLT      // Label this memory एडीडीress as QUIT
  ONE  DAT 1    // Store the value 1 in this memory address, and label it ONE (variable declaration)
  ONE  डीएटी 1    // स्टोर the value 1 in this memory एडीडीress, and label it ONE (variable declaration)
नीचे दिया गया प्रोग्राम उपयोगकर्ता इनपुट लेगा, उसे वर्गित करेगा, उत्तर आउटपुट करेगा और फिर दोहराएगा। शून्य दर्ज करने से प्रोग्राम समाप्त हो जाएगा.
नीचे दिया गया प्रोग्राम उपयोगकर्ता से इनपुट लेगा और उसे आउटपुट देगा और फिर दोहराएगा जिससे शून्य प्राप्त होने से प्रोग्राम समाप्त हो जाएगा।


(ध्यान दें: जिस इनपुट का परिणाम 999 से अधिक है, उसका एलएमसी की 3 अंकों की संख्या सीमा के कारण अपरिभाषित व्यवहार होगा)।
ध्यान दें: जिस इनपुट का आउटपुट 999 से अधिक है उसका एलएमसी 3 डिजिट की संख्या सीमा के कारण अपरिभाषित रहता है।
  START  LDA ZERO    // Initialize for multiple program run
  START  LDA ZERO    // Initialize for multiple program run
         STA RESULT
         STA RESULT
         STA COUNT
         STA COUNT
         INP          // User provided input
         INP          // User provided इनपुट
         BRZ END      // Branch to program END if input = 0
         बीआरजेड END      // Branch to program END if इनपुट = 0
         STA VALUE    // Store input as VALUE
         STA VALUE    // स्टोर इनपुट as VALUE
  LOOP    LDA RESULT  // Load the RESULT
  LOOP    LDA RESULT  // Load the RESULT
         ADD VALUE    // Add VALUE, the user provided input, to RESULT
         एडीडी VALUE    // एडीडी VALUE, the user provided इनपुट, to RESULT
         STA RESULT  // Store the new RESULT
         STA RESULT  // स्टोर the new RESULT
         LDA COUNT    // Load the COUNT
         LDA COUNT    // Load the COUNT
         ADD ONE      // Add ONE to the COUNT
         एडीडी ONE      // एडीडी ONE to the COUNT
         STA COUNT    // Store the new COUNT
         STA COUNT    // स्टोर the new COUNT
         SUB VALUE    // Subtract the user provided input VALUE from COUNT
         एसयूबी VALUE    // सब्ट्रैक्ट the user provided इनपुट VALUE from COUNT
         BRZ ENDLOOP  // If zero (VALUE has been added to RESULT by VALUE times), branch to ENDLOOP
         बीआरजेड ENDLOOP  // If zero (VALUE has been एडीडीed to RESULT by VALUE times), branch to ENDLOOP
         BRA LOOP    // Branch to LOOP to continue adding VALUE to RESULT
         BRA LOOP    // Branch to LOOP to continue एडीडीing VALUE to RESULT
  ENDLOOP LDA RESULT  // Load RESULT
  ENDLOOP LDA RESULT  // Load RESULT
         OUT          // Output RESULT
         OUT          // आउटपुट RESULT
         BRA START    // Branch to the START to initialize and get another input VALUE
         BRA START    // Branch to the START to initialize and get another इनपुट VALUE
  END    HLT          // HALT - a zero was entered so done!
  END    HLT          // HALT - a zero was entered so done!
  RESULT  DAT         // Computed result (defaults to 0)
  RESULT  डीएटी         // Computed result (defaults to 0)
  COUNT  DAT         // Counter (defaults to 0)
  COUNT  डीएटी         // Counter (defaults to 0)
  ONE    DAT 1        // Constant, value of 1
  ONE    डीएटी 1        // Constant, value of 1
  VALUE  DAT         // User provided input, the value to be squared (defaults to 0)
  VALUE  डीएटी         // User provided इनपुट, the value to be squared (defaults to 0)
  ZERO    DAT         // Constant, value of 0 (defaults to 0)
  ZERO    डीएटी         // Constant, value of 0 (defaults to 0)
नोट: यदि DAT स्टेटमेंट के बाद कोई डेटा नहीं है तो डिफ़ॉल्ट मान 0 मेमोरी एड्रेस में संग्रहीत होता है।
ध्यान दें: यदि डीएटी स्टेटमेंट के बाद कोई डेटा नहीं है तो डिफ़ॉल्ट मान 0 मेमोरी एड्रेस में संग्रहीत होता है।


उपरोक्त उदाहरण में, [BRZ ENDLOOP] अपरिभाषित व्यवहार पर निर्भर करता है, क्योंकि COUNT-VALUE नकारात्मक हो सकता है, जिसके बाद ACCUMULATOR मान अपरिभाषित होता है, जिसके परिणामस्वरूप BRZ या तो शाखाबद्ध हो जाता है या नहीं (ACCUMULATOR शून्य हो सकता है, या चारों ओर लपेटा जा सकता है)। कोड को विनिर्देश के अनुकूल बनाने के लिए, प्रतिस्थापित करें:        
उपरोक्त उदाहरण में <code>BRZ ENDLOOP</code> अपरिभाषित होता है, क्योंकि <code>COUNT-VALUE</code> ऋणात्मक हो सकती है, जिसके बाद एक्यूमुलेटर मान अपरिभाषित होता है। जिसके परिणामस्वरूप बीआरजेड शाखाबद्ध और  एक्यूमुलेटर शून्य हो हो सकता है। जिससे कोड को स्पेसिफिकेशन के लिए कम्पेटिबल या परिवर्तित किया जा सकता है।        
     ...
     ...
         LDA COUNT    // Load the COUNT
         LDA COUNT    // Load the COUNT
         ADD ONE      // Add ONE to the COUNT
         एडीडी ONE      // एडीडी ONE to the COUNT
         STA COUNT    // Store the new COUNT
         STA COUNT    // स्टोर the new COUNT
         SUB VALUE    // Subtract the user provided input VALUE from COUNT
         एसयूबी VALUE    // सब्ट्रैक्ट the user provided इनपुट VALUE from COUNT
         BRZ ENDLOOP  // If zero (VALUE has been added to RESULT by VALUE times), branch to ENDLOOP
         बीआरजेड ENDLOOP  // If zero (VALUE has been एडीडीed to RESULT by VALUE times), branch to ENDLOOP
         ...
         ...
निम्नलिखित संस्करण के साथ, जो COUNT-VALUE के बजाय VALUE-COUNT का मूल्यांकन करता है, यह सुनिश्चित करता है कि संचायक कभी भी कम प्रवाहित न हो:    
निम्नलिखित संस्करण के साथ <code>COUNT-VALUE</code> के अतिरिक्त <code>VALUE-COUNT</code> का मूल्यांकन किया जाता है क्योकि यह सुनिश्चित करता है कि एक्यूमुलेटर कभी भी अंडरफ्लो न हो:      
  ...
  ...
         LDA COUNT    // Load the COUNT
         LDA COUNT    // Load the COUNT
         ADD ONE      // Add ONE to the COUNT
         एडीडी ONE      // एडीडी ONE to the COUNT
         STA COUNT    // Store the new COUNT
         STA COUNT    // स्टोर the new COUNT
         LDA VALUE    // Load the VALUE
         LDA VALUE    // Load the VALUE
         SUB COUNT    // Subtract COUNT from the user provided input VALUE
         एसयूबी COUNT    // सब्ट्रैक्ट COUNT from the user provided इनपुट VALUE
         BRZ ENDLOOP  // If zero (VALUE has been added to RESULT by VALUE times), branch to ENDLOOP
         बीआरजेड ENDLOOP  // If zero (VALUE has been एडीडीed 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
  LOAD LDA 0    // Load position 0 into the एक्यूमुलेटर. This line will be modified on each loop to load the next lines into the एक्यूमुलेटर
       OUT      // Output the accumulator's value. The accumulator's value will be the line that was just loaded
       OUT      // आउटपुट the एक्यूमुलेटर's value. The एक्यूमुलेटर'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
       एसयूबी ONE  // सब्ट्रैक्ट 1 from the value in the एक्यूमुलेटर. This is so we can do the बीआरजेड 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
       बीआरजेड ONE  // If the previous सब्ट्रैक्टion has made the एक्यूमुलेटर 0 (which means we had the value 001 in the एक्यूमुलेटर), 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
       LDA LOAD  // Load the LOAD position into the एक्यूमुलेटर, this is in preparation to increment the एडीडीress 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
       एडीडी ONE  // Increment the position digits for the LOAD line. The value currently in the एक्यूमुलेटर would, if read as an instruction, load the next line into the एक्यूमुलेटर, compared to the last line loaded
       STA LOAD  // Store the newly incremented LOAD line back in the LOAD position
       STA LOAD  // स्टोर the newly incremented LOAD line back in the LOAD position
       BRA LOAD  // Return to the beginning of the loop
       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
  ONE  डीएटी 1    // The variable ONE. If read as an instruction, this will be interpreted as HLT/COB and will end the program
यह क्विन स्व-संशोधित कोड का उपयोग करके काम करता है। स्थिति 0 को प्रत्येक पुनरावृत्ति में एक से बढ़ाया जाता है, उस पंक्ति के कोड को आउटपुट किया जाता है, जब तक कि वह जो कोड आउटपुट कर रहा है वह 1 न हो, जिस बिंदु पर यह एक स्थिति में शाखा करता है। ONE स्थिति में मान ऑपकोड के रूप में 0 है, इसलिए इसे HALT/COB निर्देश के रूप में समझा जाता है।
यह क्विन एसएमसी का उपयोग करके कार्य करता है। क्योकि 0 को प्रत्येक इटेरशन में 1 से बढ़ाया जाता है और उस लाइन के कोड का आउटपुट किया जाता है जब तक कि वह जो कोड आउटपुट कर रहा है वह 1 न जाए और जिस पॉइंट पर मान 1 स्थिति होता है। वहाँ 1 का मान ऑपकोड के रूप में 0 होता है। इसलिए इसे <code>HALT/COB</code> इंस्ट्रक्शन के रूप में समझा जाता है।  


==यह भी देखें==
==यह भी देखें==
* [[गणना के लिए कार्डबोर्ड उदाहरणात्मक सहायता]] (एक अन्य अनुदेशात्मक मॉडल)
* [[गणना के लिए कार्डबोर्ड उदाहरणात्मक सहायता|कार्डबोर्ड इलुस्ट्रेटिव ऐड कम्प्यूटेशन]] (एक अन्य निर्देशात्मक मॉडल)
* [[TIS-100]]|TIS-100 (वीडियो गेम)
* [[TIS-100|टीआईएस-100 (वीडियो गेम)]]
* [[ मानव संसाधन मशीन ]], एक कंप्यूटर गेम जो एलएमसी से काफी प्रभावित है
* [[ मानव संसाधन मशीन |ह्यूमन रिसोर्स मशीन]] (एक कंप्यूटर गेम जो एलएमसी से प्रभावित है।)
* [[डब्लूडीआर पेपर कंप्यूटर]]
* [[डब्लूडीआर पेपर कंप्यूटर]]
* [[डिजी-कॉम्प I]]
* [[डिजी-कॉम्प I|डिजी-कॉम्प-I]]


== संदर्भ ==
== संदर्भ ==
Line 250: Line 250:
* [https://pblinkmeier.github.io/lmc-emulator/ पी. ब्रिंकमीयर का एलएमसी सिम्युलेटर]
* [https://pblinkmeier.github.io/lmc-emulator/ पी. ब्रिंकमीयर का एलएमसी सिम्युलेटर]
* [https://wellingborough.github.io/LMC/LMC0.3.html वेलिंगबोरो एलएमसी सिम्युलेटर]
* [https://wellingborough.github.io/LMC/LMC0.3.html वेलिंगबोरो एलएमसी सिम्युलेटर]
* [https://peterhigginson.co.uk/LMC/ पीटर हिगिन्सन का LMC सिम्युलेटर]
* [https://peterhigginson.co.uk/LMC/ पीटर हिगिन्सन का एलएमसी सिम्युलेटर]




Revision as of 12:52, 9 August 2023

लिटिल मैन कंप्यूटर (एलएमसी) कंप्यूटर का एक निर्देशात्मक मॉडल है, जिसे 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 आउटपुट 
LOOP बीआरजेड QUIT // Label this memory एडीडीress as LOOP. If the एक्यूमुलेटर value is 0, jump to the memory एडीडीress labeled QUIT
     एसयूबी ONE  // सब्ट्रैक्ट the value स्टोरd at एडीडीress ONE from the एक्यूमुलेटर
     OUT
     BRA LOOP // Jump (unकंडीशनलly) to the memory एडीडीress labeled LOOP
QUIT HLT      // Label this memory एडीडीress as QUIT
ONE  डीएटी 1    // स्टोर the value 1 in this memory एडीडीress, and label it ONE (variable declaration)

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

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

START   LDA ZERO     // Initialize for multiple program run
        STA RESULT
        STA COUNT
        INP          // User provided इनपुट
        बीआरजेड END      // Branch to program END if इनपुट = 0
        STA VALUE    // स्टोर इनपुट as VALUE
LOOP    LDA RESULT   // Load the RESULT
        एडीडी VALUE    // एडीडी VALUE, the user provided इनपुट, to RESULT
        STA RESULT   // स्टोर the new RESULT
        LDA COUNT    // Load the COUNT
        एडीडी ONE      // एडीडी ONE to the COUNT
        STA COUNT    // स्टोर the new COUNT
        एसयूबी VALUE    // सब्ट्रैक्ट the user provided इनपुट VALUE from COUNT
        बीआरजेड ENDLOOP  // If zero (VALUE has been एडीडीed to RESULT by VALUE times), branch to ENDLOOP
        BRA LOOP     // Branch to LOOP to continue एडीडीing VALUE to RESULT
ENDLOOP LDA RESULT   // Load RESULT
        OUT          // आउटपुट RESULT
        BRA START    // Branch to the START to initialize and get another इनपुट VALUE
END     HLT          // HALT - a zero was entered so done!
RESULT  डीएटी          // Computed result (defaults to 0)
COUNT   डीएटी          // Counter (defaults to 0)
ONE     डीएटी 1        // Constant, value of 1
VALUE   डीएटी          // User provided इनपुट, the value to be squared (defaults to 0)
ZERO    डीएटी          // Constant, value of 0 (defaults to 0)

ध्यान दें: यदि डीएटी स्टेटमेंट के बाद कोई डेटा नहीं है तो डिफ़ॉल्ट मान 0 मेमोरी एड्रेस में संग्रहीत होता है।

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

   	...
        LDA COUNT    // Load the COUNT
        एडीडी ONE      // एडीडी ONE to the COUNT
        STA COUNT    // स्टोर the new COUNT
        एसयूबी VALUE    // सब्ट्रैक्ट the user provided इनपुट VALUE from COUNT
        बीआरजेड ENDLOOP  // If zero (VALUE has been एडीडीed to RESULT by VALUE times), branch to ENDLOOP
        ...

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

	...
        LDA COUNT    // Load the COUNT
        एडीडी ONE      // एडीडी ONE to the COUNT
        STA COUNT    // स्टोर the new COUNT
        LDA VALUE    // Load the VALUE
        एसयूबी COUNT    // सब्ट्रैक्ट COUNT from the user provided इनपुट VALUE
        बीआरजेड ENDLOOP  // If zero (VALUE has been एडीडीed to RESULT by VALUE times), branch to ENDLOOP
        ...

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

LOAD LDA 0     // Load position 0 into the एक्यूमुलेटर. This line will be modified on each loop to load the next lines into the एक्यूमुलेटर
     OUT       // आउटपुट the एक्यूमुलेटर's value. The एक्यूमुलेटर's value will be the line that was just loaded
     एसयूबी ONE   // सब्ट्रैक्ट 1 from the value in the एक्यूमुलेटर. This is so we can do the बीआरजेड in the next step to see if we are on the last line in the program
     बीआरजेड ONE   // If the previous सब्ट्रैक्टion has made the एक्यूमुलेटर 0 (which means we had the value 001 in the एक्यूमुलेटर), then branch to position ONE
     LDA LOAD  // Load the LOAD position into the एक्यूमुलेटर, this is in preparation to increment the एडीडीress digits for this position
     एडीडी ONE   // Increment the position digits for the LOAD line. The value currently in the एक्यूमुलेटर would, if read as an instruction, load the next line into the एक्यूमुलेटर, compared to the last line loaded
     STA LOAD  // स्टोर the newly incremented LOAD line back in the LOAD position
     BRA LOAD  // Return to the beginning of the loop
ONE  डीएटी 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=251857’