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

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


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


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


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


=== निर्देश ===
=== निर्देश ===
Line 29: Line 29:


{| class="wikitable"
{| class="wikitable"
|+ Instructions
|+ निर्देश
|-
|-
! Numeric code
! न्यूमेरिक कोड
! Mnemonic code
!मनेमोनिक कोड
! Instruction
!निर्देश
! Description
! विवरण
|-
|-
| 1xx || ADD || ADD
| 1xx || ADD || ADD
| 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 || SUB || SUBTRACT
| 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 (BRZ) और 8xx (BRP) का उपयोग किया जा सके अच्छी तरह से।
|-
|-
| 3xx || STA || STORE
| 3xx || STA || STORE
| 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 || LDA || LOAD
| Load the value from mailbox xx (non-destructive) and enter it in the accumulator (destructive).
| मेलबॉक्स xx (गैर-विनाशकारी) से मान लोड करें और इसे संचायक (विनाशकारी) में दर्ज करें।
|-
|-
| 6xx || BRA || [[branch (computer science)|BRANCH]] (unconditional)
| 6xx || BRA || [[branch (computer science)|BRANCH]] (unconditional)
| 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 || BRZ || BRANCH IF ZERO ([[conditional (programming)|conditional]])
| 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 पर सेट करें। अन्यथा, कुछ न करें. नकारात्मक ध्वज को ध्यान में रखा गया है या नहीं यह अपरिभाषित है। जब एक SUBTRACT संचायक को अंडरफ्लो करता है, तो यह ध्वज सेट किया जाता है, जिसके बाद संचायक अपरिभाषित होता है, संभावित रूप से शून्य होता है, जिससे अंडरफ्लो पर BRZ का व्यवहार अपरिभाषित हो जाता है। यदि संचायक शून्य है और नकारात्मक ध्वज सेट नहीं है तो सुझाया गया व्यवहार शाखा में होगा।
: 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 || BRP || BRANCH IF POSITIVE (conditional)
| 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 पर सेट करें। अन्यथा, कुछ न करें. चूँकि LMC मेमोरी सेल केवल 0 और 999 के बीच मान रख सकते हैं, यह निर्देश पूरी तरह से SUBTRACT पर अंडरफ्लो द्वारा निर्धारित नकारात्मक ध्वज और संभावित रूप से ADD (अपरिभाषित) पर ओवरफ्लो पर निर्भर करता है।
: Note: since the program is stored in memory, data and program instructions all have the same address/location format.
: नोट: चूंकि प्रोग्राम मेमोरी में संग्रहीत होता है, इसलिए डेटा और प्रोग्राम निर्देशों का पता/स्थान प्रारूप समान होता है।
|-
|-
| 901 || INP || INPUT
| 901 || INP || INPUT
| 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 || OUT || OUTPUT
| 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 || HLT/COB || HALT/COFFEE BREAK
| 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.
|    || DAT || DATA || यह एक असेंबलर निर्देश है जो बस मान को अगले उपलब्ध मेलबॉक्स में लोड करता है। वैरिएबल घोषित करने के लिए DAT का उपयोग लेबल के संयोजन में भी किया जा सकता है। उदाहरण के लिए, DAT 984 मान 984 को DAT निर्देश के पते पर एक मेलबॉक्स में संग्रहीत करेगा।
|}
|}
=== उदाहरण ===
=== उदाहरण ===


