Fetch-Decode-Execute Cycle — a = b + c সিলিকনে ঠিক কী ঘটায়

FETCH — PC থেকে IR পর্যন্ত

PC (Program Counter)-কে registers-pc-flags লেসনে ISA-স্তরে পরিচয় করানো হয়েছিল, আর Level ২-র registers-and-register-files লেসনে স্পষ্ট করা হয়েছিল — PC সাধারণত register file-এর বাইরে, একটা dedicated register। FETCH স্টেজে এই fact-টাই কাজে লাগে:

১. PC-র বর্তমান মান (আমাদের উদাহরণে, প্রথমবার 0x1000) instruction memory-র address input-এ পাঠানো হয়। 2. Instruction memory — গঠনগতভাবে হুবহু Level ২-র memory-sram-dram লেসনের array (row decoder + column mux দিয়ে addressed SRAM/DRAM, কিন্তু এখানে instruction সংরক্ষণ করছে, ডেটা না) — সেই address-এ যা আছে তা output করে: 0xFF842303। 3. এই ৩২ বিট Instruction Register (IR)-এ latch হয় — ঠিক Level ২-র toy CPU-তে যা “বাইরে থেকে এসে হাজির হয়” ধরে নেওয়া হয়েছিল, এখন সেই “বাইরে থেকে আসা”-র প্রকৃত উৎস ব্যাখ্যা করা হলো। 4. PC ← PC + 4। পরের instruction-এর ঠিকানা প্রস্তুত হয়ে যায়, পরের FETCH-এর জন্য।

        ┌─────────┐
        │   PC     │──────────────┐
        │(register)│              │  address
        └────┬────┘               ▼
             │             ┌──────────────────┐
             │             │ Instruction       │
             │             │ Memory            │
             │             │ (SRAM/DRAM array) │
             │             └─────────┬──────────┘
             │                       │ data out (32 bit)
             │                       ▼
             │                 ┌──────────┐
             │                 │    IR    │
             │                 └──────────┘
             ▼
        ┌─────────┐
        │  + 4     │  (ALU বা dedicated adder)
        └────┬────┘
             │
             ▼
       নতুন PC মান (পরের clock edge-এ latch হবে)

DECODE — বিট থেকে অর্থ, আর সমান্তরাল register read

IR-এ এখন 0xFF842303 (আমাদের প্রথম instruction, lw t1, -8(s0))। DECODE স্টেজে দুইটা জিনিস সমান্তরালে ঘটে — instruction-encoding লেসনের সবচেয়ে গুরুত্বপূর্ণ insight-এর সরাসরি প্রয়োগ:

পথ ১ — Control unit। opcode = IR[6:0] = 0000011 পড়ে বোঝে এটা একটা LOAD (I-type)। funct3 = IR[14:12] = 010 পড়ে বোঝে এটা LW (word-size load, LB/LH না)। এই তথ্য থেকে control signal তৈরি হয়:

পথ ২ — Register file read, একই সাথে। rs1 = IR[19:15] = 01000 (x8=s0) — instruction-encoding লেসনের ফিক্সড-পজিশন যুক্তি অনুযায়ী, এই read register file-এ তাৎক্ষণিকভাবে পাঠানো যায়, control unit এখনো opcode বিশ্লেষণ শেষ করার জন্য অপেক্ষা না করেই — কারণ rs1 সবসময় [19:15]-এ, format যাই হোক। Register file s0-এর মান আউটপুট করে দেয়।

Immediate generation — একটা তৃতীয়, ছোট সমান্তরাল কাজ। IR-এর [31:20] বিট (I-type immediate) sign-extend হয়ে -8 তৈরি হয়। এই ছোট circuit-টাই instruction-encoding লেসনের B/J-type immediate “স্ক্র্যাম্বলিং” আলোচনার কারণ ছিল — format ভেদে কোন বিট থেকে immediate বানাতে হবে তা এই circuit-ই ঠিক করে (এখানে সহজ, কারণ I-type-এ immediate একটানা এক জায়গায়)।

EXECUTE — যেখানে ALU আসল কাজ করে

এখন ALU (Level ২-র alu-design লেসনের সেই ALU, হুবহু একই সার্কিট, কোনো পরিবর্তন ছাড়া) কাজ করে। ইনপুট: A = register file-থেকে-পড়া rs1-এর মান, B = ALUSrc mux-এর আউটপুট (register rs2 অথবা sign-extended immediate), ALUOp = control unit-থেকে।

Instruction ১ (lw t1, -8(s0)): A = s0-এর মান, B = -8 (immediate, ALUSrc=1), ALUOp = ADD। ALU গণনা করে effective address = s0 - 8 — এইটাই addressing-modes লেসনের base+displacement গণনা, এখন সত্যিই একটা ALU-তে ঘটছে।

