Control unit — hardwired control আর control signal-এর টেবিল

১ · Control unit-এর কাজ — কোন সুইচ কখন চালু

পর্ব ৩২-এ single-cycle datapath জোড়া লাগিয়েছেন: PC, instruction memory, register file, immediate generator, ALU, data memory আর কয়েকটি multiplexer. সব তার সবসময় জোড়া থাকে, কিন্তু প্রতিটি instruction এই পথের আলাদা অংশ ব্যবহার করে। add দুটি register যোগ করে register-এ লেখে। lw ঠিকানা হিসাব করে memory থেকে পড়ে। sw memory-তে লেখে, কিন্তু কোনো register-এ নয়। beq কিছুই লেখে না, শুধু PC বদলাতে পারে।

কোন পথ কখন চালু থাকবে, তা বলে দেয় কয়েকটি তার — control signal. আর যে অংশ instruction দেখে এই তারগুলোয় 0 বা 1 বসায়, তার নাম control unit. এই পর্ব পুরোটাই সেই অংশ নিয়ে।

Control signal তিন রকম। (১) Mux-এর select: কোন ইনপুট সামনে যাবে — ALUSrc, MemtoReg, আর PC-র mux-এর PCSrc. (২) Write enable ও read enable: কোনো state (register বা memory) বদলাবে কি না — RegWrite, MemWrite, MemRead. (৩) ALU-র কাজের কোড: ALUOp, যা পরের স্তরে ALU control-কে যায়। নিচের টেবিলে প্রতিটি signal-এর অর্থ। নামগুলো Patterson–Hennessy-এর Computer Organization and Design-এর RISC-V সংস্করণের, এই কোর্সে যা অনুসরণ করা হচ্ছে।

অন্য বইয়ে নাম একটু আলাদা হতে পারে — যেমন Harris & Harris-এর RISC-V বইয়ে MemtoReg-এর জায়গায় ResultSrc, আর immediate-এর format বাছতে আলাদা ImmSrc signal. ধারণা একই। পুরোনো MIPS সংস্করণে আরও একটি signal ছিল, RegDst; পর্ব ২৭-এ দেখেছেন RISC-V-এ rd সবসময় একই জায়গায় থাকে বলে সেটি লাগে না।

২ · দুই স্তরের decoding — main control আর ALU control

Control unit-কে কী কী দেখতে হয়? opcode (৭ বিট), funct3 (৩ বিট), আর add/sub আলাদা করতে funct7 (৭ বিট)। মোট ১৭ বিট। সব একসাথে একটি টেবিলে দিলে সেই টেবিলে ২^১৭ = ১৩১০৭২টি সারি — ROM বানালে বিশাল, gate বানালে জটিল। তাই কাজটি দুই স্তরে ভাগ করা হয়:

• Main control: ইনপুট শুধু opcode. আউটপুট ছয়টি signal আর ২-বিটের ALUOp. ALUOp মোটা দাগে বলে ALU-কে কোন শ্রেণির কাজ করতে হবে।
• ALU control: ইনপুট ALUOp, inst[30] (funct7-এর একমাত্র দরকারি বিট) আর funct3 — মোট ৬ বিট, ২^৬ = ৬৪টি সমন্বয়। আউটপুট ৪-বিটের ALU operation, যা পর্ব ১৩-এর ALU সরাসরি বোঝে।

লাভ দুটি। প্রথমত, ছোট: main control-কে funct field দেখতে হয় না, ALU control-কে opcode দেখতে হয় না; দুটি ছোট টেবিলের মোট gate একটি বড় টেবিলের চেয়ে অনেক কম। দ্বিতীয়ত, দ্রুত হতে পারে: ছোট circuit-এ gate-এর স্তর কম, আর ALU control-কে ALU-র ঠিক পাশে বসানো যায়, যেখানে funct-এর বিট সরাসরি instruction থেকে আসে। Patterson–Hennessy-ও এই দুই যুক্তিই দেন — একাধিক ছোট control unit main control-এর আকার কমায়, আর গতিও বাড়াতে পারে। রান্নাঘরের ভাষায়: head chef শুধু বলেন “এটি গ্রিলের আইটেম”; মাঝারি না কড়া করে সেঁকা হবে, সেই খুঁটিনাটি গ্রিলের রাঁধুনি নিজেই স্লিপ থেকে পড়ে নেন।

৩ · Main control-এর পূর্ণ truth table — আর প্রতিটি X কেন নিরাপদ

এটিই সেই বিখ্যাত টেবিল, যা বিশ্ববিদ্যালয়, চাকরি বা ইন্টারভিউর পরীক্ষায় বারবার আসে। কলামের ক্রম বইয়ের মতো রাখা হলো। X মানে don't care — 0 বা 1 যেকোনোটি দিলেই instruction ঠিক চলবে।

প্রথম চার সারি বইয়ের টেবিলের মতো; addi আমরা যোগ করেছি। একটি ছোট পার্থক্য খেয়াল রাখুন: বইয়ের RISC-V সংস্করণ ৬৪-বিটের RV64 ধরে, তাই সেখানে ld/sd লেখা। এখানে RV32I-এর lw/sw. Opcode একই (0000011, 0100011), শুধু funct3 আলাদা, তাই control-এর সারিও হুবহু এক।

প্রতিটি সারি কেন এমন

• R-type: দুটি register-এর মান লাগে, তাই ALUSrc = 0. ফল ALU থেকে register-এ যায়: MemtoReg = 0, RegWrite = 1. Memory-র কাজ নেই। ALUOp = 10, কারণ কোন কাজ — যোগ, বিয়োগ, AND, OR — তা funct বলবে।
• lw: ঠিকানা = rs1 + imm, তাই ALUSrc = 1 আর ALUOp = 00 (যোগ)। Memory পড়া হয় (MemRead = 1), আর পড়া মান register-এ যায়: MemtoReg = 1, RegWrite = 1. পাঁচটি ইউনিটই কাজে লাগে বলে lw-ই single-cycle-এর সবচেয়ে লম্বা পথ, তাই clock-এর মাপ সাধারণত lw-এর পথ দিয়েই ঠিক হয়।
• sw: ঠিকানার হিসাব lw-এর মতোই (ALUSrc = 1, ALUOp = 00). MemWrite = 1, কিন্তু RegWrite = 0 — store কোনো register-এ কিছু ফেরত দেয় না।
• beq: দুটি register তুলনা করতে হবে, তাই ALUSrc = 0, ALUOp = 01 (বিয়োগ)। ফল ০ হলে ALU-র Zero = 1. Branch = 1; কিছু লেখা হয় না।
• addi: rs1 + imm, তাই ALUSrc = 1, ALUOp = 00. ফল ALU থেকে register-এ: MemtoReg = 0, RegWrite = 1.