Line 85: Line 83:
! Mailbox
! Mailbox
! Numeric code
! Numeric code
! Operation
!ऑपरेशन
! Comments
! टिप्पणी
|-
|-
| 00
| 00
| '''901'''
| '''901'''
| Accumulator = Inbox
| Accumulator = इनबॉक्स
| INPUT the first number, enter into calculator (erasing whatever was there)
|पहला नंबर दर्ज करें, कैलकुलेटर में दर्ज करें (वहां जो कुछ भी था उसे मिटा दें)
|-
|-
| 01
| 01
| '''308'''
| '''308'''
| Mailbox 08 = Accumulator
| Mailbox 08 = Accumulator
| STORE the calculator's current value (to prepare for the next step...)
|कैलकुलेटर का वर्तमान मान संग्रहीत करें (अगले चरण की तैयारी के लिए...)
|-
|-
| 02
| 02
| '''901'''
| '''901'''
| Accumulator = Inbox
| Accumulator = इनबॉक्स
| INPUT the second number, enter into calculator (erasing whatever was there)
|दूसरा नंबर दर्ज करें, कैलकुलेटर में दर्ज करें (वहां जो कुछ भी था उसे मिटा दें)
|-
|-
| 03
| 03
| '''309'''
| '''309'''
| Mailbox 09 = Accumulator  
| Mailbox 09 = Accumulator  
| STORE the calculator's current value (again, to prepare for the next step...)
|कैलकुलेटर का वर्तमान मान संग्रहीत करें (फिर से, अगले चरण की तैयारी के लिए...)
|-
|-
| 04
| 04
| '''508'''
| '''508'''
| Accumulator = Mailbox 08
| Accumulator = Mailbox 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
| Accumulator = Accumulator - Mailbox 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
| आउटबॉक्स = Accumulator
| OUTPUT the calculator's result to the OUTBOX
|कैलकुलेटर के परिणाम को आउटबॉक्स में आउटपुट करें
|-
|-
| 07
| 07
| '''000'''
| '''000'''
| Halt
| Halt
| HALT the LMC
| एचएएलटी एलएमसी
|}
|}
==== [[स्मृति सहायक]]्स और लेबल का उपयोग करना ====
==== [[स्मृति सहायक]]्स और लेबल का उपयोग करना ====
असेंबली भाषा एक निम्न-स्तरीय प्रोग्रामिंग भाषा है जो संख्यात्मक निर्देश कोड के बजाय निमोनिक्स और लेबल का उपयोग करती है। यद्यपि एलएमसी केवल निमोनिक्स के एक सीमित सेट का उपयोग करता है, प्रत्येक निर्देश के लिए एक निमोनिक का उपयोग करने की सुविधा नीचे दिखाए गए उसी प्रोग्राम की असेंबली भाषा से स्पष्ट होती है - प्रोग्रामर को अब अज्ञात संख्यात्मक कोड के सेट को याद रखने की आवश्यकता नहीं है और अब वह अधिक यादगार निमोनिक कोड के सेट के साथ प्रोग्राम कर सकता है। यदि निमोनिक एक निर्देश है जिसमें मेमोरी एड्रेस (या तो एक शाखा निर्देश या डेटा लोड/सेव करना) शामिल है तो मेमोरी एड्रेस को नाम देने के लिए एक लेबल का उपयोग किया जाता है।
असेंबली भाषा एक निम्न-स्तरीय प्रोग्रामिंग भाषा है जो संख्यात्मक निर्देश कोड के बजाय निमोनिक्स और लेबल का उपयोग करती है। यद्यपि एलएमसी केवल निमोनिक्स के एक सीमित सेट का उपयोग करता है, प्रत्येक निर्देश के लिए एक निमोनिक का उपयोग करने की सुविधा नीचे दिखाए गए उसी प्रोग्राम की असेंबली भाषा से स्पष्ट होती है - प्रोग्रामर को अब अज्ञात संख्यात्मक कोड का एक सेट याद रखने की आवश्यकता नहीं है और वह कर सकता है अब अधिक यादगार स्मरणीय कोड के एक सेट के साथ कार्यक्रम। यदि निमोनिक एक निर्देश है जिसमें मेमोरी एड्रेस (या तो एक शाखा निर्देश या डेटा लोड/सेव करना) शामिल है तो मेमोरी एड्रेस को नाम देने के लिए एक लेबल का उपयोग किया जाता है।
 
  INP
  आईएनपी
  STA FIRST
  एसटीए प्रथम
  INP
  आईएनपी
  STA SECOND
  एसटीए सेकंड
  LDA FIRST
  एलडीए प्रथम
  SUB SECOND
  उप दूसरा
  OUT
  बाहर
  HLT
  एचएलटी
  FIRST DAT
  सबसे पहले DAT
  SECOND DAT
  दूसरा दिनांक


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


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


जब कोई प्रोग्राम असेंबल किया जाता है:
जब कोई प्रोग्राम असेंबल किया जाता है:
Line 155: Line 151:
* DAT स्टेटमेंट के साथ संयुक्त एक लेबल एक वेरिएबल के रूप में काम करता है, यह उस मेमोरी एड्रेस को लेबल करता है जिस पर डेटा संग्रहीत है। यानी 'एक DAT 1' या 'नंबर 1 DAT'
* DAT स्टेटमेंट के साथ संयुक्त एक लेबल एक वेरिएबल के रूप में काम करता है, यह उस मेमोरी एड्रेस को लेबल करता है जिस पर डेटा संग्रहीत है। यानी 'एक DAT 1' या 'नंबर 1 DAT'


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


