Multi-cycle datapath আর microprogrammed control

১ · Single-cycle-এর অপচয় থেকে multi-cycle-এর ভাবনা

পর্ব ৩২-এ (Single-cycle datapath) একটি single-cycle datapath দেখেছেন: প্রতিটি instruction একটিমাত্র clock cycle-এ শুরু থেকে শেষ। নিয়মটি সরল, CPI = ১. কিন্তু এর একটি গোপন খরচ আছে। Clock-এর দৈর্ঘ্য সব instruction-এর জন্য একই, তাই cycle-কে সবচেয়ে ধীর instruction-এর পুরো পথের সমান লম্বা রাখতে হয়। RISC-V-এ সেটি সাধারণত lw: instruction memory পড়া, register পড়া, ALU-তে ঠিকানা হিসাব, data memory পড়া, register-এ লেখা — পাঁচটি বড় কাজ পরপর। একটি beq-এর data memory বা register-এ লেখার দরকার নেই, তবু সে একই লম্বা cycle পায়, বাকি সময় বসে থাকে।

এই ভাবনা থেকে multi-cycle datapath-এর তিনটি নীতি:

1. ধাপে ভাঙা: প্রতিটি instruction-কে কয়েকটি ধাপে ভাঙা, যাতে প্রতিটি ধাপে মোটামুটি একটিই বড় কাজ থাকে — একবার memory-তে যাওয়া, বা একবার register file পড়া/লেখা, বা একবার ALU চালানো। তাহলে ধাপগুলোর delay কাছাকাছি হয়।
2. ছোট clock: প্রতিটি ধাপ একটি clock cycle. Cycle time = সবচেয়ে ধীর ধাপের delay, সবচেয়ে ধীর instruction-এর নয়। Instruction যত ধাপ চায় তত cycle নেয় — তাই CPI আর ১ নয়, instruction-ভেদে ৩ থেকে ৫.
3. Hardware পুনর্ব্যবহার: Instruction আর data-র জন্য একটিই memory (fetch-এর cycle-এ instruction পড়ে, পরের কোনো cycle-এ data). একটিই ALU — PC + 4, শাখার লক্ষ্য আর আসল হিসাব তিনটিই আলাদা cycle-এ করে। Single-cycle-এ এগুলোর জন্য আলাদা adder আর আলাদা memory লাগত, কারণ সব কাজ একই cycle-এ।

পুনর্ব্যবহারের দাম হলো: এক cycle-এর ফল পরের cycle পর্যন্ত বাঁচিয়ে রাখতে হয়, কারণ পরের cycle-এ সেই unit অন্য কাজে ব্যস্ত। তাই প্রতিটি বড় unit-এর output-এ একটি register বসে — এগুলোকে বলে nonarchitectural register, কারণ ISA-তে এদের নাম নেই, কোনো instruction এদের সরাসরি পড়ে না।

২ · Multi-cycle datapath — এক memory, এক ALU, পাঁচটি নতুন register

কোন পাঠ্যবইয়ের রীতি মানা হলো: এই পর্বের datapath আর control FSM Sarah Harris ও David Harris-এর Digital Design and Computer Architecture: RISC-V Edition-এর multi-cycle প্রসেসরের ধাঁচে — সেখানে OldPC আছে, fetch-এর cycle-এই PC + 4 লেখা হয়, আর decode-এর cycle-এ শাখার লক্ষ্য হিসাব হয়। Register-এর নাম রাখা হয়েছে প্রচলিত রূপে (IR, MDR, A, B, ALUOut); Harris–Harris-এর বইয়ে এগুলোর নাম কিছুটা আলাদা (যেমন Instr, Data, WriteData). Patterson–Hennessy-র পুরোনো MIPS সংস্করণগুলোতেও প্রায় একই নকশা ছিল — সেখানে OldPC নেই, কিন্তু চক্রের সংখ্যা একই: lw ৫, sw ও R-type ৪, beq ৩ (jump সেখানে ৩, এখানে jal ৪). পরীক্ষায় কোন বইয়ের রীতি মানছেন, এক লাইনে লিখে দেওয়াই নিরাপদ।

ছবিটি বাঁ থেকে ডানে পড়ুন। নতুন কিছু mux এসেছে, কারণ একই unit বিভিন্ন cycle-এ বিভিন্ন জায়গা থেকে input নেয়:

• AdrSrc mux: Memory-র ঠিকানা কখনো PC (fetch), কখনো ALUOut-থেকে-আসা data-র ঠিকানা (lw/sw). একটিই memory — von Neumann ধাঁচ — তাই এই mux.
• ALUSrcA mux: PC (PC + 4-এর জন্য), OldPC (শাখার লক্ষ্যের জন্য) বা A (আসল হিসাব).
• ALUSrcB mux: B (R-type, beq), sign-extend করা imm (lw, sw, addi, শাখার offset) বা ধ্রুবক 4.
• ResultSrc mux: ALUOut (আগের cycle-এর ফল), MDR (load-এর data) বা এই মুহূর্তের ALU ফল (fetch-এ PC + 4 সরাসরি PC-তে)।

