ISA কী — hardware আর software-এর চুক্তি, RISC বনাম CISC

১ · ISA — একটি চুক্তি, আর চুক্তিতে কী কী লেখা থাকে

পর্ব ০১-এ (চারটি শব্দ) দেখেছেন, ISA (instruction set architecture) হলো hardware আর software-এর মাঝখানের চুক্তি: compiler আর programmer যা দেখেন, chip যা মেনে চলার প্রতিশ্রুতি দেয়। আর microarchitecture হলো সেই চুক্তি ভেতরে কীভাবে পালন করা হয়। একই পর্বের fetch–decode–execute অংশে দেখেছেন CPU কীভাবে একটির পর একটি instruction আনে আর চালায়। এই মডিউলে আমরা চুক্তিটির ভেতরে ঢুকব — প্রথমে সাধারণ ছবি (এই পর্ব), তারপর পর্ব ২৬ থেকে ৩১-এ RISC-V-এর instruction, encoding, addressing, শাখা, function call আর C থেকে assembly.

চুক্তিটি কতটা খুঁটিনাটি, তা বোঝাতে নিচের টেবিলে একটি ISA manual-এ সাধারণত যা যা নির্দিষ্ট থাকে, আর RISC-V ও x86-64-এ তার উদাহরণ:

টেবিলের প্রতিটি সারি এমন জিনিস, যা ভুল হলে প্রোগ্রামের ফল বদলে যায়। ধরুন একটি chip add-এর পর flag লেখে না, অথচ প্রোগ্রাম ধরে নিয়েছে লিখবে — তাহলে পরের শাখা ভুল দিকে যাবে। মেমরির byte-ক্রম ভুল ধরলে একই চারটি byte ভিন্ন সংখ্যা হয়ে যায় (পর্ব ০৬-এর endianness). তাই এগুলো চুক্তির অংশ।

চুক্তির বাইরে যা থাকে

উল্টো দিকে, নিচের জিনিসগুলো ISA manual-এ পাবেন না, কারণ এগুলো শুধু গতি বদলায়, ফল নয়:

• Pipeline কয় ধাপের (পর্ব ৩৫) — ৫ ধাপ, ১৪ ধাপ বা ২০ ধাপ; প্রোগ্রাম একই ফল দেয়।
• Cache কত বড়, কয় স্তরের (পর্ব ৪৪–৪৭) — ৩২ KiB না ৪৮ KiB L1, তা compiler-কে জানতে হয় না।
• একসাথে কয়টি instruction চলে, branch predictor কেমন, register renaming হয় কি না (পর্ব ৩৭, ৩৯, ৪০)।
• প্রতিটি instruction কত cycle নেয় — অর্থাৎ CPI. একটি ISA-তে গুণ এক chip-এ ৩ cycle, অন্যটিতে ৩০ cycle হতে পারে।
• Clock কত GHz আর chip কোন কারখানায় কোন প্রযুক্তিতে বানানো।

একটি সূক্ষ্ম ব্যতিক্রম মনে রাখার মতো: সময় নিজেও তথ্য বহন করতে পারে। Cache-এর আকার ফল বদলায় না, কিন্তু কোন ডেটা cache-এ আছে তা সময় মেপে আন্দাজ করা যায় — Spectre-এর মতো নিরাপত্তা-সমস্যা এই ফাঁক থেকেই আসে (পর্ব ৪১)। চুক্তি বলে “ফল কী হবে”, “কত সময় লাগবে” সাধারণত বলে না — আর এই নীরবতার দাম মাঝে মাঝে দিতে হয়।

২ · কেন একটি ISA দশকের পর দশক বেঁচে থাকে — binary compatibility

আপনার ল্যাপটপে যে Windows বা Linux প্রোগ্রাম চলে, সেটি একটি machine code ফাইল — x86-64 instruction-এর বিটের সারি। এই ফাইল একবার compile করে লাখো কম্পিউটারে পাঠানো হয়, যার ভেতরে Intel বা AMD-এর ভিন্ন ভিন্ন প্রজন্মের core. সবগুলোতে একই ফাইল চলে, কারণ সবাই একই চুক্তি মানে। এই গুণের নাম backward compatibility (binary compatibility): নতুন chip-এ পুরোনো বাইনারি বদল ছাড়াই চলে।

এর সবচেয়ে বড় উদাহরণ x86. Intel ১৯৭৮ সালে ১৬-বিট 8086 বাজারে আনে। তারপর ৩২-বিট (80386, ১৯৮৫), তারপর AMD-এর নকশায় ৬৪-বিট x86-64 (প্রথম chip ২০০৩ সালে) — প্রতিবার পুরোনো মোড রেখে নতুন মোড যোগ হয়েছে। ফলে আজকের একটি x86-64 chip, অন্তত নীতিগতভাবে, চল্লিশ বছরের পুরোনো ১৬-বিট instruction-ও চালাতে পারে (৬৪-বিট OS-এর নিচে সরাসরি না হলেও)। তারও আগে IBM ১৯৬৪ সালে System/360 পরিবারে প্রথম দেখিয়েছিল যে এক ISA, বহু মডেল — এই কৌশলে software-এর বিনিয়োগ বাঁচে (পর্ব ০২-এর অংশ ৩); সেই বংশের ISA আজও IBM-এর mainframe-এ (IBM Z) চলে।

এর দুটি পরিণতি এই পর্বের বাকি অংশ বুঝতে জরুরি:

