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

From Vigyanwiki
(Created page with "{{Short description|Instructional model of a computer}} {{Use mdy dates|date=March 2013}} लिटिल मैन कंप्यूटर (एलएमसी) कंप...")
 
No edit summary
 
(7 intermediate revisions by 4 users not shown)
Line 1: Line 1:
{{Short description|Instructional model of a computer}}
{{Short description|Instructional model of a computer}}
{{Use mdy dates|date=March 2013}}
'''लिटिल मैन कंप्यूटर''' (एलएमसी) [[कंप्यूटर]] का एक निर्देशात्मक मॉडल है, जिसे 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 तक) हो सकता है। इसके अलावा, दूसरे छोर पर INBOX और OUTBOX लेबल वाले दो मेलबॉक्स हैं जिनका उपयोग डेटा प्राप्त करने और आउटपुट करने के लिए किया जाता है। कमरे के केंद्र में, एक कार्य क्षेत्र है जिसमें एक साधारण दो फ़ंक्शन (जोड़ और घटाव) कैलकुलेटर होता है जिसे [[संचायक (कंप्यूटिंग)]] के रूप में जाना जाता है और एक रीसेट करने योग्य काउंटर होता है जिसे प्रोग्राम काउंटर के रूप में जाना जाता है। प्रोग्राम काउंटर में लिटिल मैन द्वारा किए जाने वाले अगले निर्देश का पता होता है। प्रत्येक निर्देश के निष्पादित होने के बाद इस प्रोग्राम काउंटर को आम तौर पर 1 से बढ़ा दिया जाता है, जिससे लिटिल मैन को क्रमिक रूप से प्रोग्राम के माध्यम से काम करने की अनुमति मिलती है। [[शाखा (कंप्यूटर विज्ञान)]] निर्देश पुनरावृत्ति (लूप) और [[सशर्त (प्रोग्रामिंग)]] प्रोग्रामिंग संरचनाओं को एक प्रोग्राम में शामिल करने की अनुमति देते हैं। यदि कोई विशेष शर्त पूरी हो जाती है (आमतौर पर संचायक में संग्रहीत मूल्य शून्य या सकारात्मक होता है) तो प्रोग्राम काउंटर को गैर-अनुक्रमिक मेमोरी पते पर सेट करके उत्तरार्द्ध प्राप्त किया जाता है।


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


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


किसी प्रोग्राम को निष्पादित करने के लिए, छोटा आदमी इन चरणों का पालन करता है:
== कार्यान्वयन साइकल ==
{{See also|इंस्ट्रक्शन}}


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


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


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


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


