HDL ও Verilog পরিচিতি — Schematic যখন কোড হয়ে যায়

এটাই এই সম্পূর্ণ মডিউলের payoff project, কোড আকারে — লেসন ১৫-এ যা schematic-এ বানানো হয়েছিল, এখন সেই একই ডিজাইন Verilog-এ।

Register file

লেসন ১৫-এর instruction format-এ ফিরে তাকান: ADD Rd,Rs,Rt-এ তিনটা স্বাধীন ৩-বিট register field আছে (Rd at [13:11], Rs at [10:8], Rt at [7:5]) — যেমন “উদাহরণ” section-এর trace-এ ADD R3,R1,R2-এ R3, R1, R2 তিনটাই আলাদা register। আর STORE Rs,addr-এ যে register store হবে সেটার field position Rd-এর মতোই [13:11] (যেহেতু STORE-এর কোনো destination register লাগে না, সেই bit-জায়গাটা STORE-এর নিজের “কোন register store করব” সংখ্যার জন্য পুনর্ব্যবহার হয়)। তার মানে register file-কে তিনটা read port দিতে হবে — Rs, Rt-এর জন্য দুটো (ADD-এর ALU operand), আর Rd-এর field-position পড়ার জন্য একটা তৃতীয়টা (STORE-এর data source, যেহেতু সেই field ADD-এর Rs/Rt-এর থেকে ভিন্ন bit-এ থাকে)।

module register_file (
    input  wire        clk,
    input  wire        RegWrite,
    input  wire [2:0]  rs_addr, rt_addr, rd_addr,
    input  wire [15:0] wdata,
    output wire [15:0] rs_data, rt_data, rd_data
);
    reg [15:0] regs [0:7];   // ৮টা ১৬-বিট register — লেসন ১০-এর register file

    assign rs_data = regs[rs_addr];   // read — combinational, সবসময় বর্তমান মান
    assign rt_data = regs[rt_addr];
    assign rd_data = regs[rd_addr];   // STORE-এর data source — Rd-field position-এর register পড়া

    always @(posedge clk)
        if (RegWrite) regs[rd_addr] <= wdata;   // write — শুধু clock edge-এ
endmodule

লক্ষ্য করুন regs একটা memory array (reg [15:0] regs [0:7]) — reg-এর একটা array, প্রতিটা element ১৬-বিট। তিনটা read port (rs_data, rt_data, rd_data) assign দিয়ে — সবসময় বর্তমান address-এর মান, কোনো clock লাগে না (combinational read, ঠিক লেসন ১০-এর register file-এর মতো)। Write port একটাই, always @(posedge clk)-এর ভেতরে — শুধু clock edge-এ, শুধু RegWrite=1 হলে। লক্ষ্য করুন rd_data-কে একই ঠিকানায় (rd_addr) পড়া আর লেখা একসাথে ঘটতে পারে কোনো conflict ছাড়াই — read combinational (তাৎক্ষণিক), write শুধু clock edge-এ, তাই একই cycle-এ “পুরনো মান পড়া” আর “নতুন মান লেখা” একসাথে সংজ্ঞায়িত ও নিরাপদ।

ALU

module alu_add (
    input  wire [15:0] a, b,
    output wire [15:0] result
);
    assign result = a + b;   // এই টয় ISA-তে ALU-র একমাত্র কাজ
endmodule

Data memory

module data_memory (
    input  wire         clk,
    input  wire         MemRead, MemWrite,
    input  wire [10:0]  addr,
    input  wire [15:0]  wdata,
    output reg  [15:0]  rdata
);
    reg [15:0] mem [0:2047];   // 2048 × 16 — লেসন ১৪-এর ঠিক সেই মডেল

    always @(posedge clk) begin
        if (MemWrite) mem[addr] <= wdata;
        if (MemRead)  rdata     <= mem[addr];
    end
endmodule

Control unit — লেসন ১৫-এর টেবিল, প্রায় অক্ষরে-অক্ষরে