Register-গুলোর লেখার নিয়ম গুরুত্বপূর্ণ। PC আর IR-এ লেখা হয় শুধু PCWrite বা IRWrite চালু থাকলে — এগুলো enable-ওয়ালা register, কারণ এদের মান কয়েক cycle ধরে অপরিবর্তিত থাকতে হয়। A, B, ALUOut, MDR প্রতি cycle-এ লেখা হয় (enable নেই); তাদের মান ঠিক পরের cycle-এই ব্যবহার করতে হয়, নয়তো মুছে যায়। এতে control signal-এর সংখ্যা কমে।

৩ · পাঁচটি ধাপ — কোন instruction কয় cycle নেয়

প্রতিটি ধাপে কী হয়, তা register transfer ভাষায় (RTL, “←” মানে cycle-এর শেষের clock ধারে লেখা) লেখা যাক। প্রথম দুই ধাপ সব instruction-এর জন্য এক, কারণ তখনো control জানে না instruction কী:

আরও দুটি class: I-type ALU (addi) R-type-এর মতো ৪ cycle (ধাপ ৩-এ A + imm). jal-ও ৪: ধাপ ২-এ লক্ষ্য (OldPC + imm) আগেই ALUOut-এ, ধাপ ৩-এ PC ← ALUOut আর একই সময়ে ALU হিসাব করে OldPC + 4, ধাপ ৪-এ x[rd] ← সেই ফেরার ঠিকানা।

ধাপ ২-এর চালাকি। Decode-এর cycle-এ ALU এমনিতে বসে থাকত — control এখনো instruction-এর ধরন জানে না। তাই নকশাকার ALU-কে দিয়ে আগাম OldPC + imm হিসাব করিয়ে রাখেন। Instruction যদি শাখা হয়, ধাপ ৩-এ লক্ষ্য তৈরি, তাই beq তিন cycle-এই শেষ। যদি শাখা না হয়, হিসাবটি ফেলে দেওয়া হয় — ক্ষতি নেই, কারণ ALU-কে তো বসেই থাকতে হতো। একে বলা যায় অনুমাননির্ভর (speculative) কাজের সবচেয়ে সরল রূপ: কাজে লাগতে পারে এমন কিছু ফাঁকা সময়ে করে রাখা। একইভাবে A আর B সব instruction-এর জন্যই পড়া হয়, এমনকি lw-এর জন্যও (যার rs2 নেই) — অকাজের পড়া, কিন্তু নিরীহ।

এবার একটি আসল instruction — lw x5, 8(x10), যেখানে x10 = 0x40 আর memory-র 0x48 ঠিকানায় 7 — পাঁচ cycle ধরে চালানো যাক। প্রতিটি ধাপে register-এর মান সেই cycle-এর শেষের clock ধারের পরের:

৪ · Control-কে FSM হিসেবে — state diagram আর প্রতিটি state-এর signal

Single-cycle-এর control (পর্ব ৩৩, Control unit) ছিল একটি combinational টেবিল: opcode ঢোকে, signal বেরোয়। Multi-cycle-এ সেটি যথেষ্ট নয়, কারণ একই instruction-এর জন্য cycle ১-এ এক রকম signal, cycle ৩-এ আরেক রকম লাগে। Control-কে মনে রাখতে হয় “এই instruction-এর কোন ধাপে আছি”। স্মৃতিসহ control মানেই finite state machine — পর্ব ১৭-এর (Finite state machine) পদ্ধতি এখানে সরাসরি কাজে লাগে। প্রতিটি state একটি ধাপ; state-এর output হলো সেই ধাপের control signal; input হলো opcode (আর beq-এর জন্য ALU-র Zero).