{| class="wikitable"
{| class="wikitable"
|+ Instructions
|+ इंस्ट्रक्शन
|-
|-
! Numeric code
! न्यूमेरिक कोड
! Mnemonic code
!मनेमोनिक कोड
! Instruction
!इंस्ट्रक्शन
! Description
! विवरण
|-
|-
| 1xx || ADD || ADD
| 1xx || एडीडी || एडीडी
| Add the value stored in mailbox xx to whatever value is currently on the accumulator (calculator).
| मेलबॉक्स xx में संग्रहीत मान को वर्तमान में एक्यूमुलेटर मान से जोड़ें।
: Note: the contents of the mailbox are not changed, and the actions of the accumulator (calculator) are not defined for add instructions that cause sums larger than 3 digits. Similarly to SUBTRACT, one could set the negative flag on overflow.
: ध्यान दें: मेलबॉक्स का डेटा परिवर्तित नही किया जाता है और एक्यूमुलेटर की गतिविधियों को उन इंस्ट्रक्शन मे जोड़ने के लिए परिभाषित नहीं किया जाता है, जो 3 डिजिट से बड़े योग का कारण बनते हैं। सबट्रैक्ट के समान कोई ओवरफ्लो पर ऋणात्मक फ्लैग प्रयुक्त कर सकता है।
|-
|-
| 2xx || SUB || SUBTRACT
| 2xx || एसयूबी || सब्ट्रैक्ट
| Subtract the value stored in mailbox xx from whatever value is currently on the accumulator (calculator).
| एक्यूमुलेटर पर वर्तमान में जो भी मान है, उसमें से मेलबॉक्स xx में संग्रहीत मान घटाएँ।
: Note: the contents of the mailbox are not changed, and the actions of the accumulator are not defined for subtract instructions that cause negative results - however, a negative flag will be set so that '''7xx (BRZ)''' and '''8xx (BRP)''' can be used properly.
: ध्यान दें: मेलबॉक्स का डेटा परिवर्तित नही किया गया है और एक्यूमुलेटर के एक्शन को ऋणात्मक परिणामों का कारण बनने वाले सबट्रैक्ट इंस्ट्रक्शन के लिए परिभाषित नहीं किया गया है। हालांकि एक ऋणात्मक ऋणात्मक फ्लैग प्रयुक्त कर सकता है। ताकि 7xx (बीआरजेड) और 8xx (बीआरपी) का उपयोग किया जा सके।
|-
|-
| 3xx || STA || STORE
| 3xx || एसटीए || स्टोर
| Store the contents of the accumulator in mailbox xx (destructive).
| एक्यूमुलेटर के डेटा को मेलबॉक्स xx (डेस्ट्रकटिव) में संग्रहीत करें।
: Note: the contents of the accumulator (calculator) are not changed (non-destructive), but contents of mailbox are replaced regardless of what was in there (destructive)
: ध्यान दें: एक्यूमुलेटर का डेटा (नॉन-डेस्ट्रकटिव) परिवर्तित नही किया जाता है लेकिन मेमेलबॉक्स का डेटा परिवर्तित किया जाता है फिर चाहे उसमें कुछ भी डेस्ट्रकटिव डेटा स्थित हो।
|-
|-
| 5xx || LDA || LOAD
| 5xx || एलडीए || लोड
| Load the value from mailbox xx (non-destructive) and enter it in the accumulator (destructive).
| मेलबॉक्स xx (नॉन-डेस्ट्रकटिव) से मान लोड करें और इसे एक्यूमुलेटर (डेस्ट्रकटिव) में प्रस्तुत करें।
|-
|-
| 6xx || BRA || [[branch (computer science)|BRANCH]] (unconditional)
| 6xx || बीआरए || [[branch (computer science)|ब्रांच]] (अनकंडीशनल)
| Set the program counter to the given address (value xx).  That is, the value in mailbox xx will be the next instruction executed.
| प्रोग्राम काउंटर को दिए गए एड्रेस (मान xx) पर प्रयुक्त करें। अर्थात् मेलबॉक्स xx में यही मान अगला निष्पादित इंस्ट्रक्शन होगा।
|-
|-
| 7xx || BRZ || BRANCH IF ZERO ([[conditional (programming)|conditional]])
| 7xx || बीआरजेड || यदि ब्रांच शून्य ([[conditional (programming)|कंडीशनल]])
| If the accumulator (calculator) contains the value 000, set the program counter to the value xx. Otherwise, do nothing. Whether the negative flag is taken into account is undefined. When a SUBTRACT underflows the accumulator, this flag is set, after which the accumulator is undefined, potentially zero, causing behavior of BRZ to be undefined on underflow. Suggested behavior would be to branch if accumulator is zero and negative flag is not set.
| यदि एक्यूमुलेटर में मान 000 है, तो प्रोग्राम काउंटर का मान xx प्रयुक्त करें अन्यथा कुछ न करें शून्य रहने दे। ऋणात्मक फ्लैग को ध्यान में रखा गया है या नहीं यह अपरिभाषित है। जब एक सब्ट्रैक्ट एक्यूमुलेटर को अंडरफ्लो करता है, तो यह ऋणात्मक फ्लैग प्रयुक्त किया जाता है जिसके बाद एक्यूमुलेटर अपरिभाषित होता है या संभावित रूप से शून्य होता है, जिससे अंडरफ्लो पर बीआरजेड का कार्य अपरिभाषित हो जाता है। यदि एक्यूमुलेटर शून्य है और ऋणात्मक फ्लैग प्रयुक्त नहीं है तो प्रयुक्त किया गया डेटा ब्रांच में होता है।
: Note: since the program is stored in memory, data and program instructions all have the same address/location format.
: ध्यान दें: चूंकि प्रोग्राम मेमोरी में संग्रहीत होता है। इसलिए डेटा और प्रोग्राम इंस्ट्रक्शन का एड्रेस फॉर्मेट के समान होता है।
|-
|-
| 8xx || BRP || BRANCH IF POSITIVE (conditional)
| 8xx || बीआरपी || यदि ब्रांच धनात्मक (कंडीशनल)
| If the accumulator (calculator) is 0 or positive, set the program counter to the value xx. Otherwise, do nothing. As LMC memory cells can only hold values between 0 and 999, this instruction depends solely on the negative flag set by an underflow on SUBTRACT and potentially on an overflow on ADD (undefined).
| यदि एक्यूमुलेटर 0 या धनात्मक है, तो प्रोग्राम काउंटर को मान को xx पर प्रयुक्त करें अन्यथा कुछ न करें शून्य रहने दे। चूँकि एलएमसी मेमोरी सेल केवल 0 और 999 के बीच मान रख सकते हैं। यह इंस्ट्रक्शन पूरी तरह से सब्ट्रैक्ट पर अंडरफ्लो द्वारा निर्धारित ऋणात्मक फ्लैग और संभावित रूप से एडीडी (अपरिभाषित) ओवरफ्लो पर निर्भर करता है।
: Note: since the program is stored in memory, data and program instructions all have the same address/location format.
: ध्यान दें: चूंकि प्रोग्राम मेमोरी में संग्रहीत होता है। इसलिए डेटा और प्रोग्राम इंस्ट्रक्शन का एड्रेस फॉर्मेट के समान होता है।
|-
|-
| 901 || INP || INPUT
| 901 || आईएनपी || इनपुट
| Go to the INBOX, fetch the value from the user, and put it in the accumulator (calculator)
| इनबॉक्स पर जाएं, उपयोगकर्ता से डेटा प्राप्त करें और इसे एक्यूमुलेटर में इनपुट करे।
: Note: this will overwrite whatever value was in the accumulator (destructive)
: ध्यान दें: यह एक्यूमुलेटर में जो भी डेटा होता है उसे डेस्ट्रकटिव कर देता है।
|-
|-
| 902 || OUT || OUTPUT
| 902 || ओयूटी || आउटपुट
| Copy the value from the accumulator (calculator) to the OUTBOX.
| एक्यूमुलेटर से डेटा को आउटबॉक्स में कॉपी करें।
: Note: the contents of the accumulator are not changed (non-destructive).
: ध्यान दें: एक्यूमुलेटर का डेटा (नॉन-डेस्ट्रकटिव) परिवर्तित नही किया जाता है।
|-
|-
| 000 || HLT/COB || HALT/COFFEE BREAK
| 000 || एचएलटी/सीओबी || हॉल्ट/कॉफी ब्रेक
| Stop working/end the program.
| कार्य करना बंद करें/प्रोग्राम समाप्त करें।
|-
|-
|    || DAT || DATA || This is an [[assembly language|assembler]] instruction which simply loads the value into the next available mailbox. DAT can also be used in conjunction with labels to declare variables. For example, DAT 984 will store the value 984 into a mailbox at the address of the DAT instruction.
|    || डीएटी || डाटा || यह एक असेंबलर इंस्ट्रक्शन है जो बस-डेटा को अगले उपलब्ध मेलबॉक्स में लोड करता है। वैरिएबल घोषित करने के लिए डीएटी का उपयोग लेबल के संयोजन में भी किया जा सकता है। उदाहरण के लिए डीएटी 984 मान 984 को डीएटी इंस्ट्रक्शन के एड्रेस पर एक मेलबॉक्स में संग्रहीत करता है।
|}
|}
=== उदाहरण ===
=== उदाहरण ===


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