X কেন নিরাপদ, আর কোথায় X চলবে না

sw আর beq-এ MemtoReg = X. কারণ সরল: MemtoReg শুধু ঠিক করে register-এ কোন মান লেখা হবে। কিন্তু এই দুই instruction-এ RegWrite = 0 — কিছুই লেখা হবে না। Mux যে মানই বাছুক, তা register file-এর দরজায় গিয়ে থেমে যায়। একে বলা যায় “বন্ধ দরজার সামনের পার্সেল”: দরজা না খুললে পার্সেলে কী আছে, তাতে কিছু আসে যায় না।

উল্টো দিকে, RegWrite, MemWrite আর Branch কখনো X হতে পারে না। এরা state বদলায়। sw-এ RegWrite = X লিখলে নকশাকার 1 বেছে নিতে পারেন, তখন sw-এর rd-field (যা আসলে immediate-এর নিচের ৫ বিট) নম্বরের register-এ আবর্জনা লেখা হবে। MemRead-ও সাধারণত X রাখা হয় না: অকারণে memory পড়লে শক্তি খরচ হয়, আর যে ঠিকানা আসলে কোনো I/O device-এর register (memory-mapped I/O), সেটি পড়লেই device-এর অবস্থা বদলে যেতে পারে। নিয়মটি এক লাইনে: যে signal শুধু পথ বাছে, তার ফল যদি কোথাও জমা না হয়, তবেই সেটি X হতে পারে।

নিচের ডায়াগ্রামে একটি আসল instruction word থেকে শুরু করে প্রতিটি signal কীভাবে আসে, ধাপে ধাপে দেখুন। সমীকরণগুলো অংশ ৫-এ K-map থেকে বের করা হবে; এখানে শুধু ব্যবহার।

0x0040A283
= 0000 0000 0100 0000 1010 0010 1000 0011
imm[11:0] = 000000000100 (= 4)
rs1 = 00001 (x1)   funct3 = 010   rd = 00101 (x5)
opcode = 0000011  (LOAD)

opcode = op6 op5 op4 op3 op2 op1 op0
       =  0   0   0   0   0   1   1
আমাদের পাঁচ instruction-এ শুধু op6, op5, op4 বদলায়
→ main control দেখে op6 op5 op4 = 000

RegWrite = op4 + op5′          = 0 + 1 = 1
ALUSrc   = op5′ + op6′·op4′    = 1 + 1 = 1
MemtoReg = op4′                = 1
MemRead  = op5′·op4′           = 1
MemWrite = op6′·op5·op4′       = 1·0·1 = 0
Branch   = op6                 = 0
ALUOp    = (op5·op4, op6)      = 00

ALUOp = 00 → funct দেখার দরকার নেই
ALU operation = 0010 (add)
সাবধান: funct3 = 010 R-type-এ হলে slt হতো!
ALUOp = 00 সেটিকে উপেক্ষা করায়

ALU      : x1 + 4 = 8 + 4 = 12   (ALUSrc = 1 → imm)
Memory   : MemRead = 1 → Mem[12] = 13
Write mux: MemtoReg = 1 → 13
Register : RegWrite = 1 → x5 ← 13
PC       : Branch = 0 → PCSrc = 0 → PC ← PC + 4

৪ · ALU control-এর truth table — ALUOp থেকে চার বিট

পর্ব ১৩-এর ALU চার বিটের একটি কোড বোঝে: Ainvert, Bnegate আর ২-বিটের Operation (00 AND, 01 OR, 10 adder, 11 slt). তাই 0010 = যোগ, 0110 = Bnegate চালু রেখে যোগ, অর্থাৎ বিয়োগ, 0000 = AND, 0001 = OR. এই কোড ISA-র অংশ নয় — নকশাকার নিজে ঠিক করেন। ALU control এই কোড বানায়:

এবার শুধু দরকারি ইনপুট রেখে টেবিলটি ছোট করা যাক। funct7-এর সাতটি বিটের মধ্যে এই চার R-type-এ শুধু inst[30] বদলায়; funct3 হলো inst[14:12]. আর ALUOp = 11 কখনো আসে না, তাই সেটি don't care:

ALUOp1 ALUOp0 │ I30 I14 I13 I12 │ Operation
  0      0    │  X   X   X   X  │ 0010   lw, sw, addi
  X      1    │  X   X   X   X  │ 0110   beq
  1      X    │  0   0   0   0  │ 0010   add
  1      X    │  1   0   0   0  │ 0110   sub
  1      X    │  0   1   1   1  │ 0000   and
  1      X    │  0   1   1   0  │ 0001   or

দ্বিতীয় সারিতে “X 1” কেন? ALUOp = 11 ঘটে না, তাই ALUOp0 = 1 দেখলেই বোঝা যায় এটি 01 — beq. তেমনি ALUOp1 = 1 মানেই 10. একই minimiser (অংশ ৫-এ যে কৌশল দেখবেন) দিয়ে এই টেবিল থেকে পাওয়া সবচেয়ে ছোট সমীকরণ:

Operation3 = 0
Operation2 = ALUOp0 + ALUOp1 · I30          (Bnegate: beq বা sub)
Operation1 = ALUOp1′ + I14′                 (adder বাছা: AND/OR ছাড়া সব)
Operation0 = ALUOp1 · I14 · I12′            (শুধু or: funct3 = 110)

