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

8086-এর গঠন — BIU, EU, segment আর physical address

8086 Architecture — BIU, EU, Segments and Physical Address

Taught in Bangla, this lesson explains the 8086: 16-bit processing, 20-bit addresses and 1 MB of memory. It splits work between the BIU and EU, shows the 6-byte prefetch queue, the 14 registers, and the physical address rule segment × 10H + offset. Programs assembled with NASM and run on Unicorn prove that 1000H:0150H and 1010H:0050H reach the same byte, and show OF = 1 with CF = 0 after 7530H + 1388H. It also compares MASM and NASM notation.

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

  • 8086-এর BIU আর EU-র block diagram আঁকা, আর প্রতিটি অংশের কাজ এক লাইনে বলা
  • Instruction queue কীভাবে ভরে, কখন BIU অপেক্ষা করে আর লাফের পরে কেন queue খালি হয়, তা ধাপে ধাপে দেখানো
  • ১৪টি ১৬ বিটের register, AX থেকে DL পর্যন্ত ৮ বিটের অর্ধেক, আর প্রতিটির বিশেষ কাজ চেনা
  • যেকোনো segment:offset থেকে physical address হিসাব, উল্টো দিকের হিসাব, আর overlapping segment বোঝা
  • যোগের পরে নয়টি flag-এর মান হাতে বের করা আর কোর্সের 8086 runner-এ মিলিয়ে দেখা

১ · 8086 এক নজরে — ১৬ বিটের হিসাব, ২০ বিটের ঠিকানা

মডিউল ২-এ আপনি 8085-এর ভেতরটা দেখেছেন (পর্ব ০৭): ৮ বিটের ALU, ১৬ বিটের ঠিকানা, 64 KB মেমরি। এবার তার পরের প্রজন্ম। Intel 8086 বাজারে আসে ১৯৭৮ সালে। এটি ১৬ বিটের microprocessor: ALU, প্রধান register আর data bus সবই ১৬ বিট চওড়া। আর ঠিকানার লাইন ২০টি। এই chip থেকেই x86 পরিবারের শুরু, যার বংশধর আজও বেশিরভাগ ডেস্কটপ আর ল্যাপটপে চলে।

উপমা — রেস্তোরাঁর ওয়েটার আর রাঁধুনি: একটি ছোট রেস্তোরাঁয় 8085 ছিল একা একজন মানুষ: নিজেই গুদাম থেকে উপকরণ আনেন, নিজেই রাঁধেন। আনার সময় রান্না বন্ধ, রান্নার সময় আনা বন্ধ। 8086-এ কাজটি দুজনে ভাগ করে নিয়েছে। ওয়েটার (BIU) গুদাম আর রান্নাঘরের মাঝে দৌড়ান, পরের অর্ডারের উপকরণ আগেই এনে তাকে (queue) সাজিয়ে রাখেন। রাঁধুনি (EU) চুলা ছেড়ে নড়েন না, তাক থেকে নিয়ে রাঁধেন। আর গুদামের তাকের নম্বর লেখা হয় দুই ভাগে: “কোন ঘর” আর “ঘরের কত নম্বর তাক”, যা এই পর্বের segment আর offset.

পূর্বজ্ঞান এক লাইনে: binary, hex আর two's complement পর্ব ০৫-এ; register, ALU আর flag-এর মৌলিক ধারণা 8085-এর চোখে পর্ব ০৭-এ। লেখার নিয়ম আগের মতোই: hex লেখা হবে Intel-এর ধরনে, শেষে H দিয়ে (10150H, 0FFFFH), আর segment:offset লেখা হবে 1000H:0150H ধাঁচে। কোডের ভেতরে NASM-এর নিয়মে ছোট হাতের h থাকবে (0150h), মানে একই।

বৈশিষ্ট্য8085 (পর্ব ০৭)8086
ALU আর data bus৮ বিট১৬ বিট
Address bus১৬ বিট → 64 KB২০ বিট → 1 MB
ঠিকানা কীভাবেসরাসরি ১৬ বিটের PC, HL ইত্যাদিsegment × 10H + offset
Fetch আর executeপালা করে, একজনই করেBIU আর EU একসঙ্গে; ৬ byte-এর queue
Flag৫টি (S Z AC P CY)৯টি (৬টি status + ৩টি control)
গুণ-ভাগনেই, loop দিয়েMUL, DIV আছে
Pin আর supply৪০টি, +5 V৪০টি, +5 V; AD0–AD15 multiplexed (পর্ব ২১)

ইতিহাসের পাতা থেকে: 8086 ছিল Intel-এর প্রথম ১৬ বিটের microprocessor, ১৯৭৮ সালে বাজারে আসে; Intel-এর প্রচলিত হিসাবে এতে প্রায় ২৯ হাজার transistor. প্রথম সংস্করণ চলত 5 MHz-এ, পরে 8 MHz আর 10 MHz-এর দ্রুত সংস্করণ আসে (8086-2, 8086-1). এক বছর পরে, ১৯৭৯ সালে, এল 8088: ভেতরে হুবহু 8086-এর মতো, কিন্তু বাইরের data bus ৮ বিটের। ১৯৮১ সালের IBM PC এই 8088 বেছে নেয়, আর সেখান থেকেই x86-এর দীর্ঘ যাত্রা। এই পর্বের প্রায় সব কথা 8088-এর জন্যও খাটে; পার্থক্য শুধু bus আর queue-র মাপে, যা পর্ব ২১-এ।

এই পর্বের প্রতিটি register, flag আর মেমরির মান এসেছে কোর্সের reference lab-এর run8086.py থেকে: NASM 3.02 দিয়ে assemble করা আসল 8086 machine code, Unicorn emulator-এর ১৬ বিট real mode-এ চালানো (পর্ব ০৬-এ পরিচয়)। Lab-এর নিয়মে program বসে 1000H:0100H-এ, আর CS = DS = ES = SS = 1000H, SP = FFFEH, FLAGS = 0202H দিয়ে শুরু হয় (reference lab-এর Spec decision 13). একটি সতর্কতা আগেই: lab-এ clock গোনা হয় না (Spec decision 16), তাই এই পর্বে কোনো নির্দেশের সময় “মাপা” বলে দেখানো হবে না।

২ · BIU আর EU — দুই ভাগে ভাগ করা কাজ

Intel-এর 8086 family user's manual chip-টির ভেতরকে দুটি স্বাধীন ইউনিটে ভাগ করে দেখায়। BIU (Bus Interface Unit) বাইরের জগতের সঙ্গে সব লেনদেন করে: মেমরি থেকে নির্দেশ আনে, data পড়ে-লেখে, I/O port ছোঁয়, আর ২০ বিটের ঠিকানা বানায়। EU (Execution Unit) কখনো বাইরের bus ছোঁয় না: queue থেকে নির্দেশ নেয়, decode করে, ALU-তে হিসাব করে, register আর flag বদলায়। মেমরির data দরকার হলে EU শুধু offset বলে দেয়, বাকিটা BIU করে।

ছবি ১৪.১ — 8086-এর BIU আর EU

সবুজ = বাইরের bus; নীল = register; হলুদ = হিসাবের অংশ; বেগুনি = নিয়ন্ত্রণ; ধূসর = queue

8086-এর BIU আর EU বাইরের system bus · A19–A16, AD15–AD0 BIU · Bus Interface Unit CSDSSSESIP Σ adder seg×10H+off Bus control logic Instruction queue · ৬ byte 123 456 অভ্যন্তরীণ ১৬ বিট data bus EU · Execution Unit AHAL BHBL CHCL DHDL SPBP SIDI সাধারণ, pointer, index EU control system (decoder) ALU (১৬ বিট) FLAGS · ৯টি flag
ছবি ১৪.১ — Intel-এর 8086 manual-এর ধারায় সরল করে আঁকা। ওপরের অর্ধেক BIU: চারটি segment register, IP, ঠিকানা যোগের Σ adder, bus control আর ৬ ঘরের queue. নিচের অর্ধেক EU: আটটি সাধারণ register (প্রথম চারটির ৮ বিটের দুই অর্ধেক আলাদা দেখানো), decoder, ALU আর FLAGS. বেগুনি ভাঙা দাগ: queue-র প্রথম byte যায় EU-র decoder-এ। মাঝের ধূসর পথ দিয়ে দুই ইউনিট data আর offset আদান-প্রদান করে।
ইউনিটঅংশকাজ
BIUCS, DS, SS, ESচারটি segment-এর শুরুর মান রাখে
IPcode segment-এর ভেতরে পরের byte-এর offset
Σ addersegment × 10H + offset = ২০ বিটের physical address
Bus control আর queuebus cycle চালায়; আগে থেকে আনা নির্দেশের byte রাখে
EUAX, BX, CX, DXসাধারণ কাজের register, ৮ বিটের দুই অর্ধেকসহ
SP, BP, SI, DIstack আর মেমরির offset রাখে
Control system (decoder)queue থেকে opcode নিয়ে বোঝে কী করতে হবে
ALU আর FLAGS১৬ বিটের হিসাব; ফলের চিহ্ন নয়টি flag-এ

একটি পার্থক্য খেয়াল করুন। 8085-এর PC ছিল register array-তে, আর পুরো ১৬ বিটের ঠিকানা সরাসরি bus-এ যেত। 8086-এ IP থাকে BIU-তে, আর একা কোনো ঠিকানা নয়: এটি শুধু code segment-এর ভেতরের দূরত্ব। আসল ঠিকানা সবসময় BIU-র adder-এ দুটি মান যোগ করে তৈরি হয়। এজন্যই EU নিজে কোনো ২০ বিটের ঠিকানা জানে না; তার জগৎ পুরোটাই ১৬ বিটের।

৩ · Instruction queue — পরের নির্দেশ আগেই আনা

8086-এর BIU-তে ছয় byte-এর একটি FIFO সারি আছে, যার নাম instruction queue. Intel-এর manual-এর নিয়ম: queue-তে অন্তত দুই byte জায়গা খালি হলে, আর EU-র bus লাগছে না এমন সময়ে, BIU পরের word (দুই byte) মেমরি থেকে এনে queue-র পেছনে বসায়। EU queue-র সামনে থেকে byte নেয়। একে বলে prefetch: দরকারের আগেই আনা। ফলে বেশিরভাগ সময় EU-কে নির্দেশের জন্য বসে থাকতে হয় না, কারণ পরের নির্দেশ ততক্ষণে queue-তে চলে এসেছে। এটি pipelining-এর সবচেয়ে সরল রূপ: fetch আর execute একই সময়ে, দুটি আলাদা নির্দেশের।

কিন্তু queue অন্ধভাবে পরপর ঠিকানা থেকে আনে। JMP, CALL, শর্ত পূরণ হওয়া Jcc বা interrupt-এর মতো কিছু হলে পরের নির্দেশ আর পরপর ঠিকানায় নয়। তখন queue-র জমানো byte বাতিল করতে হয়, IP নতুন ঠিকানা পায়, আর BIU সেখান থেকে নতুন করে আনা শুরু করে। সেই মুহূর্তে EU-কে অপেক্ষা করতে হয়। নিচের মডেলে এই পুরো গল্পটি দেখুন। Program-টি ছোট:

; queue86.asm - a short jump empties the prefetch queue
        org 100h
        mov ax, 1250        ; B8 E2 04
        mov bx, 6550        ; BB 96 19
        mov cl, ah          ; 88 E1
        jmp short over      ; EB 02
        nop                 ; 90  (never runs)
        nop                 ; 90  (never runs)
over:   mov ch, bl          ; 88 DD
        hlt                 ; F4

ডানের byte-গুলো NASM-এর আসল অনুবাদ (run8086.py --bin: B8 E2 04 BB 96 19 88 E1 EB 02 90 90 88 DD F4, ১৫ byte), আর সত্যিকারের trace-এ ছয়টি নির্দেশ চলে, দুটি nop বাদ পড়ে। এবার মডেলটি চালান। এখানে সময় মাপা হয়েছে কাল্পনিক “ধাপ”-এ, আর প্রতিটি নির্দেশ EU-তে কত ধাপ নেয়, তা ইচ্ছা করে বেছে নেওয়া (mov bx-কে লম্বা রাখা হয়েছে, যাতে queue ভরে যাওয়া দেখা যায়)। আসল clock সংখ্যা Intel-এর টেবিলের বিষয়, কোর্সের lab তা মাপে না।

# BIU আর EU-র সরল মডেল: ৬ byte-এর queue, BIU একবারে ২ byte আনে
# সময় কাল্পনিক "ধাপ"-এ; আসল clock সংখ্যা নয় (Spec decision 16)
mem = {0x100 + i: b for i, b in enumerate(
    [0xB8, 0xE2, 0x04, 0xBB, 0x96, 0x19, 0x88, 0xE1,
     0xEB, 0x02, 0x90, 0x90, 0x88, 0xDD, 0xF4, 0x00])}
ins = {0x100: ("mov ax,1250", 3, 2), 0x103: ("mov bx,6550", 3, 4),
       0x106: ("mov cl,ah", 2, 1), 0x108: ("jmp over", 2, 3),
       0x10C: ("mov ch,bl", 2, 1), 0x10E: ("hlt", 1, 1)}
q, fetch, ip, busy, cur, t = [], 0x100, 0x100, 0, None, 0
while True:
    t += 1
    biu = "অপেক্ষা (জায়গা নেই)"
    if 6 - len(q) >= 2:                           # অন্তত ২ byte খালি হলে আনা
        q += [mem.get(fetch, 0), mem.get(fetch + 1, 0)]
        biu = f"আনল {fetch:04X}H-{fetch + 1:04X}H"; fetch += 2
    if busy == 0 and cur is None:                 # EU নতুন নির্দেশ নেয়
        name, size, steps = ins[ip]
        if len(q) >= size:
            del q[:size]; cur, busy = (ip, name), steps; ip += size
    eu = f"{cur[1]} চলছে" if cur else "অপেক্ষা (queue-তে পুরো নির্দেশ নেই)"
    if cur:
        busy -= 1
        if busy == 0:
            if cur[1] == "jmp over":                # লাফ: queue খালি, নতুন ঠিকানা
                q, fetch, ip = [], 0x10C, 0x10C; eu += " -> queue খালি"
            cur = None
    print(f"ধাপ {t}: BIU {biu:22} | EU {eu}")
    print(f"        queue ({len(q)}): {' '.join(f'{b:02X}' for b in q) or '—'}")
    if eu.startswith("hlt"):
        break

আসল আউটপুট (ব্রাউজারের Python; ১৩টি ধাপের প্রথম আটটি আর শেষ তিনটি):

ধাপ 1: BIU আনল 0100H-0101H        | EU অপেক্ষা (queue-তে পুরো নির্দেশ নেই)
        queue (2): B8 E2
ধাপ 2: BIU আনল 0102H-0103H        | EU mov ax,1250 চলছে
        queue (1): BB
ধাপ 3: BIU আনল 0104H-0105H        | EU mov ax,1250 চলছে
        queue (3): BB 96 19
ধাপ 4: BIU আনল 0106H-0107H        | EU mov bx,6550 চলছে
        queue (2): 88 E1
ধাপ 5: BIU আনল 0108H-0109H        | EU mov bx,6550 চলছে
        queue (4): 88 E1 EB 02
ধাপ 6: BIU আনল 010AH-010BH        | EU mov bx,6550 চলছে
        queue (6): 88 E1 EB 02 90 90
ধাপ 7: BIU অপেক্ষা (জায়গা নেই)   | EU mov bx,6550 চলছে
        queue (6): 88 E1 EB 02 90 90
ধাপ 8: BIU অপেক্ষা (জায়গা নেই)   | EU mov cl,ah চলছে
        queue (4): EB 02 90 90
...
ধাপ 11: BIU অপেক্ষা (জায়গা নেই)   | EU jmp over চলছে -> queue খালি
        queue (0): —
ধাপ 12: BIU আনল 010CH-010DH        | EU mov ch,bl চলছে
        queue (0): —
ধাপ 13: BIU আনল 010EH-010FH        | EU hlt চলছে
        queue (1): 00

তিনটি জিনিস দেখুন। প্রথমত, ধাপ ১-এ EU অপেক্ষা করে, কারণ mov ax,1250 তিন byte-এর আর queue-তে তখন দুটি। দ্বিতীয়ত, ধাপ ৬ থেকে queue পুরো ভরা (৬ byte), আর ধাপ ৭ ও ৮-এ BIU-র কাজ নেই: জায়গা না থাকলে সে আনে না। তৃতীয়ত, ধাপ ১০-এ BIU যে ছয় byte জমিয়েছিল (90 90 88 DD F4 00), লাফের পরে সব বাতিল; ধাপ ১২-এ 88 DD আবার আনতে হলো। শেষ লাইনের 00 program-এর বাইরের byte (010FH): queue জানে না program কোথায় শেষ।

মডেলের এই ধাপে
ধাপ
BIU
EU
queue
byte সংখ্যা
  1. শুরু: queue খালি। BIU প্রথম word আনে, 0100H আর 0101H: B8 E2. EU-র প্রথম নির্দেশ mov ax,1250 তিন byte-এর, তাই সে অপেক্ষা করে।
  2. EU কাজ শুরু করে। BIU আরও দুই byte আনে (04 BB). এখন তিনটি byte পুরো, EU সেগুলো নিয়ে চালানো শুরু করে। queue-তে থাকে শুধু BB, পরের নির্দেশের প্রথম byte.
  3. একসঙ্গে দুই কাজ। EU যখন mov ax চালাচ্ছে, BIU তখন 0104H–0105H আনে। queue-তে BB 96 19: পরের নির্দেশ পুরোটা আগেই তৈরি। এটিই prefetch-এর লাভ।
  4. Queue ভরে গেল। EU লম্বা mov bx,6550 নিয়ে ব্যস্ত, আর BIU ধাপ ৪, ৫, ৬-এ তিনটি word এনে queue-র ছয়টি ঘরই ভরে ফেলেছে: 88 E1 EB 02 90 90.
  5. BIU বসে থাকে। ছয় byte ভরা, খালি জায়গা শূন্য। নিয়ম অনুযায়ী অন্তত দুই byte খালি না হলে BIU আনে না, তাই এই ধাপে bus অলস।
  6. EU দুই byte নিল। mov cl,ah (88 E1) শুরু। queue-তে চার byte, কিন্তু ধাপের শুরুতে ছয়টি ছিল বলে BIU এই ধাপে আনেনি; পরের ধাপে আনবে।
  7. লাফের আগেই ভরা queue. jmp over চলছে, আর BIU সরল পথে এগিয়ে 010EH–010FH-ও এনে ফেলেছে। queue-তে ছয় byte: 90 90 88 DD F4 00.
  8. লাফ: সব বাতিল। jmp শেষে IP = 010CH. queue-র ছয়টি byte বাতিল, BIU-র আনার ঠিকানাও 010CH-এ ফেরে। 88 DD আগেই এসেছিল, তবু আবার আনতে হবে।
  9. নতুন করে আনা। BIU 010CH–010DH আনে, EU সঙ্গে সঙ্গে mov ch,bl নেয়। queue আবার খালি থেকে শুরু: লাফ মানেই prefetch-এর লাভ কিছুক্ষণের জন্য হারানো।

এই কারণেই পুরোনো x86 বই বলে, “লাফ ব্যয়বহুল।” Intel-এর টেবিলে লাফের নির্দেশের সময় বেশি ধরা হয় আংশিক এজন্যই: নতুন ঠিকানা থেকে queue আবার ভরতে হয়। আধুনিক CPU এই ক্ষতি কমাতে branch prediction ব্যবহার করে, যার তত্ত্ব Computer Architecture পর্ব ৩৫-এ। আরেকটি সূক্ষ্মতা: queue-র byte মেমরির পুরোনো কপি। Program নিজেই যদি নিজের পরের কয়েকটি byte বদলায়, queue হয়তো আগের byte চালিয়ে ফেলবে; সেজন্য self-modifying code-এ 8086-এর আচরণ queue-র মাপের ওপর নির্ভর করত।

৪ · Register — ১৪টি ১৬ বিটের ঘর

8086-এর programmer চৌদ্দটি ১৬ বিটের register দেখতে পান: চারটি সাধারণ কাজের, চারটি pointer আর index, চারটি segment, একটি IP আর একটি FLAGS. প্রথম চারটির বিশেষত্ব: প্রতিটিকে দুটি ৮ বিটের অর্ধেক হিসেবেও ব্যবহার করা যায়। AX-এর উঁচু byte AH, নিচু byte AL; একইভাবে BH/BL, CH/CL, DH/DL. এতে 8085-এর ৮ বিটের অভ্যাসও চলে, আবার ১৬ বিটের হিসাবও।

Registerদলবিশেষ কাজ (পরের পর্বগুলোতে বিস্তারিত)
AX (AH, AL)সাধারণaccumulator: MUL/DIV-এর operand আর ফল, IN/OUT
BX (BH, BL)সাধারণbase: মেমরির offset রাখতে পারে, [bx]
CX (CH, CL)সাধারণcount: LOOP, REP-এর গুনতি; shift-এর গুনতি CL-এ
DX (DH, DL)সাধারণdata: ১৬ বিট গুণের উঁচু অর্ধেক, I/O port-এর ঠিকানা
SPpointerstack pointer: SS-এর ভেতরে stack-এর মাথা
BPpointerbase pointer: stack-এর ভেতরের data, সাধারণত SS ধরে
SI, DIindexindex register: string নির্দেশের উৎস (DS:SI) আর গন্তব্য (ES:DI)
CS, DS, SS, ESsegmentcode, data, stack আর extra segment-এর শুরু
IPBIUCS-এর ভেতরে পরের নির্দেশের offset; নির্দেশ দিয়ে সরাসরি MOV করা যায় না
FLAGSEUনয়টি flag (অংশ ৭)