{| class="wikitable"
{| class="wikitable"
! Mailbox
! मेलबॉक्स
! Numeric code
! न्यूमेरिक कोड
! Operation
!ऑपरेशन
! Comments
! टिप्पणी
|-
|-
| 00
| 00
| '''901'''
| '''901'''
| Accumulator = Inbox
| एक्यूमुलेटर = इनबॉक्स
| INPUT the first number, enter into calculator (erasing whatever was there)
|पहली संख्या को कैलकुलेटर में प्रस्तुत करें (वहां जो कुछ भी था उसे मिटा दें)
|-
|-
| 01
| 01
| '''308'''
| '''308'''
| Mailbox 08 = Accumulator
| मेलबॉक्स 08 = एक्यूमुलेटर
| STORE the calculator's current value (to prepare for the next step...)
|कैलकुलेटर का वर्तमान मान संग्रहीत करें (अगले चरण की तैयारी के लिए...)
|-
|-
| 02
| 02
| '''901'''
| '''901'''
| Accumulator = Inbox
| एक्यूमुलेटर = इनबॉक्स
| INPUT the second number, enter into calculator (erasing whatever was there)
|दूसरी संख्या को कैलकुलेटर में प्रस्तुत करें (वहां जो कुछ भी था उसे मिटा दें)
|-
|-
| 03
| 03
| '''309'''
| '''309'''
| Mailbox 09 = Accumulator
| मेलबॉक्स 09 = एक्यूमुलेटर
| STORE the calculator's current value (again, to prepare for the next step...)
|कैलकुलेटर का वर्तमान मान संग्रहीत करें (फिर से, अगले चरण की तैयारी के लिए...)
|-
|-
| 04
| 04
| '''508'''
| '''508'''
| Accumulator = Mailbox 08
| एक्यूमुलेटर = मेलबॉक्स 08
| (Now that both INPUT values are STORED in Mailboxes 08 and 09...)
|(अब दोनों इनपुट मान मेलबॉक्स 08 और 09 में संग्रहीत हैं...)  
LOAD the first value back into the calculator (erasing whatever was there)
 
पहले मान को वापस कैलकुलेटर में लोड करें (वहां जो कुछ भी था उसे मिटा दें)
|-
|-
| 05
| 05
| '''209'''
| '''209'''
| Accumulator = Accumulator - Mailbox 09
| एक्यूमुलेटर = एक्यूमुलेटर - मेलबॉक्स 09
| SUBTRACT the second number from the calculator's current value (which was just set to the first number)
|कैलकुलेटर के वर्तमान मान से दूसरी संख्या घटाएं (जो कि पहली संख्या पर मान प्रयुक्त किया गया था)
|-
|-
| 06
| 06
| '''902'''
| '''902'''
| Outbox = Accumulator
| आउटबॉक्स = एक्यूमुलेटर
| OUTPUT the calculator's result to the OUTBOX
|कैलकुलेटर के परिणाम को आउटबॉक्स में आउटपुट करें।
|-
|-
| 07
| 07
| '''000'''
| '''000'''
| Halt
| हॉल्ट
| HALT the LMC
| एचएएलटी एलएमसी
|}
|}
==== मनेमोनिक्स और लेबल लैंग्वेज का उपयोग करना ====
असेंबली लैंग्वेज एक निम्न-स्तरीय प्रोग्रामिंग लैंग्वेज है जो न्यूमेरिक इंस्ट्रक्शन कोड के अतिरिक्त मनेमोनिक्स और लेबल लैंग्वेज का उपयोग करती है। यद्यपि लिटिल मैन कंप्यूटर केवल मनेमोनिक्स के एक सीमित समूह का उपयोग करता है तो प्रत्येक इंस्ट्रक्शन के लिए एक मनेमोनिक्स कोड का उपयोग करने की सुविधा नीचे दिखाए गए उसी प्रोग्राम की असेंबली लैंग्वेज से स्पष्ट होती है। जिससे प्रोग्रामर को अब अज्ञात न्यूमेरिक कोड को याद रखने की आवश्यकता नहीं है और वह कर सकता है अब अधिक मनेमोनिक्स कोड को एक प्रोग्राम कोड के साथ प्रयोग किया जा सकता है। यदि मनेमोनिक्स एक इंस्ट्रक्शन है जिसमें मेमोरी एड्रेस (या तो एक ब्रांच इंस्ट्रक्शन या डेटा लोड) सम्मिलित है तो मेमोरी एड्रेस को नाम देने के लिए एक लेबल प्रोग्रामिंग लैंग्वेज का उपयोग किया जाता है।
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 प्रोग्राम क्लोज्ड होने के आतिरिक्त एक इंडलेस लूप स्टैक हो सकता है।