module control_unit (
    input  wire       clk,
    input  wire       rst,
    input  wire [1:0] opcode,      // IR[15:14] — শুধু S_DECODE-এর পর বৈধ

    output reg IRWrite,
    output reg RegWrite,
    output reg MemRead,
    output reg MemWrite,
    output reg MemToReg
);
    localparam ADD = 2'b00, LOAD = 2'b01, STORE = 2'b10;
    localparam S_DECODE    = 3'd0,
               S_ADD_EXEC  = 3'd1,
               S_MEM_READ  = 3'd2,
               S_MEM_WRITE = 3'd3,
               S_WB        = 3'd4;

    reg [2:0] state, next_state;

    // ── state register — এই মডিউলের একমাত্র প্রকৃত flip-flop-গুলো ──
    always @(posedge clk) begin
        if (rst) state <= S_DECODE;
        else     state <= next_state;
    end

    // ── next-state logic — লেসন ১৫-এর "S_DECODE-এর next-state যুক্তি" টেবিল ──
    always @(*) begin
        case (state)
            S_DECODE: case (opcode)
                          ADD:     next_state = S_ADD_EXEC;
                          LOAD:    next_state = S_MEM_READ;
                          STORE:   next_state = S_MEM_WRITE;
                          default: next_state = S_DECODE;
                      endcase
            S_ADD_EXEC:  next_state = S_WB;
            S_MEM_READ:  next_state = S_WB;
            S_MEM_WRITE: next_state = S_DECODE;
            S_WB:        next_state = S_DECODE;
            default:     next_state = S_DECODE;
        endcase
    end

    // ── output logic — লেসন ১৫-এর সম্পূর্ণ control signal truth table, এক জায়গায় ──
    always @(*) begin
        IRWrite  = (state == S_DECODE);
        RegWrite = (state == S_WB);
        MemRead  = (state == S_MEM_READ);
        MemWrite = (state == S_MEM_WRITE);
        MemToReg = (state == S_WB) && (opcode == LOAD);
    end
endmodule

লক্ষ্য করুন MemToReg = (state == S_WB) && (opcode == LOAD); লাইনটা — এটা ঠিক লেসন ১৫-এর সেই সতর্কতামূলক Callout-এর কোডে রূপ: “control signal শুধু state-এর ফাংশন না, state এবং সংরক্ষিত ডেটা (opcode) দুটোর ফাংশন।” সেখানে এটা prose-এ বলা হয়েছিল; এখানে সেটাই সরাসরি একটা Boolean expression।

Top-level — schematic-টাই wiring

module toy_cpu (
    input  wire        clk,
    input  wire        rst,
    input  wire [15:0] instr_in   // "already fetched" — লেসন ১৫-এর স্কোপ অনুযায়ী
);
    reg  [15:0] IR;

    wire [1:0]  opcode     = IR[15:14];
    wire [2:0]  rd_field   = IR[13:11];   // ADD/LOAD-এ Rd, STORE-এ "কোন register store হবে"
    wire [2:0]  rs_field   = IR[10:8];    // শুধু ADD-এ — প্রথম source operand
    wire [2:0]  rt_field   = IR[7:5];     // শুধু ADD-এ — দ্বিতীয় source operand
    wire [10:0] addr_field = IR[10:0];    // শুধু LOAD/STORE-এ

    wire IRWrite, RegWrite, MemRead, MemWrite, MemToReg;

    // ── IR — লেসন ১৫-এর স্কোপ অনুযায়ী, "already fetched" ধরে নিয়ে ──
    always @(posedge clk)
        if (IRWrite) IR <= instr_in;

    // ── control unit ──
    control_unit ctrl (
        .clk(clk), .rst(rst), .opcode(opcode),
        .IRWrite(IRWrite), .RegWrite(RegWrite),
        .MemRead(MemRead), .MemWrite(MemWrite), .MemToReg(MemToReg)
    );

    // ── register file — তিনটা read address, একটা write address ──
    wire [15:0] rs_data, rt_data, rd_data, wb_data;
    register_file rf (
        .clk(clk), .RegWrite(RegWrite),
        .rs_addr(rs_field), .rt_addr(rt_field), .rd_addr(rd_field),
        .wdata(wb_data),
        .rs_data(rs_data), .rt_data(rt_data), .rd_data(rd_data)
    );

    // ── ALU + ALUOut ── (ADD-এ Rs+Rt; LOAD/STORE-এ ফলাফল অব্যবহৃত থাকে)
    wire [15:0] alu_result;
    reg  [15:0] ALUOut;
    alu_add alu (.a(rs_data), .b(rt_data), .result(alu_result));
    always @(posedge clk) ALUOut <= alu_result;

    // ── data memory + MDR ── (STORE-এর data আসে rd_data থেকে — Rd-field position-এর register)
    wire [15:0] mem_rdata;
    reg  [15:0] MDR;
    data_memory dmem (
        .clk(clk), .MemRead(MemRead), .MemWrite(MemWrite),
        .addr(addr_field), .wdata(rd_data), .rdata(mem_rdata)
    );
    always @(posedge clk) if (MemRead) MDR <= mem_rdata;

    // ── MemToReg MUX — লেসন ১৫-এর সেই একমাত্র MUX ──
    assign wb_data = MemToReg ? MDR : ALUOut;