AX, BX, CX, DX, SP, BP, SI, DI-কে একসঙ্গে বলে general-purpose register, কারণ সাধারণ যোগ-বিয়োগ-MOV-এ এদের যেকোনোটি চলে। তবু কিছু নির্দেশ নির্দিষ্ট register ছাড়া চলে না, যেমন LOOP সবসময় CX কমায়। কোন নির্দেশ কোন register চায়, তা পর্ব ১৬-তে (8086-এর instruction set). এবার একটি ছোট program দিয়ে register-এর অর্ধেক আর segment একসঙ্গে দেখি। বাজারঘরের smart scale-এর দুটি সংখ্যা নেওয়া হলো: net ওজন 1250 g আর আলুর দর 6550 পয়সা/kg (reference lab-এর README, “বাজারঘর devices”).

; arch86.asm - registers, halves, segments (8086, NASM)
        org 100h
        mov ax, 1250        ; net weight in g = 04E2h
        mov bx, 6550        ; rate in paisa/kg = 1996h
        mov cl, ah          ; CL <- high half of AX
        mov ch, bl          ; CH <- low half of BX
        mov bx, 0150h       ; BX = offset
        mov [bx], ax        ; DS:0150h <- E2h, 04h
        mov dx, 1010h
        mov es, dx          ; ES = 1010h
        mov di, [es:0050h]  ; 1010h:0050h = same byte
        push ax             ; SS:SP = 1000h:FFFCh
        pop bp
        hlt

সত্যিকারের run (run8086.py, NASM 3.02, Unicorn 2.1.4; trace-এর লাইন ছোট করতে SI, CS, DS, SS-এর কলাম বাদ, সেগুলো পুরো সময় 0000H, 1000H, 1000H, 1000H):

$ python -B run8086.py arch86.asm --trace --regs --mem 0150h,2 --mem 1010:0050,2 --mem 1000:FFFC,2
1000:0100 B8E204     mov ax,0x4e2    AX=04E2 BX=0000 CX=0000 DX=0000 DI=0000 ES=1000 SP=FFFE
1000:0103 BB9619     mov bx,0x1996   AX=04E2 BX=1996 CX=0000 DX=0000 DI=0000 ES=1000 SP=FFFE
1000:0106 88E1       mov cl,ah       AX=04E2 BX=1996 CX=0004 DX=0000 DI=0000 ES=1000 SP=FFFE
1000:0108 88DD       mov ch,bl       AX=04E2 BX=1996 CX=9604 DX=0000 DI=0000 ES=1000 SP=FFFE
1000:010A BB5001     mov bx,0x150    AX=04E2 BX=0150 CX=9604 DX=0000 DI=0000 ES=1000 SP=FFFE
1000:010D 8907       mov [bx],ax     AX=04E2 BX=0150 CX=9604 DX=0000 DI=0000 ES=1000 SP=FFFE
1000:010F BA1010     mov dx,0x1010   AX=04E2 BX=0150 CX=9604 DX=1010 DI=0000 ES=1000 SP=FFFE
1000:0112 8EC2       mov es,dx       AX=04E2 BX=0150 CX=9604 DX=1010 DI=0000 ES=1010 SP=FFFE
1000:0114 268B3E5000 mov di,[es:0x50] AX=04E2 BX=0150 CX=9604 DX=1010 DI=04E2 ES=1010 SP=FFFE
1000:0119 50         push ax         AX=04E2 BX=0150 CX=9604 DX=1010 DI=04E2 ES=1010 SP=FFFC
1000:011A 5D         pop bp          AX=04E2 BX=0150 CX=9604 DX=1010 DI=04E2 ES=1010 SP=FFFE
----
----
AX=04E2 BX=0150 CX=9604 DX=1010 SI=0000 DI=04E2 BP=04E2 SP=FFFE CS=1000 DS=1000 ES=1010 SS=1000 IP=011B --I------
1000:0150  E2 04
1010:0050  E2 04
1000:FFFC  E2 04
[exit code 0 via HLT, 12 instructions]
0100mov ax,12500103mov bx,65500106mov cl,ah0108mov ch,bl010Amov bx,0150h010Dmov [bx],ax010Fmov dx,1010h0112mov es,dx0114mov di,[es:0050h]0119push ax011Apop bp
নির্দেশের পরে
AX
BX
CH · CL
DX · ES
DI · BP
SP · IP
10150H
  1. mov ax,1250. 1250 = 04E2H: AH = 04H, AL = E2H. নির্দেশটি তিন byte (B8 E2 04), তাই IP 0100H থেকে 0103H. ১৬ বিটের মানও little-endian-এ লেখা: নিচু byte আগে।
  2. mov bx,6550. দর 6550 = 1996H. 8085-এ এমন মান রাখতে register pair লাগত; এখানে একটি register-ই যথেষ্ট।
  3. mov cl,ah. AX-এর উঁচু অর্ধেক 04H গেল CL-এ। CX = 0004H: CH এখনো 00H. অর্ধেক বদলালে অন্য অর্ধেক অক্ষত থাকে।
  4. mov ch,bl. BX-এর নিচু অর্ধেক 96H গেল CH-এ। CX = 9604H. ৮ বিটের অর্ধেক থেকে অন্য register-এর অর্ধেকে সরাসরি MOV চলে।
  5. mov bx,0150h. BX এখন একটি offset. এখনো কোনো মেমরি ছোঁয়া হয়নি।
  6. mov [bx],ax. EU offset 0150H দেয়, BIU যোগ করে DS × 10H + 0150H = 10000H + 0150H = 10150H. সেখানে লেখা হলো E2 04: নিচু byte নিচু ঠিকানায়।
  7. mov dx,1010h. DX = 1010H. Segment register-এ সরাসরি সংখ্যা রাখার নির্দেশ নেই, তাই আগে একটি সাধারণ register-এ আনতে হয়।
  8. mov es,dx. ES = 1010H. এই segment-এর শুরু 10100H, DS-এর শুরুর চেয়ে মাত্র 100H byte ওপরে।
  9. mov di,[es:0050h]. ঠিকানা ES × 10H + 0050H = 10100H + 0050H = 10150H, অর্থাৎ ধাপ ৬-এর একই ঘর। DI = 04E2H: অন্য নামে একই data পাওয়া গেল।
  10. push ax. SP দুই কমে FFFCH, আর SS:SP = 1000H:FFFCH = 1FFFCH-এ E2 04 লেখা হলো। Stack নিচের দিকে বাড়ে।
  11. pop bp. 1FFFCH থেকে word পড়ে BP = 04E2H, SP আবার FFFEH. মেমরিতে E2 04 রয়ে যায়; pop শুধু SP সরায়, মুছে দেয় না।

Trace-এর শেষ লাইনের --I------ হলো runner-এর flag-এর ছাপ: নয়টি ঘর O D I T S Z A P C ক্রমে, যে flag 1 সেটির অক্ষর, না হলে “-”. পুরো program-এ MOV, PUSH আর POP কোনো flag বদলায়নি, তাই শুধু শুরুর IF = 1 রয়ে গেছে (Spec decision 13). Intel-এর মতো ভাষায় বললে, data transfer নির্দেশ flag ছোঁয় না, ঠিক 8085-এর মতো।

সাবধান: 8086-এর register সব ১৬ বিটের; ২০ বিটের কোনো register নেই। “IP ২০ বিট” বা “segment register-এ পুরো ঠিকানা থাকে” লেখা পরীক্ষায় সরাসরি ভুল। ২০ বিট তৈরি হয় শুধু BIU-র adder-এর ভেতরে, bus-এ পাঠানোর মুহূর্তে।

৫ · Segment আর physical address — ১৬ বিট দিয়ে ২০ বিটের ঠিকানা

সমস্যাটি এমন: register ১৬ বিটের, তাই একটি register দিয়ে 65536টি ঠিকানার বেশি বলা যায় না। অথচ মেমরি 1 MB, অর্থাৎ ১৬ গুণ বড়। Intel-এর সমাধান: ঠিকানা দুই ভাগে বলা। প্রথম ভাগ একটি segment register, যা বলে মেমরির কোন জায়গা থেকে একটি 64 KB-এর জানালা শুরু হচ্ছে। দ্বিতীয় ভাগ offset, যা বলে সেই জানালার শুরু থেকে কত byte দূরে। BIU দুটি মিলিয়ে আসল, অর্থাৎ physical address বানায়:

Physical address = Segment × 10H + Offset

× 10H মানে hex-এ ডানে একটি 0 বসানো, বা binary-তে চার বিট বাঁয়ে সরানো। Segment 1000H হয়ে যায় 10000H (২০ বিট), তারপর ১৬ বিটের offset যোগ। ফল সবসময় ৫ hex অঙ্ক। এমন ঠিকানাকে বলে logical address বা segment:offset জোড়া, আর লেখা হয় 1000H:0150H ধাঁচে। কোন segment register কোন কাজে ডিফল্ট, তা নির্দিষ্ট:

কাজSegmentOffset আসেLab-এর উদাহরণ
পরের নির্দেশ আনাCSIP1000H:0100H → 10100H
সাধারণ dataDSBX, SI, DI বা সরাসরি সংখ্যা1000H:0150H → 10150H
Stack (PUSH, POP, CALL)SSSP; আর BP-ভিত্তিক ঠিকানা1000H:FFFCH → 1FFFCH
String-এর গন্তব্যESDIপর্ব ১৯-এ

Data-র জন্য ডিফল্ট DS-এর বদলে অন্য segment চাইলে নির্দেশের আগে একটি segment override prefix বসে: arch86.asm-এর [es:0050h]-এর জন্য NASM 26 byte বসিয়েছে (26 8B 3E 50 00). Addressing mode আর override-এর পুরো নিয়ম পরের পর্বে, পর্ব ১৫-তে (8086-এর addressing mode আর effective address). এবার হিসাবটি ধাপে ধাপে।

হিসাব
জোড়া
segment × 10H
+ offset
physical
সেখানে কী
  1. Segment-কে চার বিট সরানো। CS = 1000H = 0001 0000 0000 0000. ডানে চারটি 0 বসালে 0001 0000 0000 0000 0000 = 10000H. এটিই code segment-এর শুরু, যাকে segment base বলে।
  2. IP যোগ। 10000H + 0100H = 10100H. lab-এ program ঠিক এখানেই বসানো (Spec decision 13), আর সেখানে প্রথম byte B8, অর্থাৎ mov ax,…-এর opcode.
  3. Data: DS আর BX. mov [bx],ax-এ BX = 0150H, segment ডিফল্টভাবে DS = 1000H. 10000H + 0150H = 10150H. সত্যিকারের run-এ 1000:0150-এ E2 04.
  4. অন্য নাম, একই ঘর। ES = 1010H → 10100H; সঙ্গে 0050H যোগ করে আবার 10150H. দুটি আলাদা segment:offset একই physical byte দেখায়; runner-এর --mem 1010:0050,2-ও E2 04 দেখিয়েছে।
  5. Stack: SS আর SP. push ax-এর পরে SP = FFFCH. 10000H + FFFCH = 1FFFCH, segment-এর প্রায় ওপরের কিনারায়। Stack segment-এর মাথা থেকে নিচের দিকে নামে।
  6. পরীক্ষার ধাঁচের উদাহরণ। DS = 4321H, BX = 1234H: 43210H + 1234H = 44444H. হিসাবের ধাপ একই: আগে segment-এর ডানে 0, তারপর offset যোগ, ফল পাঁচ অঙ্কে।