প্রতিটি state-এ কোন signal চালু (বাকি সব enable 0; mux-এর মান উল্লেখ না থাকলে “don't care”). কোডের মানগুলো (00, 01, 10) এই পর্বের নকশার; বই-ভেদে মানের ক্রম আলাদা হতে পারে:

PC-তে লেখার আসল enable হলো PCWrite = PCUpdate + Branch · Zero. Signal-গুলোর বেশিরভাগ শুধু state-এর ওপর নির্ভর করে, তাই এটি মূলত একটি Moore machine; শুধু PCWrite-এ Zero ঢোকে। ALUOp থেকে ALU-র আসল কাজ বের করে আলাদা ছোট ALU control decoder (funct3, funct7 দেখে) — পর্ব ৩৩-এর মতো, একটি পার্থক্যসহ: এখানে S8 (I-type ALU)-ও ALUOp = 10 পায়, কারণ Harris–Harris-এর decoder বিট ৩০-কে sub-এর চিহ্ন ধরে শুধু তখনই, যখন opcode-এর বিট ৫ = 1 (অর্থাৎ R-type); তাই addi-এর immediate-এর বিট ৩০ বিয়োগ বানায় না। পর্ব ৩৩-এর সরল ALU control শুধু বিট ৩০ দেখে, তাই সেখানে (আর এই কোর্সের রীতিতে) addi-এর ALUOp = 00.

Next-state logic

১১টি state, তাই binary encoding-এ ⌈log₂ ১১⌉ = ৪টি flip-flop-এর state register (one-hot চাইলে ১১টি). Next-state logic-এর টেবিল ছোট: বেশিরভাগ state-এর পরের state নির্দিষ্ট, শুধু দুই জায়গায় opcode দেখে শাখা।

এই টেবিল থেকে পর্ব ১৭-এর মতো K-map বা synthesis tool দিয়ে সমীকরণ পাওয়া যায়। Opcode-এর ৭ বিট + state-এর ৪ বিট = ১১টি input, তাই হাতে K-map অসম্ভব; বাস্তবে Verilog-এ case লিখে synthesis tool-কে দেওয়া হয়, বা টেবিলটিকে একটি ROM বা PLA-তে বসানো হয়। ROM-এ বসানোর ভাবনাই আমাদের অংশ ৬-এর microprogramming-এর দিকে নিয়ে যাবে।

নিচের stepper-এ দুটি beq — একটি যেটির শাখা নেওয়া হয় না, একটি যেটির নেওয়া হয় — FSM-এর পথ ধরে দেখুন:

এবার পুরো ছোট প্রোগ্রাম — lw, add, sw, দুটি beq — cycle ধরে চালানো যাক। নিচের simulator একটি আসল RV32I machine code (hex) decode করে, ওপরের FSM-এর state ধরে এগোয়, আর প্রতিটি cycle-এর state, register আর চালু signal ছাপে:

// Multi-cycle RV32I: one memory, one ALU, extra registers IR, MDR, A, B, ALUOut (+OldPC).
// Control = FSM (Harris-Harris RISC-V style). Values shown are AFTER each clock edge.
const mem = { 0x00: 0x00852283, 0x04: 0x00528333, 0x08: 0x00652623, 0x0c: 0x00628463,
              0x10: 0x00000463, 0x14: 0x006303b3, 0x48: 7 };   // program + one data word
const x = new Array(32).fill(0); x[10] = 0x40;                         // x10 = base address
const sx = (v, b) => (v << (32 - b)) >> (32 - b);                      // sign-extend b bits
const imm = i => { const op = i & 0x7f;
  if (op === 0x23) return sx(((i >>> 25) << 5) | ((i >>> 7) & 31), 12);                        // S
  if (op === 0x63) return sx(((i >>> 31) << 12) | (((i >>> 7) & 1) << 11) |
                             (((i >>> 25) & 63) << 5) | (((i >>> 8) & 15) << 1), 13);          // B
  return sx(i >>> 20, 12); };                                                                  // I
const DISPATCH = { 0x03: "MemAdr", 0x23: "MemAdr", 0x33: "ExecuteR", 0x63: "BEQ" };
let PC = 0, OldPC = 0, IR = 0, A = 0, B = 0, ALUOut = 0, MDR = 0, st = "Fetch", cyc = 0, n = 0;
const hx = v => (v >>> 0).toString(16).padStart(2, "0");
console.log("cyc state     PC  IR       A   B   ALUOut MDR | asserted signals");
while (!(st === "Fetch" && PC === 0x18)) {             // stop when the next fetch is at 0x18
  const s = st, op = IR & 0x7f, rd = (IR >>> 7) & 31; let sig = "";
  if (s === "Fetch") { IR = mem[PC]; OldPC = PC; ALUOut = PC + 4; PC += 4; n++;
    sig = "IRWrite PCWrite SrcA=PC SrcB=4"; st = "Decode"; }
  else if (s === "Decode") { A = x[(IR >>> 15) & 31]; B = x[(IR >>> 20) & 31];
    ALUOut = OldPC + imm(IR); sig = "SrcA=OldPC SrcB=imm"; st = DISPATCH[IR & 0x7f]; }
  else if (s === "MemAdr") { ALUOut = A + imm(IR); sig = "SrcA=A SrcB=imm";
    st = op === 0x03 ? "MemRead" : "MemWrite"; }
  else if (s === "MemRead") { MDR = mem[ALUOut] ?? 0; sig = "AdrSrc=ALUOut"; st = "MemWB"; }
  else if (s === "MemWB") { x[rd] = MDR; sig = `RegWrite x${rd}<-MDR`; st = "Fetch"; }
  else if (s === "MemWrite") { mem[ALUOut] = B; sig = "AdrSrc=ALUOut MemWrite"; st = "Fetch"; }
  else if (s === "ExecuteR") { ALUOut = A + B; sig = "SrcA=A SrcB=B ALUOp=funct"; st = "ALUWB"; }
  else if (s === "ALUWB") { x[rd] = ALUOut; sig = `RegWrite x${rd}<-ALUOut`; st = "Fetch"; }
  else if (s === "BEQ") { const target = ALUOut, zero = A - B === 0; ALUOut = A - B;
    if (zero) PC = target; sig = `SrcA=A SrcB=B sub Zero=${+zero}${zero ? " PCWrite" : ""}`; st = "Fetch"; }
  console.log(`${String(++cyc).padStart(3)} ${s.padEnd(9)} ${hx(PC)} ${hx(IR).padStart(8, "0")} ` +
    `${String(A).padStart(3)} ${String(B).padStart(3)} ${String(ALUOut).padStart(6)} ${String(MDR).padStart(3)} | ${sig}`);
}
console.log(`instructions = ${n}, cycles = ${cyc}, CPI = ${(cyc / n).toFixed(2)}; ` +
  `x5 = ${x[5]}, x6 = ${x[6]}, x7 = ${x[7]}, mem[0x4c] = ${mem[0x4c]}`);

cyc state     PC  IR       A   B   ALUOut MDR | asserted signals
  1 Fetch     04 00852283   0   0      4   0 | IRWrite PCWrite SrcA=PC SrcB=4
  2 Decode    04 00852283  64   0      8   0 | SrcA=OldPC SrcB=imm
  3 MemAdr    04 00852283  64   0     72   0 | SrcA=A SrcB=imm
  4 MemRead   04 00852283  64   0     72   7 | AdrSrc=ALUOut
  5 MemWB     04 00852283  64   0     72   7 | RegWrite x5<-MDR
  6 Fetch     08 00528333  64   0      8   7 | IRWrite PCWrite SrcA=PC SrcB=4
  7 Decode    08 00528333   7   7      9   7 | SrcA=OldPC SrcB=imm
  8 ExecuteR  08 00528333   7   7     14   7 | SrcA=A SrcB=B ALUOp=funct
  9 ALUWB     08 00528333   7   7     14   7 | RegWrite x6<-ALUOut
 10 Fetch     0c 00652623   7   7     12   7 | IRWrite PCWrite SrcA=PC SrcB=4
 11 Decode    0c 00652623  64  14     20   7 | SrcA=OldPC SrcB=imm
 12 MemAdr    0c 00652623  64  14     76   7 | SrcA=A SrcB=imm
 13 MemWrite  0c 00652623  64  14     76   7 | AdrSrc=ALUOut MemWrite
 14 Fetch     10 00628463  64  14     16   7 | IRWrite PCWrite SrcA=PC SrcB=4
 15 Decode    10 00628463   7  14     20   7 | SrcA=OldPC SrcB=imm
 16 BEQ       10 00628463   7  14     -7   7 | SrcA=A SrcB=B sub Zero=0
 17 Fetch     14 00000463   7  14     20   7 | IRWrite PCWrite SrcA=PC SrcB=4
 18 Decode    14 00000463   0   0     24   7 | SrcA=OldPC SrcB=imm
 19 BEQ       18 00000463   0   0      0   7 | SrcA=A SrcB=B sub Zero=1 PCWrite
instructions = 5, cycles = 19, CPI = 3.80; x5 = 7, x6 = 14, x7 = 0, mem[0x4c] = 14

৫ · CPI আর পারফরম্যান্স — multi-cycle কখন জেতে, কখন হারে

পর্ব ০৩-এর (পারফরম্যান্স মাপা) iron law এখানে সব প্রশ্নের উত্তর দেয়:

একই প্রোগ্রাম, একই ISA, তাই IC দুই নকশায় এক। লড়াইটা CPI আর T_c-এর মধ্যে: single-cycle-এর CPI = ১ কিন্তু T_c লম্বা; multi-cycle-এর T_c ছোট কিন্তু CPI ৩–৫. Instruction mix থেকে গড় CPI হলো ভারযুক্ত গড়: CPI = Σ f_i × CPI_i, যেখানে f_i হলো class i-এর ভগ্নাংশ।

প্রচলিত পরীক্ষার হিসাব — পূর্ণ সমাধান

প্রশ্ন: একটি প্রোগ্রামে ২৫% lw, ১০% sw, ৫২% R-type, ১১% beq, ২% jal. Unit-এর delay: memory ২০০ ps, register file (পড়া বা লেখা) ১০০ ps, ALU ২০০ ps; mux, register-এর setup আর clock-to-Q উপেক্ষা করুন। Single-cycle আর multi-cycle নকশার মধ্যে কোনটি দ্রুত, কতগুণ?

1. Multi-cycle-এর গড় CPI: ০.২৫ × ৫ + ০.১০ × ৪ + ০.৫২ × ৪ + ০.১১ × ৩ + ০.০২ × ৪ = ১.২৫ + ০.৪০ + ২.০৮ + ০.৩৩ + ০.০৮ = ৪.১৪.
2. Single-cycle-এর T_c: সবচেয়ে লম্বা পথ lw-এর — memory (instruction) + register পড়া + ALU + memory (data) + register লেখা = ২০০ + ১০০ + ২০০ + ২০০ + ১০০ = ৮০০ ps.
3. Multi-cycle-এর T_c: প্রতিটি ধাপে একটি বড় unit, তাই সবচেয়ে ধীর unit-এর delay: max(২০০, ১০০, ২০০) = ২০০ ps.
4. গড় সময় প্রতি instruction: single = ১ × ৮০০ = ৮০০ ps; multi = ৪.১৪ × ২০০ = ৮২৮ ps.
5. Speedup (single ÷ multi) = ৮০০ / ৮২৮ ≈ ০.৯৬৬ — অর্থাৎ multi-cycle প্রায় ৩.৪% ধীর. IC = ১০^৯ হলে single ০.৮০০ s, multi ০.৮২৮ s.

অবাক লাগে? কারণটি একটি সরল অসমতায় লুকানো। দাবি: register-এর খরচ বাদ দিলেও multi-cycle তখনই জেতে, যখন CPI_multi < T_single / T_multi. যুক্তি: সময় তুলনা করলে IC × ১ × T_single > IC × CPI_multi × T_multi, দুই পাশ IC × T_multi দিয়ে ভাগ করলেই শর্তটি আসে। এখানে T_single / T_multi = ৮০০ / ২০০ = ৪, অথচ CPI = ৪.১৪ > ৪. সমস্যা হলো ধাপগুলো সমান নয়: register file-এর ধাপ ১০০ ps-এ শেষ হতো, তবু ২০০ ps-এর cycle পায়। Load-এর পাঁচ ধাপের delay যোগ করলে ৮০০, কিন্তু multi-cycle-এ তা নেয় ৫ × ২০০ = ১০০০ ps. বাস্তবে প্রতিটি cycle-এ register-এর setup আর clock-to-Q-এর খরচও যোগ হয় (t_pcq + t_setup), যা multi-cycle-কে একাধিকবার দিতে হয় — single-cycle দেয় একবার।

নিচের calculator চারটি পরিস্থিতিতে একই হিসাব করে, যার দুটিতে multi-cycle হারে আর দুটিতে জেতে:

// Single-cycle vs multi-cycle: execution time = IC x CPI x Tc. Delays in picoseconds (ps).
const IC = 1e9;                                                   // 10^9 instructions
function compare(name, d, mix) {
  // Single-cycle: one long cycle that must fit the slowest instruction's whole path.
  const path = { lw: d.mem + d.rf + d.alu + d.mem + d.rf, sw: d.mem + d.rf + d.alu + d.mem,
    R: d.mem + d.rf + d.alu + d.rf, beq: d.mem + d.rf + d.alu, jal: d.mem + d.alu + d.rf,
    mul: d.mem + d.rf + (d.mul || 0) + d.rf };
  const classes = Object.keys(mix);
  const Tc1 = d.ovh + Math.max(...classes.map(c => path[c]));
  // Multi-cycle: each step uses one big unit, so Tc = slowest unit (+ register overhead).
  const step = Math.max(d.mem, d.rf, d.alu), Tc2 = d.ovh + step;
  const cycles = { lw: 5, sw: 4, R: 4, beq: 3, jal: 4, mul: 3 + Math.ceil((d.mul || 0) / step) };
  const CPI = classes.reduce((s, c) => s + mix[c] * cycles[c], 0);
  const t1 = IC * 1 * Tc1 * 1e-12, t2 = IC * CPI * Tc2 * 1e-12;   // seconds
  console.log(`${name}\n  single: CPI 1.00  Tc ${Tc1} ps  time ${t1.toFixed(3)} s` +
    `\n  multi : CPI ${CPI.toFixed(2)}  Tc ${Tc2} ps  time ${t2.toFixed(3)} s` +
    `\n  speedup (single/multi) = ${(t1 / t2).toFixed(3)} -> ${t2 < t1 ? "multi-cycle wins" : "multi-cycle LOSES"}`);
}
const mix = { lw: 0.25, sw: 0.10, R: 0.52, beq: 0.11, jal: 0.02 };
compare("A) classic delays: mem 200, regfile 100, ALU 200", { mem: 200, rf: 100, alu: 200, ovh: 0 }, mix);
compare("B) same + 30 ps register overhead per cycle", { mem: 200, rf: 100, alu: 200, ovh: 30 }, mix);
compare("C) balanced units: mem 100, regfile 100, ALU 100", { mem: 100, rf: 100, alu: 100, ovh: 0 }, mix);
compare("D) classic + 5% mul needing 800 ps of ALU time", { mem: 200, rf: 100, alu: 200, mul: 800, ovh: 0 },
  { lw: 0.25, sw: 0.10, R: 0.47, beq: 0.11, jal: 0.02, mul: 0.05 });

A) classic delays: mem 200, regfile 100, ALU 200
  single: CPI 1.00  Tc 800 ps  time 0.800 s
  multi : CPI 4.14  Tc 200 ps  time 0.828 s
  speedup (single/multi) = 0.966 -> multi-cycle LOSES