endmodule

এই wiring লেসন ১৫-এর ব্লক ডায়াগ্রামের প্রতিটা তার, প্রতিটা MUX-এর একটা সরাসরি অনুবাদ — assign wb_data = MemToReg ? MDR : ALUOut; লাইনটাই সেই “MemToReg MUX (0=ALUOut, 1=MDR)” বাক্সের সম্পূর্ণ বর্ণনা। একমাত্র সংযোজন হলো তৃতীয় read port (rd_data) — কারণ এই toy ISA-তে ADD-এর Rs/Rt field আর STORE-এর “কোন register” field আলাদা bit-অবস্থানে থাকে (উপরের register file-এর ব্যাখ্যা দ্রষ্টব্য), তাই একটা physical read port দিয়ে দুটোই সামলানো যায় না।

Testbench — লেসন ১৫-এর ৪-instruction প্রোগ্রাম

module tb_toy_cpu;
    reg clk = 0, rst = 1;
    reg [15:0] instr_in;

    always #5 clk = ~clk;

    toy_cpu cpu (.clk(clk), .rst(rst), .instr_in(instr_in));

    // instruction encoding, লেসন ১৫-এর ফরম্যাট অনুযায়ী:
    // ADD  Rd,Rs,Rt : opcode=00, Rd[13:11], Rs[10:8], Rt[7:5]   — তিনটাই স্বাধীন field
    // LOAD Rd,addr  : opcode=01, Rd[13:11], addr[10:0]
    // STORE Rs,addr : opcode=10, Rs[13:11] (= rd_field), addr[10:0]

    initial begin
        rst = 1; instr_in = 16'h0000;
        @(posedge clk); rst = 0;

        // Memory[100]=7, Memory[104]=35 প্রি-লোড করা হয়েছে ধরে নিচ্ছি
        // (বাস্তব টেস্টে cpu.dmem.mem[100] = 7; cpu.dmem.mem[104] = 35; ব্যবহার করুন)

        instr_in = {2'b01, 3'd1, 11'd100};  // LOAD R1, 100
        repeat (3) @(posedge clk);

        instr_in = {2'b01, 3'd2, 11'd104};  // LOAD R2, 104
        repeat (3) @(posedge clk);

        instr_in = {2'b00, 3'd3, 3'd1, 3'd2, 5'b0}; // ADD R3, R1, R2
        repeat (3) @(posedge clk);

        instr_in = {2'b10, 3'd3, 11'd108};  // STORE R3, 108
        repeat (2) @(posedge clk);

        $display("R1=%0d R2=%0d R3=%0d Memory[108]=%0d",
            cpu.rf.regs[1], cpu.rf.regs[2], cpu.rf.regs[3], cpu.dmem.mem[108]);
        $finish;
    end
endmodule

প্রত্যাশিত চূড়ান্ত অবস্থা: R1=7 R2=35 R3=42 Memory[108]=42 — ঠিক লেসন ১৫-এর ১১-cycle trace টেবিলের চূড়ান্ত ফলাফল। যদি এই সংখ্যাগুলো মিলে যায়, আপনি লেসন ১৫-এর হাতে-আঁকা schematic-টাই এখন কোডে, সিমুলেশনে verify করা অবস্থায় দাঁড় করিয়েছেন।

নিজে বাড়ান:

1. cpu.dmem.mem[100] = 7; cpu.dmem.mem[104] = 35; লাইন দুটো testbench-এর শুরুতে (reset-এর পর, প্রথম clock-এর আগে) যোগ করে test-টা সম্পূর্ণ চালান।
2. লেসন ১৫-এর BuildIt-এর challenge অনুযায়ী SUB instruction যোগ করুন — alu_add-কে একটা ALUOp-সহ op-select ALU-তে বদলান (লেসন ৮), আর control_unit-এ opcode 11-এর জন্য নতুন case শাখা যোগ করুন।
3. Yosys ইনস্টল থাকলে (yosys -p "synth; stat" toy_cpu.v ...) চালিয়ে দেখুন — কতগুলো gate, কতগুলো flip-flop synthesize হলো। তুলনা করুন: এই ডিজাইনে ঠিক কয়টা flip-flop আসলে থাকা উচিত (IR ১৬ + state ৩ + ALUOut ১৬ + MDR ১৬ + register file ৮×১৬ = কত?) — সিমুলেশনের আগে হিসাব করে, তারপর tool-এর রিপোর্টের সাথে মিলিয়ে দেখুন।