শাখা আর লুপ assembly-তে — if, while, for আর switch

১ · PC + 4 আর লাফ — প্রোগ্রাম কীভাবে ক্রমে চলে, কীভাবে পথ বদলায়

পর্ব ২৬-এ (RISC-V-এর instruction) যে instruction-গুলো দেখেছেন — add, addi, lw, sw — সবগুলো একটার পর একটা চলে। কে ঠিক করে “এর পর কোনটি”? একটি বিশেষ register, program counter বা PC. PC-তে থাকে এখন যে instruction চলছে তার মেমরি-ঠিকানা। RV32I-এর প্রতিটি instruction ৩২ বিট, অর্থাৎ ৪ byte, তাই একটি শেষ হলে hardware সাধারণত PC-তে ৪ যোগ করে। একে বলে ক্রমানুসারে চলা (sequential execution): 0x1000, 0x1004, 0x1008…

কিন্তু শুধু সোজা পথে চললে কোনো সিদ্ধান্ত নেওয়া যায় না, কোনো কাজ বারবারও করা যায় না। তাই ISA-তে থাকে এমন instruction, যা PC-তে PC + 4-এর বদলে অন্য একটি ঠিকানা বসায়। প্রোগ্রাম কোন ক্রমে চলবে, সেই পুরো ব্যাপারটিকে বলে control flow. এর দুটি মৌলিক রূপ:

• Conditional branch (শর্তসাপেক্ষ শাখা): শর্ত সত্য হলে লাফ, মিথ্যা হলে সোজা পরের instruction-এ (একে বলে fall-through). C-র if আর লুপের শর্ত এভাবেই হয়।
• Unconditional jump (নিঃশর্ত লাফ): সবসময় লাফ — else-অংশ টপকানো, লুপের শুরুতে ফেরা, function ডাকা আর সেখান থেকে ফেরা।

Assembly-তে লাফের গন্তব্যকে একটি নাম দিয়ে চিহ্নিত করা হয় — একে বলে label (যেমন loop:, done:). Label কোনো instruction নয়, মেমরিতে কোনো জায়গাও নেয় না; এটি শুধু পরের instruction-এর ঠিকানার একটি নাম। Assembler label-কে ঠিকানায় বদলায়, আর শাখার instruction-এ বসায় “এখান থেকে কত byte দূরে” — সেই দূরত্বকে বলে branch offset. একটি শাখা বা label থেকে পরের শাখা পর্যন্ত যে টুকরো কোড সবসময় একসাথে, শুরু থেকে শেষ পর্যন্ত চলে, তাকে compiler-এর ভাষায় বলে basic block. Compiler পুরো প্রোগ্রামকে basic block আর তাদের মধ্যের তীর (কে কোথায় লাফাতে পারে) দিয়ে একটি গ্রাফ হিসেবে দেখে।

২ · RV32I-এর শাখা আর লাফ — beq থেকে jalr, আর target address-এর হিসাব

পর্ব ১৩-এর অংশ ৭-এ দেখেছেন, x86 আর ARM আগে cmp দিয়ে flag বানায়, তারপর আলাদা instruction-এ flag পড়ে লাফ দেয়। RISC-V-তে flag নেই; একটি instruction-ই দুটি register তুলনা করে লাফ দেয় — এই নকশার নাম compare-and-branch. RV32I-এ মোট ছয়টি:

খেয়াল করুন, bgt (বড়) বা ble (ছোট বা সমান) নেই। দরকারও নেই: a > b মানে b < a, আর a ≤ b মানে b ≥ a. তাই assembler এগুলোকে pseudo-instruction হিসেবে মেনে নেয় আর operand-দুটি অদলবদল করে আসল instruction বসায়। শূন্যের সাথে তুলনার জন্য register x0 (যার মান সবসময় ০) ব্যবহার হয়:

# উদাহরণ — RV32I pseudo-instruction আর তাদের আসল রূপ
bgt   a0, a1, L     =  blt   a1, a0, L      # a0 > a1   <=>  a1 < a0
ble   a0, a1, L     =  bge   a1, a0, L      # a0 <= a1  <=>  a1 >= a0
bgtu  a0, a1, L     =  bltu  a1, a0, L
bleu  a0, a1, L     =  bgeu  a1, a0, L
beqz  a0, L         =  beq   a0, x0, L
bnez  a0, L         =  bne   a0, x0, L
bltz  a0, L         =  blt   a0, x0, L
blez  a0, L         =  bge   x0, a0, L      # 0 >= a0
bgtz  a0, L         =  blt   x0, a0, L      # 0 < a0
j     L             =  jal   x0, L          # link discarded: plain jump
jal   L             =  jal   ra, L          # call: ra = PC + 4
jr    t0            =  jalr  x0, 0(t0)
ret                 =  jalr  x0, 0(ra)      # return from a function

দুটি লাফ: jal আর jalr

• jal rd, L (jump and link): rd-তে PC + 4 রাখে, তারপর PC = PC + offset. rd = x0 দিলে ফেরার ঠিকানা ফেলে দেওয়া হয় — শুধু লাফ, যার নাম j. rd = ra (x1) দিলে function call; PC + 4-কে বলে return address.
• jalr rd, imm(rs1): target = (rs1 + imm) এবং তার সবচেয়ে নিচের বিট ০ করে দেওয়া; rd-তে PC + 4. গন্তব্য কোডে লেখা নেই, চলার সময় register থেকে আসে — তাই এটি indirect jump. Function থেকে ফেরা (ret), function pointer দিয়ে ডাকা আর switch-এর jump table এর ওপর দাঁড়িয়ে। Function call-এর পুরো নিয়ম পর্ব ৩০-এ (Function call আর stack).

Target address — PC + offset

RISC-V-এর শাখা আর jal গন্তব্য বোঝায় শাখা-instruction-এর নিজের ঠিকানা থেকে দূরত্ব দিয়ে: branch target = PC + offset. এই পদ্ধতির নাম PC-relative addressing (পর্ব ২৮-এ addressing mode-এর অংশ হিসেবে)। কোড মেমরির যেখানেই বসানো হোক, ভেতরের লাফগুলো ঠিক থাকে, কারণ দূরত্ব বদলায় না। Offset সবসময় জোড় সংখ্যা (২-এর গুণিতক, যাতে C extension-এর ১৬-বিট compressed instruction-এও লাফানো যায়), তাই encoding-এ সবচেয়ে নিচের বিটটি রাখাই হয় না। ফলে:

• শাখা (B-type): ১৩ বিটের signed offset, −4096 থেকে +4094 byte — মোটামুটি ±৪ KiB.
• jal (J-type): ২১ বিটের signed offset, −1048576 থেকে +1048574 byte — মোটামুটি ±১ MiB.
• jalr (I-type): ১২ বিটের signed imm, −2048 থেকে +2047, যোগ হয় register-এর সাথে — তাই ৩২-বিট ঠিকানার যেকোনো জায়গায়।

এই বিটগুলো instruction-এর ভেতরে কোন ক্রমে বসে, সেই কিছুটা অদ্ভুত বিন্যাস পর্ব ২৭-এ (Instruction format আর encoding). এখানে শুধু হিসাবটা।

হাতে-কলমে: target-এর পাঁচটি অঙ্ক

(ক) 0x00001040:  beq t0, t1, L      L = 0x00001010
    offset = 0x1010 - 0x1040 = -0x30 = -48       (−4096 ≤ −48 ≤ 4094: চলবে)

(খ) 0x00400000:  bne a0, a1, +2044
    target = 0x00400000 + 0x7FC = 0x004007FC

(গ) 0x00002000:  beq t0, t1, L      L = 0x00003100
    offset = 0x1100 = 4352  > 4094  -> শাখার নাগালের বাইরে!

(ঘ) 0x00010000:  jal ra, F          F = 0x00100000
    offset = 0xF0000 = 983040  (≤ 1048574: চলবে);  ra = 0x00010004

(ঙ) 0x00001000:  jalr ra, 4(t0)     t0 = 0x00002001
    target = (0x2001 + 4) এবং নিচের বিট 0 = 0x2005 -> 0x00002004;  ra = 0x00001004

(গ)-এর সমাধান assembler নিজেই করে: শর্ত উল্টে একটি ছোট শাখা দিয়ে একটি দূরপাল্লার j-কে টপকায় — যার নাগাল ±১ MiB. একে বলে branch relaxation:

# উদাহরণ — beq t0, t1, L  (L অনেক দূরে)  হয়ে যায়:
      bne  t0, t1, skip     # opposite condition, short hop
      j    L                # jal x0, L : reach ±1 MiB
skip:

এই “উল্টো শর্তে ছোট লাফ, তারপর বড় লাফ” কৌশলটি মনে রাখুন — পরের অংশে if-else-এ ঠিক এটিই মূল চাবি।

৩ · if আর if-else — উল্টো শর্তে লাফ

C-তে লেখেন “শর্ত সত্য হলে এই কাজ”। কিন্তু শাখা-instruction-এর স্বভাব উল্টো: সে লাফ দেয় শর্ত সত্য হলে, আর না হলে সোজা নিচে নামে। then-অংশটি তো ঠিক নিচেই আছে। তাই সবচেয়ে সহজ অনুবাদ হলো: উল্টো শর্ত সত্য হলে then-অংশ টপকে যাওয়া। >=-এর উল্টো <, ==-এর উল্টো !=, >-এর উল্টো <=.

/* C */                                # RV32I — a0 = balance, a1 = amount, a2 = fail
if (balance >= amount)                       blt  a0, a1, else     # opposite of >=
    balance -= amount;                       sub  a0, a0, a1       # then-part
else                                         j    endif            # skip else-part
    fail = 1;                          else: li   a2, 1            # else-part
                                       endif:

bKash-এর টাকা পাঠানোর মতো একটি ছোট নিয়ম: ব্যালান্সে যথেষ্ট টাকা থাকলে টাকা কাটা হবে, নাহলে “ব্যর্থ” চিহ্ন বসবে। then-অংশের শেষে একটি j লাগে, যাতে else-অংশে পড়ে না যায়। শুধু if (else ছাড়া) হলে এই j-ও লাগে না। নিচের stepper-এ একই কোড দুবার চলছে — একবার ব্যালান্স 500, পাঠাতে চান 200; আরেকবার ব্যালান্স 100. প্রতিটি ধাপে সবুজ লাইনটি সেই ধাপে চলছে। “পরে” চাপুন:

1# a0 = balance, a1 = amount = 200, a2 = fail = 020x1000        blt  a0, a1, else30x1004        sub  a0, a0, a140x1008        j    endif50x100C  else:  li   a2, 160x1010  endif: ...

&& আর || — short-circuit মানে আলাদা আলাদা শাখা

C-র && আর || মানে short-circuit evaluation: বাঁ দিক দেখেই উত্তর জানা গেলে ডান দিক হিসাবই হয় না। Assembly-তে এটি স্বাভাবিকভাবে আসে — প্রতিটি ছোট শর্তের জন্য একটি শাখা:

# উদাহরণ — if (a > 0 && b > 0) c = 1;     a0 = a, a1 = b, a2 = c
      blez a0, skip         # a <= 0 : whole condition false, b is never looked at
      blez a1, skip         # b <= 0 : false
      li   a2, 1
skip:

# উদাহরণ — if (a > 0 || b > 0) c = 1;
      bgtz a0, then         # a > 0 : whole condition true, jump straight into the body
      blez a1, skip         # here a <= 0, so b decides
then: li   a2, 1
skip:

&&-এ যেকোনো একটি অংশ মিথ্যা হলেই বাইরে; ||-এ প্রথম সত্য অংশ পেলেই ভেতরে। এটি শুধু গতির ব্যাপার নয়, নিরাপত্তারও: if (p != NULL && p->count > 0)-এ প্রথম শাখা NULL দেখলে দ্বিতীয় অংশের lw কখনো চলে না, তাই NULL-এর ঠিকানা থেকে পড়ার চেষ্টাও হয় না।

৪ · লুপ — while, do-while, for আর loop rotation

লুপ মানে একটি পেছনমুখী লাফ: label-টি শাখার ওপরে, তাই offset ঋণাত্মক। প্রশ্ন শুধু শর্তটি কোথায় বসবে — ওপরে না নিচে।

/* while (i < n) { body; i++; } */      /* do { body; i++; } while (i < n); */

# (ক) top-tested — বইয়ের সরল অনুবাদ    # (খ) bottom-tested — শর্ত নিচে
loop: bge  t1, a1, done   # exit test   loop: ...body...
      ...body...                              addi t1, t1, 1
      addi t1, t1, 1                          blt  t1, a1, loop   # i < n : back
      j    loop           # back to test
done:

(ক)-তে প্রতি ঘুরে দুটি নিয়ন্ত্রণ-instruction চলে: ওপরের bge (লাফ নেই) আর নিচের j. (খ)-তে একটিই — নিচের blt. কিন্তু do-while অন্তত একবার চলে, while বা for শূন্যবারও চলতে পারে। তাই compiler while/for-কে এভাবে সাজায়: শুরুতে একবার একটি “ঢোকার যাচাই” (loop guard), তারপর নিচে শর্তওয়ালা do-while. এই রূপান্তরের নাম loop rotation, আর gcc -O1 বা তার ওপরের প্রায় সব লুপেই এটি দেখতে পাবেন।