প্রতিটির অর্থ সহজ। Bnegate দরকার বিয়োগে — beq-এ (ALUOp0 = 1) অথবা R-type-এ বিট ৩০ = 1 হলে। Adder (Operation1 = 1) দরকার ALUOp যখন 10 নয়, অথবা funct3-এর বিট ২ = 0 (add/sub-এর 000). আর OR আলাদা হয় AND (111) থেকে শুধু বিট ০-তে, add (000) থেকে বিট ২-তে — তাই I14 · I12′.

এবার sub-এর জন্য চারটি বিট হাতে বের করে দেখুন:

0x40208233
opcode = 0110011 → op6 op5 op4 = 011 (R-type)
ALUOp1 = op5·op4 = 1·1 = 1
ALUOp0 = op6     = 0
→ ALUOp = 10  ("funct দেখে ঠিক হবে")

0100 0000 0010 0000 1000 0010 0011 0011
 ↑ I30 = 1          ↑ I14 I13 I12 = 000
funct7 = 0100000, funct3 = 000

Operation3 = 0
Operation2 = ALUOp0 + ALUOp1·I30
           = 0 + 1·1 = 1   (Bnegate চালু)

Operation1 = ALUOp1′ + I14′ = 0 + 1 = 1   (adder)
Operation0 = ALUOp1·I14·I12′ = 1·0·1 = 0

sub : 0 1 1 0 = 0110 → A + B′ + 1 = 8 − 5 = 3
add : I30 = 0 → Operation2 = 0 → 0010
and : I14 = 1 → Operation1 = 0, I12 = 1 → 0000
শুধু একটি বিট (I30) add আর sub আলাদা করে

এখন দুই স্তর একসাথে চালিয়ে দেখুন। নিচের সিমুলেটর আটটি RV32I word নেয়, opcode, inst[30] আর funct3 বের করে, main control-এর টেবিল থেকে signal আর ALUOp ছাপে, ALU control-এর টেবিল থেকে ৪ বিট বের করে, আর সেই ফলকে উপরের gate-সমীকরণের সাথে মিলিয়ে দেখে। শেষ লাইনে addi-এর ফাঁদটিও যাচাই হয়। Word-গুলো একটি আলাদা Python encoder দিয়ে বানানো:

// Two-level control for a single-cycle RV32I subset: main control (opcode) -> ALUOp -> ALU control.
const MAIN = { // opcode: [type, ALUSrc, MemtoReg, RegWrite, MemRead, MemWrite, Branch, ALUOp]; X = don't care
  0x33: ["R-type", 0, 0, 1, 0, 0, 0, "10"], 0x13: ["addi", 1, 0, 1, 0, 0, 0, "00"],
  0x03: ["lw", 1, 1, 1, 1, 0, 0, "00"],     0x23: ["sw", 1, "X", 0, 0, 1, 0, "00"],
  0x63: ["beq", 0, "X", 0, 0, 0, 1, "01"] };
function aluControl(aluOp, i30, f3) {             // second level, straight from the ALU control table
  if (aluOp === "00") return "0010";              // lw, sw, addi: address / immediate add
  if (aluOp === "01") return "0110";              // beq: subtract, then look at Zero
  return { "0000": "0010", "1000": "0110", "0111": "0000", "0110": "0001" }[i30 + f3] ?? "????";
}
function aluGates(aluOp, i30, f3) {               // the same table as minimised gates
  const a1 = +aluOp[0], a0 = +aluOp[1], i14 = +f3[0], i12 = +f3[2];
  return "0" + (a0 | (a1 & i30)) + ((1 - a1) | (1 - i14)) + (a1 & i14 & (1 - i12));
}
const OP = { "0010": "add", "0110": "sub", "0000": "and", "0001": "or" };
const words = [0x002081B3, 0x40208233, 0x0020F433, 0x0020E3B3, 0x00800093, 0x0040A283, 0x0030A223, 0x00518463];
console.log("word       opcode  i30 f3  | type   AS M2R RW MR MW Br ALUOp | ALUctl op   gates");
for (const w of words) {
  const op = w & 0x7F, i30 = (w >>> 30) & 1, f3 = ((w >>> 12) & 7).toString(2).padStart(3, "0");
  const [type, ...s] = MAIN[op], aluOp = s[6], ctl = aluControl(aluOp, i30, f3), g = aluGates(aluOp, i30, f3);
  console.log(`${w.toString(16).toUpperCase().padStart(8, "0")}  ${op.toString(2).padStart(7, "0")}  ${i30}   ${f3} | ` +
    `${type.padEnd(6)} ${s.slice(0, 6).map((v, k) => String(v).padEnd(k === 1 ? 4 : 3)).join("")}${aluOp}    | ` +
    `${ctl}   ${OP[ctl].padEnd(4)} ${g === ctl ? "same" : "DIFF"}`);
}
const w = 0xC0030293;                             // addi x5, x6, -1024: inst[30] = 1 (an immediate bit!)
const f3 = ((w >>> 12) & 7).toString(2).padStart(3, "0"), i30 = (w >>> 30) & 1;
console.log(`addi x5,x6,-1024 (i30=${i30}): ALUOp=00 -> ${OP[aluControl("00", i30, f3)]},` +
  ` but if ALUOp were 10 -> ${OP[aluControl("10", i30, f3)]}`);

word       opcode  i30 f3  | type   AS M2R RW MR MW Br ALUOp | ALUctl op   gates
002081B3  0110011  0   000 | R-type 0  0   1  0  0  0  10    | 0010   add  same
40208233  0110011  1   000 | R-type 0  0   1  0  0  0  10    | 0110   sub  same
0020F433  0110011  0   111 | R-type 0  0   1  0  0  0  10    | 0000   and  same
0020E3B3  0110011  0   110 | R-type 0  0   1  0  0  0  10    | 0001   or   same
00800093  0010011  0   000 | addi   1  0   1  0  0  0  00    | 0010   add  same
0040A283  0000011  0   010 | lw     1  1   1  1  0  0  00    | 0010   add  same
0030A223  0100011  0   010 | sw     1  X   0  0  1  0  00    | 0010   add  same
00518463  1100011  0   000 | beq    0  X   0  0  0  1  01    | 0110   sub  same
addi x5,x6,-1024 (i30=1): ALUOp=00 -> add, but if ALUOp were 10 -> sub