इसलिए लेबल का उपयोग किया जाता है:
इसलिए लेबल का उपयोग किया जाता है:
* किसी शाखा निर्देश के लक्ष्य के रूप में किसी विशेष निर्देश की पहचान करें।
* किसी शाखा निर्देश के लक्ष्य के रूप में किसी विशेष निर्देश की पहचान करें।
* नामित चर के रूप में एक मेमोरी स्थान की पहचान करें (डीएटी का उपयोग करके) और प्रोग्राम द्वारा उपयोग के लिए असेंबली समय पर प्रोग्राम में वैकल्पिक रूप से डेटा लोड करें (यह उपयोग तब तक स्पष्ट नहीं है जब तक कोई यह नहीं मानता कि काउंटर में 1 जोड़ने का कोई तरीका नहीं है। कोई उपयोगकर्ता को शुरुआत में 1 इनपुट करने के लिए कह सकता है, लेकिन इसे 'एक डीएटी 1' का उपयोग करके असेंबली के समय लोड करना बेहतर होगा)
* नामित चर के रूप में एक मेमोरी स्थान की पहचान करें (डीएटी का उपयोग करके) और प्रोग्राम द्वारा उपयोग के लिए असेंबली समय पर प्रोग्राम में वैकल्पिक रूप से डेटा लोड करें (यह उपयोग तब तक स्पष्ट नहीं है जब तक कोई यह नहीं मानता कि काउंटर में 1 जोड़ने का कोई तरीका नहीं है। कोई कर सकता है शुरुआत में उपयोगकर्ता से 1 इनपुट करने के लिए कहें, लेकिन बेहतर होगा कि इसे असेंबली के समय एक DAT 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)
नीचे दिया गया प्रोग्राम उपयोगकर्ता इनपुट लेगा, उसे वर्गित करेगा, उत्तर आउटपुट करेगा और फिर दोहराएगा। शून्य दर्ज करने से प्रोग्राम समाप्त हो जाएगा.


      आईएनपी
      आउट // आउटपुट प्रारंभ करें
लूप ब्रज़ छोड़ें // इस मेमोरी एड्रेस को लूप के रूप में लेबल करें। यदि संचायक मान 0 है, तो QUIT लेबल वाले मेमोरी पते पर जाएं
      सब वन // संचायक से पते एक पर संग्रहीत मूल्य घटाएं
      बाहर
      ब्रा लूप // लूप लेबल वाले मेमोरी पते पर (बिना शर्त) जाएं