==== [[स्मृति सहायक]]्स और लेबल का उपयोग करना ====
इस समस्या को हल करने के लिए अधिकांश असेंबली लैंग्वेज (एलएमसी सहित) मनेमोनिक्स को लेबल (प्रोग्रामिंग लैंग्वेज) के साथ जोड़ती हैं। लेबल प्रोग्रामिंग लैंग्वेज एक ऐसा शब्द है जिसका उपयोग एक मेमोरी एड्रेस को नाम देने के लिए किया जाता है जहां एक इंस्ट्रक्शन या डेटा संग्रहीत किया जाता है या एक इंस्ट्रक्शन में उस एड्रेस को संदर्भित करने के लिए उपयोग किया जाता है।
असेंबली भाषा एक निम्न-स्तरीय प्रोग्रामिंग भाषा है जो संख्यात्मक निर्देश कोड के बजाय निमोनिक्स और लेबल का उपयोग करती है। यद्यपि एलएमसी केवल निमोनिक्स के एक सीमित सेट का उपयोग करता है, प्रत्येक निर्देश के लिए एक निमोनिक का उपयोग करने की सुविधा नीचे दिखाए गए उसी प्रोग्राम की असेंबली भाषा से स्पष्ट होती है - प्रोग्रामर को अब अज्ञात संख्यात्मक कोड के सेट को याद रखने की आवश्यकता नहीं है और अब वह अधिक यादगार निमोनिक कोड के सेट के साथ प्रोग्राम कर सकता है। यदि निमोनिक एक निर्देश है जिसमें मेमोरी एड्रेस (या तो एक शाखा निर्देश या डेटा लोड/सेव करना) शामिल है तो मेमोरी एड्रेस को नाम देने के लिए एक लेबल का उपयोग किया जाता है।
 