B) same + 30 ps register overhead per cycle
  single: CPI 1.00  Tc 830 ps  time 0.830 s
  multi : CPI 4.14  Tc 230 ps  time 0.952 s
  speedup (single/multi) = 0.872 -> multi-cycle LOSES
C) balanced units: mem 100, regfile 100, ALU 100
  single: CPI 1.00  Tc 500 ps  time 0.500 s
  multi : CPI 4.14  Tc 100 ps  time 0.414 s
  speedup (single/multi) = 1.208 -> multi-cycle wins
D) classic + 5% mul needing 800 ps of ALU time
  single: CPI 1.00  Tc 1200 ps  time 1.200 s
  multi : CPI 4.29  Tc 200 ps  time 0.858 s
  speedup (single/multi) = 1.399 -> multi-cycle wins

৬ · Microprogrammed control — control store, microinstruction আর sequencer

অংশ ৪-এর FSM-কে logic gate দিয়ে বানালে তাকে বলে hardwired control. বিকল্প একটি ভাবনা প্রস্তাব করেছিলেন ব্রিটিশ কম্পিউটার বিজ্ঞানী Maurice Wilkes — সাধারণত ১৯৫১ সালের একটি সম্মেলনের প্রবন্ধকে এর সূচনা ধরা হয়: control-কে circuit হিসেবে না ভেবে একটি ছোট প্রোগ্রাম হিসেবে ভাবা। প্রতিটি state-এর signal-গুলো একটি শব্দ (word) হিসেবে একটি memory-তে লেখা থাকবে; প্রতি cycle-এ একটি শব্দ পড়া হবে, তার বিটগুলোই সরাসরি control signal. এই কৌশলের নাম microprogramming.