/* C */                                   # RV32I (rotated) — a0 = &a[0], a1 = n
int sum = 0;                                    li   t0, 0            # sum
for (int i = 0; i < n; i++)                     li   t1, 0            # i
    sum += a[i];                                bge  t1, a1, done     # guard: n <= 0 ?
                                          loop: slli t2, t1, 2        # i * 4 (int = 4 byte)
                                                add  t2, a0, t2       # &a[i]
                                                lw   t2, 0(t2)        # a[i]
                                                add  t0, t0, t2       # sum += a[i]
                                                addi t1, t1, 1        # i++
                                                blt  t1, a1, loop     # i < n : again
                                          done: mv   a0, t0

নিচের stepper-এ n = 2, a[] = {40, 25} নিয়ে এই লুপটি দুবার ঘুরছে। প্রতিটি শাখায় PC-র হিসাব খেয়াল করুন — বিশেষ করে পেছনমুখী blt-এর ঋণাত্মক offset:

1# a0 = 0x2000 (a[0] = 40, a[1] = 25), a1 = n = 220x1000        li   t0, 030x1004        li   t1, 040x1008        bge  t1, a1, done50x100C  loop:  slli t2, t1, 260x1010        add  t2, a0, t270x1014        lw   t2, 0(t2)80x1018        add  t0, t0, t290x101C        addi t1, t1, 1100x1020        blt  t1, a1, loop110x1024  done:  mv   a0, t0

break, continue আর nested লুপ

• break = লুপের বাইরের label-এ একটি j (প্রায়ই একটি শর্তসাপেক্ষ শাখার সাথে মিশে: if (a[i] == key) break; হয়ে যায় beq t2, a2, done).
• continue = লুপের “পরের ঘুরের” জায়গায় লাফ। while-এ সেটি শর্ত-যাচাই; কিন্তু for-এ সেটি i++, শর্ত নয়। হাতে অনুবাদে এখানে ভুল করলে i আর বাড়ে না — অসীম লুপ। তাই for-এর জন্য compiler তিনটি label রাখে: শুরু, continue-বিন্দু (increment), আর শেষ।
• Nested লুপ: ভেতরের লুপের নিজস্ব label আর নিজস্ব counter, আর বাইরের প্রতিটি ঘুরে ভেতরের counter আবার শূন্য করতে হয় — এই রিসেট ভুলে যাওয়া হাতে লেখা assembly-র একটি পরিচিত বাগ। ভেতরের লুপ বাইরের লুপের body-র অংশ, তাই তার label-গুলো বাইরের দুই label-এর মাঝখানে।

৫ · চারটি ক্লাসিক লুপ — C আর RV32I পাশাপাশি

পরীক্ষা আর ইন্টারভিউতে বারবার যে লুপগুলো আসে, সেগুলোর ছাঁচ একই: একটি counter বা pointer, একটি শর্ত, একটি কাজ। নিচে চারটি — প্রথম দুটি বইয়ের সরল (top-tested) রূপে, যাতে C-র সাথে লাইন মিলিয়ে পড়া যায়।

/* (১) Array-র যোগফল */                   # a0 = &a[0], a1 = n  ->  a0 = sum
int s = 0;                                       li   t0, 0
for (int i = 0; i < n; i++)                      li   t1, 0
    s += a[i];                             loop: bge  t1, a1, done
return s;                                        slli t2, t1, 2
                                                 add  t2, a0, t2
                                                 lw   t2, 0(t2)
                                                 add  t0, t0, t2
                                                 addi t1, t1, 1
                                                 j    loop
                                           done: mv   a0, t0

/* (২) ধনাত্মক সংখ্যা গোনা */                  # rotated, with guard
int c = 0;                                       li   t0, 0            # c
for (int i = 0; i < n; i++)                      li   t1, 0            # i
    if (a[i] > 0) c++;                           bge  t1, a1, done
                                           loop: slli t2, t1, 2
                                                 add  t2, a0, t2
                                                 lw   t2, 0(t2)
                                                 blez t2, skip         # opposite of a[i] > 0
                                                 addi t0, t0, 1
                                           skip: addi t1, t1, 1
                                                 blt  t1, a1, loop
                                           done: mv   a0, t0

/* (৩) String-এর দৈর্ঘ্য (strlen) */          # a0 = s  ->  a0 = length
const char *p = s;                               mv   t0, a0
while (*p != '\0') p++;                    loop: lbu  t1, 0(t0)        # one byte, zero-extended
return p - s;                                    beqz t1, done         # '\0' ?
                                                 addi t0, t0, 1        # p++ (1 byte)
                                                 j    loop
                                           done: sub  a0, t0, a0

/* (৪) সর্বোচ্চ মান (n ≥ 1) */                  # a0 = &a[0], a1 = n  ->  a0 = max
int m = a[0];                                    lw   t0, 0(a0)
for (int i = 1; i < n; i++)                      li   t1, 1
    if (a[i] > m) m = a[i];                loop: bge  t1, a1, done
                                                 slli t2, t1, 2
                                                 add  t2, a0, t2
                                                 lw   t2, 0(t2)
                                                 ble  t2, t0, skip     # opposite of a[i] > m
                                                 mv   t0, t2
                                           skip: addi t1, t1, 1
                                                 j    loop
                                           done: mv   a0, t0

কয়েকটি খুঁটিনাটি লক্ষ করুন। int-এর array-তে index-কে ৪ দিয়ে গুণ (slli … 2) করতে হয়, কারণ ঠিকানা byte-এ; char-এর string-এ pointer বাড়ে ১ করে। lbu একটি byte পড়ে বাকি ২৪ বিটে ০ বসায় (zero extension), তাই 0x00 byte-ই register-এ ঠিক ০ হয়। আর (২) ও (৪)-এর ভেতরের if-এ আবার সেই উল্টো শর্ত।

Signed বনাম unsigned — লুপের শর্তে কোনটি বসবে

C-তে i আর n int হলে compiler বসায় blt/bge; unsigned বা size_t হলে bltu/bgeu. পর্ব ২০-এর অংশ ৬-এ এর বিপজ্জনক দিকটি দেখেছেন (−1 unsigned-এ বিশাল)। লুপে এর সবচেয়ে পরিচিত রূপ উল্টো দিকে গোনা: for (unsigned i = n - 1; i >= 0; i--). unsigned-এ i >= 0 সবসময় সত্য, তাই compiler শাখাটি পুরোপুরি মুছে দিতে পারে — নিচে থাকে শুধু একটি j, অসীম লুপ। gcc -Wextra এখানে “comparison is always true” ধাঁচের warning দেয়। নিরাপদ রূপ: for (unsigned i = n; i-- > 0; ).