आईएनपी
एसटीए प्रथम
आईएनपी
एसटीए सेकंड
एलडीए प्रथम
उप दूसरा
बाहर
एचएलटी
सबसे पहले DAT
दूसरा दिनांक
 
== लेबल ==
लेबल के बिना प्रोग्रामर को मेलबॉक्स (मेमोरी) पतों की मैन्युअल रूप से गणना करने की आवश्यकता होती है। 'संख्यात्मक कोड उदाहरण' में, यदि अंतिम एचएलटी निर्देश से पहले एक नया निर्देश डाला जाना था तो वह एचएलटी निर्देश पता 07 से पता 08 पर चला जाएगा (पता लेबलिंग पता स्थान 00 पर शुरू होता है)। मान लीजिए कि उपयोगकर्ता ने पहले इनपुट के रूप में 600 दर्ज किया। निर्देश 308 का अर्थ यह होगा कि यह मान पता स्थान 08 पर संग्रहीत किया जाएगा और 000 (एचएलटी) निर्देश को अधिलेखित कर दिया जाएगा। चूँकि 600 का अर्थ है मेलबॉक्स पते 00 पर शाखा, प्रोग्राम रुकने के बजाय, एक अंतहीन लूप में फंस जाएगा।
 
इस कठिनाई को हल करने के लिए, अधिकांश असेंबली भाषाएँ (एलएमसी सहित) निमोनिक्स को [[लेबल (प्रोग्रामिंग भाषा)]] के साथ जोड़ती हैं। लेबल बस एक शब्द है जिसका उपयोग या तो एक मेमोरी एड्रेस को नाम देने के लिए किया जाता है जहां एक निर्देश या डेटा संग्रहीत किया जाता है, या एक निर्देश में उस पते को संदर्भित करने के लिए उपयोग किया जाता है।


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


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


