সরাসরি পর্বে যান
পর্ব ১২ · ৮৫-এর মধ্যে · মডিউল ২

8085-এর stack আর subroutine — CALL, RET, PUSH আর POP

8085 Stack and Subroutines: CALL, RET, PUSH and POP

Taught in Bangla, this lesson explains the 8085 stack and the SP register: how PUSH and POP move two bytes, how PUSH PSW saves A and the flags, and how CALL and RET use the return address, including conditional forms and their T-states. It covers passing parameters, saving registers and unbalanced stack bugs, then builds delay subroutines from 14N + 4 and 24N + 7 formulas, including an exact 1 ms delay. Every value is checked in the course's 8085 simulator.

এই পর্বে যা শিখবেন

  • 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 বাড়ে ওপরের দিকে, অর্থাৎ ছোট ঠিকানার দিকে

8085-এর memory map আর stack, দুটি ফেরার ঠিকানাসহ 2000H2050H2060H 27FCH27FDH27FEH27FFH 2800H programতালিকা9E 30 ⋮ফাঁকা RAM খালি 16200B20 stack এদিকে বাড়ে SP ADDW থেকেফেরা 2016H TOTAL থেকেফেরা 200BH শুরুর SP2800H
ছবি ১২.১ — হলুদ ঘরে program; নীল ঘরে data: 2050H-এ দামের তালিকা আর 2060H-এ ফল 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 হয় না।

InstructionOpcodeকাজMachine cycleT
PUSH B, D, H, PSWC5, D5, E5, F5[SP−1] ← উঁচু, [SP−2] ← নিচু, SP ← SP−2OF (৬ T), MW, MW12
POP B, D, H, PSWC1, D1, E1, F1নিচু ← [SP], উঁচু ← [SP+1], SP ← SP+2OF, MR, MR10

সংকেত: 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, stack আর register
SP
27FC…27FF
BC
DE
মোট T
  1. LXI SP,2800H, ১০ T. Stack-এর তলা ঠিক হলো। SP = 2800H, কিন্তু 2800H ঘরে কিছু লেখা হবে না: প্রথম PUSH আগে SP কমায়, তারপর লেখে।
  2. LXI B,04E2H. BC = 04E2H, net ওজন 1250 g. মোট ২০ T.
  3. LXI D,1FFCH. DE = 1FFCH, দাম 8188 পয়সা। মোট ৩০ T. Stack এখনো ছোঁয়া হয়নি।
  4. PUSH B, ১২ T. SP কমে 27FFH, সেখানে উঁচু byte 04; আবার কমে 27FEH, সেখানে নিচু byte E2. SP = 27FEH. BC বদলায়নি: PUSH কপি রাখে, সরায় না।
  5. PUSH D, ১২ T. 27FDH ← 1F, 27FCH ← FC, SP = 27FCH. চারটি byte এখন FC 1F E2 04, মোট ৫৪ T.
  6. POP B, ১০ T. 27FCH থেকে নিচু byte FC যায় C-তে, 27FDH থেকে 1F যায় B-তে: BC = 1FFCH. শেষে রাখা DE-র মান আগে বেরোল। SP = 27FEH. Memory-র byte মোছা হয়নি, শুধু SP সরেছে।
  7. POP D, ১০ T. 27FEH আর 27FFH থেকে DE = 04E2H, SP = 2800H, অর্থাৎ stack আবার খালি। মোট ৭৪ T.
  8. 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 আর stack
