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

8086-এর string instruction — MOVS, CMPS, SCAS আর REP

8086 String Instructions: MOVS, CMPS, SCAS and REP

Taught in Bangla, this lesson covers the five 8086 string instructions with DS:SI as source and ES:DI as destination, the direction flag, and the REP, REPE and REPNE prefixes. Programs assembled with NASM and run on Unicorn copy a price table with rep movsw, search with repne scasb and compare with repe cmpsb, where ZF rather than CX tells the result. An overlapping copy with the wrong direction is shown corrupting data, and in-page Python models string operations and flags.

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

  • MOVS, CMPS, SCAS, LODS আর STOS-এর কাজ, কোন register কী রাখে আর কোন flag বদলায়
  • DF, CLD আর STD দিয়ে দিক বাছা, আর overlap থাকলে কোন দিক নিরাপদ
  • REP, REPE আর REPNE কখন থামে, আর থামার পরে CX, SI, DI ও ZF থেকে ফল পড়া
  • বাজারঘরের দামের লাইন কপি, দশমিক বিন্দু খোঁজা আর পণ্যের কোড মেলানো, সত্যিকারের run দিয়ে
  • Intel-এর টেবিল ধরে সময়ের হিসাব, MASM বনাম NASM, আর AI-এর সাধারণ ভুল চেনা

১ · String instruction কেন — এক instruction-এ পুরো সারি

এখানে string মানে শুধু লেখা নয়, memory-তে পরপর বসা যেকোনো byte বা word-এর সারি: একটি নাম, দামের একটি টেবিল, display-এর একটি লাইন। এমন সারি নিয়ে কাজ প্রায় সবসময় একই ছাঁচের: এক ঘর পড়া, কিছু করা, pointer এক ঘর এগোনো, গণক এক কমানো, তারপর আবার একই। 8085-এ (পর্ব ১১) এই প্রতিটি ধাপ আলাদা instruction: MOV A,M, INX H, DCR C, JNZ. ১৯৭৮ সালের 8086 এই পুরো ছাঁচকে কয়েকটি এক-byte-এর instruction-এ ভরে দিল, যাদের নাম string instruction.

উপমা — কাঠা দিয়ে চাল মাপা: আড়তে এক বস্তা থেকে আরেক বস্তায় চাল ঢালা হচ্ছে, এক কাঠা করে। একজন উৎস-বস্তায় হাত রাখেন (SI), আরেকজন গন্তব্য-বস্তায় (DI), আর খাতায় লেখা কত কাঠা বাকি (CX). প্রতি কাঠার পরে দুজনেই এক ধাপ সরেন আর খাতার সংখ্যা এক কমে। কোন দিকে সরবেন, সামনে না পেছনে, তা আগে থেকে ঠিক করা (DF). MOVSB হলো এক কাঠা ঢালা; REP MOVSB হলো “খাতা শূন্য না হওয়া পর্যন্ত ঢালতে থাকুন।” আর REPNE SCASB হলো বস্তার ভেতরে হাত চালিয়ে প্রথম কাঁকরটি খোঁজা।

চারটি register-এর ভূমিকা স্থির, আর এটিই string instruction-এর মূল কথা:

Registerভূমিকাপ্রতি কাজের পরে
DS:SIউৎস (source); segment override চলে±১ (byte) বা ±২ (word)
ES:DIগন্তব্য (destination); segment সবসময় ES±১ বা ±২
CXকত বার, শুধু REP-সহREP থাকলে এক কমে
AL / AXLODS-এর গন্তব্য, STOS-এর উৎস, SCAS-এর খোঁজার মান—
DFদিক: 0 হলে বাড়ে, 1 হলে কমেনিজে বদলায় না

DS:SI আর ES:DI-এর default segment-এর নিয়ম, আর কোনটি override করা যায়, তা পর্ব ১৫ (8086-এর addressing mode আর effective address)-এর বিষয়; এখানে শুধু মনে রাখুন: উৎস DS:SI (override চলে), গন্তব্য ES:DI (override চলে না)। Physical address = segment × 10H + offset, BIU আর EU-র ভাগ, আর flag register-এর বিট, যার একটি direction flag (DF, বিট ১০), সেগুলো পর্ব ১৪-এ।

লেখার নিয়ম: এই পর্বে সংখ্যা Intel-এর ধরনে, শেষে H দিয়ে hex (যেমন 0200H, 2EH), আর segment:offset লেখা হবে 2000H:0040H. চালানো যায় এমন code NASM-এর ভাষায়, যেখানে hex লেখা হয় 0200h. সব সত্যিকারের run কোর্সের reference lab-এর run8086.py-এ: NASM 3.02 (cpu 8086) দিয়ে assemble, তারপর Unicorn-এর 16-বিট real mode-এ চালানো। Program বসে 1000H:0100H-এ, শুরুতে CS = DS = ES = SS = 1000H, আর ১ MB memory শুরুতে শূন্য (Spec decision 13). Lab-এর --trace প্রতিটি REP-পাককে আলাদা লাইনে দেখায়, তাই প্রতিটি পাকের SI, DI, CX সরাসরি পড়া যায়। Lab কীভাবে কাজ করে আর নিজে অনুশীলনের free tool কোনগুলো, তা পর্ব ০৬-এ।

পুরো পর্বে বাজারঘরের স্মার্ট স্কেলের লেখা নিয়ে কাজ: আলুর দর "65.50" (টাকা/kg, reference README-র “বাজারঘর devices”), দামের লাইন "81.88 Tk" (১২৫০ g-এর দাম), পণ্যের কোড "PATOL", আর পর্ব ১৫-এর চারটি দাম 983, 8188, 3275, 6550 পয়সা। Display-এর buffer ধরা হয়েছে আলাদা segment 2000H-এ, ঠিক পর্ব ১৫-এর মতো।

২ · পাঁচটি মৌলিক instruction আর direction flag

প্রতিটি string instruction-এর দুটি রূপ: শেষে B (byte) বা W (word). Machine code মাত্র এক byte, কারণ operand লিখতে হয় না: CPU জানে উৎস DS:SI আর গন্তব্য ES:DI. নিচের byte NASM 3.02-এর listing থেকে (লেখকের lab-এ enc.asm), কাজের বর্ণনা Intel 8086 Family User’s Manual অনুযায়ী:

InstructionByte (B / W)কাজPointerFlag
MOVSB / MOVSWA4 / A5[ES:DI] ← [DS:SI]SI, DIবদলায় না
CMPSB / CMPSWA6 / A7[DS:SI] − [ES:DI], ফল রাখে নাSI, DIOF SF ZF AF PF CF
SCASB / SCASWAE / AFAL (বা AX) − [ES:DI], ফল রাখে নাDIOF SF ZF AF PF CF
LODSB / LODSWAC / ADAL (বা AX) ← [DS:SI]SIবদলায় না
STOSB / STOSWAA / AB[ES:DI] ← AL (বা AX)DIবদলায় না

দুটি তুলনার instruction-এ বিয়োগের দিক খেয়াল করুন: CMPS করে উৎস − গন্তব্য, SCAS করে AL − গন্তব্য. ফল ফেলে দেওয়া হয়, শুধু flag থাকে, ঠিক CMP-এর মতো। তাই পরের JA, JB, JE একই অর্থে কাজ করে: CF = 1 মানে প্রথমটি (unsigned) ছোট। Signed বনাম unsigned লাফের পুরো টেবিল পর্ব ১৬-এ।

দিক: CLD (clear direction, byte FC) DF = 0 করে, তখন SI আর DI বাড়ে। STD (set direction, FD) DF = 1 করে, তখন কমে। কত বাড়ে বা কমে তা নির্ভর করে B না W-এর ওপর: byte-এ ১, word-এ ২। Lab-এর trace-এ flag-এর ঘরে DF দেখায় D অক্ষরে: --I------ মানে DF = 0, -DI------ মানে DF = 1.

ছবি ১৯.১ — একটি REP MOVSB: উৎস DS:SI থেকে গন্তব্য ES:DI

উদাহরণ: DS:0200H-এর "65.50" যায় ES:0040H-এ, ES = 2000H, CX = 5, DF = 0

REP MOVSB-এর উৎস, গন্তব্য, CX আর DF উৎস DS:SI (DS = 1000H) 65.50 02000204 গণক CX 5 → 0 65.50 00400044 গন্তব্য ES:DI (ES = 2000H) DF = 0 (CLD): বাড়ে DF = 1 (STD): কমে byte-এ ±১, word-এ ±২ · প্রতি পাকে CX − ১
ছবি ১৯.১ — একটি REP MOVSB-এর পুরো ছবি। উৎস আর গন্তব্য আলাদা segment-এ থাকতে পারে, তাই এক instruction-এ segment পেরিয়ে কপি করা যায়। প্রতিটি পাকে একটি byte, তারপর SI আর DI দুটিই এক ঘর সরে আর CX এক কমে। সত্যিকারের run-এ শেষ অবস্থা: 2000:0040 36 35 2E 35 30, SI = 0205H, DI = 0045H, CX = 0.

REP ছাড়া একটি string instruction শুধু একবার কাজ করে; CX ছোঁয় না। যেমন একটি LODSB = “AL-এ [DS:SI] পড়া, তারপর SI এক এগোনো।” এটি কার্যত mov al,[si] আর inc si-এর জোড়া, কিন্তু দুই instruction-এর বদলে এক byte, আর inc-এর মতো flag-ও বদলায় না।

৩ · REP MOVSB আর MOVSW — block copy এক লাইনে

REP prefix হলো string instruction-এর আগে বসা একটি byte (F3), যা বলে: “CX শূন্য না হওয়া পর্যন্ত এটি বারবার চলবে।” এটি একটি instruction prefix, ঠিক পর্ব ১৫-এর segment override-এর মতো আলাদা byte. প্রতিটি পাকের আগে CPU CX দেখে; শূন্য হলে আর কিছু না করে পরের instruction-এ যায়। শূন্য না হলে কাজটি একবার করে, SI/DI সরায়, CX এক কমায়। নিচে বাজারঘরের দর "65.50" DS:0200H থেকে display buffer ES:0040H-এ (ES = 2000H) কপি (সত্যিকারের run, লেখকের lab-এ movs.asm; লাইন ছোট রাখতে BX, DX, BP, SP, CS, SS বাদ):