इसलिए लेबल का उपयोग किया जाता है:
इसलिए लेबल प्रोग्रामिंग लैंग्वेज का उपयोग किया जाता है:
* किसी शाखा निर्देश के लक्ष्य के रूप में किसी विशेष निर्देश की पहचान करें।
* किसी ब्रांच इंस्ट्रक्शन के लक्ष्य के रूप में किसी विशेष इंस्ट्रक्शन की पहचान करें।
* नामित चर के रूप में एक मेमोरी स्थान की पहचान करें (डीएटी का उपयोग करके) और प्रोग्राम द्वारा उपयोग के लिए असेंबली समय पर प्रोग्राम में वैकल्पिक रूप से डेटा लोड करें (यह उपयोग तब तक स्पष्ट नहीं है जब तक कोई यह नहीं मानता कि काउंटर में 1 जोड़ने का कोई तरीका नहीं है। कोई उपयोगकर्ता को शुरुआत में 1 इनपुट करने के लिए कह सकता है, लेकिन इसे 'एक डीएटी 1' का उपयोग करके असेंबली के समय लोड करना बेहतर होगा)
* नामित वेरिएबल के रूप में एक मेमोरी एड्रेस की पहचान करें (डीएटी का उपयोग करके) और प्रोग्राम द्वारा उपयोग के लिए असेंबली टाइम पर प्रोग्राम में वैकल्पिक रूप से डेटा लोड करें। सामान्यतः यह उपयोग तब तक स्पष्ट नहीं है जब तक कोई यह नहीं मानता कि काउंटर में 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
  लूप ब्रज़ छोड़ें // इस मेमोरी एड्रेस को लूप के रूप में लेबल करें। यदि संचायक मान 0 है, तो 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
  HLT छोड़ें // इस मेमोरी एड्रेस को QUIT के रूप में लेबल करें
  ONE  DAT 1   // Store the value 1 in this memory address, and label it ONE (variable declaration)
  एक दिनांक 1 // इस मेमोरी पते में मान 1 संग्रहीत करें, और इसे एक लेबल करें (परिवर्तनीय घोषणा)
नीचे दिया गया प्रोग्राम उपयोगकर्ता से इनपुट लेगा और उसे आउटपुट देगा और फिर दोहराएगा जिससे शून्य प्राप्त होने से प्रोग्राम समाप्त हो जाएगा। ध्यान दें: जिस इनपुट का आउटपुट 999 से अधिक है उसका एलएमसी 3 डिजिट की संख्या सीमा के कारण अपरिभाषित रहता है।
 
  START  LDA ZERO    // Initialize for multiple program run
नीचे दिया गया प्रोग्राम उपयोगकर्ता इनपुट लेगा, उसे वर्गित करेगा, उत्तर आउटपुट करेगा और फिर दोहराएगा। शून्य दर्ज करने से प्रोग्राम समाप्त हो जाएगा।<br />
         STA RESULT
(ध्यान दें: जिस इनपुट का परिणाम 999 से अधिक है, उसका एलएमसी की 3 अंकों की संख्या सीमा के कारण अपरिभाषित व्यवहार होगा)।
         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
         BRZ END // यदि इनपुट = 0 है तो प्रोग्राम END की शाखा
         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
         उप मान // उपयोगकर्ता द्वारा प्रदत्त इनपुट मान को COUNT से घटाएं
         OUT          // Output RESULT
         BRZ ENDLOOP // यदि शून्य (VALUE को परिणाम में VALUE गुना जोड़कर जोड़ा गया है), तो ENDLOOP पर शाखा करें
         BRA START   // Branch to the START to initialize and get another input VALUE
         BRA LOOP // परिणाम में मान जोड़ना जारी रखने के लिए LOOP पर शाखा करें
  END     HLT         // HALT - a zero was entered so done!
  एंडलूप एलडीए परिणाम // लोड परिणाम
  RESULT  DAT          // Computed result (defaults to 0)
         आउट // आउटपुट परिणाम
  COUNT  DAT          // Counter (defaults to 0)
         BRA START // प्रारंभ करने और दूसरा इनपुट मान प्राप्त करने के लिए START पर शाखा करें
  ONE    DAT 1       // Constant, value of 1
  END HLT // रुकें - एक शून्य दर्ज किया गया था इसलिए हो गया!
  VALUE   DAT         // User provided input, the value to be squared (defaults to 0)
  परिणाम दिनांक // परिकलित परिणाम (डिफ़ॉल्ट 0)
  ZERO    DAT         // Constant, value of 0 (defaults to 0)
  काउंट डेटा // काउंटर (डिफ़ॉल्ट 0)