HLT छोड़ें // इस मेमोरी एड्रेस को QUIT के रूप में लेबल करें
एक दिनांक 1 // इस मेमोरी पते में मान 1 संग्रहीत करें, और इसे एक लेबल करें (परिवर्तनीय घोषणा)
नीचे दिया गया प्रोग्राम उपयोगकर्ता इनपुट लेगा, उसे वर्गित करेगा, उत्तर आउटपुट करेगा और फिर दोहराएगा। शून्य दर्ज करने से प्रोग्राम समाप्त हो जाएगा।<br />
(ध्यान दें: जिस इनपुट का परिणाम 999 से अधिक है, उसका एलएमसी की 3 अंकों की संख्या सीमा के कारण अपरिभाषित व्यवहार होगा)।
(ध्यान दें: जिस इनपुट का परिणाम 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
         BRZ END // यदि इनपुट = 0 है तो प्रोग्राम END की शाखा
         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
         उप मान // उपयोगकर्ता द्वारा प्रदत्त इनपुट मान को COUNT से घटाएं
         BRZ ENDLOOP // If zero (VALUE has been added to RESULT by VALUE times), branch to ENDLOOP
         BRZ ENDLOOP // यदि शून्य (VALUE को परिणाम में VALUE गुना जोड़कर जोड़ा गया है), तो ENDLOOP पर शाखा करें
         BRA LOOP     // Branch to LOOP to continue adding VALUE to RESULT
         BRA LOOP // परिणाम में मान जोड़ना जारी रखने के लिए LOOP पर शाखा करें
  ENDLOOP LDA RESULT  // Load RESULT
  एंडलूप एलडीए परिणाम // लोड परिणाम
         OUT          // Output RESULT
         आउट // आउटपुट परिणाम
         BRA START   // Branch to the START to initialize and get another input VALUE
         BRA START // प्रारंभ करने और दूसरा इनपुट मान प्राप्त करने के लिए START पर शाखा करें
  END     HLT         // HALT - a zero was entered so done!
  END HLT // रुकें - एक शून्य दर्ज किया गया था इसलिए हो गया!
  RESULT  DAT          // Computed result (defaults to 0)
  परिणाम दिनांक // परिकलित परिणाम (डिफ़ॉल्ट 0)
  COUNT  DAT          // Counter (defaults to 0)
  काउंट डेटा // काउंटर (डिफ़ॉल्ट 0)
  ONE    DAT 1       // Constant, value of 1
  एक दिनांक 1 // स्थिरांक, 1 का मान
  VALUE   DAT         // User provided input, the value to be squared (defaults to 0)
  VALUE DAT // उपयोगकर्ता द्वारा प्रदान किया गया इनपुट, मान का वर्ग किया जाना है (डिफ़ॉल्ट रूप से 0)
  ZERO    DAT         // Constant, value of 0 (defaults to 0)
  शून्य DAT // स्थिरांक, 0 का मान (0 पर डिफ़ॉल्ट)
 
नोट: यदि DAT स्टेटमेंट के बाद कोई डेटा नहीं है तो डिफ़ॉल्ट मान 0 मेमोरी एड्रेस में संग्रहीत होता है।
नोट: यदि DAT स्टेटमेंट के बाद कोई डेटा नहीं है तो डिफ़ॉल्ट मान 0 मेमोरी एड्रेस में संग्रहीत होता है।


उपरोक्त उदाहरण में, [BRZ ENDLOOP] अपरिभाषित व्यवहार पर निर्भर करता है, क्योंकि COUNT-VALUE नकारात्मक हो सकता है, जिसके बाद ACCUMULATOR मान अपरिभाषित होता है, जिसके परिणामस्वरूप BRZ या तो शाखाबद्ध हो जाता है या नहीं (ACCUMULATOR शून्य हो सकता है, या चारों ओर लपेटा जा सकता है)। कोड को विनिर्देश के अनुकूल बनाने के लिए, प्रतिस्थापित करें:
उपरोक्त उदाहरण में, [BRZ ENDLOOP] अपरिभाषित व्यवहार पर निर्भर करता है, क्योंकि COUNT-VALUE नकारात्मक हो सकता है, जिसके बाद ACCUMULATOR मान अपरिभाषित होता है, जिसके परिणामस्वरूप BRZ या तो शाखाबद्ध हो जाता है या नहीं (ACCUMULATOR शून्य हो सकता है, या चारों ओर लपेटा जा सकता है)। कोड को विनिर्देश के अनुकूल बनाने के लिए, प्रतिस्थापित करें:      
    ...
        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
         उप मान // उपयोगकर्ता द्वारा प्रदत्त इनपुट मान को 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 का मूल्यांकन करता है, यह सुनिश्चित करता है कि संचायक कभी भी कम प्रवाहित न हो:
        ...
        एलडीए गिनती // गिनती लोड करें
        एक जोड़ें // गिनती में एक जोड़ें
        एसटीए काउंट // नई काउंट स्टोर करें
        एलडीए वैल्यू // वैल्यू लोड करें
        SUB COUNT // उपयोगकर्ता द्वारा प्रदत्त इनपुट मान से COUNT घटाएं
        BRZ ENDLOOP // यदि शून्य (VALUE को परिणाम में VALUE गुना जोड़कर जोड़ा गया है), तो ENDLOOP पर शाखा करें
        ...
एक अन्य उदाहरण एक [[क्विन (कंप्यूटिंग)]] है, जो अपने स्वयं के मशीन कोड को प्रिंट कर रहा है (मुद्रण स्रोत असंभव है क्योंकि अक्षरों को आउटपुट नहीं किया जा सकता है):
एक अन्य उदाहरण एक [[क्विन (कंप्यूटिंग)]] है, जो अपने स्वयं के मशीन कोड को प्रिंट कर रहा है (मुद्रण स्रोत असंभव है क्योंकि अक्षरों को आउटपुट नहीं किया जा सकता है):
  लोड एलडीए 0 // संचायक में स्थिति 0 लोड करें। अगली पंक्तियों को संचायक में लोड करने के लिए इस लाइन को प्रत्येक लूप पर संशोधित किया जाएगा
  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 // संचायक का मान आउटपुट करें। संचायक का मान वह लाइन होगी जो अभी लोड की गई थी
       OUT       // Output the accumulator's value. The accumulator's value will be the line that was just loaded
       सब वन // संचायक में मान से 1 घटाएं। ऐसा इसलिए है ताकि हम अगले चरण में यह देखने के लिए बीआरजेड कर सकें कि क्या हमकार्यक्रम में अंतिम पंक्ति पर हैं
       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
       बीआरजेड वन // यदि पिछले घटाव ने संचायक को 0 बना दिया है (जिसका अर्थ है कि हमारे पास संचायक में मान 001 था), तो स्थिति एक पर शाखा करें
       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
  एक दिनांक 1 // चर एक। यदि इसे एक निर्देश के रूप में पढ़ा जाता है, तो इसे HLT/COB के रूप में समझा जाएगा और कार्यक्रम समाप्त हो जाएगा
  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 न हो, जिस बिंदु पर यह एक स्थिति में शाखा करता है। ONE स्थिति में मान ऑपकोड के रूप में 0 है, इसलिए इसे HALT/COB निर्देश के रूप में समझा जाता है।
यह क्विन स्व-संशोधित कोड का उपयोग करके काम करता है। स्थिति 0 को प्रत्येक पुनरावृत्ति में एक से बढ़ाया जाता है, उस पंक्ति के कोड को आउटपुट किया जाता है, जब तक कि वह जो कोड आउटपुट कर रहा है वह 1 न हो, जिस बिंदु पर यह एक स्थिति में शाखा करता है। ONE स्थिति में मान ऑपकोड के रूप में 0 है, इसलिए इसे HALT/COB निर्देश के रूप में समझा जाता है।


==यह भी देखें==
==यह भी देखें==

Revision as of 20:14, 8 August 2023

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

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

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

निष्पादन चक्र

See also: Instruction cycle

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

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

आदेश

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

निर्देश

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

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

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

उदाहरण

संख्यात्मक निर्देश कोड का उपयोग करना

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

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

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

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

स्मृति सहायक्स और लेबल का उपयोग करना

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

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 स्टेटमेंट के साथ संयुक्त एक लेबल एक वेरिएबल के रूप में काम करता है, यह उस मेमोरी एड्रेस को लेबल करता है जिस पर डेटा संग्रहीत है। यानी 'एक DAT 1' या 'नंबर 1 DAT'

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

इसलिए लेबल का उपयोग किया जाता है:

  • किसी शाखा निर्देश के लक्ष्य के रूप में किसी विशेष निर्देश की पहचान करें।
  • नामित चर के रूप में एक मेमोरी स्थान की पहचान करें (डीएटी का उपयोग करके) और प्रोग्राम द्वारा उपयोग के लिए असेंबली समय पर प्रोग्राम में वैकल्पिक रूप से डेटा लोड करें (यह उपयोग तब तक स्पष्ट नहीं है जब तक कोई यह नहीं मानता कि काउंटर में 1 जोड़ने का कोई तरीका नहीं है। कोई कर सकता है शुरुआत में उपयोगकर्ता से 1 इनपुट करने के लिए कहें, लेकिन बेहतर होगा कि इसे असेंबली के समय एक DAT 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)

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

उपरोक्त उदाहरण में, [BRZ ENDLOOP] अपरिभाषित व्यवहार पर निर्भर करता है, क्योंकि COUNT-VALUE नकारात्मक हो सकता है, जिसके बाद ACCUMULATOR मान अपरिभाषित होता है, जिसके परिणामस्वरूप BRZ या तो शाखाबद्ध हो जाता है या नहीं (ACCUMULATOR शून्य हो सकता है, या चारों ओर लपेटा जा सकता है)। कोड को विनिर्देश के अनुकूल बनाने के लिए, प्रतिस्थापित करें: 

   	...
        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 न हो, जिस बिंदु पर यह एक स्थिति में शाखा करता है। ONE स्थिति में मान ऑपकोड के रूप में 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=251856’