$ python -B run8086.py movs.asm --trace --mem 2000:0040,6
1000:010E  FC     cld         CX=0005 SI=0200 DI=0040 ES=2000 --I------
1000:010F  F3A4   rep movsb   CX=0004 SI=0201 DI=0041 ES=2000 --I------
1000:010F  F3A4   rep movsb   CX=0003 SI=0202 DI=0042 ES=2000 --I------
1000:010F  F3A4   rep movsb   CX=0002 SI=0203 DI=0043 ES=2000 --I------
1000:010F  F3A4   rep movsb   CX=0001 SI=0204 DI=0044 ES=2000 --I------
1000:010F  F3A4   rep movsb   CX=0000 SI=0205 DI=0045 ES=2000 --I------
1000:010F  F3A4   rep movsb   CX=0000 SI=0205 DI=0045 ES=2000 --I------
2000:0040  36 35 2E 35 30 00
[exit code 0 via HLT, 13 instructions]

একই ঠিকানা 1000:010FH ছয়বার, কারণ REP-এর প্রতিটি পাক trace-এ আলাদা লাইন। ষষ্ঠ লাইনে CX = 0 দেখে CPU কিছু কপি করে না, শুধু IP পরের instruction (HLT)-এ নেয়; trace-এর পুরো লাইনে সেখানে IP=0111, আগের পাঁচটিতে IP=010F. তাই lab-এর গোনায় ১৩টি instruction, যদিও source-এ মাত্র ৮টি লাইন। নিচের stepper একই run ধাপে ধাপে দেখায়।

1mov ax,2000h / mov es,ax2mov si,0200h  ; "65.50"3mov di,0040h4mov cx,55cld6rep movsb     ; F3 A47hlt
Register আর গন্তব্য
SI DI
CX
এই পাকের উৎস → গন্তব্য
2000:0040…
  1. প্রস্তুতি. ES = 2000H (buffer), DS = 1000H (lab-এর শুরুর মান). SI = 0200H-এ "65.50", DI = 0040H, CX = 5, আর cld DF = 0 করেছে। Buffer-এ এখনো সব 00.
  2. প্রথম পাক. CX ≠ 0, তাই কপি: উৎসের PA = 10000H + 0200H = 10200H, গন্তব্যের PA = 20000H + 0040H = 20040H. '6' = 36H যায় 20040H-এ। তারপর SI = 0201H, DI = 0041H, CX = 4.
  3. দ্বিতীয় পাক. '5' = 35H যায় 20041H-এ। দুটি pointer একসঙ্গে সরে, কারণ MOVS দুটিই ব্যবহার করে। CX = 3.
  4. তৃতীয় পাক. দশমিক বিন্দু '.' = 2EH. MOVS কোনো flag বদলায় না, তাই trace-এর flag-এর ঘর পুরো সময় --I------.
  5. চতুর্থ পাক. '5' = 35H যায় 20043H-এ। CX = 1: আর একটি byte বাকি।
  6. পঞ্চম পাক. '0' = 30H যায় 20044H-এ। এখন CX = 0, SI = 0205H, DI = 0045H: দুটি pointer-ই কপি করা অংশের ঠিক পরের ঘরে।
  7. CX = 0, শেষ. পরের পরীক্ষায় CX শূন্য, তাই CPU কিছু না করে HLT-এ যায়। Lab-এর dump: 2000:0040 36 35 2E 35 30 00, অর্থাৎ "65.50", আর তার পরের byte অছোঁয়া 00. শেষে SI আর DI-কে পরের কাজের শুরু হিসেবে সরাসরি ব্যবহার করা যায়।

Word-এ কপি: MOVSW প্রতি পাকে দুই byte সরায়, আর SI/DI বাড়ে ২ করে। পর্ব ১৫-এ চারটি দাম DS থেকে ES-এর buffer-এ নিতে হাতে-লেখা loop লেগেছিল ৩০টি instruction. একই কাজ rep movsw দিয়ে (সত্যিকারের run, movsw.asm): SI = 0208H, DI = 0040H, CX = 4, তারপর এক লাইন rep movsw (F3 A5). চার পাকে SI যায় 020AH, 020CH, 020EH, 0210H; DI যায় 0042H … 0048H; শেষে 2000:0040 D7 03 FC 1F CB 0C 96 19, ঠিক পর্ব ১৫-এর একই byte, আর মোট [exit code 0 via HLT, 12 instructions]. CX-এ থাকে word-এর সংখ্যা, byte-এর নয়: চারটি দাম = ৪, ৮ নয়।

CX = 0 দিয়ে শুরু হলে: REP প্রথমেই CX দেখে, তাই কিছুই হয় না। cx0.asm-এ xor cx,cx, তারপর rep movsb: trace-এ একটিমাত্র লাইন, SI = 0200H আর DI = 0300H অপরিবর্তিত। C-এর memcpy(dst, src, 0)-এর মতোই নিরাপদ। কিন্তু REP ছাড়া একটি একক MOVSB CX দেখেই না, একটি byte কপি করেই ফেলে।

এবার পুরো আচরণ একটি ছোট মডেলে। নিচের Python প্রতিটি পাকে একই নিয়ম মানে: আগে CX দেখা, তারপর কাজ, pointer সরানো, CX কমানো, আর REPE/REPNE হলে ZF দেখা। এর পাঁচটি লাইনের প্রতিটি লেখকের lab-এর একটি run-এর সঙ্গে মেলানো (movs.asm, scan.asm, cmps.asm, lastbyte.asm, cx0.asm).

# 8086-এর string instruction-এর ছোট মডেল: SI, DI, CX, DF আর REP/REPE/REPNE
def string_op(op, ds, es, si=0, di=0, cx=0, df=0, al=0, rep=None, w=1):
    step = -w if df else w                  # DF = 0: বাড়ে, DF = 1: কমে
    zf, n = None, 0
    while True:
        if rep and cx == 0:                 # REP আগে CX দেখে
            break
        if op == "movs":                    # [ES:DI] <- [DS:SI]
            es[di:di + w] = ds[si:si + w]
            si, di = si + step, di + step
        elif op == "scas":                  # AL - [ES:DI], শুধু flag
            zf = (al == es[di]); di += step
        elif op == "cmps":                  # [DS:SI] - [ES:DI], শুধু flag
            zf = (ds[si] == es[di]); si, di = si + step, di + step
        n += 1
        if rep is None:
            break
        cx -= 1
        if (rep == "repe" and not zf) or (rep == "repne" and zf):
            break
    flag = "-" if zf is None else int(zf)  # MOVS flag ছোঁয় না
    return f"SI={si:04X} DI={di:04X} CX={cx:04X} ZF={flag} পাক={n}"

def seg(at, text, size=0x400):             # একটি 64 KB-র ছোট টুকরো
    m = bytearray(size); m[at:at + len(text)] = text.encode(); return m
ds, es = seg(0x200, "65.50"), bytearray(0x400)
r = string_op("movs", ds, es, 0x200, 0x40, 5, rep="rep")
print("rep movsb  ", r, es[0x40:0x45].decode())
line = seg(0x200, "81.88 Tk")
print("repne scasb", string_op("scas", line, line, di=0x200, cx=8, al=ord("."), rep="repne"))
s = seg(0x200, "PATOL"); s[0x210:0x215] = b"PATAL"
print("repe cmpsb ", string_op("cmps", s, s, 0x200, 0x210, 5, rep="repe"))
t = seg(0x200, "ALU-1"); t[0x210:0x215] = b"ALU-2"
print("শেষ byte   ", string_op("cmps", t, t, 0x200, 0x210, 5, rep="repe"))
print("CX = 0     ", string_op("movs", ds, es, 0x200, 0x300, 0, rep="rep"))

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

rep movsb   SI=0205 DI=0045 CX=0000 ZF=- পাক=5 65.50
repne scasb SI=0000 DI=0203 CX=0005 ZF=1 পাক=3
repe cmpsb  SI=0204 DI=0214 CX=0001 ZF=0 পাক=4
শেষ byte    SI=0205 DI=0215 CX=0000 ZF=0 পাক=5
CX = 0      SI=0200 DI=0300 CX=0000 ZF=- পাক=0

প্রথম লাইন stepper-এর শেষ অবস্থা। দ্বিতীয় আর তৃতীয় লাইন পরের অংশের বিষয়: খোঁজা থামল তৃতীয় পাকে, তুলনা থামল চতুর্থ পাকে। চতুর্থ লাইনটি সবচেয়ে গুরুত্বপূর্ণ: CX = 0, অথচ ZF = 0. Lab-এর lastbyte.asm-এ একই ফল (সেখানে string বসেছে 010DH-এ, তাই SI = 0112H, DI = 0117H; flag --I-S-APC). পাঁচ ঘর মিলিয়ে দেখলে মডেল আর lab-এর সংখ্যা হুবহু এক, শুধু শুরুর ঠিকানা আলাদা।

৪ · REPNE SCASB আর REPE CMPSB — খোঁজা আর তুলনা

CMPS আর SCAS-এর সঙ্গে REP-এর দুটি শর্তযুক্ত রূপ বসে। দুটিতেই প্রতি পাকে CX এক কমে, আর CX শূন্য হলে থামে; সঙ্গে আরেকটি শর্ত ZF-এর ওপর:

PrefixByteচলতে থাকে যতক্ষণসাধারণ ব্যবহার
REPF3CX ≠ 0MOVS, STOS (LODS-এর সঙ্গে প্রায় অর্থহীন)
REPE = REPZF3CX ≠ 0 আর ZF = 1 (সমান)CMPS: দুই সারি কতদূর মেলে
REPNE = REPNZF2CX ≠ 0 আর ZF = 0 (অসমান)SCAS: একটি মান খোঁজা

REP আর REPE একই byte F3; CPU পরের instruction দেখে বোঝে ZF পরীক্ষা করবে কি না। MOVS আর STOS flag বদলায় না, তাই তাদের সঙ্গে F3 মানে শুধু CX. NASM-এর listing-এও repe cmpsb আর repz cmpsb দুটিই F3 A6, আর repne scasb = F2 AE.

খোঁজা: স্কেলের দামের লাইন "81.88 Tk"-এ দশমিক বিন্দু কোথায়? AL = '.' (2EH), ES:DI = লাইনের শুরু, CX = ৮ (লাইনের দৈর্ঘ্য), তারপর repne scasb (সত্যিকারের run, scan.asm):