• ISA-র ভুল বা পুরোনো সিদ্ধান্ত সহজে মোছা যায় না। x86-এ আজও আছে ১৯৭০-এর দশকের অনেক instruction আর অদ্ভুত নিয়ম; বাদ দিলে পুরোনো প্রোগ্রাম ভাঙবে। তাই নতুন ISA নকশাকারেরা শুরুতেই খুব সাবধানে ভাবেন — যা যোগ করবেন, তা হয়তো চিরকাল রাখতে হবে।
• উদ্ভাবন বেশিরভাগ হয় microarchitecture-এ। চুক্তি স্থির রেখে ভেতরটা বারবার নতুন করে বানানো যায় — pipeline, out-of-order, বড় cache. এজন্যই ১৯৭৮ সালের ISA-র chip আজ হাজার হাজার গুণ দ্রুত।

উল্টো উদাহরণও আছে। Intel আর HP মিলে ২০০১ সালে Itanium (IA-64) নামে সম্পূর্ণ নতুন ৬৪-বিট ISA আনে, যা x86 চালাত ধীরে। বাজার সেটি খুব একটা গ্রহণ করেনি, আর AMD-এর x86-সামঞ্জস্যপূর্ণ ৬৪-বিট নকশা জিতে যায় — শেষে Intel-ও সেটি গ্রহণ করে। আবার Apple তিনবার ISA বদলেছে (68000 → PowerPC → x86 → ARM), প্রতিবার পুরোনো প্রোগ্রাম চালানোর জন্য অনুবাদক software (যেমন Rosetta) দিয়ে। অর্থাৎ ISA বদলানো সম্ভব, কিন্তু তার জন্য একটি বড় সেতু লাগে।

৩ · Operand কোথায় থাকে — stack, accumulator, register–memory আর load–store

একটি যোগের instruction-কে দুটি operand (যে মানগুলো নিয়ে কাজ হবে) পেতে হয় আর ফল কোথাও রাখতে হয়। ISA-গুলোর সবচেয়ে মৌলিক শ্রেণিবিভাগ হলো: operand-গুলো CPU-র ভেতরে কোথায় থাকে, আর মেমরির operand কোন instruction সরাসরি ছুঁতে পারে। চারটি প্রধান ধরন:

আরও একটি ধরন ইতিহাসে আছে: memory–memory architecture, যেখানে তিনটি operand-ই মেমরিতে থাকতে পারে — যেমন DEC-এর VAX-এ ADDL3 A, B, C (VAX-এ গন্তব্য শেষে) এক instruction-এ C = A + B. এখন এটি প্রায় বিলুপ্ত, তবে পরের অংশের “3-address” আলোচনায় এর ধারণা কাজে লাগবে।

ক্লাসিক তুলনা: C = A + B চার স্টাইলে

পরীক্ষায় সবচেয়ে বেশি আসে এই প্রশ্নটি: A, B, C তিনটি মেমরির চলক; C = A + B লিখুন প্রতিটি ধরনে। Hennessy–Patterson-এর বইয়ে যে রূপে দেখানো হয়, প্রায় সেই রূপে (register-এর নাম আমাদের; register–memory-র জন্য x86-ধাঁচের ২-operand রূপ):

# উদাহরণ — C = A + B (A, B, C মেমরিতে)
# Stack          # Accumulator     # Register-memory (x86-ধাঁচ)   # Load-store (RISC-V-ধাঁচ)
push A           load  A           mov  r1, A                     lw   r1, A
push B           add   B           add  r1, B     # B মেমরিতে     lw   r2, B
add              store C           mov  C, r1                     add  r3, r1, r2
pop  C                                                            sw   r3, C

(Load–store স্টাইলে আসল lw instruction সরাসরি নাম দিয়ে মেমরি পড়ে না — A-এর ঠিকানা আগে একটি register-এ আনতে হয়, তারপর lw t0, 0(a0); assembler-এ lw t0, A লিখলে সেটি একটি pseudo-instruction, যা ভেতরে এমন দুটি instruction হয়ে যায়। এখানে তুলনা সহজ রাখতে নামটিই লেখা হলো; আসল রূপ পর্ব ২৬ আর ২৮-এ।) এবার চারটিকে পাশাপাশি এক এক ধাপ চালিয়ে দেখুন — A = 7, B = 5:

নিচের simulator চারটি ছোট যন্ত্র বানায় — প্রতিটির নিজস্ব instruction টেবিল — একই মেমরিতে প্রোগ্রাম চালায়, আর গোনে কতবার মেমরি পড়া আর লেখা হলো। দ্বিতীয় অংশে C = A + B-এর পর D = C + A — যেখানে A আর C আবার লাগে। Run চাপুন:

// One tiny memory, four ISA styles: who touches memory, and how often?
function machine(name, prog) {
  const M = { A: 7, B: 5, C: 0, D: 0 }, R = {}, S = [];
  let acc = 0, rd = 0, wr = 0;
  const ld = a => { rd++; return M[a]; }, st = (a, v) => { wr++; M[a] = v; };
  const ops = {
    stack: { push: a => S.push(ld(a)), pop: a => st(a, S.pop()),
             add: () => S.push(S.pop() + S.pop()) },               // operands: top of stack
    accumulator: { load: a => { acc = ld(a); }, add: a => { acc += ld(a); },
                   store: a => st(a, acc) },                       // one implicit register
    "reg-memory": { mov: (d, s) => (d in M ? st(d, R[s]) : (R[d] = ld(s))),
                    add: (d, s) => { R[d] += (s in M ? ld(s) : R[s]); } },  // src may be memory
    "load-store": { lw: (r, a) => { R[r] = ld(a); }, sw: (r, a) => st(a, R[r]),
                    add: (d, x, y) => { R[d] = R[x] + R[y]; } },   // registers only
  }[name];
  for (const line of prog) { const [op, ...args] = line.split(/[ ,]+/); ops[op](...args); }
  return `${name.padEnd(12)} ${String(prog.length).padStart(5)} ${String(rd).padStart(6)}` +
         `${String(wr).padStart(7)}   C=${M.C} D=${M.D}`;
}
const progs = {   // C = A + B
  stack: ["push A", "push B", "add", "pop C"],
  accumulator: ["load A", "add B", "store C"],
  "reg-memory": ["mov r1, A", "add r1, B", "mov C, r1"],
  "load-store": ["lw r1, A", "lw r2, B", "add r3, r1, r2", "sw r3, C"],
};
const more = {    // then D = C + A, reusing whatever is already inside the CPU
  stack: ["push C", "push A", "add", "pop D"], accumulator: ["add A", "store D"],
  "reg-memory": ["add r1, A", "mov D, r1"], "load-store": ["add r4, r3, r1", "sw r4, D"],
};
console.log("C = A + B   (A = 7, B = 5)\nstyle        instr  reads writes   result");
for (const n in progs) console.log(machine(n, progs[n]));
console.log("\nC = A + B; D = C + A\nstyle        instr  reads writes   result");
for (const n in progs) console.log(machine(n, progs[n].concat(more[n])));

