এই পর্বে যা শিখবেন
PUSH,POP,CALLআরRET-এর পরে SP আর memory-র প্রতিটি byte হাতে বের করাPUSH PSWদিয়ে A আর flag একসঙ্গে রক্ষা, আর flag byte পড়ার কৌশল- Nested subroutine লেখা, আর register, memory বা stack দিয়ে parameter পাঠানো
- যেকোনো delay loop-এর T-state সূত্র বের করা, আর একটি নির্দিষ্ট সময়ের জন্য count হিসাব করা
- Stack-এর সাধারণ ভুল (POP ভুলে যাওয়া, SP না বসানো) simulator-এ ধরা, আর AI-এর দেওয়া হিসাব যাচাই করা
১ · Stack কী — রসিদের শিক আর 8085-এর SP
বাজারঘরের ক্যাশ কাউন্টারে একটি লোহার শিক আছে, যাতে বিক্রির রসিদ গেঁথে রাখা হয়। নতুন রসিদ সবসময় ওপরে বসে। হিসাব মেলাতে গেলে ওপরের রসিদটিই আগে খোলা যায়; নিচেরটি পেতে হলে ওপরেরগুলো আগে সরাতে হয়। এই নিয়মের নাম LIFO: শেষে এলে আগে যাবে। CPU-তে এই নিয়মে চলা memory-এলাকার নাম stack.
উপমা — কাজের মাঝে আরেক কাজ: কর্মচারী একটি অর্ডারের দাম যোগ করছেন, এমন সময় মালিক বললেন, “আগে গুদাম থেকে একটি বস্তা আনুন।” কর্মচারী খাতার যে লাইনে ছিলেন, সেখানে একটি চিরকুট রেখে গেলেন। গুদামে গিয়ে দেখলেন বস্তার ওজন মাপতে হবে; সেখানেও একটি চিরকুট রেখে স্কেলের কাছে গেলেন। ফেরার সময় আগে ওজনের চিরকুট, পরে খাতার চিরকুট: যে ক্রমে রেখেছিলেন, তার ঠিক উল্টো ক্রমে। 8085-এর CALL ঠিক এভাবে ফেরার ঠিকানার “চিরকুট” stack-এ রাখে, আর RET সবচেয়ে ওপরেরটি তুলে নেয়।
Stack-এর সাধারণ তত্ত্ব, অর্থাৎ ডেটা স্ট্রাকচার হিসেবে push আর pop, DSA কোর্সের পর্ব ১৩-এ আছে; function call-এ stack কীভাবে ব্যবহার হয়, তা RISC-V দিয়ে Computer Architecture পর্ব ৩০-এ। এক লাইনে মনে করিয়ে দিই: stack-এ শুধু ওপর থেকে রাখা আর ওপর থেকে নেওয়া যায়। এই পর্বের প্রশ্ন হলো, ১৯৭৬ সালের 8085 এই ধারণাকে কোন register, কোন instruction আর কত T-state দিয়ে বাস্তবে রূপ দেয়।
8085-এ stack আলাদা কোনো hardware নয়। এটি সাধারণ RAM-এর একটি অংশ, যা programmer নিজে বেছে নেন। CPU শুধু একটি ১৬ বিটের register রাখে, stack pointer (SP), যার মান stack-এর মাথার ঠিকানা: সবশেষে লেখা byte-টি কোথায় আছে (পর্ব ০৭, 8085-এর গঠন-এ SP-কে register হিসেবে দেখেছেন)। তিনটি নিয়ম মনে রাখুন:
- নিচের দিকে বাড়ে। কিছু রাখলে SP কমে, তুললে বাড়ে। তাই stack সাধারণত RAM-এর ওপরের প্রান্তে রাখা হয়, আর program ও data নিচের প্রান্তে, যাতে দুটি একে অন্যের দিকে বাড়ার জায়গা পায়।
- সবসময় দুই byte. 8085-এর stack-এ একবারে একটি register pair বা একটি ঠিকানা যায়: ১৬ বিট, দুটি byte. আলাদা করে এক byte রাখার instruction নেই।
- শুরুতে SP বসাতে হয়। Reset-এর পরে SP = 0000H (Spec decision 6). তাই প্রথম
PUSHলেখে FFFFH আর FFFEH-এ, যেখানে আপনার যন্ত্রে RAM না-ও থাকতে পারে। প্রতিটি program-এর প্রথম লাইন হওয়া উচিতLXI SP,2800H-এর মতো একটি নির্দেশ।
এই পর্বে সব সংখ্যা Intel-এর ধরনে, শেষে H দিয়ে hex: 2050H, 0FFH. কোর্সের নিয়ম মেনে program 2000H-এ, data 2050H-এ, আর stack-এর তলা 2800H-এ: প্রথম PUSH লেখে 27FFH আর 27FEH-এ। নিচের ছবিটি পরের অংশের nested subroutine-এর একটি মুহূর্তের memory, যখন দুটি ফেরার ঠিকানা stack-এ।
ছবি ১২.১ — 8085-এর memory-তে program, data আর stack
ওপরে ছোট ঠিকানা, নিচে বড়; stack বাড়ে ওপরের দিকে, অর্থাৎ ছোট ঠিকানার দিকে
9E 30; লাল আর সবুজ ঘরে stack. প্রতিটি ফেরার ঠিকানা দুই byte, ছোট ঠিকানায় নিচু byte: 27FEH-এ 0B আর 27FFH-এ 20 মিলে 200BH. SP দেখায় সবশেষে লেখা byte, 27FCH. পরের PUSH লিখবে 27FBH আর 27FAH-এ, অর্থাৎ ছবিতে আরও ওপরে, data-র দিকে।২ · PUSH আর POP — দুই byte, নির্দিষ্ট ক্রম
PUSH rp একটি register pair-কে stack-এ রাখে। ধাপগুলো Intel 8085 manual মতে: SP এক কমে, সেখানে উঁচু byte লেখা হয়; SP আবার এক কমে, সেখানে নিচু byte. ফলে নিচু byte ছোট ঠিকানায়, অর্থাৎ stack-ও little-endian, ঠিক যেমন instruction-এর ভেতরের ঠিকানা। POP rp উল্টো কাজ করে: SP-র ঘর থেকে নিচু byte, SP + 1 থেকে উঁচু byte, তারপর SP দুই বাড়ে। rp হতে পারে B (মানে BC), D (DE), H (HL) বা PSW; SP নিজে PUSH হয় না।
| Instruction | Opcode | কাজ | Machine cycle | T |
|---|---|---|---|---|
PUSH B, D, H, PSW | C5, D5, E5, F5 | [SP−1] ← উঁচু, [SP−2] ← নিচু, SP ← SP−2 | OF (৬ T), MW, MW | 12 |
POP B, D, H, PSW | C1, D1, E1, F1 | নিচু ← [SP], উঁচু ← [SP+1], SP ← SP+2 | OF, MR, MR | 10 |
সংকেত: OF = opcode fetch, MR = memory read, MW = memory write. PUSH-এর opcode fetch ৪-এর বদলে ৬ T-state, কারণ বাড়তি দুই T-এ SP-কে কমানো হয়; পুরো ছবি পর্ব ০৮ (8085-এর pin, machine cycle আর timing diagram)-এ। Opcode আর T-state কোর্সের simulator-এর টেবিলের সঙ্গে মেলানো (Spec decision 2). এবার LIFO নিয়মটি চোখে দেখি: বাজারঘরের স্মার্ট স্কেলের দুটি মান, net ওজন 1250 g = 04E2H আর দাম 8188 পয়সা = 1FFCH (81.88 টাকা, reference README-র “বাজারঘর devices”), দুটি PUSH আর দুটি POP.
1LXI SP,2800H2LXI B,04E2H3LXI D,1FFCH4PUSH B5PUSH D6POP B7POP D8HLT
| SP | |
| 27FC…27FF | |
| BC | |
| DE | |
| মোট T |
LXI SP,2800H, ১০ T. Stack-এর তলা ঠিক হলো। SP = 2800H, কিন্তু 2800H ঘরে কিছু লেখা হবে না: প্রথমPUSHআগে SP কমায়, তারপর লেখে।LXI B,04E2H. BC = 04E2H, net ওজন 1250 g. মোট ২০ T.LXI D,1FFCH. DE = 1FFCH, দাম 8188 পয়সা। মোট ৩০ T. Stack এখনো ছোঁয়া হয়নি।PUSH B, ১২ T. SP কমে 27FFH, সেখানে উঁচু byte04; আবার কমে 27FEH, সেখানে নিচু byteE2. SP = 27FEH. BC বদলায়নি:PUSHকপি রাখে, সরায় না।PUSH D, ১২ T. 27FDH ←1F, 27FCH ←FC, SP = 27FCH. চারটি byte এখনFC 1F E2 04, মোট ৫৪ T.POP B, ১০ T. 27FCH থেকে নিচু byteFCযায় C-তে, 27FDH থেকে1Fযায় B-তে: BC = 1FFCH. শেষে রাখা DE-র মান আগে বেরোল। SP = 27FEH. Memory-র byte মোছা হয়নি, শুধু SP সরেছে।POP D, ১০ T. 27FEH আর 27FFH থেকে DE = 04E2H, SP = 2800H, অর্থাৎ stack আবার খালি। মোট ৭৪ T.HLT, মোট ৭৯ T. BC আর DE জায়গা বদল করেছে, কোনো তৃতীয় register ছাড়াই। কোর্সের simulator-এর শেষ লাইন:27FCH: FC 1F E2 04,Instructions: 8 T-states: 79.
একটি জিনিস প্রায় সবাই প্রথমবার ভুল করে: POP memory মোছে না। ৬ আর ৭ নম্বর ধাপে 27FCH–27FFH-এর byte আগের মতোই আছে; শুধু SP সরে গিয়ে সেগুলোকে “মুক্ত” ঘোষণা করেছে। পরের PUSH এসে ওপরে লিখবে। তাই stack-এর পুরোনো byte দেখে কখনো ধরে নেবেন না যে সেটি এখনো বৈধ। নিচের ব্লকে একই program আপনার ব্রাউজারে চলে। এটি পাতার ভেতরে রাখা sim85.py ব্যবহার করে, যা কোর্সের reference sim8085.py-এর হুবহু কপি (শুধু command-line অংশ বাদ); প্রতিটি instruction-এর পরে SP আর stack-এর চারটি ঘর ছাপে।
# PUSH/POP চলার সময় SP আর stack-এর চারটি ঘর (sim85.py = reference sim8085.py-র কপি)
from sim85 import assemble, run, disasm_one, fmt_imm
SRC = """
ORG 2000H
LXI SP,2800H ; stack-এর তলা
LXI B,04E2H ; net ওজন 1250 g
LXI D,1FFCH ; দাম 8188 পয়সা
PUSH B
PUSH D
POP B ; শেষে রাখা জিনিস আগে বের হয়
POP D
HLT
"""
def watch(cpu, pc, op, cost):
text = fmt_imm(disasm_one(lambda a: cpu.mem[a], pc)[0])
box = " ".join(f"{cpu.mem[a]:02X}" for a in range(0x27FC, 0x2800))
print(f"{text:12} SP={cpu.SP:04X} [27FC..27FF]={box} "
f"BC={cpu.B:02X}{cpu.C:02X} DE={cpu.D:02X}{cpu.E:02X} T={cost}")
cpu = run(assemble(SRC), trace=watch)
print("মোট T-state:", cpu.tstates)আসল আউটপুট (ব্রাউজারের Python):
LXI SP,2800H SP=2800 [27FC..27FF]=00 00 00 00 BC=0000 DE=0000 T=10
LXI B,04E2H SP=2800 [27FC..27FF]=00 00 00 00 BC=04E2 DE=0000 T=10
LXI D,1FFCH SP=2800 [27FC..27FF]=00 00 00 00 BC=04E2 DE=1FFC T=10
PUSH B SP=27FE [27FC..27FF]=00 00 E2 04 BC=04E2 DE=1FFC T=12
PUSH D SP=27FC [27FC..27FF]=FC 1F E2 04 BC=04E2 DE=1FFC T=12
POP B SP=27FE [27FC..27FF]=FC 1F E2 04 BC=1FFC DE=1FFC T=10
POP D SP=2800 [27FC..27FF]=FC 1F E2 04 BC=1FFC DE=04E2 T=10
HLT SP=2800 [27FC..27FF]=FC 1F E2 04 BC=1FFC DE=04E2 T=5
মোট T-state: 79
প্রতিটি লাইন কোর্সের simulator-এর python -B sim8085.py trace push_pop.asm-এর সঙ্গে মেলে (SP, BC, DE আর মোট ৭৯ T). trace=watch দিয়ে simulator প্রতিটি instruction-এর পরে আমাদের ছোট function ডাকে; সেখানে cpu.mem থেকে stack-এর ঘর পড়া হয়। SRC-এ POP B আর POP D-এর ক্রম উল্টে চালিয়ে দেখুন: তখন BC আর DE নিজের মান ফেরত পায়, অদলবদল হয় না।
৩ · PUSH PSW আর POP PSW — A আর flag একসঙ্গে
চারটি register pair-এর চতুর্থটি একটু আলাদা: PSW (Program Status Word) = accumulator A উঁচু byte, আর flag register F নিচু byte. PUSH PSW A-কে SP − 1-এ আর F-কে SP − 2-এ লেখে। F-এর বিটের বিন্যাস S Z 0 AC 0 P 0 CY (Spec decision 3), তাই flag byte = S×80H + Z×40H + AC×10H + P×04H + CY×01H. কোনো subroutine A আর flag দুটোই বদলায়, কিন্তু ডাকা-পক্ষের সেগুলো দরকার, এমন হলে শুরুতে PUSH PSW আর শেষে POP PSW হলো আদর্শ জোড়া।
নিচের উদাহরণে 150 g আর 106 g যোগ হয়ে 256 g, যা ৮ বিটে আঁটে না: A = 00, আর চারটি flag একসঙ্গে ওঠে। তারপর অন্য একটি হিসাব flag নষ্ট করে, আর POP PSW সব ফিরিয়ে আনে (python -B sim8085.py trace psw.asm).
1LXI SP,2800H2MVI A,96H3ADI 6AH4PUSH PSW5MVI A,07H6ORA A7POP PSW8HLT
| A | |
| F | |
| S Z AC P CY | |
| SP | |
| 27FE 27FF | |
| মোট T |
LXI SP,2800H. Stack প্রস্তুত, SP = 2800H. সব flag 0, F = 00H.MVI A,96H, ৭ T. A = 96H, অর্থাৎ 150.MVIকোনো flag বদলায় না।ADI 6AH, ৭ T. 96H + 6AH = 100H. ৮ বিটে A = 00, carry বেরিয়ে CY = 1; নিচের nibble 6 + A = 10H থেকে AC = 1; ফল শূন্য, তাই Z = 1; শূন্য সংখ্যক 1 জোড়, তাই P = 1. F = 0101 0101b = 55H.PUSH PSW, ১২ T. 27FFH ← A =00, 27FEH ← F =55, SP = 27FEH. ঠিকPUSH B-এর মতো: উঁচু byte (A) বড় ঠিকানায়, নিচু byte (F) ছোট ঠিকানায়।MVI A,07H, ৭ T. A বদলে 07, কিন্তু flag এখনো 55H, কারণMVIflag ছোঁয় না।ORA A, ৪ T. এবার flag নষ্ট: 07H শূন্য নয় (Z = 0), তিনটি 1 বিজোড় (P = 0), আরORACY আর AC মুছে দেয়। F = 00H. ধরুন এটি কোনো subroutine-এর ভেতরের কাজ।POP PSW, ১০ T. 27FEH থেকে F =55, 27FFH থেকে A =00, SP = 2800H. A আর পাঁচটি flag ঠিক তৃতীয় ধাপের মতো।POP PSWflag-এর ৮টি বিটই হুবহু তোলে (Spec decision 3).HLT, মোট ৬২ T. Simulator-এর শেষ অংশ:Flags: S=0 Z=1 AC=1 P=1 CY=1 (F=55H)আর27FEH: 55 00. Carry থেকে বোঝা যায় যোগফল 256: ডাকা-পক্ষ এখন সেই তথ্য নিয়ে কাজ করতে পারে।
এই জোড়ার একটি চতুর ব্যবহার পরীক্ষায় প্রায়ই আসে: flag byte-কে সাধারণ register-এ পড়া। 8085-এ “MOV A,F” বলে কিছু নেই, কিন্তু PUSH PSW তারপর POP B লিখলে B পায় A-র মান আর C পায় F. সত্যিকারের run (flagread.asm, উপরের একই ADI-এর পরে): A=55 B=00 C=55, আর 2050H: 55. উল্টো দিকেও চলে: PUSH B তারপর POP PSW দিয়ে C-র যেকোনো মান flag-এ বসানো যায়। Stack আসলে register-এর মধ্যে ১৬ বিটের যেকোনো মান সরানোর একটি সাধারণ পথ।
SP নিজেও কয়েকটি instruction দিয়ে বদলানো যায়। পাঁচটি মনে রাখার মতো; T-state Intel-এর টেবিল থেকে, আর প্রতিটি কোর্সের simulator-এ চালিয়ে মেলানো (tcheck.asm):
| Instruction | কাজ | Byte | T |
|---|---|---|---|
LXI SP,2800H | SP ← 2800H (stack-এর জায়গা ঠিক করা) | 3 | 10 |
SPHL | SP ← HL | 1 | 6 |
XTHL | L ↔ [SP], H ↔ [SP+1]; SP বদলায় না | 1 | 16 |
INX SP, DCX SP | SP ± 1, কোনো flag বদলায় না | 1 | 6 |
DAD SP | HL ← HL + SP; শুধু CY বদলায় | 1 | 10 |
SP-র মান সরাসরি পড়ার কোনো instruction নেই। পড়তে হলে LXI H,0000H তারপর DAD SP: HL = SP. এই কৌশল পরের অংশে stack থেকে parameter পড়তে কাজে লাগবে।
৪ · CALL আর RET — ফেরার ঠিকানা stack-এ
পর্ব ১১ (8085 assembly program)-এর loop আর array-র program ছিল এক টানা কোড। কিন্তু একই কাজ, যেমন দুটি দাম যোগ করা বা কিছুক্ষণ অপেক্ষা করা, program-এর অনেক জায়গায় লাগে। প্রতিবার কোড কপি না করে একবার লিখে রাখা অংশকে বলে subroutine. সমস্যা একটাই: subroutine শেষে কোথায় ফিরবে? সে জানে না কে তাকে ডেকেছে। সমাধান CALL: লাফ দেওয়ার আগে সে return address, অর্থাৎ নিজের ঠিক পরের instruction-এর ঠিকানা, stack-এ PUSH করে। Subroutine-এর শেষে RET সেই ঠিকানা POP করে program counter-এ বসায়।
| Instruction | Byte | কাজ | Machine cycle | T |
|---|---|---|---|---|
CALL addr (CD) | 3 | stack ← পরের instruction-এর ঠিকানা; PC ← addr | OF (৬ T), MR, MR, MW, MW | 18 |
RET (C9) | 1 | PC ← stack-এর মাথার দুই byte; SP ← SP+2 | OF, MR, MR | 10 |
RST n | 1 | CALL-এর এক byte-এর রূপ, লক্ষ্য n × 8 | OF (৬ T), MW, MW | 12 |
CALL-এর পাঁচটি machine cycle-এর ক্রম (Intel 8085 manual): opcode fetch, যার বাড়তি দুই T-এ SP কমে; লক্ষ্যের নিচু byte পড়া; উঁচু byte পড়া; তারপর দুটি memory write, প্রথমে ফেরার ঠিকানার উঁচু byte, পরে নিচু byte. ফেরার ঠিকানা কোনটি? তিন byte পড়ার পরে PC যেখানে দাঁড়ায়, সেটি: 2008H-এর CALL-এর জন্য 200BH. RST n-এর কথা পর্ব ১৩ (8085-এর interrupt — TRAP, RST, SIM আর RIM)-এ, কারণ interrupt-ও ঠিক এভাবে PC-কে stack-এ রেখে ISR-এ যায়।
এবার একটি পূর্ণ উদাহরণ। বাজারঘরের তিনটি বিক্রির দাম, পয়সায়: 983 (150 g, 9.83 টাকা), 8188 (1250 g, 81.88 টাকা) আর 3275 (500 g, 32.75 টাকা), সবই README-র স্কেলের হিসাব থেকে। ১৬ বিটে 03D7H, 1FFCH, 0CCBH, little-endian ক্রমে 2050H থেকে রাখা। TOTAL subroutine তালিকা ঘুরে প্রতিটি দামের জন্য আরেকটি subroutine ADDW ডাকে, যা DE-তে একটি ১৬ বিটের দাম যোগ করে। এক subroutine-এর ভেতর থেকে আরেকটি ডাকা হলো nested subroutine. পুরো program (nested.asm):
2000 31 00 28 START: LXI SP,2800H
2003 21 50 20 LXI H,2050H ; parameter: তালিকার ঠিকানা
2006 0E 03 MVI C,03H ; parameter: কয়টি দাম
2008 CD 10 20 CALL TOTAL ; ফল DE-তে
200B EB XCHG
200C 22 60 20 SHLD 2060H
200F 76 HLT
2010 11 00 00 TOTAL: LXI D,0000H
2013 CD 1B 20 TNEXT: CALL ADDW ; DE += [HL], HL += 2
2016 0D DCR C
2017 C2 13 20 JNZ TNEXT
201A C9 RET
201B 7B ADDW: MOV A,E
201C 86 ADD M
201D 5F MOV E,A
201E 23 INX H
201F 7A MOV A,D
2020 8E ADC M
2021 57 MOV D,A
2022 23 INX H
2023 C9 RET
(কোর্সের assembler-এর listing থেকে, python -B sim8085.py asm nested.asm; লাইন নম্বরের ঘর বাদ।) নিচের stepper-এ শুধু stack যেসব মুহূর্তে বদলায়, সেগুলো; মানগুলো trace-এর ৪৫টি লাইন থেকে বাছাই করা।
12000H LXI SP,2800H22008H CALL TOTAL3200BH XCHG / SHLD / HLT42010H LXI D,0000H52013H CALL ADDW62016H DCR C / JNZ7201AH RET8201BH ADDW: ৮টি instruction92023H RET
| PC | |
| SP | |
| 27FC…27FF | |
| DE | |
| মোট T |
LXI SP,2800H. Stack খালি, SP = 2800H. এরপরLXI H,2050HআরMVI C,03Hদুটি parameter বসায়: তালিকার ঠিকানা আর দামের সংখ্যা।- 2008H-এ
CALL TOTAL, ১৮ T. তিন byte পড়ার পরে PC = 200BH; এটিই ফেরার ঠিকানা। 27FFH ←20, 27FEH ←0B, SP = 27FEH, PC = 2010H. মোট ৪৫ T. LXI D,0000H, তারপর 2013H-এCALL ADDW. যোগফল শূন্য থেকে শুরু। দ্বিতীয়CALLরাখে 2016H: 27FDH ←20, 27FCH ←16, SP = 27FCH. Stack-এ এখন দুটি ফেরার ঠিকানা, ছবি ১২.১-এর অবস্থা।ADDWচলে, তারপরRET. E + D7H = D7H, তারপর D + 03H + CY = 03H: DE = 03D7H = 983.RET27FCH আর 27FDH থেকে 2016H তোলে, SP = 27FEH. Stack-এর মাথায় আবার 200BH. মোট ১২৫ T.DCR C,JNZ, আবারCALL ADDW. C = 2, তাই লাফ। দ্বিতীয়CALL ADDWএকই ঠিকানা 2016H আবার একই দুই ঘরে লেখে, SP = 27FCH. মোট ১৫৭ T.- দ্বিতীয় দাম যোগ,
RET. 03D7H + 1FFCH = 23D3H. নিচু byte-এর যোগে carry (D7 + FC = 1D3H), যাADC Mউঁচু byte-এ নেয়। SP = 27FEH, মোট ২০৯ T. - তৃতীয়
CALL ADDWআরRET. 23D3H + 0CCBH = 309EH = 12446 পয়সা। SP আবার 27FEH, মোট ২৯৩ T. তিনবার ডাকা হলো, কিন্তু stack-এর গভীরতা কখনো ২-এর বেশি হয়নি। DCR C→ 0,JNZলাফ দেয় না (৭ T), 201AH-এRET. 27FEH আর 27FFH থেকে 200BH তোলা হলো, SP = 2800H: stack খালি, ঠিক শুরুর মতো। মোট ৩১৪ T.XCHG,SHLD 2060H,HLT.XCHG-এ HL = 309EH আর DE পায় HL-এর পুরোনো মান 2056H. 2060H-এ9E 30, অর্থাৎ 124.46 টাকা। Simulator:Instructions: 45 T-states: 339. Stack-এর ঘরে16 20 0B 20রয়ে গেছে, কিন্তু SP বলে সেগুলো আর বৈধ নয়।
শুধু CALL আর RET-এর লাইনগুলো আলাদা করে ছাপলে program-এর call tree চোখে পড়ে। নিচের ব্লকে লাইনের বাঁ দিকের ফাঁকা অংশ = সেই instruction-এর পরে stack-এ কয়টি ফেরার ঠিকানা আছে।
from sim85 import assemble, run, disasm_one, fmt_imm # শুধু CALL আর RET-এর লাইন ছাপা
SRC = """
ORG 2000H
START: LXI SP,2800H
LXI H,2050H ; তালিকার ঠিকানা
MVI C,03H ; কয়টি দাম
CALL TOTAL ; ফল DE-তে
XCHG
SHLD 2060H
HLT
TOTAL: LXI D,0000H
TNEXT: CALL ADDW ; DE += [HL] (16 বিট), HL += 2
DCR C
JNZ TNEXT
RET
ADDW: MOV A,E
ADD M
MOV E,A
INX H
MOV A,D
ADC M
MOV D,A
INX H
RET
"""
data = [b for p in (983, 8188, 3275) for b in (p & 0xFF, p >> 8)] # পয়সায় তিনটি দাম
def watch(cpu, pc, op, cost):
text = fmt_imm(disasm_one(lambda a: cpu.mem[a], pc)[0])
if text.startswith(("CALL", "RET")):
depth = (0x2800 - cpu.SP) // 2 # stack-এ কয়টি ফেরার ঠিকানা
top = f"মাথায় {cpu.mem[cpu.SP + 1]:02X}{cpu.mem[cpu.SP]:02X}H" if depth else "stack খালি"
print(f"{' ' * depth}{text:11} SP={cpu.SP:04X} {top} DE={cpu.D:02X}{cpu.E:02X}")
cpu = run(assemble(SRC), sets=[(0x2050, data)], trace=watch)
lo, hi = cpu.mem[0x2060], cpu.mem[0x2061]
print(f"2060H: {lo:02X} {hi:02X} = {hi << 8 | lo} পয়সা, {cpu.tstates} T-state")আসল আউটপুট (ব্রাউজারের Python):
CALL 2010H SP=27FE মাথায় 200BH DE=0000
CALL 201BH SP=27FC মাথায় 2016H DE=0000
RET SP=27FE মাথায় 200BH DE=03D7
CALL 201BH SP=27FC মাথায় 2016H DE=03D7
RET SP=27FE মাথায় 200BH DE=23D3
CALL 201BH SP=27FC মাথায় 2016H DE=23D3
RET SP=27FE মাথায় 200BH DE=309E
RET SP=2800 stack খালি DE=309E
2060H: 9E 30 = 12446 পয়সা, 339 T-state
depth = (0x2800 - cpu.SP) // 2: তলা থেকে SP যত নিচে, তত দুই-byte-এর জিনিস stack-এ। ADDW-এর প্রতিটি CALL একই ঘরে একই ঠিকানা 2016H রাখে, আর প্রতিটি RET-এর পরে মাথায় আবার 200BH, যা TOTAL-এর ফেরার পথ। DE-র তিনটি মান 03D7H, 23D3H, 309EH দেখায় যোগফল কীভাবে জমছে। ফল আর মোট ৩৩৯ T reference simulator-এর সঙ্গে হুবহু এক। এখানে data ;@set pragma-র বদলে run()-এর sets দিয়ে বসানো, তাই data-র লাইনের তিনটি দাম বদলে নিজের অর্ডার যোগ করে দেখতে পারেন।
শর্তযুক্ত CALL আর RET
JMP-এর যেমন আটটি শর্তযুক্ত রূপ আছে (পর্ব ০৯, 8085-এর instruction set), CALL আর RET-এরও তাই। শর্ত মিথ্যা হলে কিছু রাখা বা তোলা হয় না, শুধু PC পরের instruction-এ যায়, আর খরচ কম। T-state Spec decision 2-এর টেবিল থেকে, প্রতিটি চালিয়ে মেলানো।
| শর্ত | CALL (opcode) | RET (opcode) | কখন সত্য |
|---|---|---|---|
| NZ / Z | CNZ C4 / CZ CC | RNZ C0 / RZ C8 | Z = 0 / Z = 1 |
| NC / C | CNC D4 / CC DC | RNC D0 / RC D8 | CY = 0 / CY = 1 |
| PO / PE | CPO E4 / CPE EC | RPO E0 / RPE E8 | P = 0 / P = 1 |
| P / M | CP F4 / CM FC | RP F0 / RM F8 | S = 0 / S = 1 |
| খরচ | সত্য ১৮ T, মিথ্যা ৯ T | সত্য ১২ T, মিথ্যা ৬ T | শর্তহীন: CALL ১৮, RET ১০ |
একটি সূক্ষ্ম কথা: শর্তহীন RET ১০ T, কিন্তু শর্ত সত্য হলে RZ ১২ T. কারণ শর্তযুক্ত RET-এর opcode fetch ৬ T লম্বা; বাড়তি সময়ে CPU flag দেখে সিদ্ধান্ত নেয়। আরেকটি ফাঁদ নামে: CC মানে “carry থাকলে call”, আর CP মানে “plus হলে call”, তুলনা (compare) নয়; তুলনার instruction CMP আর CPI.
বাজারঘরের cold-room monitor-এর একটি অংশ ধরুন। Reading রাখা 1/16 °C এককে, তাই 8.00 °C = 128 = 80H; README-র নিয়মে “8.00 °C-এর ওপরে” মানে A ≥ 81H. CPI 81H-এর পরে CY = 0 মানে সীমা পেরিয়েছে, তাই CNC OVER. দুটি reading: 7.75 °C (7CH) আর 8.25 °C (84H). সত্যিকারের trace (condcall.asm, প্রাসঙ্গিক লাইন):
2009 FE 81 CPI 81H A=7C ... CY=1 T=7 total=41
200B D4 1A 20 CNC 201AH SP=2800 ... T=9 total=50
2010 FE 81 CPI 81H A=84 ... CY=0 T=7 total=70
2012 D4 1A 20 CNC 201AH SP=27FE ... T=18 total=88
201A 14 INR D D=01 ... T=4 total=92
201B C9 RET SP=2800 ... T=10 total=102
...
2060H: 01 Instructions: 15 T-states: 124
(লাইন ছোট রাখতে অন্য register “...” দিয়ে বাদ।) প্রথম CNC ৯ T নিয়ে পরের লাইনে গেল, SP অপরিবর্তিত; দ্বিতীয়টি ১৮ T নিয়ে 2015H stack-এ রেখে OVER-এ গেল। শেষে 2060H-এ ১: একটি reading সীমা পেরিয়েছে। পুরো alarm-এর নিয়মে (পরপর তিনটি reading) এই গণককে কীভাবে কাজে লাগাতে হয়, তা cold-room firmware-এর পর্বগুলোতে আসবে।
৫ · Parameter পাঠানো, register রক্ষা আর stack-এর ভুল
Subroutine-কে কাজের জিনিস দিতে হয় আর ফল ফেরত নিতে হয়। 8085-এ এর কোনো বাঁধা নিয়ম নেই; programmer নিজে একটি চুক্তি ঠিক করেন, যাকে আধুনিক ভাষায় বলে calling convention (তত্ত্ব আর আধুনিক ABI Programming Languages পর্ব ৭১-এ)। তিনটি প্রচলিত পথ:
- Register দিয়ে: সবচেয়ে দ্রুত।
TOTAL-এর মতো: HL-এ ঠিকানা, C-তে সংখ্যা, ফল DE-তে। সীমা: register মাত্র সাতটি। - নির্দিষ্ট memory ঘর দিয়ে: যেমন “parameter 2050H-এ, ফল 2060H-এ”। সহজ, কিন্তু একই subroutine-কে interrupt থেকে আবার ডাকা হলে আগের মান নষ্ট হতে পারে।
- Stack দিয়ে: ডাকা-পক্ষ
PUSHকরে, তারপরCALL. Subroutine-এর ভেতরে stack-এর মাথায় থাকে ফেরার ঠিকানা, তার ঠিক নিচে parameter: তাই ঠিকানা = SP + 2. ফেরার পরে ডাকা-পক্ষPOPদিয়ে parameter সরিয়ে stack পরিষ্কার করে।
তৃতীয় পথটি নিচের ব্লকে, নিজে বদলে চালানোর মতো করে। DOUBLE stack থেকে net ওজন 04E2H পড়ে দ্বিগুণ করে: LXI H,0002H আর DAD SP দিয়ে HL = SP + 2.
# Parameter stack-এ পাঠানো: নিজে বদলে চালান (sim85.py = reference-এর কপি)
from sim85 import cli
SRC = """
;@show 2060H 2
;@show 27FCH 4
ORG 2000H
LXI SP,2800H
LXI H,04E2H ; parameter: net 1250 g
PUSH H ; parameter stack-এ
CALL DOUBLE ; ফল DE-তে
POP H ; parameter সরিয়ে stack পরিষ্কার
XCHG
SHLD 2060H
HLT
DOUBLE: LXI H,0002H
DAD SP ; HL = SP + 2 = parameter-এর ঠিকানা
MOV E,M
INX H
MOV D,M ; DE = parameter
XCHG
DAD H ; HL = 2 x parameter
XCHG ; DE = ফল
RET
"""
cli(SRC) # cli(SRC, "trace") লিখলে প্রতিটি instruction-এর পরের অবস্থাআসল আউটপুট (ব্রাউজারের Python):
A=00 B=00 C=00 D=04 E=E2 H=09 L=C4 SP=2800 PC=2010
Flags: S=0 Z=0 AC=0 P=0 CY=0 (F=00H)
Memory 2060H..2061H:
2060H: C4 09
Memory 27FCH..27FFH:
27FCH: 0A 20 E2 04
Instructions: 17 T-states: 153
2060H-এ C4 09 = 09C4H = 2500, অর্থাৎ 1250 × 2. Stack-এর চারটি byte পুরো গল্প বলে: 27FEH–27FFH-এ parameter E2 04 (প্রথম PUSH H), আর 27FCH–27FDH-এ ফেরার ঠিকানা 0A 20 = 200AH (CALL). CALL-এর মুহূর্তে SP = 27FCH, তাই SP + 2 = 27FEH, ঠিক parameter-এর ঘর। শেষে SP = 2800H: ডাকা-পক্ষের POP H stack পরিষ্কার করেছে। Reference simulator একই ১৭টি instruction আর ১৫৩ T দেয় (param_stack.asm). cli(SRC, "trace") লিখে প্রতিটি ধাপ দেখুন।
Register-এর দায় কার, সেটিও চুক্তির অংশ। TOTAL C আর HL বদলে দেয়; ডাকা-পক্ষ এটা জানে, তাই আপত্তি নেই। কিন্তু reference lab-এর subroutine.asm-এ SQUARE B আর C ব্যবহার করে, আর ডাকা-পক্ষ চায় সেগুলো অক্ষত থাকুক; তাই SQUARE শুরুতে PUSH B আর শেষে POP B করে। আধুনিক ভাষায় প্রথম ধরনের register caller-saved (দরকার হলে ডাকা-পক্ষ নিজে বাঁচায়), দ্বিতীয় ধরনের callee-saved (ডাকা subroutine বাঁচিয়ে ফেরত দেয়)। 8085-এ প্রতিটি subroutine-এর মাথায় একটি মন্তব্য লেখার অভ্যাস করুন: কী নেয়, কী দেয়, কোন register নষ্ট করে।
এবার stack-এর দুটি ক্লাসিক ভুল, দুটিই কোর্সের simulator-এ সত্যিকারের run. প্রথম ভুল: POP ভুলে যাওয়া। SQUARE-এর একটি কপিতে POP B মুছে দেওয়া হলো, আর ডাকার আগে BC = 04E2H (bug_nopop.asm):
2008 CD 0F 20 CALL 200FH SP=27FE T=18 total=45
200F C5 PUSH B SP=27FC T=12 total=57
...
2018 C9 RET SP=27FE PC=04E2 T=10 total=292
04E2 00 NOP ...
04E3 00 NOP ...
...
runtime error: stopped after 1000000 instructions (no HLT reached?)
RET stack-এর মাথা থেকে দুই byte তোলে, আর সেখানে ছিল ফেরার ঠিকানা নয়, PUSH B-এর রাখা ওজন 04E2H! CPU 04E2H-এ লাফ দিল। সেখানে খালি memory, অর্থাৎ 00H, যা 8085-এ NOP. CPU হাজার হাজার NOP পেরিয়ে 2000H-এ পৌঁছে program আবার শুরু থেকে চালাল, আবার একই ভুল, আর এভাবে চলতে থাকল; simulator ১০ লাখ instruction-এর সীমায় থামল (Spec decision 11). STA 2050H একবারও চলেনি। নিয়মটি তাই কঠোর: subroutine-এর প্রতিটি পথে PUSH আর POP-এর সংখ্যা সমান, আর ক্রম উল্টো। মাঝপথে RZ দিয়ে আগে বেরোনোর পথ থাকলে, সেই পথেও।
দ্বিতীয় ভুল: SP না বসানো। LXI SP ছাড়া CALL করলে (bug_nosp.asm) simulator-এ program ঠিকই চলে, কারণ এখানে পুরো 64 KB-ই RAM: CALL 2009H SP=FFFE, আর FFFEH: 05 20. কিন্তু আসল যন্ত্রে FFFFH-এ ROM থাকতে পারে, বা কিছুই না থাকতে পারে। তখন ফেরার ঠিকানা লেখাই হয় না, আর RET যা পড়ে তা অর্থহীন। Simulator-এ চলা মানেই hardware-এ চলা নয়; memory map (পর্ব ২২-এ) মিলিয়ে SP বসানো programmer-এর কাজ।
Stack-এর সংঘর্ষ: 8085 কখনো সতর্ক করে না যে stack data বা program-এর ওপর এসে পড়েছে। খুব গভীর nesting, loop-এর ভেতরে POP ছাড়া PUSH, বা নিজেকেই বারবার ডাকা subroutine (recursion) SP-কে নামাতে নামাতে আপনার data-র ওপর লিখে দিতে পারে, যাকে বলে stack overflow. ছবি ১২.১-এ data 2060H-এ আর stack 27FCH-এ: মাঝে প্রায় 1.9 KB ফাঁকা, যা এই program-এর জন্য যথেষ্ট। Interrupt-ও stack ব্যবহার করে, তাই হিসাবে তার জায়গাও রাখুন।
৬ · Delay subroutine — T-state গুনে সময় বানানো
বাজারঘরের cold-room monitor প্রতি ১ সেকেন্ডে একটি reading নেয় (README). 8085-এ কোনো timer না থাকলে এই “১ সেকেন্ড অপেক্ষা” বানানোর সহজ উপায় হলো CPU-কে একটি loop-এ ঘুরিয়ে রাখা, যতক্ষণ না ঠিক ততগুলো T-state পার হয়। একে বলে software delay loop, আর এই ধরনের অপেক্ষা busy-wait. হিসাবের ভিত্তি একটাই: কোর্সের 8085 চলে 3 MHz clock-এ, যা 6 MHz crystal-কে CPU ভেতরে ২ দিয়ে ভাগ করে পায় (পর্ব ০৮). তাই একটি T-state = 1 ÷ 3 MHz = 0.333 µs, আর 1 ms = 3000 T, 1 s = 3,000,000 T.
৮ বিটের loop: 14N + 4
সবচেয়ে ছোট delay: MVI C,N / LOOP: DCR C / JNZ LOOP. হিসাব এভাবে: MVI একবার, ৭ T. প্রতিটি পাকে DCR C ৪ T আর JNZ লাফ দিলে ১০ T, মোট ১৪. কিন্তু শেষ পাকে C = 0, JNZ লাফ দেয় না, তাই ১০-এর বদলে ৭: তিন T কম। মোট = 7 + 14N − 3 = 14N + 4. নিচের stepper-এ N = 3, যাতে প্রতিটি T গোনা যায়।
12000H MVI C,03H22002H LOOP: DCR C32003H JNZ LOOP42006H HLT
| C | |
| Z | |
| এই instruction | |
| মোট T | |
| সময় |
MVI C,03H, ৭ T. গণক C = 3. এটি loop-এর বাইরে, একবারই চলে। মোট ৭ T = 2.33 µs.- প্রথম
DCR C, ৪ T. C = 2, শূন্য নয়, তাই Z = 0.DCRZ বদলায়, CY ছোঁয় না (Spec decision 4). মোট ১১. JNZ LOOP, ১০ T. Z = 0, তাই লাফ দিয়ে 2002H-এ। প্রথম পাকের খরচ 4 + 10 = 14 T. মোট ২১.- দ্বিতীয়
DCR C. C = 1, Z = 0. মোট ২৫. - আবার
JNZ, ১০ T. আরও একটি পূর্ণ পাক, ১৪ T. মোট ৩৫. - তৃতীয়
DCR C. C = 0, এবার Z = 1. মোট ৩৯. JNZলাফ দেয় না, ৭ T. Intel-এর টেবিলে শর্ত মিথ্যা হলেJNZ৭ T (Spec decision 2). শেষ পাক তাই 4 + 7 = 11 T, পূর্ণ পাকের চেয়ে তিন কম। Loop-এর মোট ৪৬ T, আর সূত্র 14 × 3 + 4 = 46 মেলে।HLT, ৫ T. Simulator-এর শেষ লাইন:Instructions: 8 T-states: 51= 46 + 5. 3 MHz-এ পুরো delay মাত্র 15.33 µs; কাজের সময় পেতে N অনেক বড় লাগবে।
সবচেয়ে বড় N = 0FFH = 255: 14 × 255 + 4 = 3574 T = 1191.33 µs, যা reference lab-এর delay.asm-এর ফলের সঙ্গে হুবহু এক (README). একটি ফাঁদ: MVI C,00H দিলে loop শূন্যবার নয়, ২৫৬ বার ঘোরে, কারণ প্রথম DCR 00H-কে FFH বানায়: 14 × 256 + 4 = 3588 T (simulator: delay_n0.asm, HLT-সহ 3593).
যেকোনো delay loop-এর সূত্র তিন ভাগে লিখুন: loop-এর বাইরের স্থির খরচ, প্রতি পাকের খরচ × N, আর শেষ পাকে লাফ না দেওয়ার ছাড় (−3 T). তারপর দরকারি T-state = সময় × clock, আর N = (দরকারি T − স্থির খরচ) ÷ প্রতি পাকের খরচ।
কাজের উদাহরণ ১ — হুবহু 1 ms
- দরকারি T-state: 1 ms × 3 MHz = 0.001 s × 3,000,000 Hz = 3000 T.
- শুধু loop (HLT ছাড়া): 14N + 4 = 3000 → N = 2996 ÷ 14 = 214 = D6H. ভাগ মিলে যায়, তাই হুবহু 3000 T. Simulator:
delay8.asm, N = 214,T-states: 3005= 3000 + HLT-এর ৫. - Subroutine হিসেবে: এবার
CALL DELAY(১৮ T) আর শেষেRET(১০ T) খরচে যোগ হয়: 18 + 7 + 14N − 3 + 10 = 14N + 32. 14N + 32 = 3000 → N = 2968 ÷ 14 = 212 = D4H. Simulator-এ (delay1ms.asm) মোট 3015 T, তা থেকেLXI SP-এর ১০ আরHLT-এর ৫ বাদ দিলে ঠিক 3000 T = 1.000 ms.
লক্ষ্য করুন, একই 1 ms-এর জন্য দুই রকম N: শুধু loop গুনলে 214, পুরো CALL-থেকে-ফেরা গুনলে 212. পরীক্ষায় উত্তর লেখার আগে প্রশ্নটি কোনটি চাইছে, তা দেখে নিন, আর নিজের সূত্রে কী কী ধরেছেন, তা লিখে দিন।
১৬ বিটের loop: 24N + 7
৮ বিটের loop সর্বোচ্চ প্রায় 1.2 ms দেয়। বড় delay-এর জন্য register pair: LXI B,N / LOOP: DCX B / MOV A,C / ORA B / JNZ LOOP. এখানে একটি ফাঁদ আছে: DCX কোনো flag বদলায় না, তাই BC শূন্য হলো কি না জানতে C আর B-কে ORA করতে হয়; ফল শূন্য কেবল তখনই, যখন দুটিই 00. খরচ: LXI ১০ T; প্রতি পাক 6 + 4 + 4 + 10 = 24; শেষ পাকে −3. মোট = 10 + 24N − 3 = 24N + 7. N = 1000 হলে 24007 T = 8002.33 µs, README-র delay16.asm-এর ফলের সঙ্গে হুবহু এক। সর্বোচ্চ N = 0FFFFH: 24 × 65535 + 7 = 1,572,847 T ≈ 524.28 ms (simulator: delay_ffff.asm, HLT-সহ 1,572,852).
ভালো delay subroutine ডাকা-পক্ষের কোনো register নষ্ট করে না। তাই শুরুতে PUSH B আর PUSH PSW, শেষে উল্টো ক্রমে POP PSW আর POP B. এই চারটি নিয়ে খরচ: 18 (CALL) + 12 + 12 + 10 + 24N − 3 + 10 + 10 + 10 (RET) = 24N + 79. নিচের ব্লক দরকারি সময় থেকে N বের করে, তারপর সেই subroutine simulator-এ চালিয়ে আসল T-state মাপে।
# Delay subroutine-এর N হিসাব, তারপর simulator-এ চালিয়ে যাচাই (3 MHz: 1 T = 1/3 µs)
from sim85 import assemble, run
F_CLK = 3_000_000 # 6 MHz crystal ÷ 2 (reference README)
LOOP8 = "MVI C,{n}\nDL: DCR C\n JNZ DL\n"
LOOP16 = "LXI B,{n}\nDL: DCX B\n MOV A,C\n ORA B\n JNZ DL\n"
KINDS = { # নাম: (subroutine-এর দেহ, এক পাকের T, স্থির T = CALL + বাকি সব)
"8-বিট, CALL সহ": (LOOP8 + " RET", 14, 32),
"16-বিট, PUSH/POP সহ": (" PUSH B\n PUSH PSW\n " + LOOP16 + " POP PSW\n POP B\n RET", 24, 79),
}
def measure(body, n): # CALL থেকে RET-এর পর পর্যন্ত আসল T-state
src = f" ORG 2000H\n LXI SP,2800H\n CALL D\n HLT\nD: {body.format(n=n)}\n"
return run(assemble(src)).tstates - 10 - 5 # LXI SP আর HLT বাদ
for want_us, kind in [(1000, "8-বিট, CALL সহ"), (500, "8-বিট, CALL সহ"),
(10_000, "16-বিট, PUSH/POP সহ")]:
body, per, fixed = KINDS[kind]
need = want_us * F_CLK // 1_000_000 # দরকারি T-state
n = round((need - fixed) / per)
t = measure(body, n)
print(f"{want_us:>6} µs, {kind}: N = {n} ({n:04X}H)")
print(f" সূত্র {per}N+{fixed} = {per * n + fixed} T, simulator = {t} T, "
f"সময় = {t * 1e6 / F_CLK:.2f} µs")আসল আউটপুট (ব্রাউজারের Python):
1000 µs, 8-বিট, CALL সহ: N = 212 (00D4H)
সূত্র 14N+32 = 3000 T, simulator = 3000 T, সময় = 1000.00 µs
500 µs, 8-বিট, CALL সহ: N = 105 (0069H)
সূত্র 14N+32 = 1502 T, simulator = 1502 T, সময় = 500.67 µs
10000 µs, 16-বিট, PUSH/POP সহ: N = 1247 (04DFH)
সূত্র 24N+79 = 30007 T, simulator = 30007 T, সময় = 10002.33 µs
প্রতিটি সারিতে সূত্র আর simulator এক। ১ ms-এ হুবহু 3000 T, কারণ 2968 চোদ্দ দিয়ে ভাগ যায়। 500 µs-এ দরকার 1500 T, কিন্তু (1500 − 32) ÷ 14 = 104.86, পূর্ণসংখ্যা নয়; কাছের N = 105 দেয় 1502 T, অর্থাৎ 0.67 µs বেশি। 10 ms-এ N = 1247 = 04DFH, ফল 30007 T, 2.33 µs বেশি, আর ডাকার আগের BC আর A অক্ষত (simulator-এর delay10ms.asm-এ ডাকার আগে BC = 1111H, A = 22H, ফেরার পরেও তাই)। এই সূত্রগুলো লেখকের lab-এ ৮৩১টি আলাদা N আর M-এ simulator চালিয়ে মেলানো হয়েছে, একটিও অমিল নেই (verify_delay.py).
কাজের উদাহরণ ২ — cold room-এর 1 s, nested loop
3,000,000 T একটি ১৬ বিটের loop-এ আঁটে না (সর্বোচ্চ প্রায় 1.57 মিলিয়ন)। সমাধান loop-এর ভেতরে loop: বাইরে D-তে ৮ বিটের গণক M, ভেতরে BC-তে N.
MVI D,100 ; 7 T, একবার
OUTER: LXI B,1249 ; 10 T ┐
INNER: DCX B ; 6 T ┐ │
MOV A,C ; 4 T │ │ প্রতি বাইরের পাক
ORA B ; 4 T │ │ = 24N + 21
JNZ INNER ; 10/7 ┘ │
DCR D ; 4 T │
JNZ OUTER ; 10/7 T ┘
- ভেতরের loop:
DCXথেকেJNZ INNERপর্যন্ত 24N − 3 T. - একটি বাইরের পাক: 10 (
LXI) + 24N − 3 + 4 (DCR) + 10 (JNZ) = 24N + 21. - মোট: 7 + M × (24N + 21) − 3 = M(24N + 21) + 4; শেষ বাইরের পাকে
JNZ OUTER৭ T, তাই −3. - সংখ্যা বসানো: M = 100 ধরলে 24N + 21 ≈ 30000 → N = 1249 (1250 দিলে 1.0007 s, একটু বেশি)। মোট = 100 × 29997 + 4 = 2,999,704 T.
- সময়: 2,999,704 × 0.333 µs = 999,901.33 µs ≈ 0.99990 s; ভুল −296 T, অর্থাৎ প্রায় 0.01 %. Simulator (
delay1s.asm):Instructions: 499902 T-states: 2999709= 2,999,704 + HLT-এর ৫.
লক্ষ করুন, এক সেকেন্ড অপেক্ষার জন্য CPU প্রায় পাঁচ লাখ instruction চালাল, যার একটিও কাজের নয়। এই সময়ে cold room-এর alarm বাজানো, স্কেলের button দেখা, কিছুই হয় না। তাই বাস্তব যন্ত্রে দীর্ঘ delay-এর কাজ দেওয়া হয় hardware timer-কে: 8085-এর সঙ্গে 8253/8254 (পর্ব ২৫), আর আধুনিক microcontroller-এ নিজস্ব timer আর SysTick (পর্ব ৪৪, Timer আর counter). Software delay টিকে থাকে খুব ছোট, নিখুঁত অপেক্ষার জন্য, যেমন কোনো chip-এর datasheet-এ লেখা “লেখার পরে অন্তত কয়েক µs অপেক্ষা করুন”।
আরও গভীরে: Delay-এর হিসাব তিনটি অনুমানের ওপর দাঁড়িয়ে, যা Spec decision 2-এ স্পষ্ট লেখা: কোনো wait state নেই, কোনো interrupt নেই, আর clock ঠিক 3 MHz. আসল 8085-এ ধীর memory READY pin নামিয়ে প্রতিটি memory cycle-এ বাড়তি T যোগ করে, তখন প্রতি পাকের ১৪ T আর ১৪ থাকে না; delay চলার মাঝে interrupt এলে ISR-এর পুরো সময় delay-এ যোগ হয়। অনেক পাঠ্যবই 6.144 MHz crystal ধরে (তখন clock 3.072 MHz), কেউ আবার 2 MHz; সূত্র একই থাকে, শুধু একটি T-state-এর মান বদলায়। আর CALL-এর ৬ T-এর opcode fetch-এর বাড়তি দুই T-এ ভেতরের incrementer/decrementer SP কমিয়ে রাখে, যাতে পরের দুটি memory write সঙ্গে সঙ্গে শুরু হতে পারে।
পরীক্ষা ও ইন্টারভিউতে: বিশ্ববিদ্যালয়, চাকরি বা ইন্টারভিউর পরীক্ষায় এই ধরনের প্রশ্ন প্রায়ই আসে:
- SP = 2800H, BC = 04E2H;
PUSH B-এর পরে কী? SP = 27FEH, [27FFH] = 04, [27FEH] = E2. CALLআরJMP-এর পার্থক্য? দুটিই PC-তে লক্ষ্য বসায়, কিন্তুCALLআগে ফেরার ঠিকানা stack-এ রাখে; ১৮ বনাম ১০ T.- 8 বিটের delay loop-এ N = FFH, clock 3 MHz: সময় কত? 14 × 255 + 4 = 3574 T × 0.333 µs = 1191.33 µs.
PUSH PSWকী রাখে? A বড় ঠিকানায় (SP − 1), flag byte ছোট ঠিকানায় (SP − 2).- 16 বিটের loop-এ
MOV A,CআরORA Bকেন?DCXকোনো flag বদলায় না; BC = 0 কি না Z flag দিয়ে জানতে এই দুটি লাগে।
Subroutine-এর ধারণা কম্পিউটারের প্রায় শুরু থেকেই। ১৯৪৯–৫১ সালে কেমব্রিজের EDSAC-এ David Wheeler একটি কৌশল ব্যবহার করেন, পরে যার নাম হয় “Wheeler jump”: ডাকা routine নিজের শেষ instruction-এ ফেরার ঠিকানা লিখে দিত, কারণ তখন stack ছিল না। Intel-এর 8008 (১৯৭২) ফেরার ঠিকানা রাখত chip-এর ভেতরের একটি ছোট address stack-এ, যার গভীরতা সীমিত (নথিমতে ৮ স্তর, যার একটি চলতি PC নিজে), তাই nesting-এর সীমা ছিল। 8080 (১৯৭৪) stack-কে বাইরের memory-তে নিয়ে আসে আর ১৬ বিটের SP যোগ করে, ফলে nesting-এর সীমা শুধু RAM-এর মাপ। 8085 (১৯৭৬) এই নকশা হুবহু রেখেছে; এজন্যই কোর্সের simulator-এর stack-এর আচরণ একটি স্বাধীন 8080 emulator-এর সঙ্গে মিলিয়ে দেখা যায় (README, cross-check).
৭ · AI-এর যুগে stack আর delay-এর হিসাব যাচাই
AI assistant 8085-এর delay subroutine বা stack-এর trace মুহূর্তে লিখে দেয়, আর লেখাটি দেখতে নিখুঁত লাগে। কিন্তু এই বিষয়ে তার ভুলগুলো খুব নির্দিষ্ট, আর প্রায় সবই এক মিনিটের simulator run-এ ধরা পড়ে:
| AI প্রায়ই যা করে | কীভাবে ধরবেন |
|---|---|
ভুল T-state: CALL ১৭, PUSH ১১, RET শর্তসহ সবসময় ১০ | Simulator-এর T= ঘর; Intel-এর টেবিল (১৮, ১২, ১২/৬) |
Delay সূত্রে শেষ পাকের −3 বাদ দেওয়া, বা CALL/RET যোগ করা-না-করা গুলিয়ে ফেলা | ছোট N (যেমন 3) দিয়ে trace চালিয়ে প্রতিটি T গুনুন |
8086-এর মতো লেখা: PUSH AX, RET 2, বা 8085-এ এক byte PUSH করা | Assembler-এর error; 8085-এ শুধু B, D, H, PSW |
| “SP খালি ঘর দেখায়” বা “stack ওপরের দিকে বাড়ে” বলা | একটি PUSH চালিয়ে SP আর memory দেখুন |
Subroutine-এর আগে-বেরোনোর পথে (RZ) POP ভুলে যাওয়া | প্রতিটি RET-এর আগে SP শুরুর মানে ফিরেছে কি না trace-এ দেখুন |
| Clock না বলে সময় দেওয়া, বা crystal-এর frequency-কে CPU clock ধরা | সূত্রে clock লিখুন: 6 MHz crystal → 3 MHz, 1 T = 0.333 µs |
AI-কে কাজে লাগাতে আগে প্রসঙ্গ, অনুমান আর যাচাইয়ের পথ বলে দিন:
AI-এর উত্তর হাতে পেলে — যাচাইয়ের চেকলিস্ট
ভাবনার প্রশ্ন
প্রতিটি প্রশ্ন নিয়ে নিজে কিছুক্ষণ ভাবুন, তারপর “→ উত্তর” চাপুন।
প্র ০১8085-এর stack নিচের ঠিকানার দিকে বাড়ে, আর SP সবশেষে লেখা byte-টি দেখায়। অন্য কোনো নকশা কি সম্ভব ছিল, আর কোন CPU কী বেছে নিয়েছে?
দুটি আলাদা সিদ্ধান্ত এখানে। প্রথমটি দিক: stack বড় ঠিকানা থেকে ছোটর দিকে বাড়বে (descending), নাকি উল্টো (ascending). দ্বিতীয়টি SP-র অর্থ: SP সবশেষে লেখা ঘর দেখাবে (full), নাকি পরের খালি ঘর (empty). 8085 “full descending”: PUSH আগে SP কমায়, তারপর লেখে। চারটি সমন্বয়ের সবকটিই কোনো না কোনো CPU-তে দেখা গেছে, তাই এটি প্রকৃতির নিয়ম নয়, নকশাকারীর পছন্দ।
Descending বেছে নেওয়ার একটি বাস্তব যুক্তি memory-র ব্যবহার। ছোট যন্ত্রে program আর স্থির data রাখা হয় memory-র নিচের দিকে, আর সেগুলো বড় হয় ওপরের দিকে। Stack যদি RAM-এর একেবারে ওপরে বসে নিচের দিকে নামে, তাহলে দুই পক্ষ মাঝখানের পুরো ফাঁকা জায়গা ভাগ করে নিতে পারে; আগে থেকে ঠিক করতে হয় না কার কত লাগবে। ছবি ১২.১-এ ঠিক এই ছবি: data 2060H-এ, stack 27FCH-এ, মাঝে প্রায় 1.9 KB.
অন্য পথের একটি পরিচিত উদাহরণ Intel-এরই 8051 microcontroller: সেখানে stack ওপরের দিকে বাড়ে, আর reset-এর পরে SP = 07H, অর্থাৎ ছোট ভেতরের RAM-এর একেবারে শুরুর দিকে। 8051-এর ভেতরের RAM মাত্র কয়েকশো byte, আর register bank-এর ঠিক পরেই stack শুরু, তাই সেখানে ওপরের দিকে বাড়াই স্বাভাবিক লেগেছে। আধুনিক ARM Cortex-M আবার full descending, 8085-এর মতো: reset-এর সময় CPU vector table-এর প্রথম শব্দ থেকে SP নেয়, যা সাধারণত SRAM-এর শেষ ঠিকানা; কোর্সের বাজারঘর board-এ তা 0x20005000 (README-র memory map).
Full বনাম empty-র পার্থক্য পরীক্ষায় ফাঁদ হয়ে আসে। 8085-এ SP = 27FEH মানে 27FEH-এ বৈধ data আছে; পরের PUSH লিখবে 27FDH-এ। কেউ যদি ভাবেন SP খালি ঘর দেখায়, তার প্রতিটি হিসাব এক byte সরে যাবে। এই ধরনের ভুল ধরার সহজ পথ একটাই: একটি PUSH চালিয়ে simulator-এ memory দেখা।
মূল উপলব্ধি: Stack-এর দিক আর SP-র অর্থ নকশার চুক্তি; 8085 আর Cortex-M full descending, 8051 ascending; যে CPU নিয়েই কাজ করুন, প্রথম PUSH-এর পরে memory দেখে চুক্তিটি নিশ্চিত করুন।
প্র ০২8085 প্রতিটি CALL-এ ফেরার ঠিকানা memory-তে লেখে, যা ১৮ T নেয়। RISC-V বা ARM-এর মতো “link register”-এ রাখলে কি ভালো হতো না?
খরচের হিসাবে প্রশ্নটি ন্যায্য। 8085-এর CALL-এর পাঁচটি machine cycle-এর দুটি memory write, শুধু ফেরার ঠিকানা লিখতে; RET-এর দুটি memory read সেটি ফেরত আনতে। JMP ১০ T, CALL ১৮ T, আর RET আরও ১০ T. যে subroutine নিজে আর কাউকে ডাকে না, তার ক্ষেত্রে ঠিকানাটি একটি register-এ রেখে দিলেই চলত।
RISC নকশা ঠিক এটাই করে। RISC-V-এর jal ফেরার ঠিকানা রাখে ra register-এ, আর ARM-এর BL রাখে LR (link register)-এ; কোনো memory-র কাজ নেই। যে function আর কাউকে ডাকে না, তাকে বলে leaf function, আর বাস্তব program-এ এমন function অনেক। শুধু যে function নিজে আরেকটি ডাকবে, সে নিজের LR-কে stack-এ বাঁচিয়ে রাখে। এতে সাধারণ ক্ষেত্রে সময় বাঁচে, আর দাম দিতে হয় compiler-এর একটু বাড়তি সতর্কতায়। এর বিস্তারিত Computer Architecture পর্ব ৩০-এ।
তাহলে 8080 আর 8085 কেন সবসময় memory? প্রথমত register-এর অভাব: মাত্র সাতটি ৮ বিটের register, তার একটি জোড়া স্থায়ীভাবে ফেরার ঠিকানার জন্য রেখে দেওয়া বিলাসিতা। দ্বিতীয়ত সরলতা: assembly-তে হাতে program লেখা হতো, আর “CALL সব সামলায়” নিয়মে ভুলের সুযোগ কম। নেস্টিং-এর গভীরতা নিয়ে programmer-কে ভাবতেই হয় না, যতক্ষণ RAM আছে। তৃতীয়ত interrupt: hardware interrupt যেকোনো মুহূর্তে আসতে পারে, আর তারও ফেরার ঠিকানা লাগে; সবকিছু একই stack-এ গেলে নিয়ম একটাই থাকে (পর্ব ১৩)।
মজার বিষয়, ARM Cortex-M দুই পথই মেলায়। সাধারণ function call-এ LR, কিন্তু exception বা interrupt এলে hardware নিজেই আটটি register stack-এ রাখে, যাতে C-তে লেখা ISR সাধারণ function-এর মতো চলে। প্রতিটি নকশা নিজের যুগের transistor আর register-এর বাজেট মেনে চলেছে।
মূল উপলব্ধি: ফেরার ঠিকানা memory-তে রাখা সরল আর সবসময় নিরাপদ, register-এ রাখা দ্রুত কিন্তু nesting-এ বাড়তি কাজ চায়; 8085 সরলতা বেছেছিল, আধুনিক RISC গতি।
প্র ০৩Software delay loop 3 MHz-এ নিখুঁত হিসাব দেয়। তবু বাস্তব firmware-এ দীর্ঘ delay-এর জন্য এটি কেন খারাপ পছন্দ?
প্রথম কারণ অপচয়। এই পর্বের ১ সেকেন্ডের delay চালাতে CPU প্রায় পাঁচ লাখ instruction চালিয়েছে (Instructions: 499902), যার একটিও কাজের নয়। এই পুরো সময় বাজারঘরের cold-room monitor তাপমাত্রার alarm দেখতে পারে না, button-এর চাপ ধরতে পারে না, আর CPU পুরো শক্তি খরচ করে চলতে থাকে। Battery-চালিত যন্ত্রে শেষ কথাটি সবচেয়ে বড়: অপেক্ষার সময় CPU-কে ঘুম পাড়িয়ে রাখার সুযোগ নষ্ট।
দ্বিতীয় কারণ ভঙ্গুরতা। Delay-এর সঠিকতা তিনটি অনুমানের ওপর: clock ঠিক 3 MHz, কোনো wait state নেই, আর কোনো interrupt আসবে না। যন্ত্রের crystal বদলালে, ধীর memory লাগালে, বা একটি interrupt যোগ করলে সব হিসাব বদলে যায়, অথচ কোড একটুও বদলায়নি। Interrupt-এর ক্ষেত্রে সমস্যা আরও সূক্ষ্ম: delay-এর মাঝে ISR চললে তার পুরো সময় delay-এ যোগ হয়, আর কতবার আসবে তা আগে থেকে জানা যায় না। একই program নতুন CPU-তে চালালে, যেখানে instruction দ্রুত, delay ছোট হয়ে যায়।
সমাধান hardware timer: একটি আলাদা counter clock গুনতে থাকে, আর সময় পূর্ণ হলে flag তোলে বা interrupt দেয়। 8085-এর যুগে এই কাজ করত 8253/8254 programmable timer (পর্ব ২৫)। আধুনিক Cortex-M-এ SysTick: কোর্সের reference lab-এর blink.c-এ SysTick-এর LOAD = 8,000,000/1000 − 1 = 7999, যা 8 MHz-এ প্রতি 1 ms-এ একটি interrupt দেয়, আর মাঝের সময় CPU WFI দিয়ে ঘুমায়। Simulator-এ LED ঠিক 500 ms পরপর জ্বলে-নেভে, আর CPU-র প্রায় সব সময় ঘুমে কাটে।
তবু software delay হারিয়ে যায়নি। খুব ছোট, নির্দিষ্ট অপেক্ষার জন্য, যেমন datasheet বলছে “একটি command-এর পরে অন্তত কয়েক µs অপেক্ষা করুন”, timer চালু করার ঝামেলার চেয়ে কয়েকটি instruction-এর loop সহজ। Bootloader বা ঘড়ি চালু হওয়ার আগের কোডেও এটি কাজে লাগে। তখনো নিয়ম একটাই: ছোট N দিয়ে trace চালিয়ে সূত্র যাচাই, আর clock কত ধরেছেন তা কোডের মন্তব্যে লেখা।
মূল উপলব্ধি: Delay loop সময় মাপে না, instruction গোনে; তাই ছোট আর নিখুঁত অপেক্ষায় এটি চলে, কিন্তু দীর্ঘ বা নির্ভরযোগ্য সময়ের জন্য hardware timer আর interrupt লাগে।
প্র ০৪8085-এ parameter কোথায় যাবে আর কোন register কে বাঁচাবে, তার কোনো বাঁধা নিয়ম নেই। বড় program-এ এর ফল কী, আর মানুষ কীভাবে সমাধান করেছিল?
ছোট program-এ নিয়ম না থাকা সুবিধা: প্রতিটি subroutine নিজের কাজের জন্য সবচেয়ে সুবিধাজনক register বেছে নেয়। TOTAL HL-এ ঠিকানা আর C-তে সংখ্যা নেয়, কারণ MOV A,M আর DCR C ঠিক এগুলোই চায়। কিন্তু program বড় হলে, বা কয়েকজন মিলে লিখলে, প্রতিটি subroutine-এর চুক্তি আলাদা মনে রাখতে হয়। একজন ধরে নিলেন DELAY BC ছোঁয় না, আরেকজন লিখলেন BC দিয়ে loop; ফল হলো এমন একটি bug যা শুধু নির্দিষ্ট পথে ধরা দেয়।
৭০-এর দশকের শেষের দিকে 8080/8085/Z80-এর জগতে সবচেয়ে প্রভাবশালী সমাধান এসেছিল অপারেটিং সিস্টেম CP/M থেকে। তার BDOS নামের সেবা-অংশ ডাকার নিয়ম ছিল সরল আর স্থির: C register-এ সেবার নম্বর, DE-তে parameter (যেমন কোনো লেখার ঠিকানা), তারপর CALL 0005H. হাজার হাজার program এই এক নিয়ম মেনে একই OS-এ চলত। অর্থাৎ hardware নিয়ম না দিলেও software-এর জগৎ নিজেই একটি calling convention তৈরি করে নিয়েছিল।
Register বাঁচানোর দায়ও দুই রকমে ভাগ হয়। এক, ডাকা subroutine সব কিছু বাঁচায় (PUSH সব, শেষে POP সব): নিরাপদ, কিন্তু প্রতিটি ডাকে বাড়তি খরচ; এই পর্বের ১০ ms delay-এ PUSH/POP-এর চারটি instruction মিলে ৪৪ T. দুই, ডাকা-পক্ষ নিজের দরকারি register বাঁচায়: দ্রুত, কিন্তু প্রতিটি ডাকার জায়গায় মনে রাখতে হয়। আধুনিক ABI দুটো মিশিয়ে register-কে দুই দলে ভাগ করে। ARM-এর AAPCS-এ প্রথম চারটি argument যায় r0–r3-এ, ফল r0-তে, আর r4–r11 callee-saved; C compiler এই নিয়ম মানে, তাই আলাদা compiler-এ লেখা কোডও একসঙ্গে চলে (Programming Languages পর্ব ৭১)।
8085-এ কাজ করার সময় তাই নিজের ছোট ABI লিখে ফেলুন: প্রতিটি subroutine-এর মাথায় তিন লাইনের মন্তব্য, “নেয়: HL = তালিকা, C = সংখ্যা। দেয়: DE = যোগফল। নষ্ট করে: A, flag, C, HL.” পরীক্ষার খাতায় এই তিন লাইন program-এর মান বাড়ায়, আর বাস্তব কাজে ঘণ্টার পর ঘণ্টার debugging বাঁচায়।
মূল উপলব্ধি: নিয়মহীন স্বাধীনতা ছোট program-এ চলে, বড় program-এ চুক্তি লাগে; CP/M থেকে AAPCS পর্যন্ত calling convention সেই চুক্তিরই লিখিত রূপ।
প্র ০৫8085 stack overflow ধরতে পারে না। আধুনিক microcontroller কীভাবে এই বিপদ সামলায়, আর এমবেডেড firmware-এ stack-এর মাপ কেন এত গুরুত্বপূর্ণ?
8085-এর কাছে stack শুধু SP-র একটি সংখ্যা। SP কমতে কমতে data বা program-এর এলাকায় ঢুকে পড়লে CPU নির্বিকারে সেখানে লেখে। এই পর্বের POP ভুলে যাওয়ার run দেখিয়েছে, ভুলটি কোনো error ছাড়াই program-কে অদ্ভুত পথে পাঠায়: RET ওজনের মান 04E2H-কে ঠিকানা ভেবে লাফ দিল, আর program বারবার শুরু থেকে চলল। এমন bug খুঁজে পাওয়া কঠিন, কারণ ফলটি দেখা যায় ভুলের জায়গা থেকে অনেক দূরে।
এমবেডেড যন্ত্রে বিপদ আরও বড়, কারণ RAM ছোট আর যন্ত্র বছরের পর বছর চলে। Desktop OS stack শেষ হলে program থামিয়ে বার্তা দেয়; microcontroller-এ কেউ পর্দার সামনে নেই। কোনো বিরল পথে, যেমন একটি interrupt-এর ভেতরে আরেকটি interrupt, stack একটু বেশি নামল আর একটি global চলক নষ্ট হলো: cold room-এর alarm-এর সীমা হঠাৎ বদলে গেল, আর কেউ জানল না। তাই firmware-এ stack-এর মাপ আগে থেকে হিসাব করা হয়: প্রতিটি function-এর frame, সবচেয়ে গভীর call-এর পথ, আর তার ওপরে interrupt-এর ভাগ।
আধুনিক chip কয়েকটি পাহারা দেয়। ARM Cortex-M-এর MPU দিয়ে stack-এর নিচে একটি ছোট “পাহারা এলাকা” লেখা-নিষেধ করা যায়; stack সেখানে পৌঁছলেই fault হয়, চুপচাপ data নষ্ট হয় না। ARMv8-M-এ stack-সীমার জন্য আলাদা register-ও যোগ হয়েছে। Software-এর দিকে একটি পুরোনো কৌশল “stack painting”: শুরুতে পুরো stack-এলাকা একটি পরিচিত নকশায় ভরে দেওয়া, তারপর কিছুক্ষণ চালিয়ে দেখা কতটুকু নকশা অক্ষত আছে; তা থেকে বোঝা যায় সর্বোচ্চ কতটা stack লেগেছে। Compiler-ও প্রতিটি function-এর stack-ব্যবহারের তালিকা দিতে পারে।
এর সবকিছুর বীজ এই পর্বেই: প্রতিটি CALL আর PUSH দুই byte নেয়, প্রতিটি RET আর POP দুই byte ফেরত দেয়, আর সবচেয়ে গভীর মুহূর্তে SP কত নিচে নামে, সেটিই stack-এর দরকারি মাপ। nested.asm-এ সর্বোচ্চ গভীরতা ২, অর্থাৎ মাত্র ৪ byte. Cortex-M-এ stack-এর মাপ, heap এড়ানো আর static allocation-এর পুরো আলোচনা পর্ব ৩৯-এ।
মূল উপলব্ধি: 8085-এ stack-এর পাহারাদার শুধু programmer; আধুনিক chip MPU আর fault দিয়ে সাহায্য করে, কিন্তু stack-এর মাপের হিসাব এখনো নকশাকারীরই কাজ।
অনুশীলন
প্রথমে নিজে হিসাব করুন বা লিখুন, তারপর উত্তর খুলুন। প্রতিটি উত্তর কোর্সের simulator-এ চালিয়ে যাচাই করা।
-
নকশা ও বাস্তবায়ন — register-রক্ষাকারী 10 ms delay: 3 MHz-এর 8085-এর জন্য
DLY10নামের একটি subroutine লিখুন, যা প্রায় 10 ms অপেক্ষা করে আর ফেরার পরে BC, A আর সব flag আগের মতো রাখে।CALLআরRETসহ মোট T-state-এর সূত্র, N-এর মান, আসল সময় আর ভুল বের করুন।DLY10: PUSH B ; 12 T PUSH PSW ; 12 T LXI B,1247 ; 10 T (04DFH) DL: DCX B ; 6 T MOV A,C ; 4 T ORA B ; 4 T JNZ DL ; 10 T, শেষ পাকে 7 T POP PSW ; 10 T POP B ; 10 T RET ; 10 Tসূত্র: 18 (
CALL) + 12 + 12 + 10 + 24N − 3 + 10 + 10 + 10 = 24N + 79. দরকার 10 ms × 3 MHz = 30000 T, তাই N = (30000 − 79) ÷ 24 = 1246.7 → N = 1247. মোট 24 × 1247 + 79 = 30007 T = 10002.33 µs, ভুল +7 T = +2.33 µs. Simulator-এ (delay10ms.asm) ডাকার আগে BC = 1111H, A = 22H রেখে চালানো হয়েছে: মোট 30039 T, তা থেকে আগের তিনটি instruction-এর ২৭ আরHLT-এর ৫ বাদ দিলে 30007; শেষেA=22 B=11 C=11, F = 00H, অর্থাৎ সব অক্ষত।POP-এর ক্রম উল্টো (আগে PSW, পরে B) রাখা জরুরি। -
ভুল খুঁজুন — চারটি ভুল দাবি: একজন শিক্ষার্থী লিখলেন: (ক) “
PUSH DতারপরPUSH B, শেষেPOP DতারপরPOP B: সব register নিজের মান ফেরত পাবে।” (খ) একটি subroutine-এPUSH Bআছে, কিন্তু একটি পথেRZদিয়ে আগেই বেরিয়ে যায়,POP B-এর আগে। (গ) “SP বসানোর দরকার নেই, simulator-এ তো চলে।” (ঘ) “MVI C,FFHদিয়ে 8 বিটের loop 3 MHz-এ 1 ms দেয়।” প্রতিটির ভুল কী?(ক) LIFO উপেক্ষা: শেষে রাখা BC আগে বেরিয়ে DE-তে যায়, আর DE-র মান BC-তে; দুটি অদলবদল হয়। এই পর্বের প্রথম stepper ঠিক এটাই দেখায় (
push_pop.asm: শেষে BC = 1FFCH, DE = 04E2H). ঠিক ক্রম:POP BতারপরPOP D. (খ)RZ-এর পথে stack-এর মাথায় BC-র মান, ফেরার ঠিকানা নয়;RETসেই মানকে ঠিকানা ধরে লাফ দেয়।bug_nopop.asm-এ BC = 04E2H ছিল, আর trace দেখায়RET ... PC=04E2, তারপরNOP-এর সারি আর শেষেstopped after 1000000 instructions. সমাধান: আগে-বেরোনোর পথেওPOP B, অথবা একটি সাধারণ শেষ-লেবেলে লাফ দিয়ে সেখানেPOP BআরRET. (গ) Reset-এর পরে SP = 0000H, তাই প্রথমCALLলেখে FFFFH আর FFFEH-এ (bug_nosp.asm:FFFEH: 05 20). Simulator-এ পুরো 64 KB RAM, তাই চলে; আসল যন্ত্রে সেখানে ROM বা ফাঁকা থাকলে ফেরার ঠিকানা হারিয়ে যায়। (ঘ) 14 × 255 + 4 = 3574 T = 1191.33 µs, 1 ms নয়। 1 ms-এর জন্য N = 214 (শুধু loop) বা N = 212 (CALL/RETসহ)। -
আগে বলুন, তারপর চালান — শর্তযুক্ত CALL: 2050H-এ
7CH, 2051H-এ84H. Program:LXI SP,2800H/LXI H,2050H/MVI D,00H/MOV A,M/CPI 81H/CNC OVER/INX H/MOV A,M/CPI 81H/CNC OVER/MOV A,D/STA 2060H/HLT;OVER: INR D/RET. দুটিCNC-এর প্রতিটি কত T নেয়, দ্বিতীয়CNC-এর পরে SP আর stack-এর মাথায় কী, শেষে 2060H-এ কী, আর মোট T-state কত?প্রথম reading 7CH < 81H, তাই
CPI-এর পরে CY = 1,CNC-এর শর্ত মিথ্যা: ৯ T, কোনো লাফ নেই, SP = 2800H. দ্বিতীয় reading 84H ≥ 81H, CY = 0:CNC১৮ T, ফেরার ঠিকানা 2015H রাখে (27FFH ← 20, 27FEH ← 15), SP = 27FEH.OVER-এ D = 1,RETSP-কে 2800H-এ ফেরায়। শেষে 2060H = 01. মোট: 10 + 10 + 7 + 7 + 7 + 9 + 6 + 7 + 7 + 18 + 4 + 10 + 4 + 13 + 5 = ১২৪ T. Simulator (condcall.asm):2060H: 01,Instructions: 15 T-states: 124; trace-এ প্রথমCNCT=9, দ্বিতীয়টিT=18আরSP=27FE. -
হিসাব — তিনটি delay: 3 MHz clock ধরে বের করুন: (ক)
MVI C,00H/DCR C/JNZloop-এর T-state আর সময়; (খ)LXI B,0FFFFH-এর ১৬ বিটের loop-এর T-state আর সময়; (গ) বাইরে M, ভেতরে N-এর nested loop (এই পর্বের ছাঁচ) দিয়ে প্রায় 0.5 s পেতে M = 50 নিলে N কত, আর মোট T-state কত?(ক) C = 00H হলে প্রথম
DCRFFH বানায়, তাই ২৫৬ পাক: 14 × 256 + 4 = 3588 T = 1196 µs (simulator:delay_n0.asm, HLT-সহ 3593). (খ) 24 × 65535 + 7 = 1,572,847 T ≈ 524,282.33 µs ≈ 524.28 ms (simulator: HLT-সহ 1,572,852). (গ) দরকার 0.5 × 3,000,000 = 1,500,000 T. সূত্র M(24N + 21) + 4; M = 50 হলে 24N + 21 ≈ 29999.9, তাই N = 1249 (1250 দিলে একটু বেশি হয়)। মোট = 50 × 29997 + 4 = 1,499,854 T = 499,951.33 µs ≈ 0.49995 s, ভুল −146 T. Simulator (delay05s.asm):Instructions: 249952 T-states: 1499859= 1,499,854 + 5.
নিজেকে যাচাই করুন
ভুল হলে কারণসহ ব্যাখ্যা পাবেন, আবার চেষ্টাও করতে পারবেন।
ক্রম8085-এ SP = 2800H, আর 2008H থেকে CALL 2100H (byte CD 00 21) চলছে। ধাপগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)
- Opcode
CDfetch আর decode, ৬ T; বাড়তি সময়ে SP কমে - 2009H থেকে লক্ষ্যের নিচু byte
00পড়া - 200AH থেকে লক্ষ্যের উঁচু byte
21পড়া; PC = 200BH - 27FFH-এ ফেরার ঠিকানার উঁচু byte
20লেখা - 27FEH-এ নিচু byte
0Bলেখা; SP = 27FEH, PC = 2100H, মোট ১৮ T
8085-এ SP = 2800H আর BC = 04E2H. PUSH B-এর পরে কী হয়?
- SP = 2802H, [2800H] = E2, [2801H] = 04
- SP = 27FEH, [27FFH] = 04, [27FEH] = E2
- SP = 27FEH, [27FFH] = E2, [27FEH] = 04
- SP = 27FEH, [2800H] = 04, [27FFH] = E2
8085-এর শর্তহীন CALL আর RET কত T-state নেয়?
- CALL ১০, RET ১০
- CALL ১৭, RET ৬
- CALL ১৮, RET ১০
- CALL ১৮, RET ১২
8085-এ CPI 81H-এর পরে CY = 1. পরের instruction CNC 3000H কী করে, আর কত T-state নেয়?
- Call হয় না, ৯ T
- 3000H-এ call হয়, ১৮ T
- Call হয় না, ৬ T
- Call হয় না, কিন্তু SP দুই কমে
3 MHz clock-এর 8085-এ MVI C,0FFH / L: DCR C / JNZ L loop-এর মোট সময় কত (HLT বাদে)?
- 255 µs
- ঠিক 1000 µs
- 3587 T = 1195.67 µs
- 3574 T = 1191.33 µs
8085-এ SP = 2800H থাকা অবস্থায় PUSH PSW চলল। কোন byte কোথায় যায়?
- 27FFH-এ flag byte, 27FEH-এ A
- 27FFH-এ A, 27FEH-এ flag byte
- শুধু 27FFH-এ flag byte
- 2800H-এ A, 27FFH-এ flag byte
একটি 8085 subroutine-এর শুরুতে PUSH B আছে, কিন্তু RET-এর আগে POP B নেই। ডাকার আগে BC = 04E2H ছিল। RET কী করে?
- ঠিক ফেরার ঠিকানায় ফেরে, শুধু BC নষ্ট হয়
- CPU error দেখিয়ে থেমে যায়
- PC = 04E2H হয়, অর্থাৎ ওজনের মানকে ঠিকানা ধরে লাফ দেয়
- দুটি জিনিস তুলে আসল ফেরার ঠিকানায় যায়
শব্দকোষ
লেখার মধ্যে ডটেড দাগ দেওয়া শব্দে মাউস রাখুন বা চাপুন — অর্থ দেখাবে। এই পর্বের সব নতুন শব্দ এখানে একসাথে:
মনে রাখুন
- Stack: RAM-এর একটি এলাকা, SP তার সবশেষে লেখা byte দেখায়, নিচের দিকে বাড়ে; প্রথমেই
LXI SP, নইলে reset-এর SP = 0000H থেকে FFFFH-এ লেখা শুরু। - PUSH আর POP: সবসময় দুই byte, উঁচু byte বড় ঠিকানায়; ১২ আর ১০ T; POP memory মোছে না; LIFO, তাই
POP-এর ক্রমPUSH-এর উল্টো। - CALL আর RET:
CALLপরের instruction-এর ঠিকানা রাখে (১৮ T),RETতা তোলে (১০ T); শর্তযুক্ত রূপ ১৮/৯ আর ১২/৬ T. - Parameter আর register: register, স্থির memory বা stack (SP + 2) দিয়ে পাঠানো; প্রতিটি subroutine-এর চুক্তি লিখে রাখুন, আর প্রতিটি পথে
PUSH=POP. - Delay: ৮ বিট 14N + 4, ১৬ বিট 24N + 7, CALL-সহ ৮ বিট 14N + 32, nested M(24N + 21) + 4; 3 MHz-এ 1 ms = 3000 T, 1 T = 0.333 µs.
আরও পড়ুন · ABCL TECH-এ আপনার পরবর্তী পদক্ষেপ
- পর্ব ১৩ · 8085-এর interrupt — TRAP, RST, SIM আর RIMপরবর্তী পর্বVector, অগ্রাধিকার, mask আর SIM/RIM-এর বিট।
- মাইক্রোপ্রসেসর, এমবেডেড সিস্টেম ও IoT · কোর্স হোম৮৫টি পর্বপুরো কোর্সের মানচিত্র আর বাজারঘরের দুটি device-এর পথ।
- পর্ব ১১ · 8085 assembly programআগের পর্বLoop, array, গুণ-ভাগ আর BCD-র পূর্ণ program, যেগুলোকে এখন subroutine-এ ভাগ করা যায়।
- পর্ব ০৯ · 8085-এর instruction setআগের পর্বশর্তযুক্ত jump, flag-এর নিয়ম আর সব instruction-এর T-state.
- পর্ব ০৮ · 8085-এর pin, machine cycle আর timing diagramআগের পর্ব৬ T-এর opcode fetch আর memory write cycle, যা CALL আর PUSH-এর ভেতরে চলে।
- Computer Architecture পর্ব ৩০ · Function call আর stackপাশের ট্র্যাকRISC-V-এ calling convention, stack frame আর recursion.
- DSA পর্ব ১৩ · Stackপাশের ট্র্যাকLIFO ডেটা স্ট্রাকচার হিসেবে stack আর তার ব্যবহার।
- Programming Languages পর্ব ৭১ · Calling convention আর ABIপাশের ট্র্যাকFunction call-এর চুক্তি: argument, ফেরত মান আর register বাঁচানোর নিয়ম।