निर्देश निष्पादन और एड्रेसिंग मोड
सीखने के लक्ष्य और सीमाएँ
सरल निर्देश के निष्पादन का क्रम समझें, पते और वहाँ रखे मान में अंतर करें, प्रभावी पता निकालें और operand-memory reads गिनें। पूर्वज्ञान: सामान्य अंकगणित, variables और binary storage की धारणा। यह processor architecture की शुरुआत है, पूरा विषय नहीं। Instruction encoding, control unit, interrupts, pipeline और virtual memory के लिए अलग पाठ चाहिए।
सभी उदाहरण एक स्पष्ट रूप से परिभाषित शिक्षण मशीन के हैं, वास्तविक MIPS, x86 या RISC-V assembly के नहीं। Memory byte-addressed है। हर instruction और data word चार bytes का है; सभी उदाहरणों के accesses aligned और valid हैं। M[a] का अर्थ byte address a से शुरू होने वाला पूरा चार-byte word है, केवल उस पते का एक byte नहीं। R1 register का नाम है; R[R1] उसमें रखा मान है। Caches, exceptions और address translation शामिल नहीं हैं। सभी मान register में समाते हैं, इसलिए arithmetic overflow नहीं होता।
1. Program से processor की स्थिति तक
Instruction set architecture (ISA) तय करती है कि मशीन कौन-से operations और programmer को दिखने वाला व्यवहार उपलब्ध कराती है। Implementation तय करता है कि circuits उन्हें कैसे पूरा करेंगे। एक ही ISA का अर्थ समान cycles या समान physical stages नहीं है।
हमारे model में program counter (PC) अगले fetch होने वाले instruction का पता बताता है। Fetch उसके bits पढ़ता है। Decode operation और operand प्राप्त करने का नियम पहचानता है। Execution पता निकाल सकता है या arithmetic कर सकता है; load/store data memory को access करता है; परिणाम तय register या memory location में जाता है। Branch सामान्य अगले पते के बजाय PC को दूसरे पते पर ले जा सकती है।
ये तार्किक गतिविधियाँ हैं, यह दावा नहीं कि हर instruction को पाँच clock cycles लगते हैं। कुछ implementations गतिविधियों को overlap करती हैं; कुछ एक गतिविधि में कई cycles लेती हैं। Instruction fetch और उसका data operand पढ़ना अलग घटनाएँ हैं।
इस model में byte address 100 पर चार-byte instruction का सामान्य अगला पता 104 है। PC+1 तभी सही होगा जब addressing या instruction length की अलग शर्त दी गई हो। वास्तविक ISA में branch का PC base अलग हो सकता है, इसलिए प्रश्न में base और displacement की इकाई स्पष्ट होनी चाहिए।
2. पता और उसमें रखा मान
मान लें M[500]=900 और M[900]=37। संख्या 500 एक पता है। वहाँ रखा word 900 है, जिसे दूसरे पते की तरह भी इस्तेमाल कर सकते हैं। एक बार पढ़ने पर 900 मिलेगा; उस pointer के पते पर फिर पढ़ने पर 37 मिलेगा। पते को बिना बताए उसके contents से न बदलें।
Memory operand का effective address (EA), addressing rule लगाने के बाद उसका वास्तविक स्थान है। फिर operand M[EA] होता है। Immediate और register operands के लिए data-memory EA आवश्यक नहीं। यहाँ तार्किक operand-memory reads में instruction fetch, address translation और cache traffic नहीं गिने जाते।
3. बार-बार काम आने वाली सारणी
A address field, k instruction में दिया constant, d byte displacement और R कोई register है।
| Mode | नियम | Load के operand-memory reads |
|---|---|---|
| Immediate | Operand = k, instruction में दिया हुआ | 0 |
| Register | Operand = R[R] | 0 |
| Direct / absolute | EA = A; operand = M[A] | 1 |
| Register indirect | EA = R[R]; operand = M[EA] | 1 |
| Memory indirect | EA = M[A]; operand = M[EA] | 2 |
| Base plus displacement | EA = R[R] + d; operand = M[EA] | 1 |
अलग ISAs में नाम और notation बदल सकते हैं। यहाँ memory indirect का अर्थ पहले एक pointer read और फिर एक operand read है। अधिक indirection levels के लिए अलग नियम देना होगा। केवल EA की गणना से M[EA] load नहीं होता। Store अपने source value को निकाले गए EA पर लिखता है; वह load की तरह destination operand नहीं पढ़ता।
4. हल किया उदाहरण: एक स्थिति, अलग modes
R[R1]=500, M[500]=900, M[508]=21 और M[900]=37 लें। हर अगला मामला इसी शुरुआती स्थिति से शुरू होता है।
- Immediate 500 से operand 500 मिलता है; operand-memory reads शून्य हैं।
- Register R1 से भी 500 मिलता है, लेकिन source register है, instruction में दिया constant नहीं।
- Direct address 500 से EA=500 और operand 900 मिलता है।
- R1 के register indirect से भी EA=500 और operand 900 मिलता है।
- Address 500 के memory indirect से EA=M[500]=900, फिर operand M[900]=37 मिलता है।
- Base R1 और displacement 8 से EA=500+8=508 तथा operand 21 मिलता है।
दो मामलों में समान परिणाम आने से modes समान नहीं हो जाते। Register या memory का मान बदलने पर परिणाम अलग हो सकते हैं।
5. हल किया उदाहरण: load, add और store
PC=100 पर LOAD R2, 8(R1) का नियम है R[R2] ← M[R[R1]+8]। ऊपर की स्थिति में EA=508 और R[R2]=21 होंगे; सामान्य अगला PC=104 होगा। फिर ADDI R2, 3 का अर्थ R[R2] ← R[R2]+3 है, इसलिए R[R2]=24 और PC=108 होंगे। अंत में STORE R2, 12(R1), M[512]=24 लिखता है और PC=112 होता है।
इस क्रम में एक तार्किक data-memory read और एक data-memory write है। सभी memory references पूछे जाएँ तो तीन instruction fetches अतिरिक्त होंगे। Add registers पढ़ता और बदलता है, पर data memory को access नहीं करता। इस सरल गिनती में store, M[512] को पहले पढ़ता भी है, ऐसा नहीं मानना चाहिए।
6. हल किया उदाहरण: array scaling और पीछे जाने वाली branch
चार-byte elements का array byte address 800 से शुरू है। Zero-based indexing में a[5] का पता 800+5×4=820 है। Index elements गिनता है; address displacement bytes गिनता है। यदि addressing rule पहले ही scale से गुणा करता है, तो दोबारा गुणा न करें।
Address 200 की चार-byte branch के लिए target को अगले sequential PC में signed byte displacement जोड़कर परिभाषित करें। Displacement −12 होने पर target=(200+4)−12=192 है। यदि प्रश्न displacement को चार-byte instructions में देता, तो −12 का अर्थ −48 bytes होता। दूसरी ISA का अनकहा नियम यहाँ लागू न करें।
मुख्य बातें और सामान्य गलतियाँ
- पहले EA लिखें; operand memory में हो तभी M[EA] पढ़ें।
- Direct memory, register indirect और memory indirect अलग रखें।
- गिनती में instruction fetch, data read और data write शामिल हैं या नहीं, स्पष्ट करें।
- Byte/word addressing, operand size, instruction length और branch-PC नियम देखें।
- निष्पादन की एक तार्किक गतिविधि आवश्यक रूप से एक clock cycle नहीं है।
- Load data को register में और store value को memory में रखता है। यहाँ दोनों base register नहीं बदलते।
मौलिक अभ्यास: छह single-correct MCQ
ये मौलिक प्रश्न हैं, पिछले वर्षों के प्रश्न नहीं। हर प्रश्न में ठीक एक विकल्प चुनें।
I01. M[120]=44 है। क्रमशः immediate constant 120 और direct address 120 से कौन-से operands मिलेंगे?
A. 44, 120 B. 120, 44 C. 120, 120 D. 44, 44
उत्तर: B
A: इसमें constant और memory contents का क्रम उलट गया है।
B: Immediate से दिया constant 120; direct से M[120]=44 मिलता है।
C: Direct operand वहाँ रखा word है, उसका पता नहीं।
D: Immediate, M[120] नहीं पढ़ता; उसका मान 120 ही है।
I02. एक-level memory-indirect addressing में address field 180, M[180]=400 और M[400]=9 हैं। Effective address और operand क्या हैं?
A. 180, 400 B. 9, 400 C. 400, 9 D. 180, 9
उत्तर: C
A: यह 180 की direct addressing है, बताई गई indirection नहीं।
B: Pointer value 400 पता है और 9 contents हैं; उलटा नहीं।
C: पहले EA=M[180]=400; फिर operand=M[400]=9।
D: अंतिम operand 9 है, लेकिन उसका effective address 400 है, मूल field 180 नहीं।
I03. R[R3]=300 और M[288]=17 हैं। Load में base R3 और signed byte displacement −12 है। सही EA/operand जोड़ी कौन-सी है?
A. 288, 17 B. 312, 17 C. 300, 288 D. 17, 288
उत्तर: A
A: EA=300+(−12)=288; उस पते को पढ़ने पर 17 मिलता है।
B: Signed displacement के बजाय उसका magnitude जोड़ने से गलत 312 मिलता है।
C: Displacement पता बदलता है; 288 पता है, दिया operand नहीं।
D: इसमें निकाला पता और उसके contents उलट गए हैं।
I04. चार-byte branch byte address 1000 से शुरू है। Target अगले sequential PC में signed byte displacement −20 जोड़कर मिलता है। Target क्या है?
A. 980 B. 1024 C. 924 D. 984
उत्तर: D
A: यह बताए अगले PC के बजाय वर्तमान instruction address से 20 घटाता है।
B: Displacement negative है, इसलिए 1004 में से घटाना चाहिए।
C: −20 पहले से bytes में है; उसे चार से गुणा करना गलत है।
D: अगला PC=1000+4=1004; target=1004−20=984।
I05. Load पहले M[A] से pointer लेता है और फिर उस pointer के पते से operand पढ़ता है। Instruction fetch, caches और translation छोड़कर कितने तार्किक data-memory reads चाहिए?
A. 0 B. 2 C. 1 D. 3
उत्तर: B
A: Pointer और operand दोनों memory में हैं; शून्य reads से नहीं मिलेंगे।
B: पहला read pointer और दूसरा read operand देता है।
C: एक read से केवल pointer मिलेगा, अंतिम operand नहीं।
D: Instruction fetch नहीं गिनना है; तीसरा data-memory read नहीं दिया गया।
I06. Array byte address 600 से शुरू है और हर element चार bytes का है। Zero-based indexing में a[7] का शुरुआती पता क्या है?
A. 607 B. 632 C. 628 D. 624
उत्तर: C
A: सात element index है; चार bytes प्रति element से गुणा करना होगा।
B: यह आठ element lengths जोड़ता है, जबकि index 7, index 0 से सात स्थान आगे है।
C: पता=600+7×4=628।
D: यह index 7 के बजाय 6 इस्तेमाल करता है।
स्रोत और दायरा
यह Computer Organization का आधारभूत पाठ है, पूरे विषय या पूरे पाठ्यक्रम की समाप्ति नहीं। आधिकारिक syllabus विषय का संबंध बताता है; technical references मूल परिभाषाओं की जाँच के लिए हैं। शिक्षण models, हल किए उदाहरण और अभ्यास मौलिक हैं। जाँच: 14 अक्टूबर 2026।
प्रगति सहेजने के लिए साइन इन करें। साइन इन