C = A + B   (A = 7, B = 5)
style        instr  reads writes   result
stack            4      2      1   C=12 D=0
accumulator      3      2      1   C=12 D=0
reg-memory       3      2      1   C=12 D=0
load-store       4      2      1   C=12 D=0

C = A + B; D = C + A
style        instr  reads writes   result
stack            8      4      2   C=12 D=19
accumulator      5      3      2   C=12 D=19
reg-memory       5      3      2   C=12 D=19
load-store       6      2      2   C=12 D=19

তুলনাটি এক টেবিলে:

৪ · কয়টি address — 0, 1, 2 আর 3-address instruction

আগের অংশের শ্রেণিবিভাগের আরেকটি চেহারা হলো: একটি হিসাবের instruction-এ কয়টি operand-এর ঠিকানা স্পষ্টভাবে লেখা থাকে। Hamacher, Stallings প্রভৃতি পাঠ্যবইয়ে আর চাকরির লিখিত পরীক্ষায় এই প্রশ্ন খুব প্রচলিত। চারটি রূপ (দেখানোর জন্য X = A op B):

Worked example: X = (A + B) × (C − D)

নিয়ম (পাঠ্যবইয়ের প্রচলিত ধারা): সব নামযুক্ত operand মেমরিতে; মধ্যবর্তী ফলের জন্য অস্থায়ী মেমরি-ঘর T1, T2 ব্যবহার করা যাবে; গন্তব্যটিকেও অস্থায়ী হিসেবে ব্যবহার করা যায়।

# উদাহরণ — X = (A + B) × (C − D)

# 3-address (৩টি)          # 2-address (৫টি)          # 1-address (৭টি)        # 0-address (৮টি)
ADD T1, A, B               MOV X, A                   LOAD  C                  PUSH A
SUB T2, C, D               ADD X, B     # X = A+B     SUB   D                  PUSH B
MUL X, T1, T2              MOV T1, C                  STORE T1   # T1 = C-D    ADD
                           SUB T1, D    # T1 = C-D    LOAD  A                  PUSH C
                           MUL X, T1                  ADD   B                  PUSH D
                                                      MUL   T1                 SUB
                                                      STORE X                  MUL
                                                                               POP  X

লক্ষ করুন 1-address কোড ডান দিক (C − D) আগে হিসাব করে T1-এ রাখে। কারণ accumulator একটিই; বাঁ দিক আগে করলে A + B-কে রাখতে হতো, তারপর C − D, তারপর আবার T1 আনতে — একটি বাড়তি instruction. গুণ বিনিময়যোগ্য, তাই (C − D) × (A + B) একই ফল দেয়। 0-address কোডটি আসলে expression-টির postfix রূপ: A B + C D − ×. Stack-এ কী ঘটে, ধাপে ধাপে দেখুন (A = 7, B = 5, C = 9, D = 4):

1PUSH A2PUSH B3ADD4PUSH C5PUSH D6SUB7MUL8POP X

এবার চার ধরনের কোড হাতে না লিখে একটি ছোট program দিয়ে বানানো যাক। নিচের code generator একটি expression tree থেকে চার ধরনের কোড তৈরি করে, প্রতিটি একটি ছোট interpreter-এ চালায় (সব নামযুক্ত operand আর T1, T2 মেমরিতে), গোনে কতবার মেমরি পড়া ও লেখা হলো, আর ফলটি সরাসরি হিসাবের সাথে মেলায়। দ্বিতীয় expression: W = A × (B + C) − D.

// Generate 3-, 2-, 1- and 0-address code from an expression tree, run it, count memory traffic
const NAME = { "+": "ADD", "-": "SUB", "*": "MUL", "/": "DIV" }, COMM = { "+": 1, "*": 1 };
const F = { ADD: (a, b) => a + b, SUB: (a, b) => a - b, MUL: (a, b) => a * b, DIV: (a, b) => a / b };
const leaf = n => typeof n === "string", swap = ([op, l, r]) => leaf(l) && !leaf(r) && COMM[op] ? [op, r, l] : [op, l, r];
function compile(e, dst) {
  const c = { 3: [], 2: [], 1: [], 0: [] }; let t = 0; const tmp = () => "T" + ++t;
  const g3 = (n, d) => { if (leaf(n)) return n;                        // d = a op b
    const a = g3(n[1]), b = g3(n[2]), r = d || tmp(); c[3].push([NAME[n[0]], r, a, b]); return r; };
  const g2 = (n, d) => { const [op, l, r] = swap(n);                   // d = d op s
    if (leaf(l)) c[2].push(["MOV", d, l]); else g2(l, d);
    if (leaf(r)) c[2].push([NAME[op], d, r]); else { const s = tmp(); g2(r, s); c[2].push([NAME[op], d, s]); } };
  const g1 = n => { if (leaf(n)) return c[1].push(["LOAD", n]); const [op, l, r] = swap(n);   // ACC = ACC op m
    if (leaf(r)) { g1(l); c[1].push([NAME[op], r]); return; }
    g1(r); const s = tmp(); c[1].push(["STORE", s]); g1(l); c[1].push([NAME[op], s]); };
  const g0 = n => leaf(n) ? c[0].push(["PUSH", n]) : (g0(n[1]), g0(n[2]), c[0].push([NAME[n[0]]]));  // postfix
  g3(e, dst); t = 0; g2(e, dst); t = 0; g1(e); c[1].push(["STORE", dst]); g0(e); c[0].push(["POP", dst]);
  return c; }