এবার চারটির মধ্যে তিনটি — যোগফল, strlen আর max — একটি ছোট RV32I interpreter-এ চালানো যাক। এটি দুই ধাপে কাজ করে, ঠিক একটি আসল assembler আর CPU-র মতো: প্রথমে প্রতিটি label-কে ঠিকানায় বদলায় আর ble, beqz-এর মতো pseudo-instruction-কে আসল রূপে আনে (operand অদলবদল বা x0 বসিয়ে); তারপর PC ধরে ধরে চালায় আর প্রতিটি চলা instruction গোনে। Array a[] = {5, −2, 9, 4, −7, 3} আর string “Dhaka”. Run চাপুন:

// Tiny RV32I interpreter: labels, branches, jal/jalr, lw/lbu; counts executed instructions.
const RN = { zero: 0, ra: 1, t0: 5, t1: 6, t2: 7, a0: 10, a1: 11 }, SWAP = { bgt: "blt", ble: "bge", bgtu: "bltu", bleu: "bgeu" };
const BR = { beq: (p, q) => p === q, bne: (p, q) => p !== q, blt: (p, q) => p < q, bge: (p, q) => p >= q,
  bltu: (p, q) => p >>> 0 < q >>> 0, bgeu: (p, q) => p >>> 0 >= q >>> 0 };
function run(src, init, mem) {
  const lab = {}, P = [], x = new Int32Array(32), dv = new DataView(mem.buffer); let pc = 0, count = 0;
  for (let s of src.split(/[\n;]/)) {                       // pass 1: label -> byte address, expand pseudo
    const m = (s = s.split("#")[0].trim()).match(/^(\w+):\s*(.*)$/); if (m) { lab[m[1]] = P.length * 4; s = m[2]; }
    let [op, a, b, c] = s.replace(/[,()]/g, " ").trim().split(/\s+/); if (!op) continue;
    if (op in SWAP) [op, a, b] = [SWAP[op], b, a];          // ble a,b,L  ==  bge b,a,L
    if (op === "beqz" || op === "bnez") [op, b, c] = [op.slice(0, 3), "zero", b];   // beqz a,L == beq a,zero,L
    P.push([op, a, b, c]); }
  const r = n => x[RN[n]], set = (n, v) => { if (RN[n]) x[RN[n]] = v; };   // x0 stays 0
  const OP = { add: (b, c) => r(b) + r(c), sub: (b, c) => r(b) - r(c), addi: (b, c) => r(b) + +c, slli: (b, c) => r(b) << +c,
    li: b => +b, mv: b => r(b), lw: (b, c) => dv.getInt32(r(c) + +b, true), lbu: (b, c) => mem[r(c) + +b] };
  for (const k in init) set(k, init[k]);
  for (; pc / 4 < P.length && count < 1e5; count++) {  // pass 2: fetch, execute, new PC
    const [op, a, b, c] = P[pc / 4]; let next = pc + 4;
    if (op in BR) { if (BR[op](r(a), r(b))) next = lab[c]; }                       // taken: PC = label
    else if (op === "j" || op === "jal") { if (op === "jal") set(a, pc + 4); next = lab[op === "j" ? a : b]; } // j L == jal zero, L
    else if (op === "jalr") { next = (r(c) + +b) & ~1; set(a, pc + 4); }
    else set(a, OP[op](b, c));
    pc = next;
  } return { r, count }; }
const mem = new Uint8Array(64), dv = new DataView(mem.buffer);
[5, -2, 9, 4, -7, 3].forEach((v, i) => dv.setInt32(4 * i, v, true)); [..."Dhaka"].forEach((ch, i) => mem[32 + i] = ch.charCodeAt(0));
const SUM = `li t0, 0; li t1, 0; loop: bge t1, a1, done; slli t2, t1, 2; add t2, a0, t2; lw t2, 0(t2); add t0, t0, t2
      addi t1, t1, 1; j loop; done: mv a0, t0`, STRLEN = `mv t0, a0; loop: lbu t1, 0(t0); beqz t1, done; addi t0, t0, 1; j loop; done: sub a0, t0, a0`;
const MAX = `lw t0, 0(a0); li t1, 1; loop: bge t1, a1, done; slli t2, t1, 2; add t2, a0, t2; lw t2, 0(t2)
      ble t2, t0, skip; mv t0, t2           # if (a[i] > max): branch on the opposite
      skip: addi t1, t1, 1; j loop; done: mv a0, t0`;
for (const [name, src, init] of [["sum", SUM, { a0: 0, a1: 6 }], ["strlen", STRLEN, { a0: 32 }], ["max", MAX, { a0: 0, a1: 6 }]]) {
  const { r, count } = run(src, init, mem), show = k => `${k} = ${String(r(k)).padStart(2)}`;
  console.log(name.padEnd(6), ["a0", "t0", "t1", "t2"].map(show).join("  "), "  executed:", count);
}

sum    a0 = 12  t0 = 12  t1 =  6  t2 =  3   executed: 46
strlen a0 =  5  t0 = 37  t1 =  0  t2 =  0   executed: 24
max    a0 =  9  t0 =  9  t1 =  6  t2 =  3   executed: 40

৬ · কয়টি instruction চলে? — dynamic instruction count-এর সূত্র

দুটি সংখ্যা আলাদা করে চিনুন। প্রোগ্রামে কতগুলো instruction লেখা আছে — static instruction count; আর চালানোর সময় আসলে কতগুলো চলে — dynamic instruction count. ১০ লাইনের একটি লুপ এক লাখবার ঘুরলে static ১০, dynamic প্রায় দশ লাখ। পর্ব ০৩-এর (CPU time-এর লৌহসূত্র) iron law-এ যে instruction count, তা এই dynamic সংখ্যাই: CPU time = IC × CPI × clock cycle time.

সূত্র বের করার নিয়ম

একটি লুপকে চার ভাগে ভাগ করুন, আর প্রতিটি ভাগ কতবার চলে গুনুন:

• Top-tested যোগফল (অংশ ৫-এর (১)): আগে ২টি (li, li). প্রতি ঘুরে bge (লাফ নেই) + ৫টি কাজ + j = ৭টি. শর্ত-যাচাই n + 1 বার চলে — শেষবার লাফ দিয়ে বেরোয় — তাই বাড়তি ১টি। পরে mv ১টি। IC = 2 + 7n + 1 + 1 = 7n + 4.
• Rotated যোগফল (অংশ ৪): আগে ৩টি (দুটি li আর guard). প্রতি ঘুরে ৫টি কাজ + নিচের blt = ৬টি. পরে ১টি। IC = 3 + 6n + 1 = 6n + 4. n = 0-তেও ঠিক: guard লাফ দিয়ে সোজা mv-এ, মোট ৪.
• ধনাত্মক গোনা (অংশ ৫-এর (২)): ডেটা-নির্ভর। p = ধনাত্মক সংখ্যার সংখ্যা হলে IC = 3 + 6n + p + 1 = 6n + p + 4. a[] = {5, −2, 9, 4, −7, 3}-এ n = 6, p = 4, তাই ৪৪.

যুক্তিটি কেন নির্ভুল: একটি basic block-এ ঢুকলে তার সব instruction চলে। তাই প্রতিটি block কতবার চলে (তার “execution frequency”) জানলেই IC = Σ (block-এর দৈর্ঘ্য × কতবার চলে). লুপের body-block n বার, লুপের আগে-পরের block একবার, আর top-tested শর্ত-block n + 1 বার — কারণ প্রতিটি ঘুরের আগে একবার, আর বেরোনোর সময় আরেকবার। Rotation শর্তকে body-র শেষে জুড়ে দিয়ে এক ঘুরে একটি j বাঁচায়: (7 − 6)n = n টি instruction.

পরীক্ষার ধাঁচে একটি পূর্ণ হিসাব: একটি লুপের IC = 4n + 5, n = 1000, গড় CPI = 1.2, clock 1 GHz (cycle 1 ns). IC = 4005; cycle = 4005 × 1.2 = 4806; সময় = 4806 ns ≈ ৪.৮১ µs.

হাতে বের করা সূত্র সবসময় simulation দিয়ে মেলানো উচিত, বিশেষ করে সীমানার মানে (n = 0, 1). নিচের analyser তিনটি যোগফল-লুপ n = 0, 1, 5, 10-এ চালায়, n = 5 আর n = 10-এর দুটি বিন্দু থেকে সরলরেখা a·n + b বের করে, তারপর চারটি n-এই সূত্র যাচাই করে। তৃতীয়টি compiler-এর -O2-এর ধাঁচে pointer-ভিত্তিক লুপ: index-এর বদলে pointer বাড়ে ৪ করে, আর শেষের ঠিকানা আগেই হিসাব করা থাকে (bge zero, a1 হলো blez a1):

// Dynamic instruction count of three sum loops for n = 0, 1, 5, 10; fit count = a*n + b.
const RN = { zero: 0, t0: 5, t1: 6, t2: 7, a0: 10, a1: 11 };
const BR = { bne: (p, q) => p !== q, blt: (p, q) => p < q, bge: (p, q) => p >= q };
function count(src, init, mem) {
  const lab = {}, P = [], x = new Int32Array(32), dv = new DataView(mem.buffer);
  for (let s of src.split(/[\n;]/)) {
    const m = (s = s.split("#")[0].trim()).match(/^(\w+):\s*(.*)$/); if (m) { lab[m[1]] = P.length; s = m[2]; }
    const t = s.replace(/[,()]/g, " ").trim().split(/\s+/); if (t[0]) P.push(t);
  }
  for (const k in init) x[RN[k]] = init[k];
  const r = n => x[RN[n]], set = (n, v) => { if (RN[n]) x[RN[n]] = v; };
  let pc = 0, n = 0;
  for (; pc < P.length; n++) {
    const [op, a, b, c] = P[pc++];
    if (op in BR) { if (BR[op](r(a), r(b))) pc = lab[c]; } else if (op === "j") pc = lab[a];
    else set(a, { add: () => r(b) + r(c), addi: () => r(b) + +c, slli: () => r(b) << +c,
      li: () => +b, mv: () => r(b), lw: () => dv.getInt32(r(c) + +b, true) }[op]());
  }
  return n;
}
const LOOPS = {
  "top-tested": `li t0, 0; li t1, 0; loop: bge t1, a1, done; slli t2, t1, 2; add t2, a0, t2
    lw t2, 0(t2); add t0, t0, t2; addi t1, t1, 1; j loop; done: mv a0, t0`,
  "rotated   ": `li t0, 0; li t1, 0; bge t1, a1, done; loop: slli t2, t1, 2; add t2, a0, t2
    lw t2, 0(t2); add t0, t0, t2; addi t1, t1, 1; blt t1, a1, loop; done: mv a0, t0`,
  "pointer   ": `li t0, 0; bge zero, a1, done; slli t1, a1, 2; add t1, a0, t1
    loop: lw t2, 0(a0); add t0, t0, t2; addi a0, a0, 4; bne a0, t1, loop; done: mv a0, t0`,
};
const mem = new Uint8Array(64);
for (const [name, src] of Object.entries(LOOPS)) {
  const c = n => count(src, { a0: 0, a1: n }, mem), N = [0, 1, 5, 10], C = N.map(c);
  const a = (c(10) - c(5)) / 5, b = c(5) - 5 * a;                  // fit from n = 5 and n = 10
  const chk = N.map((n, i) => (a * n + b === C[i] ? "ok" : `MISMATCH at n=${n}`)).join(" ");
  console.log(`${name}  n=0,1,5,10 -> ${C.join(", ").padEnd(14)} formula ${a}n + ${b}   check: ${chk}`);
}

top-tested  n=0,1,5,10 -> 4, 11, 39, 74  formula 7n + 4   check: ok ok ok ok
rotated     n=0,1,5,10 -> 4, 10, 34, 64  formula 6n + 4   check: ok ok ok ok
pointer     n=0,1,5,10 -> 3, 9, 25, 45   formula 4n + 5   check: MISMATCH at n=0 ok ok ok

৭ · switch — if-chain বনাম jump table

একটি switch-কে compiler দুইভাবে অনুবাদ করতে পারে। If-chain: case-গুলো একে একে তুলনা — x == 1? x == 2? … RISC-V-তে immediate-এর সাথে সরাসরি তুলনার শাখা নেই, তাই প্রতিটি case-এ একটি li আর একটি beq. শেষের case পর্যন্ত পৌঁছাতে সবগুলো তুলনা পেরোতে হয়। Jump table: case-এর মানগুলো ঘন হলে (যেমন 1…5) মেমরিতে একটি টেবিল রাখা হয়, যার k-তম ঘরে k-তম case-এর কোডের ঠিকানা। তখন x দিয়ে সরাসরি টেবিলের ঘর বেছে jalr — case যতই থাকুক, খরচ একই।