ध्यान दें: यदि डीएटी स्टेटमेंट के बाद कोई डेटा नहीं है तो डिफ़ॉल्ट मान 0 मेमोरी एड्रेस में संग्रहीत होता है। उपरोक्त उदाहरण में <code>BRZ_ENDLOOP</code> अपरिभाषित होता है, क्योंकि <code>COUNT-VALUE</code> ऋणात्मक हो सकती है, जिसके बाद एक्यूमुलेटर मान अपरिभाषित होता है। जिसके परिणामस्वरूप <code>BRZ</code> शाखाबद्ध और एक्यूमुलेटर शून्य हो सकता है। जिससे कोड को स्पेसिफिकेशन के लिए कम्पेटिबल या परिवर्तित किया जा सकता है।
  एक दिनांक 1 // स्थिरांक, 1 का मान
        LDA COUNT    // Load the COUNT
  VALUE DAT // उपयोगकर्ता द्वारा प्रदान किया गया इनपुट, मान का वर्ग किया जाना है (डिफ़ॉल्ट रूप से 0)
        ADD ONE      // Add ONE to the COUNT
  शून्य DAT // स्थिरांक, 0 का मान (0 पर डिफ़ॉल्ट)
        STA COUNT    // Store the new COUNT
 
        SUB VALUE    // Subtract the user provided input VALUE from COUNT
नोट: यदि DAT स्टेटमेंट के बाद कोई डेटा नहीं है तो डिफ़ॉल्ट मान 0 मेमोरी एड्रेस में संग्रहीत होता है।
        BRZ ENDLOOP  // If zero (VALUE has been added to RESULT by VALUE times), branch to ENDLOOP
 
उपरोक्त उदाहरण में, [BRZ ENDLOOP] अपरिभाषित व्यवहार पर निर्भर करता है, क्योंकि COUNT-VALUE नकारात्मक हो सकता है, जिसके बाद ACCUMULATOR मान अपरिभाषित होता है, जिसके परिणामस्वरूप BRZ या तो शाखाबद्ध हो जाता है या नहीं (ACCUMULATOR शून्य हो सकता है, या चारों ओर लपेटा जा सकता है)। कोड को विनिर्देश के अनुकूल बनाने के लिए, प्रतिस्थापित करें:
         ...
         ...
         एलडीए गिनती // गिनती लोड करें
निम्नलिखित संस्करण के साथ <code>COUNT-VALUE</code> के अतिरिक्त <code>VALUE-COUNT</code> का मूल्यांकन किया जाता है क्योकि यह सुनिश्चित करता है कि एक्यूमुलेटर कभी भी अंडरफ्लो न हो:     
         एक जोड़ें // गिनती में एक जोड़ें
    ...
         एसटीए काउंट // नई काउंट स्टोर करें
        LDA COUNT    // Load the COUNT
         उप मान // उपयोगकर्ता द्वारा प्रदत्त इनपुट मान को COUNT से घटाएं
         ADD ONE      // Add ONE to the COUNT
         BRZ ENDLOOP // यदि शून्य (VALUE को परिणाम में VALUE गुना जोड़कर जोड़ा गया है), तो ENDLOOP पर शाखा करें
         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
         ...
         ...