function run(k, code, mem) {             // every named operand (incl. temps T1, T2) lives in memory
  const M = { ...mem }, S = []; let acc = 0, rd = 0, wr = 0;
  const R = a => (rd++, M[a]), W = (a, v) => (wr++, M[a] = v);
  for (const [o, x, y, z] of code) {
    if (k === 3) W(x, F[o](R(y), R(z)));
    else if (k === 2) W(x, o === "MOV" ? R(y) : F[o](R(x), R(y)));
    else if (k === 1) o === "LOAD" ? (acc = R(x)) : o === "STORE" ? W(x, acc) : (acc = F[o](acc, R(x)));
    else o === "PUSH" ? S.push(R(x)) : o === "POP" ? W(x, S.pop()) : S.push(F[o](...S.splice(-2)));
  }
  return { rd, wr, v: M }; }
const ev = (n, m) => leaf(n) ? m[n] : F[NAME[n[0]]](ev(n[1], m), ev(n[2], m));
for (const [dst, e, mem] of [["X", ["*", ["+", "A", "B"], ["-", "C", "D"]], { A: 7, B: 5, C: 9, D: 4 }],
                             ["W", ["-", ["*", "A", ["+", "B", "C"]], "D"], { A: 6, B: 2, C: 3, D: 10 }]]) {
  const c = compile(e, dst), want = ev(e, mem);
  for (const k of [3, 2, 1, 0]) {
    const r = run(k, c[k], mem), ok = r.v[dst] === want ? "ok" : "WRONG", txt = c[k].map(i => i[0] + (i.length > 1 ? " " + i.slice(1).join(",") : ""));
    console.log(`${k}-address: ${c[k].length} instr, ${r.rd} reads, ${r.wr} writes, ${dst}=${r.v[dst]} ${ok}\n   ` + txt.join("; "));
  } }

3-address: 3 instr, 6 reads, 3 writes, X=60 ok
   ADD T1,A,B; SUB T2,C,D; MUL X,T1,T2
2-address: 5 instr, 8 reads, 5 writes, X=60 ok
   MOV X,A; ADD X,B; MOV T1,C; SUB T1,D; MUL X,T1
1-address: 7 instr, 5 reads, 2 writes, X=60 ok
   LOAD C; SUB D; STORE T1; LOAD A; ADD B; MUL T1; STORE X
0-address: 8 instr, 4 reads, 1 writes, X=60 ok
   PUSH A; PUSH B; ADD; PUSH C; PUSH D; SUB; MUL; POP X
3-address: 3 instr, 6 reads, 3 writes, W=20 ok
   ADD T1,B,C; MUL T2,A,T1; SUB W,T2,D
2-address: 4 instr, 7 reads, 4 writes, W=20 ok
   MOV W,B; ADD W,C; MUL W,A; SUB W,D
1-address: 5 instr, 4 reads, 1 writes, W=20 ok
   LOAD B; ADD C; MUL A; SUB D; STORE W
0-address: 8 instr, 4 reads, 1 writes, W=20 ok
   PUSH A; PUSH B; PUSH C; ADD; MUL; PUSH D; SUB; POP W

Instruction-এর সংখ্যা কম মানেই ভালো নয়

একটি 3-address মেমরি instruction-এ তিনটি পূর্ণ মেমরি-ঠিকানা লিখতে হয়। ৩২-বিট ঠিকানা হলে শুধু ঠিকানাতেই ৯৬ বিট, সাথে opcode — প্রায় ১৩ byte-এর instruction. 0-address-এর ADD হয়তো ১ byte. তাই পরীক্ষায় প্রায়ই সাথে প্রশ্ন থাকে “মোট কোডের মাপ কত byte”. আধুনিক RISC এই দ্বন্দ্বের মাঝামাঝি সমাধান নিয়েছে: 3-address, কিন্তু register-এ। ৩২টি register-এর নাম দিতে লাগে মাত্র ৫ বিট, তাই তিনটি operand-ই ১৫ বিটে ধরে, আর পুরো instruction ৩২ বিটে। RISC-V-এ X-এর কোড:

# উদাহরণ — RISC-V (load-store, register-এ 3-address), A..D-এর ঠিকানা a0-ভিত্তিক ধরে
lw   t0, 0(a0)      # A
lw   t1, 4(a0)      # B
lw   t2, 8(a0)      # C
lw   t3, 12(a0)     # D
add  t0, t0, t1     # A + B
sub  t2, t2, t3     # C - D
mul  t0, t0, t2     # (A+B)(C-D)   (M extension)
sw   t0, 16(a0)     # X
# ৮টি instruction × ৪ byte = ৩২ byte; ৪টি পড়া, ১টি লেখা

Instruction-এর সংখ্যা 0-address-এর সমান, মেমরি-ট্রাফিকও সমান (৪ + ১), কিন্তু সব মধ্যবর্তী ফল register-এ — আর প্রতিটি instruction একই মাপের, একই ধাঁচের। মধ্যবর্তী অস্থায়ী মানের জন্য register ব্যবহার করলে আগের কোডগুলোও বদলায়: যেমন 3-address-এ ADD R1, A, B; SUB R2, C, D; MUL X, R1, R2 — ৩টি instruction, কিন্তু মাত্র ৪টি পড়া আর ১টি লেখা। পরীক্ষায় তাই প্রশ্নে স্পষ্ট থাকা উচিত যে অস্থায়ী মান মেমরিতে না register-এ; না থাকলে উত্তরে নিজের ধরে নেওয়া নিয়মটি লিখে দিন।