এবার নিজের সংখ্যা দিয়ে হিসাব চালান। নিচের ব্লক একই সূত্রে কয়েকটি জোড়া হিসাব করে, তারপর গোনে একটি ঠিকানাকে কত রকম segment:offset নামে ডাকা যায়।

# 8086-এর physical address: segment × 10H + offset, ২০ বিটে
def phys(seg, off):
    return ((seg << 4) + off) & 0xFFFFF        # 8086-এ ২১তম বিট নেই: ঘুরে যায়

cases = [("CS:IP", 0x1000, 0x0100),            # lab-এ program শুরু
         ("DS:BX", 0x1000, 0x0150),
         ("ES:0050H", 0x1010, 0x0050),         # অন্য segment, একই ঘর
         ("SS:SP", 0x1000, 0xFFFC),            # push ax-এর পরে
         ("DS:BX", 0x4321, 0x1234),
         ("FFFFH:0010H", 0xFFFF, 0x0010)]      # 1 MB পেরোলে
for name, seg, off in cases:
    shifted = seg << 4
    print(f"{name:12} {seg:04X}H:{off:04X}H -> {shifted:05X}H + {off:04X}H"
          f" = {phys(seg, off):05X}H")

target = 0x10150                               # একই ঘরের কতগুলো নাম?
names = [(s, target - (s << 4)) for s in range(0x10000)
         if 0 <= target - (s << 4) <= 0xFFFF]
print(len(names), "টি segment:offset জোড়া 10150H দেখায়; প্রথম আর শেষ:",
      f"{names[0][0]:04X}H:{names[0][1]:04X}H, {names[-1][0]:04X}H:{names[-1][1]:04X}H")
print(f"DS = 1000H হলে segment-এর পরিসর {phys(0x1000, 0):05X}H-{phys(0x1000, 0xFFFF):05X}H,"
      f" মোট {0xFFFF + 1} byte")