• Control store: microinstruction রাখার ছোট, দ্রুত memory — সাধারণত ROM.
• Microinstruction: control store-এর একটি শব্দ = FSM-এর এক state = এক cycle-এর কাজ। কয়েকটি field-এ ভাগ করা।
• Micro-PC (µPC): এখন কোন ঠিকানার microinstruction চলছে।
• Microsequencer: পরের µPC বেছে নেয় — তিনটি উপায়ে: Seq (µPC + 1, পরের লাইন), Fetch (০-তে ফেরা, নতুন instruction) আর Dispatch (opcode দিয়ে একটি dispatch ROM থেকে ঠিকানা পড়া — microprogram-এর “switch-case”).
• Microcode: পুরো control store-এর বিষয়বস্তু — প্রসেসরের ভেতরের প্রোগ্রাম।

আমাদের FSM-এর ১১টি state থেকে ১১টি microinstruction. প্রতিটির field: ALU (কাজ), SRC1 ও SRC2 (ALUSrcA, ALUSrcB), Register (পড়া/লেখা), Memory, PCWrite আর Sequencing. এই ছোট microprogram-টি নিচে (ঠিকানা ০ থেকে ১০):

“Write MDR” মানে x[rd] ← MDR; “Write ALUOut” Register কলামে x[rd] ← ALUOut, আর Memory কলামে Mem[ALUOut] ← B. “ALUOut-cond” মানে Zero হলে PC ← ALUOut. দুটি dispatch ROM:

লক্ষ করুন, EXECR-এর পরের ঠিকানা স্বাভাবিকভাবেই ৭ (ALUWB), তাই Seq যথেষ্ট। কিন্তু EXECI (৮) আর JAL (৯)-ও ALUWB-তে যেতে চায়, অথচ তাদের পরের লাইন ৯ ও ১০. ক্লাসিক sequencer-এ “যেকোনো ঠিকানায় লাফ” নেই, তাই dispatch ROM 2-কে কাজে লাগানো হয়েছে — opcode দেখে ৭-এ পাঠায়। বাস্তব microsequencer-এ প্রায়ই সরাসরি next-address field থাকে, যা এই সমস্যা মেটায়, কিন্তু প্রতিটি শব্দ চওড়া করে।

এখন একই microprogram আর dispatch ROM একটি ছোট sequencer-এ চালানো যাক — lw আর beq-এর জন্য:

// Microprogrammed control: a control store (ROM) + micro-PC + sequencer with two dispatch ROMs.
// Fields: label, ALU, SRC1, SRC2, Register, Memory, PCWrite, Sequencing.
const STORE = [
  ["FETCH",    "add",   "PC",    "4",   "-",           "Read PC->IR",  "ALU",         "Seq"],
  ["DECODE",   "add",   "OldPC", "Imm", "Read A,B",    "-",            "-",           "Disp1"],
  ["MEMADR",   "add",   "A",     "Imm", "-",           "-",            "-",           "Disp2"],
  ["MEMREAD",  "-",     "-",     "-",   "-",           "Read ALUOut",  "-",           "Seq"],
  ["MEMWB",    "-",     "-",     "-",   "Write MDR",   "-",            "-",           "Fetch"],
  ["MEMWRITE", "-",     "-",     "-",   "-",           "Write ALUOut", "-",           "Fetch"],
  ["EXECR",    "funct", "A",     "B",   "-",           "-",            "-",           "Seq"],
  ["ALUWB",    "-",     "-",     "-",   "Write ALUOut","-",            "-",           "Fetch"],
  ["EXECI",    "funct", "A",     "Imm", "-",           "-",            "-",           "Disp2"],
  ["JAL",      "add",   "OldPC", "4",   "-",           "-",            "ALUOut",      "Disp2"],
  ["BEQ",      "sub",   "A",     "B",   "-",           "-",            "ALUOut-cond", "Fetch"],
];
const OPC = { lw: "0000011", sw: "0100011", R: "0110011", I: "0010011", jal: "1101111", beq: "1100011" };
const DISP1 = { "0000011": 2, "0100011": 2, "0110011": 6, "0010011": 8, "1101111": 9, "1100011": 10 };
const DISP2 = { "0000011": 3, "0100011": 5, "0010011": 7, "1101111": 7 };
function run(kind) {
  const opcode = OPC[kind]; let upc = 0, steps = 0;
  console.log(`--- ${kind} (opcode ${opcode}) ---`);
  do {
    const [label, alu, s1, s2, reg, mem, pcw, seq] = STORE[upc];
    let next;
    if (seq === "Seq") next = upc + 1;                       // micro-PC + 1
    else if (seq === "Fetch") next = 0;                      // back to FETCH
    else next = (seq === "Disp1" ? DISP1 : DISP2)[opcode];   // ROM indexed by opcode
    console.log(`uPC ${String(upc).padStart(2)} ${label.padEnd(8)} ALU=${alu.padEnd(5)} ${s1}/${s2}`.padEnd(38) +
      `Reg=${reg.padEnd(12)} Mem=${mem.padEnd(12)} PC=${pcw.padEnd(11)} ${seq} -> ${next}`);
    upc = next; steps++;
  } while (upc !== 0);
  console.log(`${kind}: ${steps} microinstructions = ${steps} clock cycles`);
}
run("lw"); run("beq");