৫ · Instruction-এর প্রকারভেদ — পাঁচটি দল

যেকোনো ISA-র instruction তালিকা খুললে দেখবেন, শত শত instruction আসলে কয়েকটি দলে পড়ে। দলগুলো জানলে নতুন ISA শেখা অনেক সহজ — শুধু জানতে হয় প্রতিটি দলে এই ISA কী নাম দিয়েছে।

বাস্তব প্রোগ্রামে কোন দল কত ঘন ঘন চলে? মাপজোখে বারবার দেখা গেছে, সাধারণ integer প্রোগ্রামে load/store আর যোগ-তুলনা-শাখা মিলে বেশিরভাগ — আর জটিল instruction খুব কম। (সঠিক শতাংশ benchmark, compiler আর ISA-ভেদে অনেক বদলায়, তাই কোনো একটি সংখ্যা মুখস্থ না করাই ভালো।) এই পর্যবেক্ষণই RISC আন্দোলনের সূচনা করেছিল — পরের অংশে।

Data transfer দলের ভেতরে আরেকটি প্রশ্ন আছে: মেমরির ঠিকানা কীভাবে বলা হবে — ধ্রুবক হিসেবে instruction-এর ভেতরেই (immediate), register-এ, register + offset, নাকি PC থেকে দূরত্ব হিসেবে। এই নিয়মগুলোকে বলে addressing mode; RISC-V-এর চারটি সরল mode আর x86-এর জটিলগুলোর তুলনা পর্ব ২৮-এ। শাখা আর লুপের assembly পর্ব ২৯-এ, function call পর্ব ৩০-এ।

৬ · RISC বনাম CISC — দুই দর্শন, এক বিতর্ক, আর আজকের মিলন

পর্ব ০২-এর অংশ ৫-এ RISC আন্দোলনের ইতিহাস দেখেছেন — IBM 801, Berkeley RISC, Stanford MIPS. এখানে প্রশ্নটা নকশার: দুই শিবির আসলে কোন কোন সিদ্ধান্তে আলাদা, আর কেন।

CISC-কে “ভুল নকশা” ভাবা ঠিক নয়। ১৯৬০–৭০-এর দশকে মেমরি ছিল খুব দামি আর ধীর, compiler ছিল দুর্বল, আর অনেক প্রোগ্রাম লেখা হতো সরাসরি assembly-তে। তখন একটি instruction-এ বেশি কাজ মানে ছোট প্রোগ্রাম, কম মেমরি-ট্রাফিক, আর programmer-এর সুবিধা। Microcode দিয়ে জটিল instruction বানানোও সস্তা ছিল — control unit-এর ভেতরে একটি ছোট ROM-এর program. সমস্যা দেখা দিল যখন পরিস্থিতি বদলাল: compiler ভালো হলো, cache এলো, আর একটি chip-এ পুরো CPU বসানোর যুগে প্রতিটি transistor মূল্যবান হয়ে উঠল।

১৯৮০-র বিতর্ক

১৯৮০ সালে David Patterson আর David Ditzel একটি ছোট প্রবন্ধ প্রকাশ করেন — “The Case for the Reduced Instruction Set Computer” (ACM-এর Computer Architecture News-এ)। তাঁদের যুক্তির সারকথা, যতটা সাধারণভাবে উদ্ধৃত হয়: ISA ক্রমাগত জটিল হচ্ছে, অথচ compiler সেই জটিল instruction-গুলো কমই ব্যবহার করে; জটিলতা নকশার সময় বাড়ায়, ভুলের ঝুঁকি বাড়ায়, আর সাধারণ instruction-গুলোকেও ধীর করে; একটি chip-এ সরল ISA বানালে বাঁচানো জায়গা cache বা register-এ খরচ করা যায়। প্রায় একই সময়ে DEC-এর VAX নকশাকারদের পক্ষ থেকে (Douglas Clark ও William Strecker) পাল্টা মন্তব্য প্রকাশিত হয় — জটিল instruction-এর পক্ষে, আর মাপজোখ ছাড়া সিদ্ধান্ত নেওয়ার বিপক্ষে। এর পরের এক দশক মাপজোখ, prototype chip আর বাণিজ্যিক RISC processor (ARM, MIPS, SPARC, পরে PowerPC) দিয়ে বিতর্ক এগোয়।

বিতর্কটি iron law দিয়ে পরিষ্কার বোঝা যায় (পর্ব ০৩-এর অংশ ৩): CPU time = IC × CPI × T. CISC কমাতে চায় IC, RISC কমাতে চায় CPI আর T — বেশি instruction-এর দাম দিয়ে। কোনটি জিতবে, তা নির্ভর করে তিনটির গুণফলের ওপর, শুধু একটির ওপর নয়। অংশ ৯-এ একটি সংখ্যার উদাহরণ।

একটি CISC instruction বনাম তার RISC সমতুল্য

মেমরির একটি সংখ্যার সাথে register-এর মান যোগ করে আবার মেমরিতেই রাখা — C-তে *p += k;. x86-এ এটি একটি instruction, RISC-V-এ তিনটি। নিচে ধাপে ধাপে (মেমরির ঠিকানা 0x1000-এ আছে 40, k = 2):

rbx = 0x1000   eax = 2   mem[0x1000] = 40
encoding: 01 03   (2 bytes: opcode 01, ModRM 03)
one instruction: read memory, add, write memory
mem[0x1000] = 42

uop 1: load   tmp  <- [rbx]        ; 40
uop 2: add    tmp  <- tmp + eax    ; 42
uop 3: store  [rbx] <- tmp         ; (often split: address + data)
exact count and fusion vary by core