৫ · Opcode-এর বিট থেকে সমীকরণ — K-map দিয়ে সরলীকরণ

টেবিল তো হলো; এখন এটিকে gate বানাতে হবে। প্রথমে পাঁচটি opcode বিট ধরে পাশাপাশি লিখুন:

instruction  op6 op5 op4 op3 op2 op1 op0
R-type        0   1   1   0   0   1   1
lw            0   0   0   0   0   1   1
sw            0   1   0   0   0   1   1
beq           1   1   0   0   0   1   1
addi          0   0   1   0   0   1   1

op3 থেকে op0 পাঁচটিতেই এক (0011), তাই আমাদের ছোট CPU-র জন্য এরা কোনো তথ্য দেয় না। বাকি থাকে তিনটি চলক — op6, op5, op4 — অর্থাৎ ৩-চলকের K-map (পর্ব ০৯)। আটটি ঘরের পাঁচটিতে আমাদের instruction; বাকি তিনটি (100, 101, 111) আমাদের CPU-তে কখনো আসবে না বলে ধরে নিই, তাই X. সারি op6, কলাম op5 op4 (Gray ক্রমে 00, 01, 11, 10):

            op5op4:  00     01     11     10
op6 = 0             lw     addi   R      sw
op6 = 1             (X)    (X)    (X)    beq

এবার প্রতিটি signal-এর জন্য ঘরগুলোয় তার মান বসিয়ে দল বানান। এখানে চারটি পুরো করে দেখানো হলো (নোটেশন: A′ মানে A-এর উল্টো; কোডে ~A বা 1 - A).

RegWrite    00 01 11 10        দল ১: কলাম 00,01 (1 1 X X) → op5′
op6 = 0      1  1  1  0        দল ২: কলাম 01,11 (1 1 X X) → op4
op6 = 1      X  X  X  0        RegWrite = op5′ + op4

ALUSrc      00 01 11 10        দল ১: কলাম 00,01 (1 1 X X) → op5′
op6 = 0      1  1  0  1        দল ২: সারি 0-এর 10 আর 00 (ঘুরে পাশাপাশি) → op6′·op4′
op6 = 1      X  X  X  0        ALUSrc = op5′ + op6′·op4′

MemtoReg    00 01 11 10        sw, beq-এর ঘরও X (অংশ ৩)
op6 = 0      1  0  0  X        দল: কলাম 00 আর 10, দুই সারি (1 X X X) → op4′
op6 = 1      X  X  X  X        MemtoReg = op4′

Branch      00 01 11 10        দল: পুরো দ্বিতীয় সারি (X X X 1) → op6
op6 = 0      0  0  0  0        Branch = op6
op6 = 1      X  X  X  1

লক্ষ করুন, X না থাকলে প্রতিটি সমীকরণ অনেক বড় হতো। যেমন Branch-এর জন্য তখন beq-এর পুরো minterm op6·op5·op4′ লাগত; X-এর কারণে মাত্র একটি literal, op6. MemtoReg-এ sw আর beq-এর X-ও কাজে লেগেছে: op4′ দলটি সেই দুই ঘরকে 1 ধরে নেয় — নিরাপদ, কারণ তখন RegWrite = 0. বাকি চারটি signal একইভাবে:

দুই কলামের তুলনাই এই অংশের বড় শিক্ষা। addi আসার আগে 001 ঘরটি X ছিল; addi এলে সেটি একটি নির্দিষ্ট মান পায়, আর যে সমীকরণ সেই X-এর ওপর নির্ভর করছিল, সেটি ভাঙে। যেমন ALUOp1 = op4 থাকলে addi-তেও ALUOp1 = 1 হতো — ঠিক উপরের সতর্কবার্তার ফাঁদ। তাই নতুন instruction যোগ করা মানে শুধু একটি সারি যোগ নয়; পুরোনো সব সমীকরণ আবার যাচাই করা।

হাতে K-map ছোট টেবিলে চলে, কিন্তু চলক বাড়লে যন্ত্র লাগে। নিচের minimiser পুরো ৭টি opcode বিট নেয়, টেবিলে নেই এমন সব opcode-কে don't care ধরে, আর প্রতিটি signal-এর জন্য সবচেয়ে ছোট SOP খোঁজে — প্রথমে সবচেয়ে কম product term, তারপর সবচেয়ে কম literal. কৌশলটি নিখুঁত খোঁজ: যে instruction-গুলোতে signal = 1, তাদের সম্ভাব্য সব দলে ভাগ করা; প্রতিটি দলের জন্য সেই বিটগুলোর সবচেয়ে ছোট উপসেট বাছা, যা 0-সারির সবগুলোকে বাদ দেয়। তারপর সমীকরণটিকে প্রতিটি instruction-এ চালিয়ে টেবিলের সাথে মেলায়:

// Minimal SOP for every main-control signal from opcode bits op6..op0; unused opcodes = don't care.
const INS = { R: "0110011", lw: "0000011", sw: "0100011", beq: "1100011", addi: "0010011" };
const SIG = { RegWrite: "11001", ALUSrc: "01101", MemtoReg: "01XX0", MemRead: "01000",  // R lw sw beq addi
  MemWrite: "00100", Branch: "00010", ALUOp1: "10000", ALUOp0: "00010" };                  // X = don't care
const names = Object.keys(INS), lit = (i, v) => "op" + (6 - i) + (v === "1" ? "" : "'");
function bestCube(block, off) {   // fewest literals among the bits on which the whole block agrees
  let best = null, fixed = [...Array(7).keys()].filter(i => block.every(m => m[i] === block[0][i]));
  for (let mask = 0; mask < 1 << fixed.length; mask++) {
    const keep = fixed.filter((_, j) => (mask >> j) & 1);   // the cube must exclude every 0-row
    if (off.every(o => keep.some(i => o[i] !== block[0][i])) && (!best || keep.length < best.length)) best = keep;
  }
  return best && best.map(i => lit(i, block[0][i]));
}
function* parts(a) {              // every way to split the 1-rows into groups (one product term each)
  if (!a.length) return yield [];
  for (const p of parts(a.slice(1))) {
    for (let i = 0; i < p.length; i++) yield p.map((b, j) => (j === i ? [a[0], ...b] : b));
    yield [[a[0]], ...p]; } }