/* C */                              # RV32I — a0 = x, a1 = &table (0x2000)
switch (x) {                         0x1000        addi t0, a0, -1      # index = x - 1
  case 1: r = 10; break;             0x1004        li   t1, 5
  case 2: r = 20; break;             0x1008        bgeu t0, t1, default # index >= 5 (unsigned)?
  case 3: r = 30; break;             0x100C        slli t0, t0, 2       # index * 4
  case 4: r = 40; break;             0x1010        add  t0, a1, t0      # &table[index]
  case 5: r = 50; break;             0x1014        lw   t0, 0(t0)       # target address
  default: r = -1;                   0x1018        jr   t0              # jalr x0, 0(t0)
}                                    0x101C case1: li a0, 10   |  0x1020  j end
                                     0x1024 case2: li a0, 20   |  0x1028  j end
table @0x2000:                       0x102C case3: li a0, 30   |  0x1030  j end
  0x101C 0x1024 0x102C               0x1034 case4: li a0, 40   |  0x1038  j end
  0x1034 0x103C                      0x103C case5: li a0, 50   |  0x1040  j end
                                     0x1044 default: li a0, -1
                                     0x1048 end:

সবচেয়ে সুন্দর কৌশলটি তৃতীয় লাইনে। index = x − 1 ঋণাত্মক হতে পারে (x = 0 বা −2), আবার ৪-এর বেশিও হতে পারে (x = 7). দুটি তুলনার বদলে compiler একটিই unsigned তুলনা বসায়: ঋণাত্মক সংখ্যা unsigned চোখে বিশাল (−1 = 0xFFFFFFFF), তাই bgeu দুই ধরনের ভুল index-কেই default-এ পাঠায়। Bounds check বাদ দিলে lw টেবিলের বাইরের যেকোনো মেমরি পড়ে সেটিকে ঠিকানা ভেবে লাফ দিত — এটি শুধু বাগ নয়, নিরাপত্তার গর্তও। x = 3-এর পুরো যাত্রা ধাপে ধাপে:

10x1000        addi t0, a0, -120x1004        li   t1, 530x1008        bgeu t0, t1, default40x100C        slli t0, t0, 250x1010        add  t0, a1, t060x1014        lw   t0, 0(t0)70x1018        jr   t080x101C case1: li a0, 10 ; j end90x1024 case2: li a0, 20 ; j end100x102C case3: li a0, 30 ; j end110x1034 case4: li a0, 40 ; j end120x103C case5: li a0, 50 ; j end130x1044 default: li a0, -1140x1048 end:

এবার একই switch-কে দুইভাবে চালিয়ে গোনা যাক — jump table আর if-chain, কয়েকটি x-এ, সীমার বাইরের মানসহ। Interpreter টেবিলে label-এর ঠিকানা নিজে বসায়, assembler-linker যেমন করে:

// switch (x) { case 1..5: r = 10*x; default: r = -1 }  as a jump table vs an if-chain (RV32I).
const RN = { zero: 0, t0: 5, t1: 6, a0: 10, a1: 11 }, BASE = 0x1000, TABLE = 0x2000;
const BR = { beq: (p, q) => p === q, bgeu: (p, q) => p >>> 0 >= q >>> 0 };
function asm(src) {
  const lab = {}, P = []; for (let s of src.split(/[\n;]/)) {
    const m = (s = s.split("#")[0].trim()).match(/^(\w+):\s*(.*)$/); if (m) { lab[m[1]] = BASE + 4 * P.length; s = m[2]; }
    const t = s.replace(/[,()]/g, " ").trim().split(/\s+/); if (t[0]) P.push(t);
  } return { lab, P }; }
function exec({ lab, P }, x0, mem) {
  const x = new Int32Array(32), dv = new DataView(mem.buffer), r = n => x[RN[n]], set = (n, v) => { if (RN[n]) x[RN[n]] = v; };
  x[RN.a0] = x0; x[RN.a1] = TABLE;                  // a1 = table base (real code: lui + addi)
  let pc = BASE, n = 0;
  for (; pc < BASE + 4 * P.length; n++) {
    const [op, a, b, c] = P[(pc - BASE) / 4]; pc += 4;
    if (op in BR) { if (BR[op](r(a), r(b))) pc = lab[c]; } else if (op === "j") pc = lab[a];
    else if (op === "jr") pc = r(a) & ~1;           // jr t0 == jalr zero, 0(t0)
    else set(a, { add: () => r(b) + r(c), addi: () => r(b) + +c, slli: () => r(b) << +c,
      li: () => +b, lw: () => dv.getInt32(r(c) + +b, true) }[op]());
  }
  return [r("a0"), n];
}
const CASES = `case1: li a0, 10; j end; case2: li a0, 20; j end; case3: li a0, 30; j end
  case4: li a0, 40; j end; case5: li a0, 50; j end; default: li a0, -1; end:`;
const jt = asm(`addi t0, a0, -1; li t1, 5; bgeu t0, t1, default   # one unsigned test: x<1 or x>5
  slli t0, t0, 2; add t0, a1, t0; lw t0, 0(t0); jr t0\n` + CASES);
const chain = asm([1, 2, 3, 4, 5].map(k => `li t0, ${k}; beq a0, t0, case${k}`).join("; ") + "; j default\n" + CASES);
const mem = new Uint8Array(TABLE + 32), dv = new DataView(mem.buffer);
[1, 2, 3, 4, 5].forEach((k, i) => dv.setInt32(TABLE + 4 * i, jt.lab["case" + k], true));
console.log("table:", [0, 1, 2, 3, 4].map(i => "0x" + dv.getInt32(TABLE + 4 * i, true).toString(16)).join(" "));
console.log("  x | result | jump table | if-chain");
for (const v of [1, 3, 5, 0, 7, -2]) {
  const [r1, n1] = exec(jt, v, mem), [r2, n2] = exec(chain, v, mem);
  console.log(`${String(v).padStart(3)} | ${String(r1).padStart(6)} | ${String(n1).padStart(10)} | ${String(n2).padStart(8)}${r1 === r2 ? "" : "  DIFFERENT"}`);
}

table: 0x101c 0x1024 0x102c 0x1034 0x103c
  x | result | jump table | if-chain
  1 |     10 |          9 |        4
  3 |     30 |          9 |        8
  5 |     50 |          9 |       12
  0 |     -1 |          4 |       12
  7 |     -1 |          4 |       12
 -2 |     -1 |          4 |       12

Compiler কখন কোনটি বেছে নেয়