a0 = 0x1000   a1 = 2
lw  a2, 0(a0)     a2 = 40     (memory read)

add a2, a2, a1    a2 = 40 + 2 = 42   (registers only)

sw  a2, 0(a0)     mem[0x1000] = 42   (memory write)
x86   : 1 instruction,  2 bytes
RV32I : 3 instructions, 12 bytes
RV32IC: 3 instructions,  6 bytes  (c.lw, c.add, c.sw)
both  : 1 memory read + 1 memory write

আজকের মিলন — দুই দিক থেকেই

১৯৯৫ সালে Intel-এর Pentium Pro (P6) থেকে প্রধান x86 core-গুলো ঠিক stepper-এর ধাপ ২-এর মতো কাজ করে: সামনে একটি জটিল decoder x86 instruction-কে RISC-ধাঁচের micro-op-এ ভাঙে, আর পেছনের out-of-order “কারখানা” (পর্ব ৪০) সেই micro-op চালায়। জটিল বা বিরল instruction এখনও microcode ROM থেকে আসে। অর্থাৎ RISC-এর মূল কৌশল — সরল, সমান মাপের ছোট কাজ pipeline-এ চালানো — x86-ও গ্রহণ করেছে, শুধু চুক্তি না বদলে।

উল্টো দিকে RISC শিবিরও “শুদ্ধ” থাকেনি। ARM-এর ৬৪-বিট ISA AArch64-এ আছে একসাথে দুটি register load/store করা (ldp/stp), জটিল addressing mode, মেমরিতে সরাসরি atomic যোগ (ldadd, ARMv8.1 থেকে), AES আর SHA-র cryptography instruction, এমনকি JavaScript-এর সংখ্যা রূপান্তরের জন্য বিশেষ একটি instruction (fjcvtzs, ARMv8.3). RISC-V-তেও extension-এর মাধ্যমে বিট-কৌশল (B), cryptography আর vector instruction যোগ হয়েছে। আজ “RISC” মানে কম instruction নয় — মানে মূলত load–store, স্থির দৈর্ঘ্য আর সরল encoding.

৭ · আজকের প্রধান ISA — কোথায় কোনটি চলে

বাজারের ভাগ বছরে বছরে বদলায়, তাই এখানে কোনো শতাংশ দেওয়া হলো না। একটি কথা অবশ্য নিশ্চিত: আপনার একটি ফোনের ভেতরেই কয়েকটি ISA একসাথে থাকতে পারে — প্রধান CPU-তে ARM, আর modem, ক্যামেরা বা power-নিয়ন্ত্রক অংশে ছোট ছোট অন্য core (কখনো RISC-V). ব্যবহারকারী শুধু প্রধান ISA-টি দেখেন।

৮ · RISC-V — এই কোর্সের শিক্ষার ISA

এই কোর্সের মূল ISA RISC-V, Patterson–Hennessy-র RISC-V সংস্করণের ধারায়। কারণ তিনটি: এটি সরল আর নিয়মিত, তাই datapath আর pipeline (মডিউল ৬) হাতে আঁকা যায়; এটি উন্মুক্ত, তাই spec, simulator আর এমনকি পূর্ণ CPU নকশা বিনামূল্যে পাওয়া যায়; আর এটি বাস্তবে ব্যবহৃত, শুধু খেলনা নয়। ISA-টির মান নির্ধারণ করে RISC-V International নামের একটি অলাভজনক সংস্থা (আগে RISC-V Foundation; ২০২০ সালের দিকে সুইজারল্যান্ডে নিবন্ধিত হয়ে নতুন নাম)।

Base আর extension — মডিউলার নকশা

RISC-V একটি ISA নয়, একটি পরিবার। ছোট একটি base ISA, তার ওপর প্রয়োজনমতো extension:

এত ঐচ্ছিক অংশ থাকলে software কীভাবে জানবে কোন chip-এ কী আছে? এজন্য RISC-V International profile প্রকাশ করে — যেমন RVA22, RVA23 — যা বলে “application processor হতে হলে অন্তত এই extension-গুলো থাকতেই হবে”। এটি এখনো বিবর্তনশীল একটি এলাকা; নির্দিষ্ট profile-এর তালিকা মূল নথিতে দেখে নেওয়াই নিরাপদ।

যা programmer দেখেন

• ৩২টি integer register, x0 থেকে x31, প্রতিটি XLEN বিটের (RV32-এ ৩২, RV64-এ ৬৪)। এদের register file-এ একসাথে রাখা হয়।
• x0 সবসময় ০ — একে বলে zero register. x0-তে লিখলে লেখাটি ফেলে দেওয়া হয়, পড়লে সবসময় ০ আসে। এতে অনেক কাজ আলাদা instruction ছাড়াই হয়: mv a0, a1 আসলে addi a0, a1, 0; nop আসলে addi x0, x0, 0. এমন সুবিধার নামগুলোকে বলে pseudo-instruction (পর্ব ২৬)।
• PC আলাদা — x0–x31-এর অংশ নয়; সাধারণ instruction দিয়ে সরাসরি লেখা যায় না, শুধু শাখা আর লাফ দিয়ে বদলায়।
• মেমরি byte-addressed, little-endian: প্রতিটি byte-এর নিজস্ব ঠিকানা; একটি ৩২-বিট word-এর সবচেয়ে কম গুরুত্বের byte সবচেয়ে ছোট ঠিকানায় (পর্ব ০৬)। (Spec পরে ঐচ্ছিক big-endian মোডের জায়গা রেখেছে, তবে বাস্তবে প্রায় সব RISC-V সিস্টেম little-endian.)
• Instruction ৩২ বিটের, C extension থাকলে ১৬ বিটেরও। কোনো flag register নেই (পর্ব ২০-এর অংশ ২); তুলনা আর শাখা এক instruction-এ।
• Register-গুলোর calling-convention নাম আছে — a0–a7 argument, t0–t6 অস্থায়ী, s0–s11 সংরক্ষিত, sp, ra — বিস্তারিত পর্ব ২৬ আর ৩০-এ।