function minimise(on, off) { let best = null, cost = t => t.length * 100 + t.flat().length; // terms, then literals
  for (const p of parts(on)) { const t = p.map(b => bestCube(b, off));
    if (!t.includes(null) && (!best || cost(t) < cost(best))) best = t; }
  return best;
}
const val = (t, m) => +t.some(c => c.every(l => (m[6 - +l[2]] === "1") === !l.endsWith("'")));
for (const set of [names.slice(0, 4), names]) {
  console.log(`-- ${set.join(", ")}   (columns: value given by the equation)`);
  for (const [sig, col] of Object.entries(SIG)) {
    const want = n => col[names.indexOf(n)], pick = v => set.filter(n => want(n) === v).map(n => INS[n]);
    const eq = minimise(pick("1"), pick("0")), got = set.map(n => val(eq, INS[n]));
    const ok = set.every((n, k) => want(n) === "X" || +want(n) === got[k]);
    console.log(`${sig.padEnd(8)} = ${eq.map(c => c.join("·")).join(" + ").padEnd(18)} ` +
      `${set.map((n, k) => n + ":" + (want(n) === "X" ? "X→" : "") + got[k]).join(" ").padEnd(36)} ${ok ? "ok" : "FAIL"}`);
  }
}

-- R, lw, sw, beq   (columns: value given by the equation)
RegWrite = op4 + op5'         R:1 lw:1 sw:0 beq:0                  ok
ALUSrc   = op6'·op4'          R:0 lw:1 sw:1 beq:0                  ok
MemtoReg = op5'               R:0 lw:1 sw:X→0 beq:X→0              ok
MemRead  = op5'               R:0 lw:1 sw:0 beq:0                  ok
MemWrite = op6'·op5·op4'      R:0 lw:0 sw:1 beq:0                  ok
Branch   = op6                R:0 lw:0 sw:0 beq:1                  ok
ALUOp1   = op4                R:1 lw:0 sw:0 beq:0                  ok
ALUOp0   = op6                R:0 lw:0 sw:0 beq:1                  ok
-- R, lw, sw, beq, addi   (columns: value given by the equation)
RegWrite = op4 + op5'         R:1 lw:1 sw:0 beq:0 addi:1           ok
ALUSrc   = op6'·op4' + op5'   R:0 lw:1 sw:1 beq:0 addi:1           ok
MemtoReg = op4'               R:0 lw:1 sw:X→1 beq:X→1 addi:0       ok
MemRead  = op5'·op4'          R:0 lw:1 sw:0 beq:0 addi:0           ok
MemWrite = op6'·op5·op4'      R:0 lw:0 sw:1 beq:0 addi:0           ok
Branch   = op6                R:0 lw:0 sw:0 beq:1 addi:0           ok
ALUOp1   = op5·op4            R:1 lw:0 sw:0 beq:0 addi:0           ok
ALUOp0   = op6                R:0 lw:0 sw:0 beq:1 addi:0           ok

৬ · Hardwired control-এর circuit — PLA বা দুই স্তরের AND–OR

সমীকরণগুলো সবই SOP, তাই সরাসরি দুই স্তরের logic-এ বসে: প্রথমে AND, তারপর OR. এমন নকশাকে বলে hardwired control — নিয়ন্ত্রণের নিয়ম তারের সংযোগেই গাঁথা। একে নিয়মিত আকারে বানানোর পুরোনো আর পরিচিত উপায় PLA: একটি AND-তল আর একটি OR-তল। আমাদের আটটি signal-এর জন্য আলাদা product term লাগে মাত্র আটটি:

ছবিতে তিনটি জিনিস খেয়াল করুন। প্রথমত, product term ভাগাভাগি হয়: P2 (op5′) RegWrite আর ALUSrc দুজনেই নেয়, P7 (op6) যায় Branch আর ALUOp0-তে। PLA-র সুবিধাই এটি — একটি AND-পদ একবার বানিয়ে যত output-এ খুশি জোড়া যায়। দ্বিতীয়ত, এক-literal-এর পদ (P1, P2, P4, P7) আসলে কোনো AND gate চায় না; বাস্তব নকশায় তারা সোজা তার, আর একটিমাত্র পদের output (M2R, MR, MW, Br, Op1, Op0)-এর OR gate-ও লাগে না। তৃতীয়ত, delay: inverter → AND → OR, মোটামুটি তিন gate-এর পথ। Single-cycle CPU-তে এই সময় register file পড়ার সাথে একসাথে চলে, তাই সাধারণত এটি critical path-এর বড় অংশ নয়; ALU control-এর দুই স্তর যোগ হলেও তা ALU-র নিজের delay-এর তুলনায় ছোট।

Verilog-এ (পর্ব ১৪) একই নকশা কয়েকটি assign-এ লেখা যায়। নিচেরটি উদাহরণ (এই পাতায় চালানো যায় না), synthesis-যোগ্য ধাঁচে লেখা:

// উদাহরণ: hardwired main control — RV32I subset (R-type, lw, sw, beq, addi)
module main_control (
    input  wire [6:0] opcode,
    output wire       RegWrite, ALUSrc, MemtoReg, MemRead, MemWrite, Branch,
    output wire [1:0] ALUOp
);
    wire o6 = opcode[6], o5 = opcode[5], o4 = opcode[4];
    assign RegWrite = o4 | ~o5;
    assign ALUSrc   = ~o5 | (~o6 & ~o4);
    assign MemtoReg = ~o4;
    assign MemRead  = ~o5 & ~o4;
    assign MemWrite = ~o6 & o5 & ~o4;
    assign Branch   = o6;
    assign ALUOp    = {o5 & o4, o6};
endmodule