print("২০টি ঠিকানার লাইন:", 2**20, "byte =", 2**20 // 1024, "KiB")

আসল আউটপুট (ব্রাউজারের Python):

CS:IP        1000H:0100H -> 10000H + 0100H = 10100H
DS:BX        1000H:0150H -> 10000H + 0150H = 10150H
ES:0050H     1010H:0050H -> 10100H + 0050H = 10150H
SS:SP        1000H:FFFCH -> 10000H + FFFCH = 1FFFCH
DS:BX        4321H:1234H -> 43210H + 1234H = 44444H
FFFFH:0010H  FFFFH:0010H -> FFFF0H + 0010H = 00000H
4096 টি segment:offset জোড়া 10150H দেখায়; প্রথম আর শেষ: 0016H:FFF0H, 1015H:0000H
DS = 1000H হলে segment-এর পরিসর 10000H-1FFFFH, মোট 65536 byte
২০টি ঠিকানার লাইন: 1048576 byte = 1024 KiB

প্রথম পাঁচটি লাইন stepper আর সত্যিকারের run-এর সঙ্গে মেলে। ষষ্ঠ লাইনটি বিশেষ: FFFF0H + 0010H = 100000H, যা ২১ বিট; 8086-এ ২১তম ঠিকানার লাইন নেই, তাই উঁচু বিট হারিয়ে ঠিকানা ঘুরে 00000H-এ আসে (অংশ ৬)। সপ্তম লাইন: segment প্রতি ১ বাড়লে offset 10H কমালে একই ঘর, তাই 10150H-কে 0016H:FFF0H থেকে 1015H:0000H পর্যন্ত ৪০৯৬ নামে ডাকা যায়। আর DS-এর একটি মান দিয়ে ঠিক 64 KB ছোঁয়া যায়, তার বেশি নয়।

উল্টো হিসাবও পরীক্ষায় আসে: physical address আর offset দেওয়া, segment বের করুন। উত্তর: (physical − offset) ÷ 10H. যেমন physical 4A3B0H আর offset 0B30H হলে 4A3B0H − 0B30H = 49880H, তাই segment 4988H. বিয়োগফলের শেষ অঙ্ক 0 না হলে সেই offset দিয়ে ঠিকানাটি পাওয়াই যায় না, কারণ segment-এর শুরু সবসময় 16-এর গুণিতকে, যাকে বলে paragraph. Segment ধারণার সাধারণ তত্ত্ব, যেখানে প্রতিটি segment-এর সীমা আর অনুমতিও থাকে, পড়তে পারেন Operating Systems পর্ব ৩৪-এ; 8086-এর segmentation তার সবচেয়ে সরল রূপ, কোনো সুরক্ষা ছাড়া।

MASM আর NASM — একই ঠিকানা, আলাদা লেখা

বহু বই আর পরীক্ষার প্রশ্ন লেখা হয় Microsoft-এর MASM (বা TASM)-এর ধাঁচে, অথচ এই কোর্সের চালানো যায় এমন কোড NASM-এ। ঠিকানার লেখায় পার্থক্যগুলো ছোট, কিন্তু জানা জরুরি:

কাজMASM/TASMNASM
Override দিয়ে পড়াmov di, es:[0050h]mov di, [es:0050h]
Label-এর offsetmov dx, offset msgmov dx, msg
মাপ বলে দেওয়াmov word ptr [bx], 5mov word [bx], 5
Program-এর কাঠামো.MODEL, .DATA, .CODEorg 100h (.COM); পর্ব ১৭-তে পাশাপাশি

৬ · Overlapping segment আর 1 MB-এর মানচিত্র

Segment-এর শুরু প্রতি 16 byte-এ বসানো যায়, অথচ প্রতিটি segment 64 KB লম্বা। তাই দুটি segment প্রায় সবসময় একে অপরের ওপর পড়ে। arch86.asm-এ DS = 1000H-এর segment 10000H–1FFFFH, আর ES = 1010H-এর segment 10100H–200FFH: মাঝের 10100H–1FFFFH দুটিরই অংশ। এটি ভুল নয়, নকশারই অংশ। এর লাভ দুটি: ছোট program অল্প মেমরিতে আঁটানো যায় (CS, DS, SS একই মান দিলে পুরো program একটি 64 KB-এর জানালায়, যেমন DOS-এর .COM ফাইল আর এই lab-এ), আর একটি program-কে মেমরির যেকোনো paragraph-এ বসিয়ে শুধু segment register বদলে চালানো যায়। ঝুঁকিও আছে: এক segment-এর stack বাড়তে বাড়তে অন্য segment-এর data মুছে দিতে পারে, আর 8086 তা ধরার কোনো ব্যবস্থা রাখেনি।

ছবি ১৪.২ — 8086-এর 1 MB মেমরির মানচিত্র (মাপ অনুযায়ী নয়)

নিচে ছোট ঠিকানা; মাঝে lab-এর দুটি overlapping segment; ওপরে reset-এর পরের প্রথম নির্দেশ

8086-এর 1 MB মেমরির মানচিত্র FFFF0H: reset CS=FFFFH, IP=0 ⋮ দুটি segment-এর ভাগের জায়গা 10150H 00000H–003FFH vector table FFFFFH 00000H DS=1000H 10000H– 1FFFFH ES=1010H 10100H– 200FFH
ছবি ১৪.২ — বাঁয়ের বন্ধনী DS = 1000H-এর 64 KB, ডানের বন্ধনী ES = 1010H-এর 64 KB; গাঢ় নীল অংশ দুটিরই। লাল দাগ 10150H, যেখানে arch86.asm লিখেছে আর অন্য নামে পড়েছে। সবচেয়ে নিচের 1 KB-তে 256টি interrupt-এর ঠিকানার তালিকা (পর্ব ২০); সবচেয়ে ওপরের 16 byte-এ reset-এর পরের প্রথম নির্দেশ।

মানচিত্রের দুই প্রান্ত Intel নির্দিষ্ট করে দিয়েছে। নিচের প্রান্তে 00000H–003FFH: ২৫৬টি interrupt-এর প্রতিটির জন্য ৪ byte (IP আর CS), মোট 1 KB-এর interrupt vector table; এর বিস্তারিত পর্ব ২০-এ (8086-এর interrupt). ওপরের প্রান্তে reset: Intel-এর manual অনুযায়ী RESET-এর পরে CS = FFFFH, IP = 0000H, DS = SS = ES = 0000H, flag সব 0 আর queue খালি। তাই প্রথম নির্দেশ আসে FFFFH × 10H + 0000H = FFFF0H থেকে, মেমরির শেষ ১৬ byte-এ। সেখানে সাধারণত ROM-এর একটি far JMP থাকে, যা আসল startup কোডে নিয়ে যায়। কোর্সের lab reset মডেল করে না; সে DOS-এর মতো সরাসরি 1000H:0100H থেকে শুরু করে (Spec decision 13).

আর 1 MB পেরোলে কী হয়? FFFFH:0010H = 100000H, যা ২১ বিট। 8086-এর ঠিকানার লাইন ২০টি, তাই ২১তম বিট বাইরে যায়ই না, আর ঠিকানা ঘুরে 00000H-এ পড়ে, যাকে বলে wraparound. কোর্সের lab-এ এই নির্দেশ চালিয়ে দেখা হয়েছে: Unicorn একটি 386-শ্রেণির CPU, তাই সে 100000H-এই পড়তে চায়, আর lab শুধু 1 MiB মেমরি রাখে বলে run থামে error: CPU exception: Invalid memory read (UC_ERR_READ_UNMAPPED) at 1000:0105 বার্তায়। অর্থাৎ এই একটি আচরণ lab-এ আসল 8086-এর মতো নয়; Spec decision 15-এ আরও চারটি নথিভুক্ত পার্থক্য আছে, যেগুলো অংশ ৭-এ একটির দেখা পাবেন।

আরও গভীরে: ১৯৮১ সালের IBM PC 8088 ব্যবহার করত, আর কিছু পুরোনো program এই wraparound-এর ওপর নির্ভর করত। ১৯৮২ সালের 80286-এ ঠিকানার লাইন ২৪টি, তাই real mode-এ FFFFH:0010H সত্যিই 100000H-এ পৌঁছায়, ঘোরে না। পুরোনো program বাঁচাতে IBM PC/AT (১৯৮৪)-এ ২১তম লাইনটি (A20) একটি gate দিয়ে বন্ধ রাখার ব্যবস্থা হয়, যাকে বলে A20 gate; OS বুটের সময় এটি খুলত। আর FFFF0H থেকে FFFFH:FFFFH পর্যন্ত প্রায় 64 KB-এর বাড়তি জায়গা পরে DOS-এ “high memory area” নামে ব্যবহার হয়েছে। আজকের x86 PC-ও প্রথমে real mode-এ জেগে ওঠে, 8086-এর এই নিয়মেই।

৭ · Flag register — নয়টি flag, ছয়টি ফলের, তিনটি নিয়ন্ত্রণের

8086-এর FLAGS register ১৬ বিটের, যার নয়টি বিট ব্যবহার হয়। ছয়টি status flag: শেষ হিসাবের ফলের চিহ্ন, 8085-এর পাঁচটির সঙ্গে নতুন OF. তিনটি control flag: programmer নিজে বসান, CPU-র আচরণ বদলাতে। পুরো বিন্যাস, যা পরীক্ষায় প্রায়ই আঁকতে বলা হয়:

বিটFlagধরনকখন 1, বা কী করে
0CF carrystatusউঁচু বিট থেকে carry (যোগ) বা borrow (বিয়োগ): unsigned সীমা পেরোনো
2PF paritystatusফলের নিচের ৮ বিটে 1-এর সংখ্যা জোড়
4AF auxiliary carrystatusবিট ৩ থেকে বিট ৪-এ carry; DAA, AAA-র জন্য
6ZF zerostatusফলের সব বিট 0
7SF signstatusফলের সবচেয়ে উঁচু বিট (৮ বিটে বিট ৭, ১৬ বিটে বিট ১৫)
8TF trapcontrol1 হলে প্রতিটি নির্দেশের পরে interrupt type 1: single-step debugging
9IF interrupt enablecontrol1 হলে INTR pin-এর অনুরোধ মানা হয়; STI, CLI
10DF directioncontrol0 হলে string নির্দেশ SI/DI বাড়ায়, 1 হলে কমায়; CLD, STD
11OF overflowstatussigned (two's complement) ফল সীমা পেরোলে

বিট ১, ৩, ৫ আর ১২–১৫ ব্যবহার হয় না। বিট ১ সবসময় 1, তাই lab-এর শুরুর FLAGS = 0202H মানে IF = 1 আর বিট ১ = 1. সবচেয়ে বড় নতুনত্ব OF. 8085-এ শুধু CY ছিল, তাই signed হিসাবের overflow ধরতে programmer-কে নিজে চিহ্ন মেলাতে হতো (পর্ব ০৫)। 8086-এ ALU একই যোগের পরে দুটি প্রশ্নের উত্তর একসঙ্গে দেয়: CF বলে unsigned অর্থে ফল আঁটল কি না, OF বলে signed অর্থে। নিয়মটি: OF = 1 যখন দুটি operand-এর চিহ্ন এক, অথচ ফলের চিহ্ন আলাদা; সমতুল্যভাবে, উঁচু বিটে ঢোকা carry আর উঁচু বিট থেকে বেরোনো carry আলাদা হলে।

; flags86.asm - ADD sets CF, OF, SF, ZF, AF, PF
        org 100h
        mov al, 100         ; 64h
        add al, 50          ; 96h: signed overflow
        mov al, 200         ; C8h
        add al, 100         ; 12Ch: unsigned carry
        mov ax, 30000       ; 7530h paisa
        add ax, 5000        ; 88B8h: signed overflow
        pushf
        pop dx              ; DX <- FLAGS word
        mov al, 0F0h
        add al, 10h         ; 100h: ZF, CF
        hlt

সত্যিকারের run (run8086.py --trace; register-এর কলাম থেকে শুধু AX আর DX রাখা, flag-এর ছাপ O D I T S Z A P C ক্রমে):

1000:0100 B064    mov al,0x64    AX=0064 DX=0000 --I------
1000:0102 0432    add al,0x32    AX=0096 DX=0000 O-I-S--P-
1000:0104 B0C8    mov al,0xc8    AX=00C8 DX=0000 O-I-S--P-
1000:0106 0464    add al,0x64    AX=002C DX=0000 --I-----C
1000:0108 B83075  mov ax,0x7530  AX=7530 DX=0000 --I-----C
1000:010B 058813  add ax,0x1388  AX=88B8 DX=0000 O-I-S--P-
1000:010E 9C      pushf          AX=88B8 DX=0000 O-I-S--P-
1000:010F 5A      pop dx         AX=88B8 DX=0A86 O-I-S--P-
1000:0110 B0F0    mov al,0xf0    AX=88F0 DX=0A86 O-I-S--P-
1000:0112 0410    add al,0x10    AX=8800 DX=0A86 --I--Z-PC
----
[exit code 0 via HLT, 11 instructions]

প্রথম যোগটি, 100 + 50, বিট ধরে খুলে দেখি। বাজারঘরের ভাষায়: দুটি ব্যাগ, 100 g আর 50 g; মোট 150 g ৮ বিটের unsigned সীমায় (255) আরামে আঁটে, অথচ signed সীমা (127) পেরিয়ে যায়।

হিসাব আর flag
হিসাব
CF · OF
SF · ZF
AF · PF
দশমিকে
  1. দুটি operand. AL = 64H = 0110 0100 (100), যোগ হবে 32H = 0011 0010 (50). দুটিরই বিট ৭ = 0: signed অর্থে দুটিই ধনাত্মক।
  2. AF: নিচের nibble. 4 + 2 = 6, বিট ৩ থেকে বিট ৪-এ carry নেই, তাই AF = 0.
  3. CF: পুরো যোগ। ফল 1001 0110 = 96H = 150, যা ২৫৫-এর কম; বিট ৭ থেকে কিছু বেরোয়নি, তাই CF = 0. Unsigned অর্থে ফল নির্ভুল।
  4. OF: চিহ্নের হিসাব। বিট ৬-এর যোগে carry তৈরি হয়ে বিট ৭-এ ঢুকেছে (1), কিন্তু বিট ৭ থেকে বেরোয়নি (0): দুটি আলাদা, তাই OF = 1. দুটি ধনাত্মক যোগ করে ফলের বিট ৭ = 1, অর্থাৎ signed অর্থে −106: ভুল ফল।
  5. SF, ZF, PF. ফলের বিট ৭ = 1, তাই SF = 1; ফল শূন্য নয়, ZF = 0; 1001 0110-এ চারটি 1, জোড়, তাই PF = 1.
  6. Runner-এর সঙ্গে মিলিয়ে দেখা। সত্যিকারের trace-এ add al,0x32-এর পরে O-I-S--P-: OF, IF, SF, PF = 1, বাকি সব 0. হাতের হিসাব আর emulator এক।

দ্বিতীয় যোগ উল্টো ঘটনা: 200 + 100 = 300, ৮ বিটে আঁটে না, AL = 2CH (44) আর CF = 1; কিন্তু signed অর্থে C8H = −56, আর −56 + 100 = 44 একদম ঠিক, তাই OF = 0. তৃতীয়টি বাজারঘরের দুটি অর্ডার, 300.00 টাকা আর 50.00 টাকা, পয়সায় 30000 + 5000 = 35000. ১৬ বিটের unsigned সীমা 65535, তাই CF = 0; signed সীমা 32767, তাই OF = 1 আর AX-এর signed অর্থ −30536. দামের মতো যে সংখ্যা কখনো ঋণাত্মক হয় না, তার জন্য CF দেখাই ঠিক; তাপমাত্রার মতো signed সংখ্যায় OF. কোন flag দেখে লাফ দেবেন, সেটি নির্ভর করে সংখ্যাটি কী অর্থে রাখা, আর এখান থেকেই পর্ব ১৬-এর JB বনাম JL-এর পার্থক্য আসে।

PUSHF তারপর POP DX পুরো FLAGS word-টি একটি register-এ আনে: DX = 0A86H = OF (800H) + IF (200H) + SF (80H) + PF (4H) + বিট ১ (2H). একটি নথিভুক্ত পার্থক্য এখানে: আসল 8086-এ ব্যবহার না হওয়া বিট ১২–১৫ PUSHF-এ 1 দেখায়, তাই আসল chip-এ মানটি হতো FA86H; Unicorn ৩৮৬-শ্রেণির CPU বলে সেগুলো 0 দেখায় (Spec decision 15). নিচের ব্লক একই নিয়মে চারটি যোগের flag আর FLAGS word বানায়, runner-এর ছাপের ধাঁচে।

# ADD-এর পরে 8086-এর ছয়টি status flag, run8086.py-র ধাঁচে ছাপা
def add(a, b, bits):
    mask, top = (1 << bits) - 1, 1 << (bits - 1)
    t = a + b
    r = t & mask
    f = {"O": int((a & top) == (b & top) and (r & top) != (a & top)),
         "S": int(bool(r & top)),                    # ফলের সবচেয়ে উঁচু বিট
         "Z": int(r == 0),
         "A": int((a & 0xF) + (b & 0xF) > 0xF),      # বিট ৩ থেকে carry
         "P": int(bin(r & 0xFF).count("1") % 2 == 0),  # শুধু নিচের byte
         "C": int(t > mask)}
    return r, f

POS = {"O": 11, "D": 10, "I": 9, "T": 8, "S": 7, "Z": 6, "A": 4, "P": 2, "C": 0}
for a, b, bits in [(0x64, 0x32, 8), (0xC8, 0x64, 8), (0x7530, 0x1388, 16),
                   (0xF0, 0x10, 8)]:
    r, f = add(a, b, bits)
    f["I"] = 1                                       # lab-এ শুরুতে IF = 1
    text = "".join(k if f.get(k) else "-" for k in POS)
    word = 2 + sum(f.get(k, 0) << p for k, p in POS.items())  # বিট ১ সবসময় 1
    w = bits // 4
    sa = a - (1 << bits) if a >= 1 << (bits - 1) else a
    sr = r - (1 << bits) if r >= 1 << (bits - 1) else r
    print(f"{a:0{w}X}h + {b:0{w}X}h = {r:0{w}X}h  {text}  FLAGS={word:04X}h"
          f"  unsigned {a}+{b}={r}  signed {sa}+{b}={sr}")

আসল আউটপুট (ব্রাউজারের Python):

64h + 32h = 96h  O-I-S--P-  FLAGS=0A86h  unsigned 100+50=150  signed 100+50=-106
C8h + 64h = 2Ch  --I-----C  FLAGS=0203h  unsigned 200+100=44  signed -56+100=44
7530h + 1388h = 88B8h  O-I-S--P-  FLAGS=0A86h  unsigned 30000+5000=35000  signed 30000+5000=-30536
F0h + 10h = 00h  --I--Z-PC  FLAGS=0247h  unsigned 240+16=0  signed -16+16=0

চারটি flag-ছাপই সত্যিকারের trace-এর সঙ্গে অক্ষরে অক্ষরে মেলে, আর তৃতীয় লাইনের 0A86h ঠিক POP DX-এর মান। দ্বিতীয় আর চতুর্থ লাইনের “unsigned … = 44” আর “= 0” হলো register-এ যা থাকে; হারানো বিটটি CF-এ। তৃতীয় লাইনে PF = 1. 88B8H-এর পুরো ১৬ বিটে ছয়টি 1, কিন্তু সেটি কারণ নয়: PF শুধু নিচের byte B8H (1011 1000, চারটি 1) দেখে, যা 8086-এর একটি পরিচিত ফাঁদ। চতুর্থ লাইনে ZF আর CF দুটিই 1: ফল শূন্য, অথচ আসল যোগফল 256.

তিনটি control flag ফল থেকে বসে না; programmer বা CPU নিজে সেগুলো বদলায়, আর প্রতিটির নিজের পর্ব আছে। IF হলো বাইরের interrupt-এর দরজা: CLI দরজা বন্ধ করে, STI খোলে। Firmware-এ যখন একটি ভাগ করা মান, যেমন smart scale-এর শেষ ওজন, একসঙ্গে দুই ধাপে বদলাতে হয়, তখন মাঝখানে interrupt এসে অর্ধেক-বদলানো মান পড়ে না ফেলে সেজন্য অল্প সময় IF = 0 রাখা হয়; এই ধারণা পর্ব ২০-এ আর পরে Cortex-M-এ পর্ব ৪৩-এ ফিরে আসবে। TF debugger-এর হাতিয়ার: 1 করলে প্রতিটি নির্দেশের পরে CPU থামে আর type 1 interrupt-এ যায়, যাতে একটি একটি নির্দেশ দেখা যায়, ঠিক কোর্সের runner-এর --trace-এর মতো। DF ঠিক করে string নির্দেশ মেমরিতে সামনে না পেছনে যাবে, যা পর্ব ১৯-এ। Interrupt ঢোকার সময় CPU নিজেই IF আর TF মুছে দেয় (reference lab-এর Spec decision 14-ও এটি মানে)।

বাজারঘরের দাম — ১৬ বিট কতটা সহজ করে

পর্ব ০৭-এ দেখেছেন, smart scale-এর দামের সূত্র price = (net_g × 6550 + 500) ÷ 1000 8085-এ কয়েক byte জুড়ে loop চালিয়ে করতে হতো। 8086-এ একই কাজ কয়েকটি নির্দেশে, কারণ MUL ১৬ × ১৬ বিট গুণ করে ৩২ বিটের ফল DX:AX-এ রাখে, আর DIV সেটিকে ভাগ করে। নির্দেশগুলোর পুরো নিয়ম পর্ব ১৬-তে; এখানে শুধু register-এর চওড়ার লাভটি দেখুন (সত্যিকারের run, price86.asm):

        mov ax, 1250        ; net weight, g
        mov bx, 6550        ; rate, paisa per kg
        mul bx              ; DX:AX <- AX x BX (32-bit)
        add ax, 500         ; round half up
        adc dx, 0
        mov cx, 1000
        div cx              ; AX <- quotient, DX <- remainder
        hlt

$ python -B run8086.py price86.asm --trace     (৭টির মধ্যে ৩টি লাইন; শুধু AX, CX, DX)
1000:0106 F7E3    mul bx         AX=EE6C CX=0000 DX=007C
1000:0108 05F401  add ax,0x1f4   AX=F060 CX=0000 DX=007C
1000:0111 F7F1    div cx         AX=1FFC CX=03E8 DX=0000

DX:AX = 007CEE6CH = 8,187,500, যোগ 500-এর পরে 007CF060H = 8,188,000, আর ভাগফল AX = 1FFCH = 8188 পয়সা = 81.88 টাকা, ঠিক README-এর মান। মাঝের গুণফল ২৩ বিটের, তবু দুটি ১৬ বিটের register জুড়ে তা সহজে আঁটল।

পরীক্ষা ও ইন্টারভিউতে: “BIU আর EU-র কাজ লিখুন” → BIU: fetch, ঠিকানা তৈরি, bus আর queue; EU: decode, ALU, register আর flag. “8086 কত মেমরি ছুঁতে পারে” → ২০টি লাইন, 220 = 1 MB. “CS = 3400H, IP = 1A20H হলে physical address” → 34000H + 1A20H = 35A20H. “Queue-র মাপ” → 8086-এ ৬ byte, 8088-এ ৪ byte. “OF আর CF-এর পার্থক্য” → CF unsigned সীমা, OF signed সীমা; 7530H + 1388H-এ OF = 1, CF = 0.

৮ · AI-এর যুগে 8086-এর গঠন যাচাই

8086 নিয়ে AI assistant-এর উত্তর সাধারণত আত্মবিশ্বাসী আর সুন্দর করে সাজানো থাকে। ভুল লুকিয়ে থাকে সংখ্যায় আর chip-এর নামে, আর সেগুলো ধরা সহজ, যদি জানেন কোথায় দেখবেন:

AI প্রায়ই যা করেকীভাবে ধরবেন
Segment আর offset সরাসরি যোগ করে (3400H + 1A20H = 4E20H)Segment-এর ডানে একটি 0 বসিয়েছে কি না দেখা; ফল সবসময় পাঁচ hex অঙ্ক
8086-এ 8085-এর AC/CY নাম বা Z80-এর IX, IY ঢুকিয়ে দেয়; বা 386-এর EAX, FS, GSIntel-এর 8086 manual-এর register তালিকা; NASM-এ cpu 8086 দিয়ে assemble করলে 186+ নির্দেশ বাতিল হয় (Spec decision 13)
Queue-র মাপ ৪ বা ৮ বলে, 8086 আর 8088 গুলিয়ে ফেলে8086: ৬ byte, 8088: ৪ byte (Intel-এর manual)
PF পুরো ১৬ বিট দেখে হিসাব করেRunner-এ add ax,1388h চালিয়ে PF দেখা: শুধু নিচের byte গোনে
নির্দেশের clock সংখ্যা নিশ্চিতভাবে বলে, উৎস ছাড়াIntel-এর টেবিলের সঙ্গে মেলানো; কোর্সের lab কোনো clock মাপে না (Spec decision 16)
mov ds, 2000h লেখেNASM-এ assemble করুন: “invalid combination of opcode and operands”
MASM-এর es:[bx] আর NASM-এর [es:bx] মিশিয়ে ফেলেকোন assembler, তা প্রশ্নে বলে দেওয়া; কোড চালিয়ে দেখা

AI-কে কাজে লাগাতে প্রসঙ্গ আর যাচাইয়ের শর্ত শুরুতেই দিন:

আমি Intel 8086 (8088, 80286 বা 386 নয়) শিখছি, NASM syntax-এ, .COM program (org 100h). ১. CS = 1000H, DS = 1000H, ES = 1010H. mov [bx],ax (BX = 0150H) আর mov di,[es:0050h]-এর physical address কত? segment × 10H + offset ধাপ লিখে দেখাও। ২. AL = 64H হলে add al,32H-এর পরে CF, PF, AF, ZF, SF, OF-এর মান কী? প্রতিটি কেন, এক লাইনে বলো। PF কোন বিটগুলো দেখে? ৩. 8086-এর BIU আর EU-তে কোন কোন register আর অংশ থাকে? Queue কত byte, আর কখন BIU নতুন byte আনে? ৪. কোনো নির্দেশের clock সংখ্যা দিতে হলে Intel-এর 8086 manual-এর টেবিল থেকে দাও, না জানলে বলো "নিশ্চিত নই"। 386-এর register বা নির্দেশ আনবে না।

AI-এর উত্তর হাতে পেলে — যাচাইয়ের চেকলিস্ট

ভাবনার প্রশ্ন

প্রতিটি প্রশ্ন নিয়ে নিজে কিছুক্ষণ ভাবুন, তারপর “→ উত্তর” চাপুন।

প্র ০১Intel কেন সরাসরি ২০ বিটের register না বানিয়ে segment:offset-এর জটিল পথে গেল? এই সিদ্ধান্তের লাভ আর দীর্ঘমেয়াদি দাম কী ছিল?

১৯৭০-এর দশকের শেষে Intel-এর সামনে দুটি চাপ ছিল। প্রথমত, 64 KB মেমরি তখন ছোট হয়ে আসছিল, আরও বড় ঠিকানার জায়গা দরকার। দ্বিতীয়ত, 8080 আর 8085-এর জন্য লেখা বিপুল software, আর গ্রাহকেরা চাইছিলেন সেগুলো নতুন chip-এ সহজে নিয়ে যেতে। 8086-এর নকশা দ্রুত শেষ করতে হয়েছিল, আর এর register ও নির্দেশ এমনভাবে সাজানো হয়েছিল যাতে 8080-এর assembly কোড যন্ত্র দিয়ে source স্তরে অনুবাদ করা যায় (binary হুবহু চলত না)। ১৬ বিটের register আর ১৬ বিটের ALU রেখে ঠিকানা বড় করার সবচেয়ে সস্তা উপায় ছিল একটি দ্বিতীয় register যোগ করে ঠিকানা তৈরি করা। পুরো ২০ বা ৩২ বিটের register মানে বড় ALU, বড় নির্দেশ আর বেশি transistor, আর ৪০ pin-এর package-এ সেই ভার বাড়ত।

লাভ ছিল বাস্তব। ছোট program একটি 64 KB-এর জানালায় থাকলে তার সব ঠিকানা ১৬ বিটের, নির্দেশ ছোট, আর সেই program-কে মেমরির যেকোনো paragraph-এ বসিয়ে শুধু segment register বদলে চালানো যায়; DOS-এর .COM program ঠিক এভাবেই চলত, আর এই কোর্সের lab-ও তাই করে। Code, data আর stack আলাদা segment-এ রাখার ধারণাও পরিষ্কার হলো। কিন্তু দাম ছিল দীর্ঘ। 64 KB-এর বড় কোনো array রাখা কঠিন, কারণ offset ১৬ বিট; programmer-দের near আর far pointer, “memory model” (small, medium, large, huge) আর segment গোনার জটিলতা নিয়ে বহু বছর লড়তে হয়েছে। একই physical ঠিকানার ৪০৯৬টি নাম থাকায় দুটি pointer সমান কি না তুলনা করাও সহজ ছিল না।

Intel পরে এই নকশা থেকে বেরোনোর পথ খুলল। ১৯৮২ সালের 80286 protected mode-এ segment register-কে একটি টেবিলের index বানাল, আর ১৯৮৫ সালের 80386 ৩২ বিটের offset আর paging এনে segment-কে প্রায় অপ্রাসঙ্গিক করে দিল। আধুনিক 64 বিটের x86-এ segment প্রায় নেই বললেই চলে। তবু প্রতিটি x86 CPU আজও real mode-এ জেগে ওঠে, 8086-এর সেই segment × 10H + offset নিয়মে।

মূল উপলব্ধি: Segmentation ছিল ১৬ বিটের যন্ত্র দিয়ে বড় মেমরি ছোঁয়ার সস্তা আপস; স্বল্পমেয়াদে সামঞ্জস্য আর সরলতা দিয়েছে, দীর্ঘমেয়াদে বড় data আর pointer-এর জটিলতা দিয়েছে।

প্র ০২Instruction queue কেন ৬ byte, ৬০ নয়? Queue বড় করলে কী লাভ হতো আর কী ক্ষতি, আর এই ধারণা আধুনিক CPU-তে কী রূপ নিয়েছে?

Queue-র উদ্দেশ্য bus-কে ব্যস্ত রাখা, যাতে EU নির্দেশের জন্য অপেক্ষা না করে। 8086-এর নির্দেশ prefix বাদে ১ থেকে ৬ byte পর্যন্ত লম্বা, আর অনেক নির্দেশ চালাতে EU-র কয়েকটি clock লাগে। একটি bus cycle-এ BIU দুই byte আনে। ছয় byte মানে মোটামুটি এক বা দুটি পরের নির্দেশ আগেই তৈরি: সাধারণ সরল কোডে এটুকুই EU-কে খাওয়াতে যথেষ্ট, কারণ EU যে গতিতে byte খায়, BIU প্রায় সেই গতিতে আনতে পারে। এর চেয়ে বড় queue বেশিরভাগ সময় ভরা পড়ে থাকত, কোনো কাজে না লেগে।

বড় queue-র ক্ষতিও স্পষ্ট। প্রতিটি লাফে queue-র সব byte বাতিল হয়। Queue যত বড়, তত বেশি byte অকারণে আনা হয়, আর সেই bus cycle-গুলো data পড়া-লেখার কাজ থেকে কেড়ে নেওয়া। সাধারণ program-এ কয়েকটি নির্দেশ পরপরই একটি লাফ আসে, তাই ৬০ byte আগে আনা মানে অধিকাংশ বাতিল। Chip-এর জায়গার প্রশ্নও ছিল: প্রায় ২৯ হাজার transistor-এর chip-এ (Intel-এর প্রচলিত হিসাব) প্রতিটি byte-এর ঘর দামি। আর 8088-এ, যার বাইরের data bus ৮ বিটের, queue ৪ byte, আর BIU এক byte খালি হলেই আনে: সরু bus-এর সঙ্গে মিলিয়ে ছোট queue.

আধুনিক CPU একই ধারণাকে অনেক দূর নিয়ে গেছে। এখন instruction cache, বহু ধাপের pipeline আর branch predictor একসঙ্গে কাজ করে: predictor অনুমান করে লাফ কোথায় যাবে, আর CPU সেই পথ থেকেই আগাম আনে, যাতে লাফেও queue খালি না হয়। ভুল অনুমান হলে pipeline খালি করে আবার শুরু, ঠিক 8086-এর queue বাতিলের বড় রূপ। Cortex-M-এর মতো microcontroller-এও ছোট prefetch buffer থাকে, কারণ flash মেমরি CPU-র চেয়ে ধীর; সেখানে সমস্যাটি 8086-এর মতোই, সমাধানও একই ধাঁচের। এর তত্ত্ব Computer Architecture পর্ব ৩৫-এ।

মূল উপলব্ধি: Queue-র মাপ ঠিক হয় EU কত দ্রুত byte খায়, bus কত দ্রুত আনে আর লাফ কত ঘন ঘন আসে, এই তিনের ভারসাম্যে; 8086-এর ৬ byte সেই যুগের সরল কোডের জন্য যথেষ্ট ছিল।

প্র ০৩8086-এর 1 MB সীমা IBM PC-র জগতে কী প্রভাব ফেলেছিল, আর “640 KB” সংখ্যাটি কোথা থেকে এল?

১৯৮১ সালের IBM PC-তে 8088 ছিল, যার ঠিকানার জায়গা 8086-এর মতোই 1 MB. IBM এই 1 MB ভাগ করে দিল: নিচের অংশ সাধারণ RAM-এর জন্য, ওপরের অংশ video মেমরি, expansion card-এর ROM আর BIOS ROM-এর জন্য। Reset-এর পরে প্রথম নির্দেশ FFFF0H থেকে আসে, তাই BIOS ROM থাকতেই হতো একেবারে ওপরে; আর interrupt vector table 00000H-এ, তাই RAM লাগত একেবারে নিচে। এই দুই বাঁধাধরা প্রান্তের মাঝে video মেমরি বসানো হলো A0000H থেকে। ফলে program-এর জন্য সরাসরি পাওয়া RAM দাঁড়াল 00000H থেকে 9FFFFH পর্যন্ত, অর্থাৎ 640 KB. এই সংখ্যাটি তাই 8086-এর নিয়ম নয়, IBM PC-র মেমরি মানচিত্রের সিদ্ধান্ত, যদিও সেটি 8086-এর 1 MB সীমার ভেতরেই নেওয়া।

তখন 640 KB বিশাল মনে হতো, কারণ প্রথম দিকের PC অনেক কম RAM নিয়ে বিক্রি হতো। কিন্তু কয়েক বছরের মধ্যে software বড় হলো, আর 640 KB-ই হয়ে উঠল দেয়াল। বাড়তি মেমরি ব্যবহারের জন্য একের পর এক কৌশল এল: expanded memory, যেখানে ওপরের অংশের একটি জানালা দিয়ে বাইরের মেমরির পাতা অদলবদল হতো; 80286-এর পরে extended memory; আর A20 gate খুলে FFFFH:0010H থেকে প্রায় 64 KB-এর “high memory area”. প্রতিটি কৌশল segment আর real mode-এর নিয়মের ভেতরে থেকে কোনোভাবে বেশি মেমরি ছোঁয়ার চেষ্টা।

এই ইতিহাসের শিক্ষা এমবেডেড কাজেও খাটে। একটি microcontroller-এর memory map (পর্ব ৩১) একবার ঠিক হলে তা পণ্যের পুরো জীবন ধরে বাঁধা থাকে: কোথায় flash, কোথায় SRAM, কোথায় peripheral register. বাজারঘরের smart scale-এর firmware আজ যে জায়গায় বসে, কাল OTA update-এর জন্য বাড়তি জায়গা লাগলে মানচিত্র বদলানো কঠিন হবে। সেজন্য নকশার শুরুতেই ভবিষ্যতের জন্য জায়গা রাখা বুদ্ধিমানের কাজ।

মূল উপলব্ধি: 1 MB 8086-এর hardware সীমা, আর 640 KB সেই সীমার ভেতরে IBM PC-র মানচিত্রের ফল; একবার বাঁধা মেমরি মানচিত্র বহু বছর ধরে পুরো ecosystem-কে আকার দেয়।

প্র ০৪একই যোগের পরে CF = 0 অথচ OF = 1, বা উল্টোটা, হয় কীভাবে? CPU কেন সংখ্যাটি signed না unsigned জানে না, আর দায়িত্বটি কার?

ALU-র কাছে একটি register শুধু ১৬টি বিট; সংখ্যাটি দাম না তাপমাত্রা, ধনাত্মক না ঋণাত্মক, তা সে জানে না। Two's complement-এর সৌন্দর্য হলো, একই binary যোগ signed আর unsigned দুই অর্থেই সঠিক বিট দেয়, যতক্ষণ ফল সীমার ভেতরে থাকে (পর্ব ০৫)। তাই CPU আলাদা দুটি যোগের নির্দেশ রাখে না; একটি ADD করে, আর দুই অর্থের জন্য দুটি সতর্কবাতি জ্বালায়। CF বলে: unsigned ধরলে ফল আঁটেনি। OF বলে: signed ধরলে ফল আঁটেনি। কোন বাতি দেখবেন, সেটি programmer-এর সিদ্ধান্ত, কারণ সংখ্যার অর্থ তিনিই জানেন।

এই পর্বের runner-এর উদাহরণগুলো চারটি ঘটনাই দেখায়। 64H + 32H: unsigned 150 ঠিক (CF = 0), signed −106 ভুল (OF = 1). C8H + 64H: unsigned 300 আঁটেনি (CF = 1), signed −56 + 100 = 44 ঠিক (OF = 0). F0H + 10H: unsigned 256 আঁটেনি (CF = 1), signed −16 + 16 = 0 ঠিক (OF = 0). আর দুটি বড় ঋণাত্মক যোগ করলে দুটিই 1 হতে পারে, যেমন 8000H + 8000H: ফল 0000H, CF = 1, OF = 1, কারণ unsigned 65536 আর signed −65536 কোনোটিই আঁটে না। OF-এর নিয়ম সহজ: দুটি একই চিহ্নের সংখ্যা যোগ করে উল্টো চিহ্ন এলে overflow; ভিন্ন চিহ্নের যোগে overflow অসম্ভব।

8085-এ OF ছিল না, তাই signed overflow ধরতে programmer-কে চিহ্নের বিট হাতে মেলাতে হতো। 8086 এটি hardware-এ দিল, আর তার সঙ্গে এল দুই সেট শর্তযুক্ত লাফ: unsigned তুলনার জন্য JA/JB (CF আর ZF দেখে), signed-এর জন্য JG/JL (SF, OF আর ZF দেখে), যা পর্ব ১৬-এ। C ভাষাতেও একই দায় ভাগ: unsigned overflow নিয়মমাফিক ঘুরে যায়, signed overflow undefined behavior. ARM Cortex-M-এ একই দুটি বাতি C আর V নামে (পর্ব ২৯)। বাজারঘরের firmware-এ দাম (পয়সা) সবসময় unsigned, cold room-এর তাপমাত্রা signed: ভুল flag দেখলে বিল বা alarm দুটিই ভুল হবে।

মূল উপলব্ধি: CPU একই যোগে দুই অর্থের সতর্কবাতি দেয়, CF unsigned-এর জন্য আর OF signed-এর জন্য; সংখ্যার অর্থ জানেন programmer, তাই ঠিক বাতিটি বেছে নেওয়াও তাঁর দায়িত্ব।

প্র ০৫8086 আর এর বংশধরেরা PC-র জগৎ জয় করল, অথচ এমবেডেড জগতে আজ ARM Cortex-M প্রধান। কেন, আর তবু 8086 শেখার মূল্য কোথায়?

8086-এর সাফল্যের বড় কারণ IBM PC. ১৯৮১ সালে IBM তাদের PC-তে 8088 বেছে নেয়, যা ভেতরে 8086-এর মতো কিন্তু বাইরের data bus ৮ বিটের, তাই সস্তা ৮ বিটের মেমরি আর সহায়ক chip দিয়ে board বানানো যেত। PC-র জনপ্রিয়তার সঙ্গে x86-এর জন্য লেখা software-এর পাহাড় জমল, আর প্রতিটি নতুন Intel chip (80286, 80386 থেকে আজকের core) সেই software চালানোর প্রতিশ্রুতি রাখল। Backward compatibility-ই x86-এর আসল শক্তি। Intel এমবেডেড বাজারের জন্যও 80186 আর 80188-এর মতো সংস্করণ এনেছিল, যেগুলোতে timer, interrupt controller আর DMA একই chip-এ ছিল, আর বহু বছর শিল্প-যন্ত্রে চলেছে।

কিন্তু এমবেডেড জগতের মাপকাঠি আলাদা: কম শক্তি, কম খরচ, ছোট chip, একই chip-এ flash, SRAM আর peripheral, আর দ্রুত interrupt সাড়া। x86-এর জটিল, নানা দৈর্ঘ্যের নির্দেশ decode করতে বড় circuit লাগে, আর পুরোনো সামঞ্জস্যের ভার থাকে। ARM-এর Cortex-M (প্রথম নকশা Cortex-M3, ২০০৪–০৫ সালের দিকে) শুরু থেকে microcontroller-এর জন্য বানানো: ৩২ বিটের সরল register মডেল, ঘন Thumb নির্দেশ, NVIC দিয়ে C-তে লেখা interrupt handler, আর segment-এর কোনো ঝামেলা নেই, শুধু একটি সমতল 4 GB-এর memory map. ARM নকশাটি বহু chip নির্মাতাকে license দেয়, তাই একই core হাজারো আলাদা microcontroller-এ পাওয়া যায়। মডিউল ৫ থেকে কোর্সের virtual বাজারঘর board এই ধাঁচের।

তবু 8086 শেখার মূল্য তিনটি। প্রথমত, এটি একটি পূর্ণ কিন্তু ছোট CPU, যার প্রতিটি অংশ এক পাতায় আঁকা যায়: BIU, EU, queue, segment, flag. দ্বিতীয়ত, এর ধারণাগুলো সব জায়গায় ফিরে আসে: prefetch আর pipeline, base + offset ঠিকানা, stack, interrupt vector table, signed আর unsigned flag. তৃতীয়ত, বিশ্ববিদ্যালয়, চাকরি আর ইন্টারভিউর পরীক্ষায় 8086-এর physical address, register আর program প্রায় নিয়মিত বিষয়। আর আজকের প্রতিটি x86 PC চালু হওয়ার প্রথম মুহূর্তে 8086-এর real mode-এই থাকে।

মূল উপলব্ধি: x86 জিতেছে software-এর সামঞ্জস্যে, Cortex-M জিতেছে microcontroller-এর জন্য বানানো সরলতা আর কম শক্তিতে; 8086 শেখা মানে এই দুই জগতের মূল ধারণাগুলো একটি ছোট, পরিষ্কার chip-এ দেখা।

অনুশীলন

প্রথমে নিজে লিখুন বা হিসাব করুন, তারপর উত্তর খুলুন। প্রতিটি program-এর উত্তর কোর্সের 8086 runner-এ চালিয়ে যাচাই করা।

  1. নকশা ও বাস্তবায়ন — এক নামে লেখা, অন্য নামে পড়া: একটি NASM program লিখুন, যা DS = 2000H রেখে offset 0010H-এ smart scale-এর ওজন 1250 (একটি word) লেখে, তারপর ES-এ এমন একটি মান রাখে যাতে [es:0000h] ঠিক একই physical ঘর দেখায়, আর সেখান থেকে DI-তে পড়ে। কোন physical address, ES কত, আর শেষে DI কত?
            org 100h
            mov ax, 2000h
            mov ds, ax              ; DS = 2000h
            mov word [0010h], 1250  ; 20010h <- E2h, 04h
            mov ax, 2001h
            mov es, ax              ; ES = 2001h
            mov di, [es:0000h]      ; 20010h again
            hlt

    Physical address = 2000H × 10H + 0010H = 20010H. ES:0000H দিয়ে একই ঘর পেতে ES × 10H = 20010H, অর্থাৎ ES = 2001H. সত্যিকারের run: DI=04E2 DS=2000 ES=2001, 2000:0010 E2 04, ৭টি নির্দেশ (HLT-সহ)। খেয়াল করুন: segment register-এ সরাসরি সংখ্যা রাখা যায় না, তাই দুবারই আগে AX-এ আনা হয়েছে। আর NASM-এ word লিখতেই হয়, কারণ [0010h] আর 1250 থেকে assembler মাপ বুঝতে পারে না (MASM-এ word ptr).

  2. ভুল খুঁজুন — দুটি ভুল একসঙ্গে: একজন লিখলেন mov ds, 2000h, তারপর mov word [0010h], 1250, আর খাতায় লিখলেন “ওজন লেখা হবে physical address 2010H-এ।” program আর হিসাবের ভুল দুটি কী, আর ঠিক রূপ কী?

    প্রথম ভুল: 8086-এ segment register-এ সরাসরি সংখ্যা (immediate) রাখার কোনো নির্দেশ নেই। NASM 3.02 সত্যিই থামে: p2.asm:2: error: invalid combination of opcode and operands. ঠিক রূপ: mov ax, 2000h তারপর mov ds, ax (অনুশীলন ১-এর মতো)। দ্বিতীয় ভুল: segment আর offset সরাসরি যোগ করা হয়েছে, 2000H + 0010H = 2010H. আগে segment-কে × 10H করতে হয়: 20000H + 0010H = 20010H, পাঁচ অঙ্কের ঠিকানা। 2010H আসলে 0201H:0000H-এর মতো সম্পূর্ণ অন্য একটি ঘর।

  3. আগে বলুন, তারপর চালান — দুই অর্থের overflow: mov ax, 8000h, add ax, 8000h, hlt. শেষে AX আর CF, PF, AF, ZF, SF, OF কত? Runner-এর ছাপ (O D I T S Z A P C) কেমন হবে?

    8000H + 8000H = 10000H: AX = 0000H, বিট ১৫ থেকে বেরোনো 1 যায় CF-এ, তাই CF = 1. ZF = 1 (ফল শূন্য), SF = 0. দুটি operand-ই signed অর্থে −32768, যোগফল −65536 ১৬ বিটের signed সীমায় আঁটে না, আর দুটি ঋণাত্মক থেকে ধনাত্মক (0) চিহ্ন এসেছে, তাই OF = 1. নিচের byte 00H-এ কোনো 1 নেই, শূন্যটি জোড়, তাই PF = 1. নিচের nibble 0 + 0, তাই AF = 0. সত্যিকারের run: AX=0000, ছাপ O-I--Z-PC, ৩টি নির্দেশ (HLT-সহ)। CF আর OF দুটিই 1: unsigned 65536 আর signed −65536 কোনোটিই আঁটেনি।

  4. হিসাব — physical address-এর চার রকম প্রশ্ন: (ক) CS = 3400H, IP = 1A20H হলে পরের নির্দেশের physical address কত? (খ) SS = 2F00H, SP = FFFEH হলে stack-এর মাথা কোথায়? (গ) DS = 5000H দিয়ে কোন ঠিকানার পরিসর ছোঁয়া যায়? (ঘ) Physical address 4A3B0H আর offset 0B30H হলে segment কত?

    (ক) 34000H + 1A20H = 35A20H. (খ) 2F000H + FFFEH = 3EFFEH; লক্ষ করুন, যোগে উঁচু অঙ্কে carry গেছে (F + F), তাই ফলের প্রথম অঙ্ক 2 থেকে 3. (গ) 50000H + 0000H থেকে 50000H + FFFFH, অর্থাৎ 50000H–5FFFFH, মোট 65536 byte. (ঘ) 4A3B0H − 0B30H = 49880H; শেষ অঙ্ক 0, তাই segment = 49880H ÷ 10H = 4988H. যাচাই: 49880H + 0B30H = 4A3B0H. চারটি ফলই Python-এ (seg << 4) + off সূত্রে মিলিয়ে দেখা (0x35a20, 0x3effe, 0x50000 থেকে 0x5ffff, 0x49880).

নিজেকে যাচাই করুন

ভুল হলে কারণসহ ব্যাখ্যা পাবেন, আবার চেষ্টাও করতে পারবেন।

ক্রম8086-এ mov [bx],ax (DS = 1000H, BX = 0150H) চলার ধাপগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)

  1. EU-র decoder queue-র সামনে থেকে নির্দেশের byte নেয়
  2. EU বোঝে মেমরিতে লিখতে হবে, offset = BX = 0150H
  3. BIU DS-কে × 10H করে: 10000H
  4. BIU offset যোগ করে physical address 10150H বানায়
  5. BIU bus-এ লেখার cycle চালায়: 10150H-এ E2H, 10151H-এ 04H

8086-এ CS = 3400H আর IP = 1A20H. পরের নির্দেশ কোন physical address থেকে আসবে?

  • 4E20H
  • 1D600H
  • 35A20H
  • 34000H

8086 আর 8088-এর instruction queue-র মাপ যথাক্রমে কত?

  • ৪ byte আর ৬ byte
  • ৬ byte আর ৪ byte
  • দুটিরই ৬ byte
  • দুটিরই ৮ byte

৮ বিটের যোগ AL = 64H, add al, 32H-এর পরে 8086-এর CF আর OF কত?

  • CF = 1, OF = 1
  • CF = 0, OF = 0
  • CF = 1, OF = 0
  • CF = 0, OF = 1

8086-এ segment × 10H + offset-এর যোগটি chip-এর কোন অংশ করে?

  • BIU-র ঠিকানা যোগের adder
  • EU-র ALU
  • মেমরি chip নিজে
  • Assembler, program assemble করার সময়

DS = 1000H আর ES = 1010H. 8086-এ [0150H] (DS ধরে) আর [ES:0050H]-এর সম্পর্ক কী?

  • দুটি আলাদা ঘর, 100H byte দূরে
  • দুটি একই physical ঘর, 10150H
  • ES:0050H অবৈধ, কারণ segment overlap করা যায় না
  • একই ঘর, কিন্তু ES দিয়ে পড়লে byte-গুলো উল্টো ক্রমে আসে

8086-এ mov ax, 7530H তারপর add ax, 1388H-এর পরে AX = 88B8H. PF কত, আর কেন?

  • PF = 1, কারণ পুরো ১৬ বিটে ছয়টি 1, জোড়
  • PF = 0, কারণ ফল signed অর্থে ঋণাত্মক
  • PF = 1, কারণ নিচের byte B8H-এ চারটি 1
  • PF = 1, কারণ 1388H-এ জোড় সংখ্যক 1

শব্দকোষ

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

মনে রাখুন

  1. ১৬ আর ২০: ১৬ বিটের ALU, register আর data bus; ২০ বিটের ঠিকানা: 220 = 1 MB. ২০ বিটের কোনো register নেই।
  2. BIU আর EU: BIU আনে, ঠিকানা বানায়, bus চালায়, queue রাখে (CS DS SS ES IP); EU decode করে, হিসাব করে (AX BX CX DX SP BP SI DI, ALU, FLAGS).
  3. Queue: ৬ byte (8088-এ ৪); অন্তত দুই byte খালি হলে BIU আনে; লাফে সব বাতিল।
  4. Physical address: segment × 10H + offset; 1000H:0150H = 1010H:0050H = 10150H; reset-এর পরে FFFF0H; vector table 00000H–003FFH.
  5. নয়টি flag: CF PF AF ZF SF OF (status), TF IF DF (control); CF unsigned, OF signed; PF শুধু নিচের byte.

পরের পর্বে: পর্ব ১৫ (8086-এর addressing mode আর effective address). [bx+si+08h]-এর মতো ঠিকানা কীভাবে হিসাব হয়, BP দিলে কেন SS ধরা হয়, আর segment override কখন লাগে, সত্যিকারের run দিয়ে।

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

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