Instruction ৩ (add t3, t1, t2): A = t1-এর মান (= 7, ধরুন আগের দুই load-এর পর), B = t2-এর মান (= 35, ALUSrc=0, register থেকে সরাসরি), ALUOp = ADD। ALU গণনা করে 7 + 35 = 42।

এই মুহূর্তটাই এই পুরো মডিউলের payoff — b + c-এর প্রকৃত যোগফল, 42, এই ALU-র ভেতরে, সেই একই ripple-carry adder circuit-এ (Level ২-র combinational-adders লেসন) গণনা হচ্ছে যা আমরা transistor থেকে শুরু করে হাতে বানিয়েছিলাম।

MEMORY — শুধু যখন প্রয়োজন

Instruction ১, ২ (lw): MemRead=1। ALU-র গণনা করা ঠিকানা (s0-8, তারপর s0-12) data memory-র address input-এ যায় — ঠিক Level ২-র memory-sram-dram লেসনের সেই একই মেকানিজম (address → row decoder → column mux → data out), শুধু এবার instruction memory না, data memory। আউটপুট MDR (Memory Data Register)-এ latch হয়: MDR ← 7 (instruction ১), তারপর MDR ← 35 (instruction ২)।

Instruction ৩ (add): MemRead=0, MemWrite=0 — এই স্টেজে data memory-র সাথে কোনো যোগাযোগ হয় না। ALU-র ফলাফল (42) শুধু পরের স্টেজে এগিয়ে যায়।

Instruction ৪ (sw): MemWrite=1। ALU-র গণনা করা ঠিকানা (s0-4) data memory-র address-এ যায়, আর t3-এর মান (42, রেজিস্টার file থেকে সরাসরি পড়া, দ্বিতীয় read port দিয়ে) সেই ঠিকানায় লেখা হয়।

WRITEBACK — ফলাফল ফিরে আসে register file-এ

Instruction ১, ২: RegWrite=1, MemToReg=1 — MDR-এর মান (memory থেকে পড়া) register file-এর write port দিয়ে লেখা হয়: t1 ← 7, তারপর t2 ← 35। Write address আসে IR[11:7]-থেকে (rd ফিল্ড) — আবার সেই ফিক্সড-পজিশন সুবিধা, যেকোনো instruction format-এই rd একই জায়গায়।

Instruction ৩: RegWrite=1, MemToReg=0 — এবার MDR না, বরং ALU-র ফলাফল সরাসরি (42) লেখা হয়: t3 ← 42।

Instruction ৪ (sw): RegWrite=0 — S-type instruction-এর কোনো destination register নেই (instruction-encoding লেসনের S-type ফরম্যাট মনে করুন — rd ফিল্ডই নেই সেখানে), তাই writeback স্টেজে কিছুই লেখা হয় না register file-এ। (Data memory-তে লেখা ইতিমধ্যে MEMORY স্টেজেই ঘটে গেছে।)

   PC ──► Instruction Memory ──► IR = 0x00730E33
                                    │
                    ┌───────────────┼────────────────┐
                    ▼               ▼                 ▼
              opcode[6:0]     rs1[19:15]=t1(6)   rs2[24:20]=t2(7)
                    │               │                 │
                    ▼               ▼                 ▼
             Control Unit    Register File       Register File
           RegWrite=1              read t1            read t2
           MemRead=0,Write=0        (=7)               (=35)
           ALUSrc=0, MemToReg=0        │                 │
                    │                  └────────┬────────┘
                    │                            ▼
                    │                    ┌───────────────┐
                    │                    │      ALU        │  ◄── ALUOp=ADD
                    │                    │   7 + 35 = 42    │      (alu-design লেসন)
                    │                    └───────┬───────────┘
                    │                            │
                    │                    MEMORY স্টেজ — কিছুই হয় না
                    │                            │
                    │                            ▼
                    │                    MemToReg mux → ALU result (42)
                    │                            │
                    └────────────► rd = IR[11:7] = t3(28)
                                                 │
                                                 ▼
                                   Register File write port: t3 ← 42

Cycle পুনরাবৃত্তি — CPU-র heartbeat

Instruction ৪-এর WRITEBACK (বা MEMORY, যেহেতু store-এ writeback নেই) শেষ হলে, পরের clock edge-এ PC (যা FETCH স্টেজেই ইতিমধ্যে 0x1010-এ আপডেট হয়ে গেছে, প্রতিটা instruction fetch-এর সাথে সাথেই) instruction memory-কে আবার address করে — এবার a=b+c-এর পরের লাইনের instruction। এই FETCH → DECODE → EXECUTE → MEMORY → WRITEBACK → FETCH → … লুপ কখনো থামে না, যতক্ষণ প্রোগ্রাম চলছে (বা halt/ecall exit-এর মতো বিশেষ instruction না আসছে)।