1mov di,0200h  ; "81.88 Tk"2mov cx,83mov al,'.'    ; 2Eh4cld5repne scasb   ; F2 AE6hlt
খোঁজার অবস্থা
DI CX
তুলনা
Flag (trace)
সিদ্ধান্ত
  1. প্রস্তুতি. ES:DI = 1000H:0200H-এ "81.88 Tk" (38 31 2E 38 38 20 54 6B), CX = 8, AL = 2EH. Lab-এর .COM program-এ ES = DS = 1000H, তাই আলাদা করে ES বসাতে হয়নি।
  2. প্রথম পাক. SCASB হিসাব করে AL − [ES:DI] = 2EH − 38H = F6H, ফল রাখে না। F6H-এর উপরের বিট 1, তাই SF = 1; 2EH < 38H, তাই borrow, CF = 1; F6H-এ ছয়টি 1, তাই PF = 1. ZF = 0, অর্থাৎ মিল নেই, আর REPNE চালিয়ে যায়। DI = 0201H, CX = 7.
  3. দ্বিতীয় পাক. 2EH − 31H = FDH: SF = 1, CF = 1, কিন্তু FDH-এ সাতটি 1, তাই PF = 0. ZF = 0, তাই চলবে। DI = 0202H, CX = 6.
  4. তৃতীয় পাক: মিল. 2EH − 2EH = 0, ZF = 1. REPNE-এর শর্ত ভাঙল, তাই এখানেই থামা। কিন্তু খেয়াল করুন: থামার আগেই DI এক এগিয়ে 0203H আর CX এক কমে 5. Pointer আর গণক সবসময় পাকের শেষে সরে, ZF পরীক্ষা হয় তারপরে।
  5. ফল পড়া. ZF = 1 মানে পাওয়া গেছে (ZF = 0 হলে CX শেষ হয়ে থেমেছে, পাওয়া যায়নি)। অবস্থান = DI − 1 − শুরু = 0203H − 1 − 0200H = 2, অর্থাৎ তৃতীয় অক্ষর। বাকি CX = 5 হলো বিন্দুর পরের byte-সংখ্যা: "88 Tk".

না পেলে কী হয়? nf.asm-এ "81.88"-এ 'X' খোঁজা: পাঁচ পাক, শেষে CX = 0, DI = 0205H, আর ZF = 0 (flag --I------); trace-এ REP MOVSB-এর মতো একটি বাড়তি লাইন, যেখানে CX = 0 দেখে CPU থামে। তাই খোঁজার পরে নিয়ম: je found বা jne not_found, ZF দেখে।

তুলনা: পণ্যের কোড "PATOL" (পটল) আর টেবিলের "PATAL" কি এক? SI = প্রথমটি, DI = দ্বিতীয়টি, CX = 5, repe cmpsb (সত্যিকারের run, cmps.asm): প্রথম তিন পাকে 'P', 'A', 'T' মেলে, ZF = 1, flag --I--Z-P-. চতুর্থ পাকে 'O' (4FH) − 'A' (41H) = 0EH, ZF = 0, থামা। শেষে SI = 0204H, DI = 0214H, CX = 1. প্রথম অমিলের ঘর SI − 1 = 0203H, অর্থাৎ চতুর্থ অক্ষর। ওই পাকের flag থেকে ক্রমও জানা যায়: 0EH-এ CF = 0, ZF = 0, তাই ja লাফ দেবে, "PATOL" বর্ণক্রমে "PATAL"-এর পরে।

CX দেখে “সমান” বলবেন না: "ALU-1" আর "ALU-2"-এর অমিল শেষ byte-এ। repe cmpsb পঞ্চম পাকে অমিল পায়, আর সেই পাকেই CX = 0 হয়। ফলে শেষে CX = 0, ঠিক যেমন পুরো মিল হলে হতো। পার্থক্য শুধু ZF-এ: lab-এর lastbyte.asm-এ শেষ flag --I-S-APC, ZF = 0. তাই নিয়ম: REPE বা REPNE-এর পরে সবসময় ZF দিয়ে সিদ্ধান্ত (je/jne); CX শুধু বলে কত ঘর বাকি। এটি একটি ক্লাসিক off-by-one ধাঁচের ভুল।

একটি কাজের কৌশল: REPNE SCASB দিয়ে C-এর strlen. লাইনের শেষে শূন্য byte (null terminator) থাকলে AL = 0, CX = FFFFH (“যত লাগে”) দিয়ে খুঁজুন; থামার পরে not cx দেয় পরীক্ষা করা byte-সংখ্যা (শূন্য সহ), আর dec cx দেয় দৈর্ঘ্য। "price=81.88 Tk"-এর সত্যিকারের run (strlen.asm): থামার পরে CX = FFF0H, not cx → 000FH, dec cx → 000EH, আর program ছাপে 14. C-এর string আর শূন্য byte-এর বিস্তারিত C কোর্সের পর্ব ১৯-এ।

CMPSB আর SCASB আসলে একটি বিয়োগ করে ফল ফেলে দেয়। নিচের ব্লক সেই বিয়োগের ছয়টি flag হিসাব করে, প্রথম অমিল থেকে ক্রম বলে, আর strlen-এর CX-এর হিসাব দেখায়। প্রতিটি flag-এর লাইন lab-এর trace-এর সঙ্গে মেলানো।

# CMPSB/SCASB-এর flag: CPU আসলে একটি বিয়োগ করে, ফল কোথাও রাখে না
def sub_flags(a, b):                     # 8 বিটের a - b
    r = (a - b) & 0xFF
    f = {"O": ((a ^ b) & (a ^ r) & 0x80) != 0,
         "S": r >= 0x80,
         "Z": r == 0,
         "A": (a & 0x0F) < (b & 0x0F),
         "P": bin(r).count("1") % 2 == 0,
         "C": a < b}                     # unsigned borrow
    return "".join(k if f[k] else "-" for k in "OSZAPC"), f

def order(x, y):                         # প্রথম অমিলের byte দেখে ক্রম
    for a, b in zip(x.encode(), y.encode()):
        if a != b:
            text, f = sub_flags(a, b)
            verdict = "JB লাফ দেয় (ছোট)" if f["C"] else "JA লাফ দেয় (বড়)"
            return f"{chr(a)}-{chr(b)} {text}  {verdict}"
    return "সব সমান: ZF=1, JE লাফ দেয়"

print("PATOL vs PATAL:", order("PATOL", "PATAL"))
print("ALU-1 vs ALU-2:", order("ALU-1", "ALU-2"))
print("LEVEL vs LEVEL:", order("LEVEL", "LEVEL"))
print("scasb '.' vs '8':", sub_flags(ord("."), ord("8"))[0])

# strlen: CX = FFFFh থেকে শুরু, REPNE SCASB শূন্য byte-এ থামে
line = b"price=81.88 Tk\0"
cx = 0xFFFF
for byte in line:                        # প্রতি পাকে CX এক কমে
    cx -= 1
    if byte == 0:
        break
print(f"CX={cx:04X}  NOT CX={~cx & 0xFFFF:04X}  দৈর্ঘ্য={(~cx & 0xFFFF) - 1}")

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

PATOL vs PATAL: O-A ------  JA লাফ দেয় (বড়)
ALU-1 vs ALU-2: 1-2 -S-APC  JB লাফ দেয় (ছোট)
LEVEL vs LEVEL: সব সমান: ZF=1, JE লাফ দেয়
scasb '.' vs '8': -S--PC
CX=FFF0  NOT CX=000F  দৈর্ঘ্য=14

Lab-এর trace-এর flag-এর ঘর (O D I T S Z A P C ক্রমে) থেকে D, I, T বাদ দিলে ঠিক এই লেখা: cmps.asm-এর শেষ পাক --I------, lastbyte.asm-এর --I-S-APC, আর scan.asm-এর প্রথম পাক --I-S--PC. "ALU-1" বনাম "ALU-2"-এ AF = 1, কারণ নিচের চার বিটে 1 − 2-এ borrow লাগে। "LEVEL"-এর লাইনটি reference lab-এর reverse.asm-এর palindrome পরীক্ষার সঙ্গে মেলে, যা repe cmpsb দিয়ে "LEVEL"-কে তার উল্টোর সঙ্গে মিলিয়ে Y ছাপে। শেষ লাইন strlen.asm-এর trace: not cx CX=000F, তারপর dec cx CX=000E.

৫ · LODS আর STOS — পড়া, বদলানো, লেখা

MOVS কপি করে কিন্তু মাঝপথে কিছু বদলাতে পারে না। বদলাতে হলে জোড়া লাগে: LODSB একটি byte AL-এ আনে, মাঝে যেকোনো instruction, তারপর STOSB AL লিখে দেয়। আর শুধু একটি মান দিয়ে একটি এলাকা ভরতে REP STOSB বা REP STOSW, C-এর memset-এর মতো। নিচের run (stos.asm) বাজারঘরের display-এর ১৬ ঘরের লাইন ফাঁকা করে, তারপর ছোট হাতের "alu"-কে বড় হাতের "ALU" করে বসায়:

        mov ax, 2000h
        mov es, ax
        mov di, 0040h
        mov ax, 2020h       ; দুটি space
        mov cx, 8           ; 8 word = 16 byte
        cld
        rep stosw           ; F3 AB: ES:0040h..004Fh = 20h
        mov si, name        ; DS:SI = "alu"
        mov di, 0040h
        mov cx, 3
up:     lodsb               ; AL = [DS:SI], SI + 1
        and al, 0DFh        ; বিট 5 মুছে: 'a' (61h) → 'A' (41h)
        stosb               ; [ES:DI] = AL, DI + 1
        loop up

সত্যিকারের ফল: rep stosw-এর আট পাকে DI যায় 0042H, 0044H … 0050H, AX-এর মান পুরো সময় 2020H. তারপর তিন পাকে AL হয় 61H → 41H, 6CH → 4CH, 75H → 55H. শেষ dump: 2000:0040 41 4C 55 20 20 20 20 20 20 20 20 20 20 20 20 20, অর্থাৎ "ALU" আর তেরোটি space; মোট [exit code 0 via HLT, 31 instructions]. লক্ষ করার মতো দুটি বিষয়: LODSB শুধু SI সরায়, STOSB শুধু DI, তাই দুই pointer এখানে আলাদা গতিতেও চালানো যেত (যেমন প্রতি দ্বিতীয় byte বাদ দিয়ে লেখা)। আর এই loop-এ REP নেই, কারণ মাঝে and আছে; CX গোনে LOOP (CX আর LOOP দিয়ে array-র পুরো program পর্ব ১৭-এ)।