উপরের সংখ্যা দিয়ে একটি হিসাব: ধরুন x = 1…5 আর একটি সীমার বাইরের মান — ছয়টিই সমান সম্ভাবনার। If-chain-এর গড় = (4 + 6 + 8 + 10 + 12 + 12) / 6 = 52/6 ≈ ৮.৬৭; jump table-এর গড় = (9 × 5 + 4) / 6 = 49/6 ≈ ৮.১৭. প্রায় সমান! বাস্তবে টেবিলের ঠিকানা আনতে আরও দুটি instruction লাগে (lui + addi, এখানে a1-এ আগে থেকে রাখা ছিল), তখন বৈধ case-এ ১১, গড় ৫৯/৬ ≈ ৯.৮৩ — if-chain-ই সামান্য এগিয়ে। সাধারণভাবে N টি ঘন case-এ if-chain-এর গড় খরচ N-এর সাথে বাড়ে (মোটামুটি N + 3), jump table-এরটি স্থির। তাই:

• অল্প case: if-chain বা তুলনার একটি ছোট গাছ। gcc-র নিজস্ব সীমা target-ভেদে ভিন্ন — সাধারণত ৪–৫টির কম ভিন্ন case-এ jump table বানায় না (--param case-values-threshold দিয়ে বদলানো যায়)।
• অনেক, ঘন case (যেমন bytecode interpreter-এর opcode, state machine): jump table.
• অনেক, ছড়ানো case (যেমন 1, 100, 5000, 70000): টেবিল হবে বিশাল আর প্রায় ফাঁকা, তাই compiler বানায় binary search-এর মতো তুলনার গাছ — প্রায় 2·log₂N টি তুলনা। কয়েকটি case একই কাজ করলে (case 1, 3, 5, 7: …) bit mask দিয়ে একটি তুলনাও সম্ভব।

আরেকটি দাম আছে, যা instruction গুনে দেখা যায় না: jalr-এর গন্তব্য আগে থেকে অনুমান করা কঠিন, আর ভুল অনুমানে pipeline-এ অনেকগুলো cycle নষ্ট হয়। এর বিস্তারিত পর্ব ৩৭-এ (Control hazard আর branch prediction).

৮ · Flag, compare-and-branch আর শাখাহীন কোড — x86, ARM আর RISC-V

একই সিদ্ধান্ত তিনটি ISA তিনভাবে প্রকাশ করে। পর্ব ১৩-এ hardware-এর দিকটা দেখেছেন; এখানে একটি লুপ পাশাপাশি — n টি int-এর যোগফল, প্রতিটি “compiler-এর -O2-এর ধাঁচে” হাতে লেখা (আসল আউটপুট compiler-এর সংস্করণভেদে একটু ভিন্ন হতে পারে):

# উদাহরণ — x86-64 (Intel syntax): rdi = a, esi = n
        xor     eax, eax                 ; sum = 0
        test    esi, esi                 ; sets flags from n
        jle     .Ldone                   ; guard: n <= 0
        xor     ecx, ecx                 ; i = 0
.Lloop: add     eax, DWORD PTR [rdi+rcx*4]
        add     rcx, 1
        cmp     ecx, esi                 ; flags := i - n
        jl      .Lloop                   ; signed less: SF != OF
.Ldone: ret

# উদাহরণ — ARM64 (AArch64): x0 = a, w1 = n
        mov     w2, 0                    // sum
        cmp     w1, 0
        b.le    .Ldone                   // guard
        mov     x3, 0                    // i
.Lloop: ldr     w4, [x0, x3, lsl 2]      // a[i], index scaled inside the load
        add     w2, w2, w4
        add     x3, x3, 1
        cmp     w3, w1                   // flags NZCV := i - n
        b.lt    .Lloop                   // N != V
.Ldone: mov     w0, w2
        ret

x86 আর ARM-এ তুলনা আর শাখা দুটি আলাদা instruction, মাঝখানে যোগসূত্র status flags আর condition code (jl, b.lt). RISC-V-তে একটি blt দুটির কাজ করে। আবার x86 আর ARM-এর load-এ index × 4 ভেতরেই হয়, RISC-V-তে আলাদা slli + add লাগে — যে কারণে RISC-V compiler pointer-লুপ পছন্দ করে। ARM64-এরও কিছু compare-and-branch আছে: cbz/cbnz (শূন্যের সাথে) আর tbz/tbnz (একটি বিট).

শাখা না দিয়েই সিদ্ধান্ত — predication আর conditional move

শাখার একটি লুকোনো খরচ আছে। Pipeline-এ (পর্ব ৩৫) CPU শাখার ফল জানার আগেই পরের instruction আনতে শুরু করে, অনুমান করে কোন পথে যাবে। অনুমান ভুল হলে আনা কাজ ফেলে দিতে হয় — আধুনিক বড় core-এ এক-একটি ভুলে প্রায় ১০–২০ cycle. ডেটা এলোমেলো হলে (যেমন max লুপে কখন নতুন সর্বোচ্চ আসবে) অনুমান প্রায়ই ভুল হয়। তাই ছোট সিদ্ধান্তে শাখাই এড়ানো যায় — branchless code:

• Conditional move: x86-এর cmovcc, ARM64-এর csel — flag দেখে দুটি মানের একটি বেছে নেয়, PC বদলায় না।
• Predication: পুরো instruction-ই শর্তসাপেক্ষ — শর্ত মিথ্যা হলে instruction চলে কিন্তু কোনো ফল লেখে না। পুরোনো ৩২-বিট ARM-এ প্রায় প্রতিটি instruction-এ ৪ বিটের শর্ত-ঘর ছিল (addge, movlt); Intel-এর Itanium (IA-64) পুরো নকশাই predicate register-এর ওপর দাঁড় করিয়েছিল। AArch64 সাধারণ predication বাদ দিয়ে শুধু csel-এর মতো কয়েকটি রেখেছে।
• RISC-V: base RV32I-এ এমন কিছু নেই, তবে slt দিয়ে নিজে বানানো যায়। পরে যোগ হয়েছে ঐচ্ছিক extension: Zbb-এ সরাসরি max, min, maxu, minu, আর Zicond (২০২৩ সালের দিকে অনুমোদিত)-এ czero.eqz/czero.nez — শর্ত-register শূন্য বা অশূন্য হলে ফলকে শূন্য করে দেয়; দুটি czero আর একটি or মিলে একটি conditional select. কোন core-এ কোন extension আছে, তা নির্দিষ্ট chip-এর বিবরণ দেখে নিশ্চিত হতে হয়।