A
F
S Z AC P CY
SP
27FE 27FF
মোট T
  1. LXI SP,2800H. Stack প্রস্তুত, SP = 2800H. সব flag 0, F = 00H.
  2. MVI A,96H, ৭ T. A = 96H, অর্থাৎ 150. MVI কোনো flag বদলায় না।
  3. 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.
  4. PUSH PSW, ১২ T. 27FFH ← A = 00, 27FEH ← F = 55, SP = 27FEH. ঠিক PUSH B-এর মতো: উঁচু byte (A) বড় ঠিকানায়, নিচু byte (F) ছোট ঠিকানায়।
  5. MVI A,07H, ৭ T. A বদলে 07, কিন্তু flag এখনো 55H, কারণ MVI flag ছোঁয় না।
  6. ORA A, ৪ T. এবার flag নষ্ট: 07H শূন্য নয় (Z = 0), তিনটি 1 বিজোড় (P = 0), আর ORA CY আর AC মুছে দেয়। F = 00H. ধরুন এটি কোনো subroutine-এর ভেতরের কাজ।
  7. POP PSW, ১০ T. 27FEH থেকে F = 55, 27FFH থেকে A = 00, SP = 2800H. A আর পাঁচটি flag ঠিক তৃতীয় ধাপের মতো। POP PSW flag-এর ৮টি বিটই হুবহু তোলে (Spec decision 3).
  8. 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কাজByteT
LXI SP,2800HSP ← 2800H (stack-এর জায়গা ঠিক করা)310
SPHLSP ← HL16
XTHLL ↔ [SP], H ↔ [SP+1]; SP বদলায় না116
INX SP, DCX SPSP ± 1, কোনো flag বদলায় না16
DAD SPHL ← HL + SP; শুধু CY বদলায়110

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-এ বসায়।

InstructionByteকাজMachine cycleT
CALL addr (CD)3stack ← পরের instruction-এর ঠিকানা; PC ← addrOF (৬ T), MR, MR, MW, MW18
RET (C9)1PC ← stack-এর মাথার দুই byte; SP ← SP+2OF, MR, MR10
RST n1CALL-এর এক byte-এর রূপ, লক্ষ্য n × 8OF (৬ T), MW, MW12

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 আর stack
PC
SP
27FC…27FF
DE
মোট T
  1. LXI SP,2800H. Stack খালি, SP = 2800H. এরপর LXI H,2050H আর MVI C,03H দুটি parameter বসায়: তালিকার ঠিকানা আর দামের সংখ্যা।
  2. 2008H-এ CALL TOTAL, ১৮ T. তিন byte পড়ার পরে PC = 200BH; এটিই ফেরার ঠিকানা। 27FFH ← 20, 27FEH ← 0B, SP = 27FEH, PC = 2010H. মোট ৪৫ T.
  3. LXI D,0000H, তারপর 2013H-এ CALL ADDW. যোগফল শূন্য থেকে শুরু। দ্বিতীয় CALL রাখে 2016H: 27FDH ← 20, 27FCH ← 16, SP = 27FCH. Stack-এ এখন দুটি ফেরার ঠিকানা, ছবি ১২.১-এর অবস্থা।
  4. ADDW চলে, তারপর RET. E + D7H = D7H, তারপর D + 03H + CY = 03H: DE = 03D7H = 983. RET 27FCH আর 27FDH থেকে 2016H তোলে, SP = 27FEH. Stack-এর মাথায় আবার 200BH. মোট ১২৫ T.
  5. DCR C, JNZ, আবার CALL ADDW. C = 2, তাই লাফ। দ্বিতীয় CALL ADDW একই ঠিকানা 2016H আবার একই দুই ঘরে লেখে, SP = 27FCH. মোট ১৫৭ T.
  6. দ্বিতীয় দাম যোগ, RET. 03D7H + 1FFCH = 23D3H. নিচু byte-এর যোগে carry (D7 + FC = 1D3H), যা ADC M উঁচু byte-এ নেয়। SP = 27FEH, মোট ২০৯ T.
  7. তৃতীয় CALL ADDW আর RET. 23D3H + 0CCBH = 309EH = 12446 পয়সা। SP আবার 27FEH, মোট ২৯৩ T. তিনবার ডাকা হলো, কিন্তু stack-এর গভীরতা কখনো ২-এর বেশি হয়নি।
  8. DCR C → 0, JNZ লাফ দেয় না (৭ T), 201AH-এ RET. 27FEH আর 27FFH থেকে 200BH তোলা হলো, SP = 2800H: stack খালি, ঠিক শুরুর মতো। মোট ৩১৪ T.
  9. 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 / ZCNZ C4 / CZ CCRNZ C0 / RZ C8Z = 0 / Z = 1