निम्नलिखित संस्करण के साथ, जो COUNT-VALUE के बजाय VALUE-COUNT का मूल्यांकन करता है, यह सुनिश्चित करता है कि संचायक कभी भी कम प्रवाहित न हो:
इसका एक अन्य उदाहरण [[क्विन (कंप्यूटिंग)]] है, जो अपने स्वयं के मशीन कोड को प्रिंट कर करता है। प्रिंट-सोर्स असंभव होता है क्योंकि टेक्स्ट को आउटपुट नहीं किया जा सकता है:
        ...
  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
        SUB COUNT // उपयोगकर्ता द्वारा प्रदत्त इनपुट मान से COUNT घटाएं
       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
        BRZ ENDLOOP // यदि शून्य (VALUE को परिणाम में VALUE गुना जोड़कर जोड़ा गया है), तो ENDLOOP पर शाखा करें
       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 होता है। इसलिए इसे <code>HALT/COB</code> इंस्ट्रक्शन के रूप में समझा जाता है।  
  लोड एलडीए 0 // संचायक में स्थिति 0 लोड करें। अगली पंक्तियों को संचायक में लोड करने के लिए इस लाइन को प्रत्येक लूप पर संशोधित किया जाएगा
       OUT // संचायक का मान आउटपुट करें। संचायक का मान वह लाइन होगी जो अभी लोड की गई थी
       सब वन // संचायक में मान से 1 घटाएं। ऐसा इसलिए है ताकि हम अगले चरण में यह देखने के लिए बीआरजेड कर सकें कि क्या हमकार्यक्रम में अंतिम पंक्ति पर हैं
       बीआरजेड वन // यदि पिछले घटाव ने संचायक को 0 बना दिया है (जिसका अर्थ है कि हमारे पास संचायक में मान 001 था), तो स्थिति एक पर शाखा करें
       एलडीए लोड // लोड स्थिति को संचायक में लोड करें, यह इस स्थिति के लिए पता अंक बढ़ाने की तैयारी में है
       एक जोड़ें // लोड लाइन के लिए स्थिति अंक बढ़ाएँ। संचायक में वर्तमान में मान, यदि एक निर्देश के रूप में पढ़ा जाता है, तो लोड की गई अंतिम पंक्ति की तुलना में, अगली पंक्ति संचायक में लोड हो जाएगी
       एसटीए लोड // नई बढ़ी हुई लोड लाइन को वापस लोड स्थिति में स्टोर करें
       ब्रा लोड // लूप की शुरुआत पर लौटें
  एक दिनांक 1 // चर एक। यदि इसे एक निर्देश के रूप में पढ़ा जाता है, तो इसे HLT/COB के रूप में समझा जाएगा और कार्यक्रम समाप्त हो जाएगा
यह क्विन [[स्व-संशोधित कोड]] का उपयोग करके काम करता है। स्थिति 0 को प्रत्येक पुनरावृत्ति में एक से बढ़ाया जाता है, उस पंक्ति के कोड को आउटपुट किया जाता है, जब तक कि वह जो कोड आउटपुट कर रहा है वह 1 न हो, जिस बिंदु पर यह एक स्थिति में शाखा करता है। ONE स्थिति में मान ऑपकोड के रूप में 0 है, इसलिए इसे HALT/COB निर्देश के रूप में समझा जाता है।


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


== संदर्भ ==
== संदर्भ ==
Line 247: Line 234:
* [http://www.povinelli.org/teaching/eece2710/lmc.html Richard J. Povinelli:Teaching:Introduction to Computer Hardware and Software:Little Man Computer]
* [http://www.povinelli.org/teaching/eece2710/lmc.html Richard J. Povinelli:Teaching:Introduction to Computer Hardware and Software:Little Man Computer]
* [http://elearning.algonquincollege.com/coursemat/dat2343/lectures.f03/12-LMC.htm The "Little Man" Computer]
* [http://elearning.algonquincollege.com/coursemat/dat2343/lectures.f03/12-LMC.htm The "Little Man" Computer]
=== सिमुलेटर ===
=== सिमुलेटर ===


Line 258: Line 241:
* [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/ पीटर हिगिन्सन का एलएमसी सिम्युलेटर]




Line 265: Line 248:
श्रेणी:1965 में कंप्यूटर से संबंधित परिचय
श्रेणी:1965 में कंप्यूटर से संबंधित परिचय


 
[[Category:Articles with hatnote templates targeting a nonexistent page]]
[[Category: Machine Translated Page]]
[[Category:Created On 25/07/2023]]
[[Category:Created On 25/07/2023]]
[[Category:Lua-based templates]]
[[Category:Machine Translated Page]]
[[Category:Pages with script errors]]
[[Category:Short description with empty Wikidata description]]
[[Category:Templates Vigyan Ready]]
[[Category:Templates that add a tracking category]]
[[Category:Templates that generate short descriptions]]
[[Category:Templates using TemplateData]]

Latest revision as of 16:14, 22 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 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’