এবার একটি ছোট প্রোগ্রাম instruction ধরে ধরে চালানো যাক। মেমরির 0x100-এ আছে 25, 0x104-এ 17. প্রোগ্রামটি দুটি সংখ্যা পড়ে, যোগ-বিয়োগ-AND করে, যোগফল 0x108-এ রাখে — আর মাঝখানে ইচ্ছা করে x0-তে লেখার চেষ্টা করে:

00addi x5, x0, 25604lw   x6, 0(x5)08lw   x7, 4(x5)0cadd  x8, x6, x710sub  x9, x6, x714addi x0, x8, 10018and  x10, x6, x71csw   x8, 8(x5)

নিচের interpreter এই RV32I অংশটুকু (add, addi, sub, and, or, lw, sw) সত্যিই নকল করে: ৩২টি ৩২-বিট register (Int32Array, তাই যোগফল আপনা থেকেই mod 2³²), x0-তে লেখা বাতিল, আর একটি byte-ভিত্তিক little-endian মেমরি। প্রতিটি instruction-এর পর register ছাপে:

// Tiny RV32I subset: 32 registers (x0 hard-wired to 0), byte-addressed little-endian memory
const x = new Int32Array(32), mem = new Uint8Array(512);
const lw = a => mem[a] | mem[a + 1] << 8 | mem[a + 2] << 16 | mem[a + 3] << 24;
const sw = (a, v) => { for (let i = 0; i < 4; i++) mem[a + i] = (v >>> (8 * i)) & 0xff; };
const set = (rd, v) => { if (rd !== 0) x[rd] = v; };        // writes to x0 are discarded
sw(0x100, 25); sw(0x104, 17);                                // data: A at 0x100, B at 0x104
const prog = [
  "addi x5, x0, 256", "lw x6, 0(x5)", "lw x7, 4(x5)", "add x8, x6, x7",
  "sub x9, x6, x7", "addi x0, x8, 100", "and x10, x6, x7", "sw x8, 8(x5)",
];
const R = s => +s.slice(1);
let pc = 0;
const show = [0, 5, 6, 7, 8, 9, 10];
console.log("pc   instruction          " + show.map(r => ("x" + r).padStart(5)).join(""));
for (const line of prog) {
  const [op, ...a] = line.replace(/[(),]/g, " ").trim().split(/\s+/);
  if (op === "add") set(R(a[0]), x[R(a[1])] + x[R(a[2])]);
  else if (op === "sub") set(R(a[0]), x[R(a[1])] - x[R(a[2])]);
  else if (op === "and") set(R(a[0]), x[R(a[1])] & x[R(a[2])]);
  else if (op === "or") set(R(a[0]), x[R(a[1])] | x[R(a[2])]);
  else if (op === "addi") set(R(a[0]), x[R(a[1])] + Number(a[2]));
  else if (op === "lw") set(R(a[0]), lw(x[R(a[2])] + Number(a[1])));
  else if (op === "sw") sw(x[R(a[2])] + Number(a[1]), x[R(a[0])]);
  console.log(pc.toString(16).padStart(2, "0") + "   " + line.padEnd(20) + show.map(r => String(x[r]).padStart(5)).join(""));
  pc += 4;                                                    // every RV32I instruction is 4 bytes
}
const bytes = [...mem.slice(0x108, 0x10c)].map(b => b.toString(16).padStart(2, "0")).join(" ");
console.log(`mem[0x108] = ${lw(0x108)}  bytes at 0x108..0x10b: ${bytes}  (little-endian)`);
console.log(`x0 after "addi x0, x8, 100": ${x[0]} (the result ${x[8] + 100} was thrown away)`);

pc   instruction             x0   x5   x6   x7   x8   x9  x10
00   addi x5, x0, 256        0  256    0    0    0    0    0
04   lw x6, 0(x5)            0  256   25    0    0    0    0
08   lw x7, 4(x5)            0  256   25   17    0    0    0
0c   add x8, x6, x7          0  256   25   17   42    0    0
10   sub x9, x6, x7          0  256   25   17   42    8    0
14   addi x0, x8, 100        0  256   25   17   42    8    0
18   and x10, x6, x7         0  256   25   17   42    8   17
1c   sw x8, 8(x5)            0  256   25   17   42    8   17
mem[0x108] = 42  bytes at 0x108..0x10b: 2a 00 00 00  (little-endian)
x0 after "addi x0, x8, 100": 0 (the result 142 was thrown away)

৯ · ISA আর পারফরম্যান্স, নকশার তিন নীতি আর privilege level

IC বনাম CPI — একটি হিসাব

Iron law (পর্ব ০৩) বলে, ISA-র সিদ্ধান্ত IC আর CPI দুটিকেই প্রভাবিত করে — প্রায়ই উল্টো দিকে। ধরুন একই C প্রোগ্রাম দুটি ISA-র জন্য compile করা হলো, দুটি chip-ই 3 GHz-এ চলে:

Q-তে ৬০% বেশি instruction চলেছে, তবু Q 1.0 ÷ 0.667 = 1.5 গুণ দ্রুত, কারণ CPI কমেছে আরও বেশি হারে। কিন্তু P-এর microarchitecture যদি micro-op আর out-of-order দিয়ে CPI-কে 2.0-তে নামায়, তাহলে P-এর সময় 0.667 s — সমান। এ কারণেই ISA একা performance ঠিক করে না: সংখ্যাগুলো সবসময় নির্দিষ্ট chip আর compiler-এর।

Patterson–Hennessy-র নকশা-নীতি