যদি পরের instruction একটা branch হতো — PCSrc mux আর Zero flag

আমাদের চার-instruction sequence-এ কোনো branch নেই, কিন্তু ধরুন a = b + c-এর ঠিক পরে সোর্স কোডে থাকত if (a == 0) goto skip; — compiler এটাকে (addressing-modes লেসনের PC-relative আলোচনার সেই পরিচিত instruction-টাই) এভাবে এনকোড করত:

beq  t3, zero, offset     # 0x00730463-এর মতোই একটা B-type, t3-কে zero-এর সাথে তুলনা

এই instruction একই পাঁচ-স্টেজ কাঠামো পার হয়, শুধু EXECUTE আর তার পরের অংশ একটু ভিন্নভাবে কাজ করে:

EXECUTE-এ দুইটা জিনিস একসাথে ঘটে। ALU দুইটা ভিন্ন গণনা করে সমান্তরালে (Level ২-র alu-design লেসনে “সবগুলো sub-unit সবসময় চলে” নীতির আরেকটা প্রয়োগ) —

১. t3 - zero (বিয়োগ, শুধু Zero flag বের করার জন্য — ফলাফল নিজে ফেলে দেওয়া হয়) — t3 == 0 কি না জানতে alu-design লেসনের সেই flag generation সার্কিট ব্যবহার হয়, কোনো আলাদা “compare circuit” ছাড়াই। 2. PC + offset — effective address, addressing-modes লেসনের PC-relative গণনা, প্রতিটা branch-এ সবসময় গণনা হয়ে যায়, শর্ত সত্য হোক বা না হোক (আগের লেসনের Callout মনে করুন)।

একটা নতুন control signal — PCSrc। DECODE স্টেজে control unit opcode=1100011 (BRANCH) দেখে একটা নতুন সংকেত সক্রিয় করে যা বলে “এই instruction-এর ফলাফল অনুযায়ী PC-এর পরবর্তী মান নির্ভর করবে Zero flag-এর উপর।” WRITEBACK স্টেজের বদলে (branch-এ কোনো register লেখা হয় না, RegWrite=0), একটা ছোট MUX পরের PC নির্বাচন করে:

PCSrc = Branch_signal AND Zero_flag
পরের PC = PCSrc ? (PC + offset) : (PC + 4)

      PC + 4 (স্বাভাবিক পরের ঠিকানা)
           │
           ▼
      ┌─────────┐
      │  MUX     │◄── select = PCSrc = (Branch signal) AND (Zero flag)
      └────┬────┘
           │
      PC + offset (branch taken)
           │
           ▼
      পরের clock edge-এ PC-তে latch হবে

সম্পূর্ণ single-cycle datapath — সব টুকরো এক ডায়াগ্রামে

এতক্ষণ প্রতিটা স্টেজ আলাদা করে দেখানো হয়েছে। এখানে সবগুলো একসাথে — এই লেসনের চার-instruction sequence-এর যেকোনো একটা (lw, add, বা sw) এই একটামাত্র datapath দিয়েই চলে, শুধু control signal ভিন্ন হয়। এটাই Level ২-র datapath-and-control-unit লেসনের toy datapath-এর হুবহু বড়-ভাই সংস্করণ — একই “component-গুলো bus দিয়ে জোড়া, control unit উপরে বসে সিদ্ধান্ত নেয়” নীতি, শুধু toy ৩-instruction ISA-র বদলে RV32I।

                                    ┌─────────┐
                              ┌────►│  +4      │──┐
                              │      └─────────┘   │      ┌────────┐
                        ┌─────┴───┐                ├─────►│  MUX    │──┐
                        │   PC    │                │      │(PCSrc) │  │
                        └─────┬───┘                │      └────────┘  │
                              │            ┌────────┘           ▲     │
                              │            │ PC + branch offset  │     │
                              ▼            │ (addressing-modes    │     │
                     ┌──────────────┐      │  লেসন, PC-relative)  │     │
                     │ Instruction   │      │                     │     │
                     │ Memory        │      │                     │     │
                     └──────┬───────┘      │                     │     │
                            │ IR (32 bit)  │                     │     │
        ┌───────────────────┼──────────────┴─────────────┐       │     │
        ▼                   ▼                             ▼       │     │
   opcode[6:0]        rs1[19:15]                    rs2[24:20]    │     │
   funct3[14:12]            │                             │       │     │
   funct7[31:25]            ▼                             ▼       │     │
        │             ┌──────────────────────────────────────┐   │     │
        ▼             │         Register File (rs1,rs2 read)   │   │     │
  ┌──────────┐         │           rd = IR[11:7] (write)         │   │     │
  │ Control   │         └───┬────────────────────────┬──────────┘   │     │
  │ Unit      │             │ rs1_val                │ rs2_val       │     │
  │(RegWrite, │             │                         │               │     │
  │ MemRead,  │             │                   ┌─────┴─────┐         │     │
  │ MemWrite, │             │                   │   MUX      │◄── ALUSrc  │     │
  │ ALUSrc,   │             │                   │(imm বনাম    │         │     │
  │ MemToReg, │             │                   │ rs2_val)   │         │     │
  │ ALUOp,    │             │                   └─────┬─────┘         │     │
  │ Branch)   │             │                         │  Imm Generator │     │
  └───┬──────┘             ▼                         ▼  (instruction-  │     │
      │              ┌─────────────────────────────────┐ encoding লেসন) │     │
      │              │              ALU                  │◄──────────────┘     │
      │              │   (alu-design লেসন — Zero flag      │                    │
      │              │    সহ, Branch AND Zero = PCSrc)      │                    │
      │              └───────┬───────────────────┬────────┘                    │
      │                      │ result             │ Zero flag ──────────────────┘
      │                      ▼                    │  (branch-এ ব্যবহৃত)
      │              ┌───────────────┐             │
      │              │  Data Memory   │◄────────────┘ address
      │              │ (memory-sram-  │
      │              │  dram লেসন)    │
      │              └───────┬───────┘
      │                      │ MemRead হলে data out
      │                      ▼
      │              ┌───────────────┐
      │              │  MUX          │◄── MemToReg (ALU result বনাম memory data)
      │              └───────┬───────┘
      │                      │
      └──────────────────────┴─────────► Register File write port (RegWrite হলে)