উৎসের segment বদলানো: উৎস DS:SI-কে prefix দিয়ে অন্য segment-এ নেওয়া যায়, গন্তব্য ES:DI-কে যায় না। NASM-এ prefix-টি instruction-এর আগে লিখতে হয়: es movsb = 26 A4, cs lodsb = 2E AC (listing থেকে). ovr.asm-এ DS:0010H-এ 'D' আর ES:0010H-এ 'K' রেখে es movsb চালালে ES:0020H-এ যায় 'K' (4BH): উৎস ES থেকে পড়া হয়েছে। CS override-এর একটি সাধারণ ব্যবহার হলো ROM-এ রাখা স্থির টেবিল (যেমন code-এর পাশে রাখা বার্তা) RAM-এর buffer-এ কপি করা। MASM-এ operand-সহ রূপ MOVS আছে, যেখানে operand-এর ধরন দেখে assembler B বা W বাছে আর উৎসে segment লেখা থাকলে prefix বসায়; কিন্তু CPU সবসময় SI আর DI-ই ব্যবহার করে, operand শুধু assembler-এর জন্য (Microsoft-এর MASM নথির নিয়ম, lab-এ MASM নেই, চালানো হয়নি)।

.EXE program-এ ES: Lab-এর .COM program-এ ES = DS = CS, তাই mov es,ax ভুলে গেলেও অনেক সময় কাজ চলে। DOS-এর .EXE program শুরু হয় DS আর ES দুটিই PSP (program segment prefix)-এর দিকে রেখে; তাই MASM-এর বইয়ের program-এ শুরুতে mov ax,@data, mov ds,ax, mov es,ax থাকে। ES না বসালে STOS বা MOVS নীরবে ভুল segment-এ লেখে, কোনো error ছাড়া।

৬ · Overlap আর দিক — কখন STD লাগে

উৎস আর গন্তব্য একই buffer-এ, আর একে অপরের ওপর পড়লে (overlapping copy) দিক বাছাই আর ঐচ্ছিক থাকে না। ধরা যাক display-এর লাইনে "65.50"-এর আগে দুটি ঘর খালি করতে হবে (যেমন সামনে "Tk" বসানোর জন্য), অর্থাৎ পুরো লেখা দুই ঘর ডানে সরাতে হবে: উৎস 0200H–0204H, গন্তব্য 0202H–0206H. দুটি run, একটি CLD দিয়ে (ovf.asm), একটি STD দিয়ে (ovb.asm):

1; CLD: si=0200h di=0202h2; STD: si=0204h di=0206h3mov cx,54cld   ; বা std5rep movsb6cld   ; STD-এর পরে ফেরত
0200H থেকে ৭ byte
CLD: SI DI
CLD: memory
STD: SI DI
STD: memory
  1. শুরু. 0200H থেকে 36 35 2E 35 30 00 00 = "65.50" আর দুটি খালি ঘর। দুটি run-এ CX = 5; পার্থক্য শুধু শুরুর SI/DI আর DF.
  2. প্রথম পাক. CLD: 0200H-এর '6' যায় 0202H-এ, অর্থাৎ বিন্দু '.' মুছে গেল, যা এখনো কপি হয়নি। STD: শুরু শেষ byte থেকে, 0204H-এর '0' যায় 0206H-এ; কিছুই মোছেনি, কারণ 0206H খালি ছিল।
  3. দ্বিতীয় পাক. CLD: 0201H-এর '5' যায় 0203H-এ (সেখানে আগেই '5' ছিল, তাই দেখতে অপরিবর্তিত)। STD: 0203H-এর '5' যায় 0205H-এ। STD-এ প্রতিটি byte পড়া হয় তার ঘর মোছার আগেই।
  4. তৃতীয় পাক: CLD-এর বিপদ. CLD এখন পড়ে 0202H, যেখানে প্রথম পাকে নিজেই '6' লিখেছিল। আসল '.' আর নেই, তাই 0204H-এ যায় '6'. STD পড়ে 0202H-এর আসল '.' আর বসায় 0204H-এ।
  5. চতুর্থ পাক. CLD একই ভুল আবার: 0203H-এর '5' যায় 0205H-এ। STD: 0201H-এর '5' যায় 0203H-এ (আগের মানও '5'). দুই run-এই CX = 1.
  6. শেষ. CLD-এর dump 36 35 36 35 36 35 36: গন্তব্যে "65656", ভুল। STD-এর dump 36 35 36 35 2E 35 30: গন্তব্য 0202H-এ "65.50", ঠিক (প্রথম দুই ঘরে পুরোনো "65" থেকে যায়, পরে সেখানে "Tk" লেখা হবে)। STD-এর পরে SI = 01FFH, DI = 0201H, আর program শেষে cld দিয়ে DF আবার 0.

নিয়মটি সহজ: গন্তব্য যদি উৎসের ভেতরে, উৎসের শুরুর পরে পড়ে, তাহলে পেছন থেকে কপি (STD, SI আর DI শেষ byte-এ)। অন্য সব ক্ষেত্রে সামনে থেকে (CLD). বাঁয়ে সরানোয় (উৎস 0202H, গন্তব্য 0200H) CLD-ই নিরাপদ: lab-এর ovl.asm দেখায় 36 35 2E 35 30 35 30, গন্তব্যে "65.50". STD-এর সময় SI আর DI-কে শেষ byte-এ বসাতে হয়: শুরু + n − 1, word হলে শুরু + n − 2. এটি ঠিক C-এর memmove-এর নিয়ম; memcpy overlap-এ সঠিক ফলের কোনো প্রতিশ্রুতি দেয় না (C কোর্সের পর্ব ৪৫). নিচের ব্লক নিয়মটি একটি function-এ বেঁধে তিনটি ক্ষেত্র চালায়; প্রতিটি সারি lab-এর একটি run-এর সঙ্গে মেলানো (ovf.asm, ovb.asm, ovl.asm).

# Overlap: একই buffer-এ "65.50" দুই ঘর ডানে বা বাঁয়ে সরানো
def rep_movsb(mem, si, di, cx, df):       # byte-by-byte, ঠিক CPU-র মতো
    step = -1 if df else 1
    while cx:
        mem[di] = mem[si]
        si, di, cx = si + step, di + step, cx - 1
    return si, di

def safe_move(mem, src, dst, n):          # memmove-এর নিয়ম
    if dst > src and dst < src + n:       # গন্তব্য উৎসের ভেতরে, ডানে
        return "STD", rep_movsb(mem, src + n - 1, dst + n - 1, n, df=1)
    return "CLD", rep_movsb(mem, src, dst, n, df=0)

def show(mem):
    return " ".join(f"{b:02X}" for b in mem[0x200:0x207])

for title, src, dst, how in [("ডানে, CLD (ভুল)", 0x200, 0x202, "cld"),
                             ("ডানে, নিরাপদ", 0x200, 0x202, "safe"),
                             ("বাঁয়ে, নিরাপদ", 0x202, 0x200, "safe")]:
    mem = bytearray(0x400)
    mem[src:src + 5] = b"65.50"
    if how == "cld":
        flag, (si, di) = "CLD", rep_movsb(mem, src, dst, 5, df=0)
    else:
        flag, (si, di) = safe_move(mem, src, dst, 5)
    text = mem[dst:dst + 5].decode()
    print(f"{title:16}{flag}  {show(mem)}  গন্তব্যে '{text}'  SI={si:04X} DI={di:04X}")

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

ডানে, CLD (ভুল) CLD  36 35 36 35 36 35 36  গন্তব্যে '65656'  SI=0205 DI=0207
ডানে, নিরাপদ    STD  36 35 36 35 2E 35 30  গন্তব্যে '65.50'  SI=01FF DI=0201
বাঁয়ে, নিরাপদ  CLD  36 35 2E 35 30 35 30  গন্তব্যে '65.50'  SI=0207 DI=0205

তিনটি সারির byte আর শেষ SI/DI তিনটি run-এর সঙ্গে হুবহু এক (ovl.asm-এর --regs: SI=0207 DI=0205). CLD-এর ভুল ফলে একটি ছাঁচ দেখা যায়: দূরত্ব ২ হলে প্রথম দুটি byte "65" বারবার ফিরে আসে, যেন একটি ছাপ বারবার পড়ছে। এই আচরণ কখনো কখনো ইচ্ছা করেও কাজে লাগানো হয়: STOSB ছাড়াই একটি ছাঁচ দিয়ে buffer ভরা। কিন্তু অনিচ্ছায় ঘটলে এটি সবচেয়ে কষ্টে-ধরা bug-এর একটি, কারণ কোনো error নেই, শুধু ভুল লেখা।

DF মনে রাখার দায়: DF একটি স্থায়ী অবস্থা; কোনো routine STD করে ফেরত CLD না করলে পরের সব string instruction উল্টো চলে। nocld.asm-এ আগের একটি std রয়ে গেছে আর কপির code CLD করেনি: SI যায় 0200H → 01FBH, DI যায় 0300H → 02FBH. ফলে 0300H-এ মাত্র '6' পৌঁছায়, আর বাকি চারটি byte (0200H-এর আগের শূন্যগুলো) বসে 02FCH–02FFH-এ, গন্তব্যের আগের ঘরে, যেখানে হয়তো অন্য data ছিল। তাই প্রচলিত নিয়ম: প্রতিটি string routine-এর শুরুতে নিজে CLD বা STD লিখুন, আর STD করলে ফেরার আগে CLD. আধুনিক x86-এর calling convention-ও (যেমন System V আর Microsoft x64 ABI) function-এ ঢোকা আর বেরোনোর সময় DF = 0 ধরে নেয়; procedure-এর নিয়ম পর্ব ১৮-এ, আর calling convention-এর সাধারণ ধারণা Programming Languages & Compilers পর্ব ৭১-এ।