NC / CCNC D4 / CC DCRNC D0 / RC D8CY = 0 / CY = 1
PO / PECPO E4 / CPE ECRPO E0 / RPE E8P = 0 / P = 1
P / MCP F4 / CM FCRP F0 / RM F8S = 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 আর T-state
C
Z
এই instruction
মোট T
সময়
  1. MVI C,03H, ৭ T. গণক C = 3. এটি loop-এর বাইরে, একবারই চলে। মোট ৭ T = 2.33 µs.
  2. প্রথম DCR C, ৪ T. C = 2, শূন্য নয়, তাই Z = 0. DCR Z বদলায়, CY ছোঁয় না (Spec decision 4). মোট ১১.
  3. JNZ LOOP, ১০ T. Z = 0, তাই লাফ দিয়ে 2002H-এ। প্রথম পাকের খরচ 4 + 10 = 14 T. মোট ২১.
  4. দ্বিতীয় DCR C. C = 1, Z = 0. মোট ২৫.
  5. আবার JNZ, ১০ T. আরও একটি পূর্ণ পাক, ১৪ T. মোট ৩৫.
  6. তৃতীয় DCR C. C = 0, এবার Z = 1. মোট ৩৯.
  7. JNZ লাফ দেয় না, ৭ T. Intel-এর টেবিলে শর্ত মিথ্যা হলে JNZ ৭ T (Spec decision 2). শেষ পাক তাই 4 + 7 = 11 T, পূর্ণ পাকের চেয়ে তিন কম। Loop-এর মোট ৪৬ T, আর সূত্র 14 × 3 + 4 = 46 মেলে।
  8. 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

  1. দরকারি T-state: 1 ms × 3 MHz = 0.001 s × 3,000,000 Hz = 3000 T.
  2. শুধু loop (HLT ছাড়া): 14N + 4 = 3000 → N = 2996 ÷ 14 = 214 = D6H. ভাগ মিলে যায়, তাই হুবহু 3000 T. Simulator: delay8.asm, N = 214, T-states: 3005 = 3000 + HLT-এর ৫.
  3. 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   ┘
  1. ভেতরের loop: DCX থেকে JNZ INNER পর্যন্ত 24N − 3 T.
  2. একটি বাইরের পাক: 10 (LXI) + 24N − 3 + 4 (DCR) + 10 (JNZ) = 24N + 21.
  3. মোট: 7 + M × (24N + 21) − 3 = M(24N + 21) + 4; শেষ বাইরের পাকে JNZ OUTER ৭ T, তাই −3.
  4. সংখ্যা বসানো: M = 100 ধরলে 24N + 21 ≈ 30000 → N = 1249 (1250 দিলে 1.0007 s, একটু বেশি)। মোট = 100 × 29997 + 4 = 2,999,704 T.
  5. সময়: 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-কে কাজে লাগাতে আগে প্রসঙ্গ, অনুমান আর যাচাইয়ের পথ বলে দিন:

আমি Intel 8085 assembly শিখছি (8080, Z80 বা 8086 নয়)। Hex লিখি Intel ধরনে, যেমন 2050H. Clock 3 MHz (6 MHz crystal), wait state নেই। ১. একটি delay subroutine লেখো যা 5 ms অপেক্ষা করে, BC আর PSW অক্ষত রাখে, আর CALL ও RET সহ মোট T-state-এর সূত্র দেখায়। ২. N-এর মান, মোট T-state আর আসল সময় (µs) বের করো; প্রতিটি instruction-এর T-state আলাদা টেবিলে দাও, আর শেষ পাকে JNZ-এর খরচ আলাদা করে বলো। ৩. LXI SP,2800H থেকে শুরু করে CALL-এর পরে SP আর stack-এর প্রতিটি byte কী হবে, তা দেখাও। ৪. Intel 8085 manual-এর T-state ছাড়া অন্য কোনো সংখ্যা ব্যবহার কোরো না; নিশ্চিত না হলে বলো।

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-এ চালিয়ে যাচাই করা।

  1. নকশা ও বাস্তবায়ন — 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) রাখা জরুরি।

  2. ভুল খুঁজুন — চারটি ভুল দাবি: একজন শিক্ষার্থী লিখলেন: (ক) “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 সহ)।

  3. আগে বলুন, তারপর চালান — শর্তযুক্ত 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, RET SP-কে 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-এ প্রথম CNC T=9, দ্বিতীয়টি T=18 আর SP=27FE.

  4. হিসাব — তিনটি delay: 3 MHz clock ধরে বের করুন: (ক) MVI C,00H / DCR C / JNZ loop-এর T-state আর সময়; (খ) LXI B,0FFFFH-এর ১৬ বিটের loop-এর T-state আর সময়; (গ) বাইরে M, ভেতরে N-এর nested loop (এই পর্বের ছাঁচ) দিয়ে প্রায় 0.5 s পেতে M = 50 নিলে N কত, আর মোট T-state কত?

    (ক) C = 00H হলে প্রথম DCR FFH বানায়, তাই ২৫৬ পাক: 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) চলছে। ধাপগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)

  1. Opcode CD fetch আর decode, ৬ T; বাড়তি সময়ে SP কমে
  2. 2009H থেকে লক্ষ্যের নিচু byte 00 পড়া
  3. 200AH থেকে লক্ষ্যের উঁচু byte 21 পড়া; PC = 200BH
  4. 27FFH-এ ফেরার ঠিকানার উঁচু byte 20 লেখা
  5. 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 হয়, অর্থাৎ ওজনের মানকে ঠিকানা ধরে লাফ দেয়
  • দুটি জিনিস তুলে আসল ফেরার ঠিকানায় যায়

শব্দকোষ

লেখার মধ্যে ডটেড দাগ দেওয়া শব্দে মাউস রাখুন বা চাপুন — অর্থ দেখাবে। এই পর্বের সব নতুন শব্দ এখানে একসাথে:

মনে রাখুন

  1. Stack: RAM-এর একটি এলাকা, SP তার সবশেষে লেখা byte দেখায়, নিচের দিকে বাড়ে; প্রথমেই LXI SP, নইলে reset-এর SP = 0000H থেকে FFFFH-এ লেখা শুরু।
  2. PUSH আর POP: সবসময় দুই byte, উঁচু byte বড় ঠিকানায়; ১২ আর ১০ T; POP memory মোছে না; LIFO, তাই POP-এর ক্রম PUSH-এর উল্টো।
  3. CALL আর RET: CALL পরের instruction-এর ঠিকানা রাখে (১৮ T), RET তা তোলে (১০ T); শর্তযুক্ত রূপ ১৮/৯ আর ১২/৬ T.
  4. Parameter আর register: register, স্থির memory বা stack (SP + 2) দিয়ে পাঠানো; প্রতিটি subroutine-এর চুক্তি লিখে রাখুন, আর প্রতিটি পথে PUSH = POP.
  5. Delay: ৮ বিট 14N + 4, ১৬ বিট 24N + 7, CALL-সহ ৮ বিট 14N + 32, nested M(24N + 21) + 4; 3 MHz-এ 1 ms = 3000 T, 1 T = 0.333 µs.

পরের পর্বে: পর্ব ১৩ (8085-এর interrupt — TRAP, RST, SIM আর RIM). Interrupt আসলে hardware-এর পাঠানো একটি CALL: CPU চলতি কাজ থামিয়ে PC-কে এই পর্বের stack-এ রেখে ISR-এ যায়, আর ISR-এর RET তাকে ফেরায়। Vector, priority, মাস্ক আর SIM/RIM-এর বিট সেখানে।

আরও পড়ুন · ABCL TECH-এ আপনার পরবর্তী পদক্ষেপ

এই পর্বটি শেয়ার করুন:
এই পর্বে ভুল পেয়েছেন? জানান