--- lw (opcode 0000011) ---
uPC  0 FETCH    ALU=add   PC/4        Reg=-            Mem=Read PC->IR  PC=ALU         Seq -> 1
uPC  1 DECODE   ALU=add   OldPC/Imm   Reg=Read A,B     Mem=-            PC=-           Disp1 -> 2
uPC  2 MEMADR   ALU=add   A/Imm       Reg=-            Mem=-            PC=-           Disp2 -> 3
uPC  3 MEMREAD  ALU=-     -/-         Reg=-            Mem=Read ALUOut  PC=-           Seq -> 4
uPC  4 MEMWB    ALU=-     -/-         Reg=Write MDR    Mem=-            PC=-           Fetch -> 0
lw: 5 microinstructions = 5 clock cycles
--- beq (opcode 1100011) ---
uPC  0 FETCH    ALU=add   PC/4        Reg=-            Mem=Read PC->IR  PC=ALU         Seq -> 1
uPC  1 DECODE   ALU=add   OldPC/Imm   Reg=Read A,B     Mem=-            PC=-           Disp1 -> 10
uPC 10 BEQ      ALU=sub   A/B         Reg=-            Mem=-            PC=ALUOut-cond Fetch -> 0
beq: 3 microinstructions = 3 clock cycles

৭ · Horizontal বনাম vertical, hardwired বনাম microprogrammed

একটি microinstruction-এ signal কীভাবে লেখা হবে, তার দুই প্রান্ত:

এই দুটি horizontal আর vertical microcode-এর মাঝামাঝি নকশাই বাস্তবে বেশি দেখা যায় (field-encoded): যেমন অংশ ৬-এর টেবিলে প্রতিটি field-এর কয়েকটি মাত্র বিকল্প, তাই প্রতি field ২ বিট, ৭টি field-এ ১৪ বিট।

Hardwired বনাম microprogrammed — কোনটি কখন

১৯৬০ থেকে ১৯৭০-এর দশকে এক প্রবল যুক্তি ছিল: তখন ROM ছিল তুলনামূলক দ্রুত আর সস্তা, আর main memory ছিল ধীর। তাই জটিল instruction একবার memory থেকে এনে ভেতরের দ্রুত microcode দিয়ে অনেক কাজ করানো লাভজনক। পরে cache এসে main memory-কে কার্যত দ্রুত করল, আর compiler সরল instruction ভালো ব্যবহার করতে শিখল — তখন microcode-এর এই সুবিধা কমে গেল (ভাবনার প্রশ্ন ৩ দেখুন)।

৮ · Microcode-এর ইতিহাস আর আজকের CPU — System/360 থেকে x86-এর update

আজকের x86-এ microcode. আধুনিক x86 প্রসেসর বেশিরভাগ সাধারণ instruction (যেমন add, mov) hardwired decoder দিয়ে সরাসরি কয়েকটি micro-op-এ ভাঙে, আর সেগুলো pipeline-এ চলে। কিন্তু জটিল বা কম ব্যবহৃত instruction — যেমন string-এর লম্বা copy, কিছু system instruction, বা অস্বাভাবিক ক্ষেত্রের সামলানো — একটি microcode ROM থেকে micro-op-এর দীর্ঘ ক্রম হিসেবে আসে। অর্থাৎ আজকের CPU-তে hardwired আর microcode পাশাপাশি থাকে: সাধারণ পথ দ্রুত, জটিল পথ নমনীয়।