৭ · বাজারঘরের পণ্য খোঁজা, সময়ের হিসাব আর interrupt

এবার সব একসঙ্গে: স্কেলের কাছে চারটি পণ্যের ৫ অক্ষরের কোড আছে, আর কেউ "PATOL" টাইপ করলে তার দর (পয়সা/kg) বের করতে হবে। প্রতিটি টেবিল-ঘরের সঙ্গে repe cmpsb; ZF = 1 হলেই পাওয়া। আলুর দর 6550 README থেকে; অন্য তিনটি দর এই উদাহরণের জন্য কাল্পনিক। সত্যিকারের run (lookup.asm, reference lab-এর print_u16.inc-এর কপি সহ):

        cld
        mov bx, codes       ; BX = টেবিলের চলতি ঘর
        xor dx, dx          ; DX = index i
next:   mov si, key         ; DS:SI = খোঁজার কোড
        mov di, bx          ; ES:DI = টেবিলের ঘর
        mov cx, 5
        repe cmpsb
        je found            ; ZF = 1: পাঁচটি byte-ই সমান
        add bx, 5
        inc dx
        cmp dx, 4
        jb next
        ...
key:    db 'PATOL'
codes:  db 'ALU  ', 'PEYAJ', 'PATAL', 'PATOL'
rates:  dw 6550, 8000, 4500, 6000

$ python -B run8086.py lookup.asm
3 6000
[exit code 0 via INT 21h/4Ch, 145 instructions]

Trace-এ তৃতীয় ঘরে ("PATAL") চতুর্থ পাকে থামা দেখা যায় (CX=0001, flag --I------), আর চতুর্থ ঘরে পাঁচ পাকই --I--Z-P-, শেষে CX = 0 আর ZF = 1: এবার সত্যিই সমান, তাই je found. খেয়াল করুন, প্রতিটি নতুন ঘরের আগে SI, DI আর CX নতুন করে বসাতে হয়, কারণ আগের তুলনা তিনটিকেই বদলে দিয়েছে।

সময়ের দাম (datasheet-এর মান): কোর্সের lab 8086-এর clock গোনে না (Spec decision 16), তাই নিচের সংখ্যাগুলো Intel 8086 Family User’s Manual-এর instruction-timing টেবিল থেকে, মাপা নয়। এখানে শুধু সেই সংখ্যাগুলো, যা একাধিক সূত্রে মিলিয়ে দেখা গেছে:

InstructionএকবারREP-সহ
MOVS189 + 17 প্রতি পাক
LODS129 + 13 প্রতি পাক
STOS11—
SCAS15—
CMPS22—
LOOP17 (লাফ দিলে) / 5 (না দিলে)—

এই টেবিল থেকে একটি তুলনা। ১০০০ byte কপি করতে rep movsb = 9 + 17 × 1000 = ১৭০০৯ clock. একই কাজ lodsb / stosb / loop-এর হাতে-লেখা loop-এ প্রতি পাকে 12 + 11 + 17 = 40 clock, শেষ পাকে LOOP লাফ দেয় না বলে 12 + 11 + 5 = 28: মোট 999 × 40 + 28 = ৩৯৯৮৮ clock, দ্বিগুণেরও বেশি। কারণ REP-এর ভেতরের পাক CPU-র microcode-এ চলে: প্রতি পাকে instruction আবার fetch আর decode করতে হয় না। জোড় ঠিকানায় rep movsw দিয়ে ৫০০ word কপি করলে 9 + 17 × 500 = ৮৫০৯ clock; বিজোড় ঠিকানায় word-এর প্রতিটি memory কাজে Intel-এর নোট অনুযায়ী আরও ৪ clock যোগ হয় (পর্ব ২১-এ BHE̅ আর A0-এর হিসাব). এগুলো সব datasheet-এর আদর্শ সংখ্যা; wait state বা bus ব্যস্ত থাকলে বাস্তবে বেশি সময় লাগে।

লম্বা REP চলার সময় interrupt: ৬৪ KB কপি করা একটি REP MOVSB লাখ লাখ clock নিতে পারে। এই পুরো সময় interrupt আটকে থাকলে keypad বা timer-এর সাড়া দেরিতে আসত। তাই 8086 REP-এর পাকের মাঝে interrupt নেয়: অবস্থা থাকে CX, SI আর DI-এ, আর ফেরার ঠিকানা হিসেবে রাখা হয় REP prefix-এর ঠিকানা, যাতে IRET-এর পরে বাকি পাক চলে। ফলে interrupt latency একটি পাকের বেশি বাড়ে না। Interrupt-এর পুরো ক্রিয়া পর্ব ২০ (8086-এর interrupt — vector table, INT আর ISR)-এ; CPU ছাড়াই block কপি করার hardware, DMA, পর্ব ৪৬ (DMA — CPU ছাড়া data সরানো)-এ। কোর্সের lab-এ REP চলার মাঝে কোনো hardware interrupt আসে না, তাই এই আচরণ এখানে শুধু Intel-এর নথির বর্ণনা, run নয়। Unicorn-এর সঙ্গে আসল 8086-এর যে চারটি পার্থক্য lab-এ জানা (Spec decision 15: PUSH SP, shift-এর count, PUSHF-এর উপরের চার বিট, divide error-এর ফেরার ঠিকানা), তার কোনোটি string instruction-এর ফলে প্রভাব ফেলে না।

পরীক্ষা ও ইন্টারভিউতে: বিশ্ববিদ্যালয়, চাকরি বা ইন্টারভিউর পরীক্ষায় এই ধরনের প্রশ্ন প্রায়ই আসে:

  • String instruction-এ উৎস আর গন্তব্য কোথায়? উৎস DS:SI (segment override চলে), গন্তব্য ES:DI (override চলে না); গণক CX.
  • DF-এর কাজ কী, আর কোন instruction দিয়ে বসানো হয়? DF = 0 (CLD) হলে SI/DI বাড়ে, DF = 1 (STD) হলে কমে; byte-এ ১, word-এ ২ করে।
  • REPE আর REPNE-এর পার্থক্য? REPE চলে যতক্ষণ CX ≠ 0 আর ZF = 1; REPNE চলে যতক্ষণ CX ≠ 0 আর ZF = 0. প্রথমটি তুলনায়, দ্বিতীয়টি খোঁজায়।
  • REPNE SCASB-এ মিল পেলে DI কোথায় থাকে? মিলে যাওয়া byte-এর ঠিক পরের ঘরে (CLD হলে), তাই অবস্থান = DI − 1.
  • Overlap থাকা block কপিতে কী সাবধানতা? গন্তব্য উৎসের পরে আর ভেতরে পড়লে STD আর শেষ byte থেকে শুরু; অন্যথায় CLD.

আরও গভীরে: 8086-এর string instruction চলে chip-এর microcode-এ। Ken Shirriff ২০২৩ সালে die-এর ছবি থেকে microcode পড়ে দেখিয়েছেন, REP-এর পাকে CX-এর শূন্য-পরীক্ষা হয় একটি আলাদা ১৬ বিটের zero-পরীক্ষা দিয়ে, সাধারণ ZF দিয়ে নয়, আর interrupt এলে CPU instruction pointer দুই byte পিছিয়ে prefix-এ ফেরত নেয়। এর একটি পরিচিত ফল: একাধিক prefix থাকলে (যেমন REP আর segment override একসঙ্গে) interrupt-এর পরে শুধু শেষ prefix মনে থাকে, তাই rep es movsb-এর মতো মিশ্রণ interrupt-এর পরে ভুলভাবে চলতে পারত; তাঁর লেখা অনুযায়ী এটি 80286-এর আগে ঠিক হয়নি। সাবধানী programmer তাই এমন মিশ্রণের আগে interrupt বন্ধ রাখতেন বা মিশ্রণ এড়াতেন।

8085-এ (১৯৭৬) block কপির কোনো একক instruction ছিল না, প্রতিটি byte-এর জন্য চার-পাঁচটি instruction. একই সময়ের Zilog Z80 (১৯৭৬) LDIR, CPIR-এর মতো block instruction এনেছিল, যেখানে HL, DE আর BC একই ভূমিকা নিত। ১৯৭৮ সালের 8086 এই ধারণাকে সাধারণ করল: পাঁচটি কাজ, byte আর word, দুই দিক, আর তিন রকম REP. আজকের x86-64-এও rep movsb আর rep stosb টিকে আছে, আর নতুন Intel CPU-তে এগুলোকে দ্রুত করার আলাদা ব্যবস্থার কথা Intel-এর optimization নথিতে আছে বলে জানা যায়।

৮ · AI-এর যুগে string instruction যাচাই

AI assistant 8086-এর string-এর program দ্রুত লিখে দেয়, কিন্তু এই বিষয়ে তার ভুলগুলো চেনা ছাঁচের, আর প্রায় সবই NASM আর run8086.py --trace এক মিনিটে ধরে ফেলে:

AI প্রায়ই যা করেকীভাবে ধরবেন
CLD লেখে না, বা STD-এর পরে CLD-এ ফেরে নাTrace-এর flag-এর ঘরে D খুঁজুন; nocld.asm-এর মতো আগে একটি std রেখে চালান
REPE CMPSB-এর পরে CX = 0 দেখে “সমান” বলেশেষ byte আলাদা রেখে পরীক্ষা ("ALU-1" বনাম "ALU-2"); সিদ্ধান্ত ZF দিয়ে
MOVSW-এ CX-এ byte-সংখ্যা দেয়শেষ SI − শুরু SI = ২ × CX কি না দেখুন; গন্তব্যের পরের ঘরের dump
গন্তব্যে segment override লেখে ([ds:di]-এর মতো)গন্তব্য সবসময় ES:DI; প্রথমে ES বসানো হয়েছে কি না দেখুন
Z80-এর LDIR বা 386-এর ECX/ESI 8086-এর code-এ মেশায়NASM-এ cpu 8086 দিয়ে assemble; অচেনা instruction বা register-এ error
8086-এর জন্য বানানো clock, বা আধুনিক CPU-র সংখ্যাIntel 8086 manual-এর টেবিল; lab clock গোনে না (Spec decision 16)

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