“Computer Organization and Design”-এর RISC-V সংস্করণে ISA নকশার তিনটি নীতি বলা হয়েছে (পুরোনো MIPS সংস্করণগুলোতে এগুলোর সাথে “make the common case fast”-সহ তালিকাটি একটু ভিন্ন ছিল):

1. Simplicity favours regularity (সরলতা নিয়মিততাকে পছন্দ করে)। সব হিসাবের instruction-এ ঠিক তিনটি operand, একই ক্রমে; সব instruction একই মাপের। নিয়মিত হলে hardware সরল, আর সরল hardware দ্রুত ও সস্তা।
2. Smaller is faster (ছোট হলে দ্রুত)। Register মাত্র ৩২টি, ৩২০টি নয় — বেশি হলে register file বড় হয়, signal-কে বেশি দূর যেতে হয়, clock ধীর হয়। এজন্যই operand register-এ, মেমরিতে নয়।
3. Good design demands good compromises (ভালো নকশায় ভালো আপস লাগে)। সব instruction ৩২ বিট রাখার নিয়ম আর বড় ধ্রুবক রাখার প্রয়োজন — দুটি একসাথে পুরো মেটে না। RISC-V তাই কয়েকটি format রেখেছে (R, I, S, B, U, J), যাদের বিটগুলো যতটা সম্ভব একই জায়গায় — পর্ব ২৭-এর বিষয়।

Privilege level — কে কী করতে পারে

ISA শুধু সাধারণ প্রোগ্রামের instruction নয়, operating system-এর নিয়মও বেঁধে দেয়। একটি অ্যাপ যেন অন্য অ্যাপের মেমরি পড়তে বা hardware সরাসরি চালাতে না পারে, তার জন্য CPU কয়েকটি privilege level-এ চলে। RISC-V-এর privileged spec-এ তিনটি প্রধান mode: U (user — সাধারণ অ্যাপ), S (supervisor — OS kernel), M (machine — সবচেয়ে ক্ষমতাবান, firmware). x86-এ এর সমতুল্য ring 0 (kernel) থেকে ring 3 (user), ARM-এ EL0–EL3.

অ্যাপ যখন ফাইল খুলতে চায়, সে নিজে disk ছুঁতে পারে না; সে একটি system call করে। RISC-V-এ এর instruction ecall: এটি একটি exception তোলে, CPU নিয়ন্ত্রিতভাবে উচ্চতর mode-এ গিয়ে OS-এর নির্দিষ্ট handler-এ লাফ দেয়, কাজ শেষে sret/mret দিয়ে ফেরে। Pipeline-এ exception কীভাবে সামলানো হয়, তা পর্ব ৩৮-এ; OS-এর দিক থেকে system call দেখতে পাবেন অপারেটিং সিস্টেম কোর্সের System call পর্বে।

এই runner কোন ISA বলে?

শেষে একটি বাস্তব যন্ত্রকে প্রশ্ন করা যাক। এই পাতার কোড যে সার্ভারে চলে, সেটি কোন ISA-র, কয় বিটের, আর সেখানে gcc কোনো বাড়তি option ছাড়া কোন x86 extension ব্যবহার করতে পারে? (Script-টি ইচ্ছা করে CPU-র model-এর নাম বা flag-তালিকা ছাপে না।)

# Which ISA does this runner speak? (no CPU model name or flag list is printed)
echo "machine     : $(uname -m)"
command -v getconf >/dev/null && echo "LONG_BIT    : $(getconf LONG_BIT)" || echo "getconf not found"
v=$(printf '\001\000' | od -An -tu2 | tr -d ' ')     # bytes 01 00 read as one 16-bit number
[ "$v" = "1" ] && echo "byte order  : little-endian (01 00 -> 1)" || echo "byte order  : big-endian ($v)"
if command -v gcc >/dev/null; then
  m=$(echo | gcc -dM -E -x c - 2>/dev/null)          # macros of gcc's default target
  echo "x86 extensions gcc may use with no -march option:"
  for f in SSE2 SSE4_2 AVX AVX2 AVX512F; do
    case "$m" in *"__${f}__ 1"*) s=yes ;; *) s=no ;; esac
    printf '  %-8s %s\n' "$f" "$s"
  done
else
  echo "gcc not found"
fi

machine     : x86_64
LONG_BIT    : 64
byte order  : little-endian (01 00 -> 1)
x86 extensions gcc may use with no -march option:
  SSE2     yes
  SSE4_2   no
  AVX      no
  AVX2     no
  AVX512F  no

১০ · AI-এর যুগে ISA শেখা

AI টুল RISC আর CISC-এর সংজ্ঞা সুন্দর গুছিয়ে বলে, কিন্তু নির্দিষ্ট ISA-র খুঁটিনাটি, instruction গোনা আর chip-এর তথ্যে প্রায়ই ভুল করে। প্রচলিত ভুলগুলো:

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

• কোন ISA-র কথা হচ্ছে স্পষ্ট — RISC-V, MIPS, ARM আর x86-এর নাম বা নিয়ম মিশে যায়নি
• Address-কোডের প্রতিটি instruction নিজে হাতে বা simulator-এ চালিয়ে ফল মিলিয়েছি
• Instruction আর মেমরি-ট্রাফিক আলাদা করে গুনেছি — একটি কম হলে অন্যটিও কম, এমন ধরে নিইনি
• RISC-V কোডে x0-তে লেখা, flag-এর ব্যবহার বা delay slot-এর মতো অসম্ভব জিনিস নেই
• Chip বা ISA-র ইতিহাসের তারিখ আর spec মূল উৎসে (manual, datasheet, spec) মিলিয়েছি
• “X সবসময় দ্রুত” ধরনের দাবিতে iron law দিয়ে প্রশ্ন করেছি — IC, CPI আর clock কোনটি বদলাচ্ছে?