শিল্পে সাধারণত উল্টো পথে লেখা হয়: পুরো ৭-বিট opcode-এর ওপর একটি case, প্রতিটি instruction-এর জন্য signal-এর সারি, আর default-এ সব write enable 0 (সাথে একটি illegal-instruction signal). তারপর synthesis tool নিজেই minimisation করে। এটি আসলে পর্ব ১২-এর decoder-এর ধারণা: প্রতিটি instruction-এর জন্য ৭ বিটের পূর্ণ AND (one-hot লাইন), তারপর OR. Gate একটু বেশি লাগে, কিন্তু অচেনা opcode কখনো ভুল করে কোনো signal চালু করে না। পাঠ্যবইয়ের পুরোনো MIPS সংস্করণের একটি পরিশিষ্টেও এভাবে প্রতিটি instruction-এর জন্য একটি AND-পদ রেখে PLA দেখানো হয়েছিল।

৭ · নতুন instruction যোগ করা — bne, jal, lui আর PCSrc

PCSrc = Branch · Zero

PC-র সামনের mux দুটি ঠিকানার একটি বাছে: PC + ৪, নাকি PC + imm (branch target). এর select, PCSrc, main control সরাসরি দেয় না — কারণ branch নেওয়া হবে কি না, তা জানা যায় ALU তুলনা শেষ করার পর। তাই main control শুধু বলে “এটি branch” (Branch = 1), আর একটি AND gate সেটিকে ALU-র Zero-র সাথে মেলায়:

PCSrc = Branch · Zero
beq x3, x5, 8 : ALU = x3 − x5;  সমান হলে Zero = 1 → PCSrc = 1 → PC ← PC + 8

bne — নতুন opcode নয়, তাই main control-এর নতুন সারিও নয়

পরীক্ষায় খুব চেনা প্রশ্ন: “datapath-এ bne যোগ করতে কী বদলাবেন?” প্রথম পর্যবেক্ষণ — bne-এর opcode beq-এর মতোই 1100011; পার্থক্য শুধু funct3-এ (beq 000, bne 001). Main control শুধু opcode দেখে, তাই সে দুটিকে আলাদা করতেই পারে না: দুটির জন্যই ALUSrc = 0, ALUOp = 01, Branch = 1. পরিবর্তন লাগে branch-এর শর্তে। দুটি সমান বৈধ উপায়:

উপায় ১ (funct3 দিয়ে উল্টানো):
    PCSrc = Branch · (Zero ⊕ funct3[0])
    beq: funct3[0] = 0 → Zero        bne: funct3[0] = 1 → Zero′

উপায় ২ (আলাদা signal):
    decoder funct3 দেখে Branch আর BranchNE আলাদা করে
    PCSrc = Branch · Zero  +  BranchNE · Zero′

প্রথমটিতে একটি XOR gate যোগ হলো, main control একেবারে অপরিবর্তিত। blt, bge-এর জন্য Zero যথেষ্ট নয় — ফলের চিহ্ন আর overflow লাগে (পর্ব ১৩-এর slt-এর যুক্তি), তাই সেখানে ALU থেকে আরও একটি flag বা একটি আলাদা comparator লাগে।

jal আর lui — নতুন পথ, নতুন signal

jal rd, offset দুটি কাজ করে: PC ← PC + imm (সবসময়, কোনো শর্ত নেই), আর rd ← PC + ৪. Datapath-এ branch-এর adder আগে থেকেই PC + imm বানায়, তবে immediate generator-কে J-format চিনতে হবে। নতুন যা লাগে: (১) একটি Jump signal, আর PCSrc = Branch · Zero + Jump; (২) register-এ লেখার mux-এ তৃতীয় ইনপুট PC + ৪, তাই MemtoReg দুই বিটের হয় (00 = ALU, 01 = memory, 10 = PC + ৪)। jalr-এর লক্ষ্য rs1 + imm, যা ALU-র ফল — তাই PC-র mux-এ আরও একটি ইনপুট লাগে।

lui rd, imm rd-তে লেখে imm << ১২. এর বিট ১৯..১৫ immediate-এর অংশ, তাই “rs1 = x0 ধরে যোগ” ভরসা করা যায় না — register file সেখানে যে register-ই পড়ুক, তা আসল x0 না-ও হতে পারে। একটি সহজ সমাধান: ALU-র প্রথম ইনপুটে একটি নতুন mux (ALUSrcA: 0 = rs1, 1 = শূন্য), তারপর ALUSrc = 1, ALUOp = 00 — ফল ০ + imm. (একই mux-এ PC ইনপুট যোগ করলে auipc-ও হয়ে যায়।) সব মিলিয়ে বাড়ানো টেবিল:

jal-এ ALUSrc, ALUSrcA আর ALUOp X, কারণ ALU-র ফল কোথাও যায় না: লেখা হয় PC + ৪, লাফ দেয় branch adder. এবার সমীকরণে কী ভাঙে, দেখুন। jal-এর op6..op4 = 110 — beq-এর সাথে হুবহু এক! পুরোনো Branch = op6 তাই jal-এও Branch = 1 দিত। পার্থক্য op3-এ (beq 0, jal 1), তাই Branch = op6·op3′, আর Jump = op3. তেমনি lui-এর op6..op4 = 011, R-type-এর সমান; পার্থক্য op2-এ। তাই ALUOp1 = op5·op4 থেকে হয় op5·op4·op2′, আর ALUSrcA = op2. একই minimiser দিয়ে সাত instruction-এর পূর্ণ সমাধান যাচাই করা হয়েছে: RegWrite = op4 + op5′ + op2, ALUSrc = op6′·op4′ + op5′ + op2, MemtoReg[1] = op6, MemtoReg[0] = op6′·op4′, Branch = op6·op3′, Jump = op3. যে বিট আগে “অকেজো” ছিল, নতুন instruction-এ সেটিই সিদ্ধান্ত নেয়।

৮ · Stuck-at fault — একটি control তার আটকে গেলে

কারখানায় chip বানানোর সময় কোনো তার মাটির সাথে লেগে যেতে পারে (সবসময় 0), বা সরবরাহের সাথে (সবসময় 1). পরীক্ষার জন্য এই ত্রুটিকে সরল একটি মডেলে ভাবা হয়: stuck-at fault — তারটি “stuck-at-0” বা “stuck-at-1”. Control-এর তারে এমন ত্রুটি হলে কোন instruction ভুল করবে, তা টেবিল দেখেই বলা যায়: যেসব instruction-এ ওই signal-এর দরকারি মান আটকে থাকা মানের উল্টো, শুধু তারাই ভাঙে; যেখানে signal-টি X, সেখানে কিছু হয় না।