আমি Intel 8086 (16-বিট real mode) assembly শিখছি, NASM syntax-এ .COM program (org 100h) লিখছি। 386 বা x86-64 নয়। ১. DS:0200h-এ "65.50" আছে। এটিকে একই buffer-এ দুই ঘর ডানে (0202h থেকে) সরানোর code লেখো string instruction দিয়ে। কেন CLD না STD, ব্যাখ্যা করো। ২. "PATOL" আর "PATAL" REPE CMPSB দিয়ে তুলনা করলে শেষে SI, DI, CX আর ZF কত হবে (SI=0200h, DI=0210h, CX=5 থেকে শুরু)? ৩. "ALU-1" আর "ALU-2"-এর ক্ষেত্রে CX আর ZF কত? CX দেখে সমান বলা যায় কি? ৪. প্রতিটি ধাপ দেখাও। নিশ্চিত না হলে অনুমান কোরো না, বলো।

উত্তর মেলানো সহজ, কারণ এগুলো এই পর্বের run: প্রথমটিতে STD, SI = 0204H, DI = 0206H, আর শেষে CLD; দ্বিতীয়টিতে SI = 0204H, DI = 0214H, CX = 1, ZF = 0; তৃতীয়টিতে CX = 0 কিন্তু ZF = 0, তাই সমান নয়। AI-এর উত্তরে সবচেয়ে বেশি যে ভুল দেখা যায়: থামার পরে SI/DI-কে অমিলের ঘরে ধরা, যেখানে আসলে তারা এক ঘর পরে। AI-কে সবচেয়ে ভালো কাজে লাগানো যায় নতুন test case বানাতে (খালি string, শেষ byte-এ অমিল, CX = 0) আর ব্যাখ্যা চাইতে; সংখ্যা সবসময় নিজের run থেকে।

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

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

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

প্র ০১যে কাজ একটি সাধারণ loop দিয়েই করা যায়, তার জন্য 8086-এ আলাদা string instruction কেন রাখা হলো? আজকের CPU-তে এই সিদ্ধান্তের কী হলো?

১৯৭০-এর দশকের শেষে দুটি জিনিস দামি ছিল: memory আর bus-এর সময়। একটি হাতে-লেখা কপি loop (lodsb-ছাড়া রূপে mov al,[si], mov [di],al, inc si, inc di, loop) প্রতি byte-এ পাঁচটি instruction fetch করে, আর প্রতিটি fetch-এর জন্য bus-এ যেতে হয়, যে bus-এ data-ও যাওয়া-আসা করে। rep movsb দুই byte-এর একটি instruction, যা একবার fetch হয়; তারপর ভেতরের পাক CPU-র microcode চালায়, শুধু data-র জন্য bus ব্যবহার করে। Intel-এর টেবিলে তাই ১০০০ byte কপিতে প্রায় ১৭০০৯ বনাম ৩৯৯৮৮ clock (এই পর্বের হিসাব, datasheet-এর মান). Code ছোট হওয়াও কম লাভ নয়: ROM-এ রাখা firmware-এ প্রতিটি byte গোনা হতো।

দ্বিতীয় কারণ high-level ভাষা আর OS. String-এর তুলনা, খোঁজা আর memory ভরা প্রায় প্রতিটি program-এ আছে, আর DOS-এর মতো OS screen buffer বা disk buffer কপিতে প্রচুর সময় দিত। এক instruction-এ করা গেলে compiler আর library-লেখকের কাজও সহজ হয়। এটি CISC (complex instruction set) ভাবনার একটি পরিষ্কার উদাহরণ: বারবার আসা কাজকে hardware-এর ভেতরে নেওয়া।

পরের ইতিহাস মিশ্র। ১৯৮০-৯০-এর দশকে কিছু x86 CPU-তে string instruction সাধারণ instruction-এর loop-এর চেয়ে ধীর ছিল বলে বহু optimization গাইডে লেখা হয়েছিল, কারণ নতুন CPU সাধারণ instruction দ্রুত করতে বেশি মনোযোগ দিয়েছিল। পরে Intel আবার rep movsb আর rep stosb-কে দ্রুত করার ব্যবস্থা যোগ করে, আর Intel-এর optimization নথিতে এর কথা আছে বলে জানা যায়; আজকের অনেক memcpy বাস্তবায়ন অবস্থা বুঝে এগুলো ব্যবহার করে। RISC নকশা (ARM, RISC-V) অন্য পথ নিয়েছে: সাধারণ load/store দিয়ে loop, সঙ্গে একসঙ্গে কয়েকটি register নেওয়ার instruction (Cortex-M-এর LDM/STM) বা বড় ক্ষেত্রে DMA (পর্ব ৪৬).

মূল উপলব্ধি: String instruction ছিল ধীর bus আর ছোট memory-র যুগে fetch বাঁচানোর উপায়; কোনটি দ্রুত, তা প্রজন্ম ভেদে বদলায়, তাই সময়ের দাবি সবসময় নির্দিষ্ট CPU-র নথি বা মাপ দিয়ে যাচাই করতে হয়।

প্র ০২উৎসের segment (DS) বদলানো যায়, কিন্তু গন্তব্যের (ES) যায় না। দুই segment register রাখার আর এই অসমতার পেছনে যুক্তি কী?

দুটি আলাদা segment রাখার মূল লাভ হলো এক instruction-এ এক segment থেকে অন্য segment-এ কপি। 8086-এ একটি segment মাত্র ৬৪ KB, আর ১ MB memory-তে program-এর data, display-এর memory (IBM PC-তে text screen-এর buffer আলাদা এলাকায়) আর OS-এর buffer প্রায়ই আলাদা segment-এ থাকত। উৎসের জন্য DS আর গন্তব্যের জন্য ES থাকায় rep movsw সরাসরি program-এর data থেকে screen-এ লিখতে পারত। এই পর্বের প্রথম run-ও তাই: DS:0200H থেকে ES = 2000H-এর buffer-এ।

অসমতার কারণ encoding আর সরলতা। String instruction এক byte-এর, তাতে ModR/M নেই, তাই segment বলার জায়গা শুধু prefix. 8086-এর prefix-এর নিয়ম ছিল “পরের instruction-এর memory operand-এর segment বদলানো”; একটি instruction-এ দুটি memory operand থাকায় Intel ঠিক করল prefix শুধু “সাধারণ” operand, অর্থাৎ DS-এর দিকের উৎসকেই বদলাবে। গন্তব্যকে ES-এ বেঁধে রাখায় microcode সরল হলো, আর programmer-এর জন্যও নিয়ম স্পষ্ট: লেখা সবসময় ES-এ। গন্তব্য বদলাতে হলে ES-কেই বদলাতে হয়, যার জন্য দুটি instruction (mov ax,…, mov es,ax) লাগে।

এর ব্যবহারিক ফল দুটি। প্রথমত, .EXE program-এ ES না বসালে STOS বা MOVS নীরবে PSP-র segment-এ লেখে, যা নতুনদের একটি পরিচিত bug. দ্বিতীয়ত, ROM থেকে RAM-এ কপি করতে উৎসে CS override (cs movsb, বা cs lodsb = 2E AC) খুব কাজের, কারণ স্থির টেবিল প্রায়ই code-এর পাশেই থাকে। আর আগের প্রশ্নের microcode-এর গল্প মনে রাখুন: REP আর override একসঙ্গে থাকলে 8086-এ interrupt-এর পরে সমস্যা হতে পারত, তাই override-যুক্ত লম্বা REP আরও সাবধানে লিখতে হতো।

মূল উপলব্ধি: দুই segment register দিয়েছে segment পেরিয়ে কপির ক্ষমতা, আর এক-byte encoding আর সরল নিয়মের জন্য গন্তব্যকে ES-এ বাঁধা হয়েছে; তার দাম হলো ES বসানোর দায় সবসময় programmer-এর।

প্র ০৩একটি লম্বা REP MOVSB চলার সময় interrupt এলে 8086 কী করে? এমবেডেড সিস্টেমে latency-র দৃষ্টিতে এই নকশার গুরুত্ব কী, আর আধুনিক microcontroller একই সমস্যা কীভাবে সামলায়?

একটি সাধারণ instruction কয়েক থেকে কয়েক ডজন clock নেয়, তাই CPU instruction শেষ করে তারপর interrupt নেয়। কিন্তু CX = FFFFH দিয়ে একটি rep movsb Intel-এর টেবিলে প্রায় ১১ লাখ clock (9 + 17 × 65535); 5 MHz-এর একটি 8086-এ তা প্রায় ০.২ সেকেন্ড। এই সময় interrupt আটকে থাকলে একটি serial port-এর byte হারিয়ে যেত বা timer-এর tick পিছিয়ে যেত। তাই Intel REP-কে পাকের মাঝে থামার যোগ্য করেছে: পুরো অবস্থা দৃশ্যমান register-এ (CX, SI, DI), তাই interrupt নেওয়ার সময় ফেরার ঠিকানা হিসেবে prefix-এর ঠিকানা রাখলেই চলে। IRET-এর পরে instruction আবার শুরু হয়, আর বাকি CX থেকে চলতে থাকে। ISR যদি CX, SI, DI বা DF নষ্ট না করে, তাহলে কপি নির্ভুলভাবে শেষ হয়; এজন্যই ISR-কে যেসব register ছোঁয় সেগুলো বাঁচিয়ে রাখতে হয় (পর্ব ২০).

এমবেডেড দৃষ্টিতে এটি interrupt latency-র প্রশ্ন: সবচেয়ে খারাপ ক্ষেত্রে interrupt কতক্ষণ অপেক্ষা করে? REP থামার যোগ্য হওয়ায় latency-তে একটি পাকের বেশি যোগ হয় না, কপির দৈর্ঘ্য যতই হোক। কিন্তু আগে আলোচিত একটি দুর্বলতা আছে: একাধিক prefix-এর ক্ষেত্রে interrupt-এর পরে শুধু শেষটি মনে থাকে, তাই নির্ভরযোগ্য code-এ rep es movsb-এর মতো মিশ্রণ এড়ানো বা তার চারপাশে interrupt বন্ধ রাখা হতো। দ্বিতীয় বিকল্পের দামও বোঝা দরকার: interrupt বন্ধ রাখলে latency আবার পুরো কপির সমান হয়ে যায়।