Single-cycle বনাম multi-cycle — এই ট্রেস কোনটা

এই লেসনের বর্ণনা প্রতিটা instruction-কে পাঁচটা যৌক্তিক ধাপে ভাগ করেছে, কিন্তু এটা বলেনি প্রতিটা ধাপ কয়টা clock cycle নেয়। দুইটা বৈধ বাস্তবায়ন সম্ভব — Level ২-র datapath-and-control-unit লেসনের সেই আলোচনার সরাসরি সম্প্রসারণ:

Single-cycle। প্রতিটা instruction ঠিক এক clock cycle-এ, সব পাঁচটা স্টেজ combinationally, sequential logic ছাড়াই। Clock period-কে সবচেয়ে ধীর instruction (এখানে lw/sw, যাদের memory access আছে) অনুযায়ী যথেষ্ট লম্বা রাখতে হয়।

Multi-cycle। প্রতিটা স্টেজ নিজের clock cycle নেয় — একটা add-এর লাগে তিন cycle (FETCH, DECODE+EXECUTE, WRITEBACK — MEMORY বাদ, কারণ দরকার নেই), একটা lw/sw-এর লাগে চার-পাঁচ cycle। এটাই Level ২-র toy CPU যা করেছিল — শুধু এবার একটা real ISA দিয়ে।

নিচের “example” অংশের cycle-বাই-cycle ট্রেসটা multi-cycle assumption ব্যবহার করছে (Level ২-র toy CPU-র সাথে সরাসরি তুলনীয় রাখতে)। তৃতীয় একটা কৌশল — pipelining — যেখানে ভিন্ন instruction ভিন্ন স্টেজে একই সাথে থাকে (instruction ২ DECODE হচ্ছে যখন instruction ১ EXECUTE হচ্ছে) — Level ৩-র পরের লেসনগুলোর মূল বিষয়, এখানে শুধু নাম উল্লেখ করাই যথেষ্ট।

Critical path — single-cycle হলে clock period কত হতো

Level ২-র alu-design লেসনে আমরা দেখেছিলাম একটা ALU-র critical path কীভাবে তার সবচেয়ে ধীর sub-unit (adder) দিয়ে নির্ধারিত হয়। একটা single-cycle CPU-তে এই একই যুক্তি পুরো datapath জুড়ে বিস্তৃত হয় — পুরো instruction cycle-টাই একটা মাত্র বিশাল combinational circuit, আর তার critical path হলো সবচেয়ে দীর্ঘ instruction-এর সম্পূর্ণ পথ।

lw/sw-এর জন্য পুরো পথ: 5+2+6+5+2 = 20 একক। add-এর জন্য (MEMORY স্টেজ বাদ, কারণ ব্যবহৃত হয় না, কিন্তু single-cycle-এ এড়ানো যায় না — MUX-কে এখনো সিদ্ধান্ত নিতে হয় কোন পথের ফলাফল ব্যবহার হবে, তাই delay-টা থেকেই যায়): একই 20 একক।