শেষ সারিটি সূক্ষ্ম: Branch stuck-at-1 সব instruction ভাঙে না, শুধু যার ALU-র ফল কাকতালীয়ভাবে ০. পরীক্ষার প্রশ্নে এই “শর্তসাপেক্ষ” উত্তরই সবচেয়ে বেশি নম্বর পায়। এবার MemtoReg stuck-at-0 একটি ছোট প্রোগ্রামে ধাপে ধাপে দেখুন:

addi x1, x0, 8     → x1 = 8
addi x2, x0, 5     → x2 = 5
add  x3, x1, x2    → x3 = 13
sw   x3, 4(x1)     → Mem[12] = 13
এবার চলবে: lw x5, 4(x1)

             AS  M2R  RW  MR  MW  Br  ALUOp
হওয়ার কথা :  1   1    1   1   0   0   00
ত্রুটিসহ   :  1   0    1   1   0   0   00
শুধু MemtoReg বদলেছে — তার মাটিতে লেগে আছে

ALU    : x1 + 4 = 12
Memory : MemRead = 1 → Mem[12] = 13 পড়া হলো
এখন পর্যন্ত কোনো ভুল নেই

mux-এর ইনপুট: 0 → ALU-র ফল = 12
              1 → memory     = 13
MemtoReg = 0 → বাছা হলো 12
x5 ← 12   (ঠিক উত্তর 13)

beq  x3, x5, 8   : 13 − 12 ≠ 0 → Zero = 0 → নেওয়া হয় না
addi x6, x0, 1   : চলে যায় → x6 = 1 (হওয়ার কথা 0)
শেষে: x5 = 12, x6 = 1; বাকি সব ঠিক

MemtoReg = 1 লাগে শুধু lw-এ
R-type, addi: দরকার 0 → ঠিক
sw, beq     : X       → ঠিক
→ ভাঙে শুধু lw
টেস্ট: lw দিয়ে এমন মান আনুন যা ঠিকানার সমান নয়

নিচের প্রোগ্রাম এই বিশ্লেষণ যন্ত্রে করে। এটি একটি সরল single-cycle মডেল: control আসে অংশ ৫-এর সমীকরণ থেকে (তাই X-এর জায়গায় chip-এ যে মান থাকত, সেটিই), immediate generator opcode দেখে format বাছে, আর memory পড়া বন্ধ থাকলে output ধরা হয় ০ (আসল hardware-এ সেটি অনির্ধারিত)। প্রথমে ত্রুটিহীন অবস্থায় দশ instruction-এর প্রোগ্রামটি চলে; তারপর প্রতিটি ত্রুটির জন্য দুটি জিনিস ছাপা হয় — (১) ঠিক একই আগের অবস্থা থেকে কোন কোন instruction-এর ফল (register, memory বা পরের PC) আলাদা হয়, (২) ত্রুটি নিয়ে পুরো প্রোগ্রাম চালালে শেষ অবস্থা কী:

// Single-cycle RV32I subset with one control line stuck at 0 or 1: which instructions go wrong?
const PROG = [0x00800093, 0x00500113, 0x002081B3, 0x40208233, 0x0030A223,
              0x0040A283, 0x00518463, 0x00100313, 0x0020E3B3, 0x0020F433];
const NAME = ["addi", "addi", "add", "sub", "sw", "lw", "beq", "addi", "or", "and"];
const bit = (w, n) => (w >>> n) & 1, nt = x => 1 - x;
function control(op) {                          // hardwired equations from the K-maps (op6, op5, op4)
  const o6 = bit(op, 6), o5 = bit(op, 5), o4 = bit(op, 4);
  return { RegWrite: o4 | nt(o5), ALUSrc: nt(o5) | (nt(o6) & nt(o4)), MemtoReg: nt(o4),
    MemRead: nt(o5) & nt(o4), MemWrite: nt(o6) & o5 & nt(o4), Branch: o6, ALUOp: (o5 & o4) * 2 + o6 };
}
const immGen = w => (w & 0x7F) === 0x23 ? ((w >> 25) << 5) | ((w >>> 7) & 31)              // S
  : (w & 0x7F) === 0x63 ? ((w >> 31) << 12) | (bit(w, 7) << 11) | (((w >>> 25) & 63) << 5)
                          | (((w >>> 8) & 15) << 1) : w >> 20;                               // B : I
const aluCtl = (op, w) => ((op & 1) | ((op >> 1) & bit(w, 30))) << 2 | (nt(op >> 1) | nt(bit(w, 14))) << 1
                          | ((op >> 1) & bit(w, 14) & nt(bit(w, 12)));
const ALU = { 2: (a, b) => a + b, 6: (a, b) => a - b, 0: (a, b) => a & b, 1: (a, b) => a | b };
function step([pc, reg, mem], fault) {          // one clock cycle of the single-cycle datapath
  const w = PROG[pc / 4], c = { ...control(w & 0x7F), ...fault }, r = [...reg], m = { ...mem };
  const rd = (w >>> 7) & 31, a = reg[(w >>> 15) & 31], b2 = reg[(w >>> 20) & 31];
  const res = ALU[aluCtl(c.ALUOp, w)](a, c.ALUSrc ? immGen(w) : b2) | 0;
  const data = c.MemRead ? (mem[res] ?? 0) : 0;  // model: memory outputs 0 when MemRead = 0
  if (c.MemWrite) m[res] = b2;
  if (c.RegWrite && rd) r[rd] = c.MemtoReg ? data : res;
  return [c.Branch && res === 0 ? pc + immGen(w) : pc + 4, r, m];
}
function run(f) { let s = [0, Array(32).fill(0), {}]; const t = [s];
  while (s[0] % 4 === 0 && s[0] / 4 < PROG.length && t.length < 40) t.push(s = step(s, f)); return t; }