আধুনিক microcontroller-এ একই ভাবনা দেখা যায়। ARMv7-M (Cortex-M3/M4)-এ একসঙ্গে কয়েকটি register load/store করা LDM/STM চলার মাঝে exception এলে instruction থেমে পরে আবার চলতে পারে বা নতুন করে শুরু হয়, যার জন্য ARM-এর architecture manual-এ আলাদা অবস্থা-বিট আছে; বিস্তারিত পর্ব ৩০-এ। আর বড় block কপির জন্য microcontroller সাধারণত CPU-কেই ব্যবহার করে না: DMA controller নিজে data সরায়, CPU অন্য কাজ বা ঘুমাতে পারে, আর কাজ শেষে একটি interrupt আসে (পর্ব ৪৬). তখন latency-র প্রশ্ন সরে যায় bus-এর ভাগাভাগিতে: DMA আর CPU একই bus চাইলে কে আগে পাবে।

মূল উপলব্ধি: লম্বা কাজকে থামার যোগ্য করা, আর তার অবস্থা দৃশ্যমান register-এ রাখা, হলো real-time সাড়া বাঁচানোর পুরোনো আর এখনো চালু কৌশল; 8086-এর REP তার প্রথম দিকের একটি উদাহরণ।

প্র ০৪Direction flag একটি “global” অবস্থা, যা কোনো routine বদলে রেখে গেলে পরের সব string instruction-এর আচরণ বদলে যায়। এমন অবস্থা কেন বিপজ্জনক, আর software জগৎ এর বিরুদ্ধে কী নিয়ম বানিয়েছে?

DF instruction-এর ভেতরে লেখা থাকে না; এটি flag register-এর একটি বিট, যা শেষবার কে বসিয়েছিল তার ওপর নির্ভর করে। তাই একই rep movsb line দুই রকম ফল দিতে পারে, code দেখে বোঝার উপায় নেই। এই পর্বের nocld.asm-এ একটি পুরোনো std-এর জন্য কপি উল্টো দিকে গিয়ে গন্তব্যের আগের চার byte নষ্ট করল, আর আসল গন্তব্যে পৌঁছাল মাত্র একটি byte. কোনো error নেই, কোনো সতর্কতা নেই। ভুলটি দেখা দেয় অন্য জায়গায়, অন্য সময়ে, যখন সেই নষ্ট হওয়া data ব্যবহার হয়: debugging-এর সবচেয়ে কঠিন ধরন।

এর বিরুদ্ধে দুটি নিয়ম প্রচলিত। প্রথমটি রক্ষণশীল: প্রতিটি string routine নিজের শুরুতে CLD বা STD লিখবে, আগের অবস্থার ওপর ভরসা করবে না। দ্বিতীয়টি চুক্তিভিত্তিক: calling convention-এ লেখা থাকে যে function-এ ঢোকা আর বেরোনোর সময় DF = 0; যে STD করে, সে ফেরার আগে CLD করবে। আধুনিক x86-এর System V ABI আর Microsoft-এর x64 calling convention দুটিই এমন শর্ত রাখে বলে তাদের নথিতে আছে। চুক্তিভিত্তিক নিয়মের লাভ হলো compiler প্রতিটি rep movsb-এর আগে CLD না বসিয়ে এক byte আর কিছু সময় বাঁচাতে পারে।

কিন্তু চুক্তি ভাঙলে কী হয়, তার একটি বহুল আলোচিত উদাহরণ আছে। ২০০৮ সালের দিকে GCC-র একটি নতুন সংস্করণ ABI-র ওপর ভরসা করে CLD বসানো বন্ধ করে, আর তখন দেখা যায় Linux kernel signal handler চালানোর আগে DF পরিষ্কার করত না; ফলে একটি program-এর STD-এর মাঝে signal এলে handler-এর string কাজ উল্টো চলতে পারত। এটি kernel-এ ঠিক করা হয় বলে সেই সময়ের আলোচনায় পাওয়া যায়। শিক্ষাটি সাধারণ: interrupt বা signal handler-এর শুরুতে যে অবস্থার ওপর code নির্ভর করে, তা নিজে নিশ্চিত করতে হয়, কারণ handler যেকোনো মুহূর্তে ঢুকতে পারে। এমবেডেড ISR-এ একই কথা খাটে, যেখানে ISR-এর ভেতরে string instruction থাকলে আগে CLD লেখাই নিরাপদ।

মূল উপলব্ধি: লুকানো mode-বিট যেকোনো instruction-এর অর্থ বদলাতে পারে; তাকে হয় প্রতিবার নিজে বসাতে হয়, নয়তো একটি লিখিত চুক্তিতে বাঁধতে হয়, আর handler-এর প্রবেশপথে সেই চুক্তি সবচেয়ে বেশি ভাঙে।

প্র ০৫C-তে memcpy আর memmove দুটি আলাদা function কেন? 8086-এর CLD/STD-এর গল্প এই পার্থক্যকে কীভাবে ব্যাখ্যা করে?

পার্থক্য overlap-এ। C standard অনুযায়ী memcpy-এর উৎস আর গন্তব্য একে অপরের ওপর পড়লে আচরণ undefined, অর্থাৎ বাস্তবায়ন যেকোনো দিক বা যেকোনো ক্রমে কপি করতে পারে। memmove প্রতিশ্রুতি দেয় যে overlap থাকলেও ফল এমন হবে যেন আগে পুরো উৎস একটি আলাদা জায়গায় কপি হয়েছিল। 8086-এ এর বাস্তবায়ন ঠিক এই পর্বের নিয়ম: গন্তব্য উৎসের পরে আর ভেতরে পড়লে STD আর শেষ byte থেকে, নইলে CLD. memcpy-কে এই পরীক্ষা করতে হয় না, তাই সে সবসময় দ্রুততম দিক বেছে নিতে পারে, যেমন word ধরে কপি বা হাতের কাছের CPU-র সবচেয়ে দ্রুত পথ।

“undefined” কথাটি তাত্ত্বিক নয়। এই পর্বের ovf.asm দেখিয়েছে, ভুল দিকে কপি করলে "65.50" হয়ে যায় "65656", কোনো error ছাড়া। আর কোন দিক ভুল, তা নির্ভর করে বাস্তবায়নের ওপর: একটি memcpy সামনে থেকে কপি করলে ডানে সরানো ভাঙে, পেছন থেকে করলে বাঁয়ে সরানো ভাঙে। ২০১০ সালের দিকে GNU C library-র একটি সংস্করণ কিছু CPU-তে memcpy-কে দ্রুত করতে কপির ক্রম বদলায়, আর তখন overlap-এ ভুলভাবে memcpy ব্যবহার করা কিছু জনপ্রিয় program-এ শব্দ বা ছবিতে গোলমাল দেখা দেয় বলে সে সময়ের bug-আলোচনায় পাওয়া যায়। Library ঠিক ছিল; program এমন একটি আচরণের ওপর নির্ভর করছিল, যা standard কখনো দেয়নি।

এমবেডেড firmware-এ এই পার্থক্য প্রায়ই আসে: একটি ring buffer বা UART-এর লাইন-buffer-এ data বাঁয়ে সরানো (প্রথম কয়েকটি byte পড়ার পরে), বা একটি packet-এর মাঝে header ঢোকানো। নিয়ম সরল: একই buffer-এর ভেতরে সরালে memmove, আলাদা buffer হলে memcpy. আর assembly-তে নিজে লিখলে আগে দিক ঠিক করুন, তারপর SI/DI শুরু না শেষ, তারপর CX-এ byte না word, তা ঠিক করুন। Ring buffer-এর ধারণা DSA কোর্সে আছে, আর UART-এর ring buffer পর্ব ৪৯-এ।

মূল উপলব্ধি: memmove হলো CLD/STD-এর সিদ্ধান্তকে একটি function-এর প্রতিশ্রুতিতে বাঁধা; overlap-এর সম্ভাবনা থাকলে সেই প্রতিশ্রুতি চাই, নইলে ফল নির্ভর করবে কারও অদেখা বাস্তবায়নের ওপর।

অনুশীলন