Microcode update. Intel-এর ক্ষেত্রে মোটামুটি Pentium Pro-র যুগ থেকে (১৯৯০-এর দশকের মাঝামাঝি) প্রসেসরের microcode-এর একটি অংশ চালু হওয়ার সময় সংশোধন করা যায়; AMD-ও একই ধরনের ব্যবস্থা রাখে। সংশোধন আসে BIOS/UEFI-এর update-এ, অথবা operating system চালু হওয়ার সময় লোড করে (Windows Update বা Linux-এর microcode package). Update সাধারণত নির্মাতার digital signature দিয়ে যাচাই করা হয়, আর বন্ধ করলে মুছে যায় — প্রতিবার আবার লোড হয়। ২০১৮ সালে প্রকাশিত Spectre-এর একটি রূপের (শাখার লক্ষ্যে অনুমান) বিরুদ্ধে microcode update নতুন নিয়ন্ত্রণ-ব্যবস্থা যোগ করেছিল, যা operating system ব্যবহার করে branch predictor-এর প্রভাব সীমিত করে। Meltdown-এর প্রধান প্রতিরক্ষা অবশ্য ছিল operating system-এ (kernel-এর page table আলাদা রাখা, KPTI) আর পরের chip-এ hardware বদল — সব ত্রুটি microcode দিয়ে সারানো যায় না। এই আক্রমণগুলোর ধারণা আর প্রতিরক্ষা পর্ব ৪১-এ (Speculative execution আর নিরাপত্তা)।

কেন pipelining multi-cycle-কে সরিয়ে দিল। Multi-cycle-এ প্রতিটি cycle-এ hardware-এর বেশিরভাগ অংশ বসে থাকে: fetch-এর সময় register file অলস, MemRead-এর সময় ALU অলস। পর্ব ৩৫-এর (Pipelining) ভাবনা হলো: একই পাঁচ ধাপ রেখে প্রতিটি ধাপে আলাদা instruction রাখা — গার্মেন্টস কারখানার assembly line-এর মতো, যেখানে কেউ কাটে, কেউ সেলাই করে, কেউ ইস্ত্রি — সবাই একসাথে, ভিন্ন ভিন্ন শার্টে। তখন cycle time ছোট থাকে (multi-cycle-এর মতো) আর আদর্শ CPI প্রায় ১ (single-cycle-এর মতো)। দাম হলো আলাদা instruction ও data memory (বা cache) আবার ফিরে আসা, আর hazard সামলানো (পর্ব ৩৬). Multi-cycle-এর ধাপ-ভাগ, মাঝের register আর FSM-এ ভাবার অভ্যাস — সবই pipeline-এর সিঁড়ি।

৯ · AI-এর যুগে — FSM আর microcode AI দিয়ে, যাচাই simulation দিয়ে

“Multi-cycle RISC-V-এর control FSM দিন” বললে AI দ্রুত একটি টেবিল দেয়। কিন্তু এই বিষয়ে তার ভুলগুলো নির্দিষ্ট ধরনের:

• MIPS আর RISC-V মেশানো: RISC-V-এর নকশায় MIPS-এর opcode, j-এর ৩ cycle, বা PC + 4-এর পরে offset-কে ৪ দিয়ে গুণ আর PC + 4-এর সাথে যোগ করা (RISC-V-এ লক্ষ্য = instruction-এর নিজের ঠিকানা + offset).
• Cycle গোনায় ভুল: সব instruction-কে ৫ cycle ধরা, বা beq-কে ৪ বলা; mix-এর CPI-তে ভগ্নাংশ ১০০% না মেলা।
• Signal-এর ভুল সময়: lw-এর MemRead cycle-এই RegWrite চালু করা, বা BEQ state-এ ALUOut-কে লক্ষ্য হিসেবে ধরে আবার একই cycle-এ ALUOut-এ লক্ষ্য হিসাব করা।
• Single বনাম multi তুলনায় অন্ধ বিশ্বাস: “multi-cycle সবসময় দ্রুত” — অথচ ওপরের পরিস্থিতি A আর B-তে হারে।
• বানানো ইতিহাস ও specs: কোনো chip-এর control store-এর আকার, কোন মডেল hardwired ছিল, বা কোন microcode update কোন দুর্বলতা সারিয়েছে — আত্মবিশ্বাসী কিন্তু ভুল সংখ্যা।

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

• রীতি (বই, OldPC, jal-এর cycle) উত্তরের শুরুতেই স্পষ্ট, আর MIPS-এর কিছু ঢুকে পড়েনি
• প্রতিটি instruction-এর state-পথ অংশ ৪-এর diagram-এ আঙুল রেখে মিলিয়েছি, আর ভগ্নাংশগুলোর যোগফল ১
• CPI আর speedup নিজের হাতে বা অংশ ৫-এর calculator-এ আবার হিসাব করেছি
• একটি ছোট প্রোগ্রাম অংশ ৪-এর simulator-এ চালিয়ে cycle সংখ্যা মিলিয়েছি; সম্ভব হলে Verilog নকশা simulation-এ চালিয়েছি
• ইতিহাস ও chip-এর তথ্য পাঠ্যবই, নির্মাতার manual বা নির্ভরযোগ্য উৎসে মিলিয়েছি