# উদাহরণ — int max(int a, int b); x86-64 অংশ Intel syntax-এ
# x86-64 (gcc -O2 ধাঁচে)       # ARM64                       # RV32I, শুধু base (শাখাহীন, mask দিয়ে)
cmp    edi, esi                cmp   w0, w1                  slt  t0, a0, a1    # t0 = (a < b) ? 1 : 0
mov    eax, esi                csel  w0, w0, w1, ge          sub  t0, x0, t0    # mask = 0 or 0xFFFFFFFF
cmovge eax, edi                ret                           xor  t1, a0, a1    # a ^ b
ret                                                          and  t1, t1, t0    # (a ^ b) & mask
                                                             xor  a0, a0, t1    # a, or a ^ a ^ b = b
# RV32I + Zicond:  slt t0,a0,a1; czero.nez t1,a0,t0; czero.eqz t2,a1,t0; or a0,t1,t2

Mask কৌশলের যুক্তি: slt দেয় ০ বা ১; ০ থেকে বিয়োগ করলে ০ বা −1, আর −1 মানে সব ৩২ বিট ১ — একটি পূর্ণ bitmask. a < b হলে mask সব-১, তাই a ⊕ (a ⊕ b) = b; নাহলে mask ০, ফল a. উদাহরণ a = −3, b = 5: t0 = 1 → −1; a ⊕ b = −8; ফল −3 ⊕ −8 = 5. পাঁচটি instruction, কোনো শাখা নেই, আর চলার সময় ডেটা যা-ই হোক একই পথ — এজন্যই cryptography-র কোডে এই ধরন প্রিয়। শাখার বদলে এমন কোড বসানোর compiler-কৌশলকে বলে if-conversion.

এই কৌশলগুলো সত্যিই সব মানে ঠিক কি না, সীমানাসহ, তা C-তে যাচাই করা যায়। নিচে max, min আর abs-এর শাখাহীন রূপ সাধারণ রূপের সাথে মেলানো হচ্ছে — সীমানার ৮টি মানের সব জোড়ায় আর দশ লাখ এলোমেলো জোড়ায়। Overflow-এর undefined behaviour এড়াতে abs-এর ফল unsigned (INT32_MIN-এর পরম মান int32-এ ধরে না):

#include <stdio.h>
#include <stdint.h>
#include <string.h>
/* Branchless versions: a comparison gives 0 or 1, negating it gives a mask 0 or all-ones. */
static int32_t max_bl(int32_t a, int32_t b) { int32_t m = -(int32_t)(a < b); return a ^ ((a ^ b) & m); }
static int32_t min_bl(int32_t a, int32_t b) { int32_t m = -(int32_t)(a < b); return b ^ ((a ^ b) & m); }
static uint32_t abs_bl(int32_t x) { uint32_t m = 0u - (uint32_t)(x < 0); return ((uint32_t)x ^ m) - m; }

static int32_t to_i32(uint32_t u) { int32_t v; memcpy(&v, &u, sizeof v); return v; }

/* Ordinary versions with if/?: (the compiler may still turn these into cmov/csel) */
static int32_t max_br(int32_t a, int32_t b) { return a > b ? a : b; }
static int32_t min_br(int32_t a, int32_t b) { return a < b ? a : b; }
static uint32_t abs_br(int32_t x) { return x < 0 ? 0u - (uint32_t)x : (uint32_t)x; }

int main(void) {
    const int32_t edge[] = { INT32_MIN, INT32_MIN + 1, -7, -1, 0, 1, 9, INT32_MAX };
    long checks = 0, bad = 0;
    for (int i = 0; i < 8; i++)
        for (int j = 0; j < 8; j++) {
            int32_t a = edge[i], b = edge[j]; checks += 3;
            bad += (max_bl(a, b) != max_br(a, b)) + (min_bl(a, b) != min_br(a, b)) + (abs_bl(a) != abs_br(a));
        }
    uint32_t s = 2026u;                                   /* deterministic LCG */
    for (int k = 0; k < 1000000; k++) {
        s = s * 1664525u + 1013904223u; int32_t a = to_i32(s);
        s = s * 1664525u + 1013904223u; int32_t b = to_i32(s); checks += 3;
        bad += (max_bl(a, b) != max_br(a, b)) + (min_bl(a, b) != min_br(a, b)) + (abs_bl(a) != abs_br(a));
    }
    printf("max(-7, 9) = %d, min(-7, 9) = %d, abs(-7) = %u, abs(INT32_MIN) = %u\n",
           max_bl(-7, 9), min_bl(-7, 9), abs_bl(-7), abs_bl(INT32_MIN));
    printf("checks: %ld, mismatches: %ld\n", checks, bad);
    return 0;
}

max(-7, 9) = 9, min(-7, 9) = -7, abs(-7) = 7, abs(INT32_MIN) = 2147483648
checks: 3000192, mismatches: 0

শাখাহীন কোড সবসময় দ্রুত নয়। এটি দুই পথের কাজই করে, আর ফল দুই পথের ইনপুটের ওপর নির্ভর করে। শাখা যদি প্রায় সবসময় একদিকে যায় (যেমন “error হলে” পরীক্ষা), predictor প্রায় নিখুঁত অনুমান করে আর শাখা প্রায় বিনা খরচে চলে — তখন শাখাই ভালো। শাখাহীন কোড জেতে যখন সিদ্ধান্ত এলোমেলো আর দুই পথ ছোট। কেন, তা পর্ব ৩৭-এ পরিমাপসহ দেখবেন।

৯ · AI-এর যুগে শাখা আর লুপের assembly

AI টুল C থেকে RISC-V assembly বেশ গুছিয়ে লেখে, কিন্তু ঠিক এই পর্বের খুঁটিনাটিতেই ভুল করে — আর assembly-র ভুল চোখে দেখে ধরা কঠিন, কারণ কোড দেখতে “ঠিকঠাক” লাগে। প্রচলিত ভুলগুলো:

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

• প্রতিটি শাখার শর্ত C-র শর্তের ঠিক উল্টো (বা ঠিক একই, যদি লাফ body-তে যায়) — একটি একটি করে মিলিয়েছি
• signed/unsigned: C-র type দেখে blt/bltu ঠিক বসেছে
• n = 0, n = 1 আর একটি বড় n-এ কোডটি simulator-এ (বা RARS, Spike, QEMU-তে) চালিয়েছি
• অন্তত একটি branch target হাতে হিসাব করেছি, আর offset ±৪ KiB-এর ভেতরে কি না দেখেছি
• Dynamic count-এর সূত্র simulation-এর গোনার সাথে মিলেছে
• Compiler কী বানায় তা Compiler Explorer-এ বা riscv64-unknown-elf-gcc -O2 -S দিয়ে তুলনা করেছি