প্রথমে নিজে হিসাব করুন বা লিখুন, তারপর উত্তর খুলুন। প্রতিটি উত্তর NASM 3.02 আর কোর্সের run8086.py-এ যাচাই করা; সময়ের সংখ্যা Intel-এর টেবিল থেকে।

  1. নকশা ও বাস্তবায়ন — পণ্যের কোড খোঁজা: বাজারঘরের স্কেলে চারটি পণ্যের ৫ অক্ষরের কোড একটানা রাখা: 'ALU ', 'PEYAJ', 'PATAL', 'PATOL', আর তাদের দর (পয়সা/kg) একটি word-টেবিলে: 6550, 8000, 4500, 6000 (আলুর দর README থেকে, বাকিগুলো কাল্পনিক). key-এ রাখা কোড টেবিলে খুঁজে তার index আর দর ছাপার একটি NASM program লিখুন REPE CMPSB দিয়ে; না পেলে দর হিসেবে 65535 ছাপুন। কোন register কোন ভূমিকায়, ব্যাখ্যা করুন।
            org 100h
            cld                     ; দিক: সামনে
            mov bx, codes           ; BX = চলতি টেবিল-ঘর
            xor dx, dx              ; DX = index
    next:   mov si, key             ; DS:SI = খোঁজার কোড
            mov di, bx              ; ES:DI = টেবিল-ঘর
            mov cx, 5
            repe cmpsb
            je found                ; ZF = 1: পুরো মিল
            add bx, 5
            inc dx
            cmp dx, 4
            jb next
            mov ax, 0FFFFh          ; পাওয়া যায়নি
            jmp show
    found:  mov si, dx
            shl si, 1               ; word-এর index
            mov ax, [rates+si]
    show:   push ax
            mov ax, dx
            call print_u16          ; index
            mov dl, ' '
            mov ah, 02h
            int 21h
            pop ax
            call print_u16          ; দর
            call newline
            mov ax, 4C00h
            int 21h
    key:    db 'PATOL'
    codes:  db 'ALU  ', 'PEYAJ', 'PATAL', 'PATOL'
    rates:  dw 6550, 8000, 4500, 6000
    %include "print_u16.inc"

    সত্যিকারের run (lookup.asm): ছাপে 3 6000, অর্থাৎ index ৩, দর ৬০.০০ টাকা/kg; [exit code 0 via INT 21h/4Ch, 145 instructions]. ভূমিকা: SI খোঁজার কোড, DI টেবিল-ঘর, CX পাঁচ অক্ষর, BX পরের ঘরের শুরু মনে রাখে (কারণ CMPSB DI বদলে দেয়), DX index. সিদ্ধান্ত je দিয়ে, CX দিয়ে নয়: "PATAL"-এর তুলনা থামে CX = 1-এ, কিন্তু শেষ byte-এ অমিল হলে CX = 0 হয়েও ZF = 0 থাকত। Index আগে ছাপা হয়, কারণ তারপর space ছাপতে DL-এ ' ' বসে আর DX-এর index নষ্ট হয়; দরটি তাই আগেই stack-এ রাখা। Index দিয়ে দর আনতে shl si,1, কারণ 8086-এ scale নেই (পর্ব ১৫).

  2. ভুল খুঁজুন — তিনটি কপি আর তুলনা: (ক) আগে কোথাও একটি routine std করে ফেরত আসেনি; তারপর mov si,0200h, mov di,0300h, mov cx,5, rep movsb দিয়ে "65.50" কপি। (খ) পাঁচ byte "65.50" কপি করতে mov cx,5 আর rep movsw. (গ) দুটি ৫ অক্ষরের কোড তুলনায় repe cmpsb-এর পরে jcxz equal (CX শূন্য হলে “সমান”). প্রতিটিতে কী হয়, আর ঠিক রূপ কী?

    (ক) DF = 1 রয়ে গেছে, তাই কপি উল্টো চলে: সত্যিকারের run (nocld.asm)-এ SI 0200H → 01FBH, DI 0300H → 02FBH; 0300H-এ শুধু '6' (1000:0300 36 00 00 …), আর বাকি চার byte গিয়ে পড়ে 02FCH–02FFH-এ, গন্তব্যের আগে, সম্ভবত অন্য data-র ওপর। ঠিক রূপ: rep movsb-এর আগে cld; আর যে routine STD করেছিল, সে ফেরার আগে CLD করবে। (খ) CX গোনে word, তাই ৫ × ২ = ১০ byte কপি হয়: run (bug1.asm)-এ SI 010DH → 0117H, আর গন্তব্যে 36 35 2E 35 30 41 4C 55 2E 2E, অর্থাৎ "65.50"-এর পরের "ALU.."-ও চলে এসেছে, গন্তব্যের পরের পাঁচ byte নষ্ট। ঠিক রূপ rep movsb আর CX = 5, বা word-এ গেলে CX = byte ÷ 2 আর বিজোড় শেষ byte-এর জন্য একটি বাড়তি movsb. (গ) শেষ byte-এ অমিল হলেও CX = 0 হয়: "ALU-1" বনাম "ALU-2"-এর run (lastbyte.asm)-এ CX = 0 কিন্তু ZF = 0 (--I-S-APC). jcxz ভুল করে “সমান” বলবে। ঠিক রূপ je equal.

  3. আগে বলুন, তারপর মেলান — REPNE SCASB: DS = ES = 1000H, offset 0200H থেকে "BAZARGHAR" (৯টি byte). mov di,0200h, mov cx,9, mov al,'G', cld, repne scasb. শেষে DI, CX আর ZF কত, কয়টি পাক চলে, আর 'G'-এর অবস্থান (০ থেকে গুনে) কত?

    'G' আছে ষষ্ঠ ঘরে, offset 0205H (B A Z A R G …). REPNE প্রতিটি অমিলে চলে আর মিলের পাকে থামে, তাই ৬টি পাক। প্রতি পাকে DI এক বাড়ে আর CX এক কমে, মিলের পাকেও: DI = 0200H + 6 = 0206H, CX = 9 − 6 = 3, ZF = 1. অবস্থান = DI − 1 − 0200H = 5. সত্যিকারের run (predict.asm)-এর শেষ পাক: repne scasb AX=0047 CX=0003 … DI=0206 … --I--Z-P-, [exit code 0 via HLT, 11 instructions] (৫টি শুরুর instruction + ৬ পাক). পথে তৃতীয় পাকে ('Z' = 5AH) flag --I-S-APC, কারণ 47H − 5AH ঋণাত্মক: 'G' বর্ণক্রমে 'Z'-এর আগে। বাকি CX = 3 হলো 'G'-এর পরের অক্ষর: "HAR".

  4. হিসাব — সময় (datasheet-এর মান): Intel-এর 8086 টেবিল ধরে নিন: REP MOVS = 9 + 17 প্রতি পাক, LODS = 12, STOS = 11, LOOP = 17 (লাফ দিলে) বা 5 (না দিলে). বাজারঘরের display-এর ২৫৬ byte-এর একটি buffer কপি করতে (ক) rep movsb, (খ) lodsb/stosb/loop-এর loop কত clock নেয়? 5 MHz clock-এ সময় কত? (গ) জোড় ঠিকানায় rep movsw দিয়ে কত?

    (ক) 9 + 17 × 256 = 9 + 4352 = ৪৩৬১ clock; 5 MHz-এ এক clock = 0.2 µs, তাই 4361 × 0.2 µs = 872.2 µs. (খ) প্রতি পাক 12 + 11 + 17 = 40 clock, শেষ পাকে LOOP লাফ দেয় না: 12 + 11 + 5 = 28. মোট 255 × 40 + 28 = 10200 + 28 = ১০২২৮ clock = 2045.6 µs, প্রায় ২.৩ গুণ বেশি। (গ) ২৫৬ byte = ১২৮ word: 9 + 17 × 128 = 9 + 2176 = ২১৮৫ clock = 437 µs, ঠিকানা জোড় হলে; বিজোড় হলে প্রতিটি word-এর memory কাজে বাড়তি সময় লাগে (Intel-এর নোট). প্রতিটি গুণফল Python-এ মিলিয়ে দেখা, কিন্তু মূল সংখ্যাগুলো datasheet-এর আদর্শ মান; wait state, queue খালি থাকা বা DMA-র সঙ্গে bus ভাগাভাগিতে বাস্তবে বেশি লাগে, আর কোর্সের lab সময় মাপে না (Spec decision 16).

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

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

ক্রম8086 যখন REPNE SCASB-এর একটি পাক চালায় (DF = 0), ধাপগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)

  1. CX শূন্য কি না দেখা; শূন্য হলে পরের instruction-এ যাওয়া
  2. AL − [ES:DI] হিসাব করে শুধু flag বসানো
  3. DI এক বাড়ানো
  4. CX এক কমানো
  5. ZF = 1 হলে থামা, নইলে আবার প্রথম ধাপে

8086-এর MOVSB instruction-এর উৎস আর গন্তব্য কোথায়?

  • উৎস ES:DI, গন্তব্য DS:SI
  • উৎস DS:SI, গন্তব্য ES:DI
  • উৎস DS:SI, গন্তব্য DS:DI
  • উৎস DS:BX, গন্তব্য ES:BP

DF = 1 অবস্থায় একটি MOVSW চলার পরে SI আর DI কীভাবে বদলায়?

  • দুটিই ১ করে বাড়ে
  • দুটিই ১ করে কমে
  • দুটিই ২ করে কমে
  • SI ২ কমে, DI ২ বাড়ে

DS = ES, SI-তে "ALU-1", DI-তে "ALU-2", CX = 5, DF = 0. REPE CMPSB-এর পরে কোন কথাটি ঠিক?

  • CX = 0, তাই দুটি কোড সমান
  • CX = 1, ZF = 0
  • CX = 0, ZF = 1
  • CX = 0, ZF = 0, আর কোড দুটি সমান নয়

একই buffer-এ ৫ byte-এর লেখা 0200H থেকে 0202H-এ (দুই ঘর ডানে) সরাতে হবে REP MOVSB দিয়ে। কোন ব্যবস্থা ঠিক?

  • STD, SI = 0204H, DI = 0206H, CX = 5
  • CLD, SI = 0200H, DI = 0202H, CX = 5
  • STD, SI = 0200H, DI = 0202H, CX = 5
  • CLD, SI = 0200H, DI = 0202H, CX = 7

"81.88 Tk" (offset 0200H থেকে) -এ REPNE SCASB দিয়ে '.' খোঁজা হলো (CX = 8, DF = 0). থামার পরে DI কত?

  • 0202H
  • 0203H
  • 0208H
  • 0200H

NASM-এর listing-এ repne scasb = F2 AE আর rep movsb = F3 A4. repe cmpsb-এর machine code কী?

  • F2 A6
  • F3 A4
  • F3 A6
  • F3 AE

CX = 0 অবস্থায় 8086 REP MOVSB চালালে কী হয়?

  • একটি byte কপি হয়, তারপর থামে
  • CX ঘুরে FFFFH হয় আর ৬৫৫৩৫ byte কপি হয়
  • CPU একটি exception দেয়
  • কিছুই কপি হয় না, SI আর DI বদলায় না

শব্দকোষ

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

মনে রাখুন

  1. পাঁচ কাজ: MOVS (A4/A5), CMPS (A6/A7), SCAS (AE/AF), LODS (AC/AD), STOS (AA/AB); উৎস DS:SI (override চলে), গন্তব্য ES:DI (চলে না), গণক CX.
  2. দিক: CLD → DF = 0, বাড়ে; STD → DF = 1, কমে; byte-এ ১, word-এ ২; STD করলে ফেরার আগে CLD.
  3. REP: REP/REPE = F3, REPNE = F2; প্রতি পাকে আগে CX দেখা, তারপর কাজ, pointer সরানো, CX − ১, তারপর (REPE/REPNE হলে) ZF.
  4. ফল পড়া: থামার পরে ZF দিয়ে সিদ্ধান্ত; SI/DI শেষ পরীক্ষা করা ঘরের পরে, তাই অবস্থান = DI − 1 − শুরু; strlen = NOT CX − 1.
  5. Overlap: গন্তব্য উৎসের পরে আর ভেতরে হলে STD আর শেষ byte থেকে; অন্যথায় CLD. এটিই memmove.

পরের পর্বে: পর্ব ২০ (8086-এর interrupt — vector table, INT আর ISR). 0000H:0000H-এর ২৫৬টি vector, INT n, IRET, আর একটি divide-error handler-এর সত্যিকারের run; সঙ্গে দেখবেন লম্বা REP-এর মাঝে interrupt এলে stack-এ কী থাকে।

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

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