const same = (x, y) => JSON.stringify(x) === JSON.stringify(y), gold = run({});
const show = s => "x1..x8=" + s[1].slice(1, 9).join(",") + " mem=" + JSON.stringify(s[2]) + " pc=" + s[0];
console.log("no fault         : " + show(gold.at(-1)));
for (const f of [{ RegWrite: 0 }, { RegWrite: 1 }, { ALUSrc: 1 }, { ALUSrc: 0 }, { MemtoReg: 0 },
                 { MemtoReg: 1 }, { Branch: 0 }, { Branch: 1 }, { MemWrite: 1 }]) {
  const bad = gold.slice(0, -1).filter(s => !same(step(s, f), step(s, {}))).map(s => NAME[s[0] / 4] + "@" + s[0]);
  console.log(`${Object.entries(f)[0].join(" stuck ").padEnd(17)}: wrong = ${bad.join(" ")}\n${"".padEnd(19)}${show(run(f).at(-1))}`);
}

no fault         : x1..x8=8,5,13,3,13,0,13,0 mem={"12":13} pc=40
RegWrite stuck 0 : wrong = addi@0 addi@4 add@8 sub@12 lw@20 or@32
                   x1..x8=0,0,0,0,0,0,0,0 mem={"4":0} pc=40
RegWrite stuck 1 : wrong = sw@16
                   x1..x8=8,5,13,0,13,0,13,0 mem={"12":13} pc=40
ALUSrc stuck 1   : wrong = add@8 sub@12 beq@24 or@32
                   x1..x8=8,5,10,-1018,10,1,10,0 mem={"12":10} pc=40
ALUSrc stuck 0   : wrong = addi@0 addi@4 sw@16 lw@20
                   x1..x8=0,0,0,0,0,0,0,0 mem={"0":0} pc=40
MemtoReg stuck 0 : wrong = lw@20
                   x1..x8=8,5,13,3,12,1,13,0 mem={"12":13} pc=40
MemtoReg stuck 1 : wrong = addi@0 addi@4 add@8 sub@12 or@32
                   x1..x8=0,0,0,0,0,0,0,0 mem={"4":0} pc=40
Branch stuck 0   : wrong = beq@24
                   x1..x8=8,5,13,3,13,1,13,0 mem={"12":13} pc=40
Branch stuck 1   : wrong = and@36
                   x1..x8=8,5,13,3,13,0,13,0 mem={"12":13} pc=38
MemWrite stuck 1 : wrong = addi@0 addi@4 add@8 sub@12 lw@20 beq@24 or@32 and@36
                   x1..x8=8,5,13,3,13,0,13,0 mem={"0":5,"3":5,"5":0,"8":0,"12":3,"13":5} pc=40

৯ · Hardwired বনাম microprogrammed control — আর বাস্তব প্রসেসর

আমাদের control একটি gate-এর জাল। অন্য পথ হলো microprogrammed control: প্রতিটি instruction-এর জন্য control signal-এর একটি ক্রম একটি ছোট ROM-এ (microcode) লেখা থাকে, আর একটি ছোট sequencer প্রতি cycle-এ ROM থেকে পরের সারি পড়ে। ধারণাটি Maurice Wilkes ১৯৫১ সালে প্রস্তাব করেন। Multi-cycle datapath-এ এর পুরো রূপ দেখবেন পর্ব ৩৪-এ; এখানে শুধু তুলনা:

১৯৬০-৭০-এর দশকে memory ছিল ধীর, আর CPU-র ভেতরের ROM তুলনায় দ্রুত; তাই microcode দিয়ে শক্তিশালী, জটিল instruction বানানো লাভজনক ছিল। ১৯৭০-এর দশকের শেষ থেকে ১৯৮০-এর দশকে RISC আন্দোলন (IBM 801, Berkeley RISC, Stanford MIPS) যুক্তি দেয়: compiler জটিল instruction খুব কমই ব্যবহার করে, সরল instruction-কে hardwired control-এ এক cycle-এ চালানোই ভালো, আর তাতে pipelining (পর্ব ৩৫) সহজ হয়।

আজকের x86 CPU দুটিকেই মেশায় — বিস্তারিত সংস্থা প্রতিটি প্রজন্মে বদলায়, তাই এখানে মোটা দাগে বলা হলো। Decoder সাধারণ instruction-কে সরাসরি এক বা কয়েকটি micro-op-এ ভাঙে (hardwired ধাঁচে); কয়েকটি micro-op-এর বেশি লাগে এমন জটিল বা বিরল instruction (যেমন string-এর কিছু কাজ, কিছু system instruction) একটি microcode ROM থেকে micro-op-এর ক্রম আনে। Intel আর AMD BIOS/UEFI বা operating system-এর মাধ্যমে microcode update দেয়, যা দিয়ে কিছু bug আর নিরাপত্তা-সমস্যার প্রশমন পাঠানো হয়েছে। Micro-op কীভাবে superscalar আর out-of-order core-এ চলে, তা পর্ব ৩৯ আর পর্ব ৪০-এ।

১০ · AI-এর যুগে — control টেবিলের দাবি যাচাই

Control টেবিল দেখতে সরল, তাই AI-এর উত্তর প্রায়ই আত্মবিশ্বাসী আর সুন্দর — কিন্তু একটি ঘর ভুল হলেই CPU ভুল চলে। বিশেষ করে MIPS আর RISC-V-এর বই দুটি এত কাছাকাছি যে AI প্রায়ই দুটি মিশিয়ে ফেলে। সুখবর: এখানে সবকিছু যন্ত্রে যাচাই করা যায়।

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

• opcode-গুলো RISC-V-এর (0110011, 0000011, 0100011, 1100011, 0010011), MIPS-এর নয়
• কোনো write enable (RegWrite, MemWrite) বা Branch-এ X নেই
• প্রতিটি সমীকরণ পাঁচটি instruction-এ বসিয়ে হাতে বা স্ক্রিপ্টে টেবিলের সাথে মিলিয়েছি
• ALU control-এর কোড পর্ব ১৩-এর ALU-র সাথে মেলে (0010 add, 0110 sub, 0000 AND, 0001 OR)
• সম্ভব হলে Verilog-এ লিখে testbench বা simulator-এ প্রতিটি instruction চালিয়ে দেখেছি