Hardware description language — Verilog-এর পরিচয় আর simulation

১ · ছবি আঁকা থেকে কোড লেখা — কেন hardware description language

মডিউল ২-এর আগের পর্বগুলোতে আপনি circuit দেখেছেন ছবিতে: gate-এর চিহ্ন, তার দিয়ে জোড়া — যাকে বলে schematic. পর্ব ১১-এ full adder, পর্ব ১২-এ multiplexer আর decoder, পর্ব ১৩-এ ALU. কয়েকটি gate-এর জন্য ছবি চমৎকার। কিন্তু আজকের একটি ফোনের প্রসেসরে কয়েকশো কোটি transistor. প্রতি সেকেন্ডে একটি করে gate আঁকলেও একজন মানুষের সারাজীবনে একটি chip আঁকা শেষ হবে না — আর একটি ভুল তার খুঁজে বের করা প্রায় অসম্ভব।

HDL দেখতে প্রোগ্রামিং ভাষার মতো — if, case, for সবই আছে — কিন্তু এটি CPU-তে চালানোর জন্য instruction নয়। এটি একটি circuit-এর বর্ণনা। C প্রোগ্রাম compile হয়ে machine code হয়; Verilog কোড “compile” হয়ে হয় gate আর তারের তালিকা, যাকে বলে netlist. একই লেখা দুইভাবে ব্যবহার হয়:

এই দুই কাজের মাঝখানে পুরো পথটিকে বলে design flow. নিচের ডায়াগ্রামে “পরে” চাপুন — একটি ছোট half adder লেখা থেকে চিপ পর্যন্ত প্রতিটি ধাপে কী তৈরি হয়, সেটি দেখুন:

module half_adder (input wire a, input wire b,
                   output wire sum, output wire carry);
    assign sum   = a ^ b;   // XOR gate
    assign carry = a & b;   // AND gate
endmodule

a b | sum carry
0 0 |  0    0
0 1 |  1    0
1 0 |  1    0
1 1 |  0    1
4/4 pass

$ yosys -p "synth -top half_adder; stat" half_adder.v
   ...
   Number of cells:      2
     $_AND_              1
     $_XOR_              1

LUT 1 (sum)  : input a,b → মেমরি-বিট 0 1 1 0
LUT 2 (carry): input a,b → মেমরি-বিট 0 0 0 1
routing      : a, b pin → দুই LUT → output pin
সব মিলিয়ে একটি bitstream ফাইল → board-এ load

XOR2 cell + AND2 cell  (কারখানার cell library থেকে)
→ placement (কোথায় বসবে) → routing (ধাতুর তার)
→ timing ও নিয়ম যাচাই → GDSII ফাইল → fab-এ chip

Verilog, VHDL আর নতুন প্রজন্মের HDL

অন্য বড় ভাষাটি VHDL — নামের V এসেছে VHSIC (Very High Speed Integrated Circuit) থেকে, যা ছিল ১৯৮০-র দশকে মার্কিন প্রতিরক্ষা বিভাগের একটি কর্মসূচি। উদ্দেশ্য ছিল সরবরাহকারীদের কাছ থেকে নেওয়া chip-এর নকশা একটি নির্দিষ্ট, স্পষ্ট ভাষায় নথিভুক্ত রাখা। VHDL প্রথম IEEE মান হয় ১৯৮৭ সালে — IEEE 1076 নামে। এর গঠন Ada ভাষার মতো — কড়া type-নিয়ম, বেশি শব্দ, কিন্তু ভুল কম। মোটা দাগে বলা হয়, ইউরোপ আর প্রতিরক্ষা-মহাকাশ শিল্পে VHDL বেশি প্রচলিত, আর আমেরিকা ও এশিয়ার বাণিজ্যিক chip শিল্পে Verilog/SystemVerilog — তবে এটি কেবল প্রবণতা, কঠোর নিয়ম নয়।

নতুন প্রজন্মের ভাষাগুলো একটু আলাদা ভাবনা থেকে এসেছে। Chisel তৈরি হয়েছে UC Berkeley-তে; এতে Scala প্রোগ্রাম চালালে সেটি Verilog তৈরি করে — অর্থাৎ আপনি একটি “circuit বানানোর প্রোগ্রাম” লেখেন। Berkeley-র Rocket Chip-এর মতো কয়েকটি পরিচিত RISC-V নকশা এভাবে লেখা বলে জানা যায়। SpinalHDL-ও Scala-ভিত্তিক; জনপ্রিয় open-source VexRiscv core এতে লেখা। তবে প্রায় সবই শেষে Verilog বের করে দেয়, কারণ synthesis আর FPGA tool-এর জগৎ এখনো Verilog/VHDL-কেন্দ্রিক। তাই এই কোর্সে আমরা Verilog (আর দরকারমতো SystemVerilog-এর দুই-একটি সুবিধা) শিখব।

২ · সবচেয়ে বড় মানসিক বদল — hardware একসাথে চলে

C বা Python শেখা কারও কাছে প্রথম Verilog ফাইলটি পরিচিত মনে হয়: লাইনের পর লাইন, সেমিকোলন, = চিহ্ন। আর সেখানেই ফাঁদ। C-তে লাইনগুলো একটির পর একটি চলে — CPU একবারে একটি instruction. কিন্তু circuit-এ প্রতিটি gate নিজের জায়গায় বসে আছে, বিদ্যুৎ পাচ্ছে, আর input বদলালেই নিজের output বদলাচ্ছে — অন্য gate-এর “পালা” আসার অপেক্ষা ছাড়াই। একে বলে concurrency.

নিচের তিনটি লাইন একটি ছোট circuit বর্ণনা করে: y = (a AND b) OR (NOT c). ইচ্ছে করে লাইনগুলো “উল্টো” ক্রমে লেখা — আগে y, পরে তার input n1 আর n2. Verilog-এ এতে কোনো সমস্যা নেই। একই তিনটি লাইন C-তে লিখলে কী হয়, সেটিও পাশাপাশি দেখুন। শুরুতে a = 1, b = 0, c = 1; তারপর b বদলে 1 হয়:

1// Verilog: তিনটি স্থায়ী তার2assign y  = n1 | n2;3assign n1 = a & b;4assign n2 = ~c;5// C: একই লাইন, একবার, ক্রমানুসারে6y  = n1 | n2;7n1 = a & b;8n2 = !c;

Verilog-এ ক্রমিক লেখাও আছে — always block-এর ভেতরে (অংশ ৬)। কিন্তু সেখানেও পুরো block-টি একটি circuit-এর বর্ণনা, আর প্রতিটি block অন্য সব block ও assign-এর সাথে একসাথে চলে।

৩ · Verilog-এর মূল গঠন — module, port, wire, reg আর সংখ্যা

Verilog-এ প্রতিটি circuit একটি module. Module হলো একটি বাক্সের মতো — বাইরে থেকে দেখা যায় শুধু তার pin (input আর output), ভেতরে কী আছে তা বাক্সের নিজস্ব ব্যাপার। একটি module অন্য module-কে নিজের ভেতরে বসাতে পারে, ঠিক যেমন একটি বড় circuit board-এ ছোট ছোট chip বসানো থাকে। নিচের ছোট module-টি একটি ৪-বিট সংখ্যা নিয়ে বলে সেটি বিজোড় কি না আর শূন্য কি না:

// A 4-bit number n: is it odd? is it zero?
module nibble_info (
    input  wire [3:0] n,        // 4-bit input bus: n[3] = MSB, n[0] = LSB
    output wire       is_odd,
    output wire       is_zero
);
    assign is_odd  = n[0];                // LSB = 1 means odd
    assign is_zero = (n == 4'b0000);      // a 4-input NOR in hardware
endmodule

লাইন ধরে ধরে পড়া যাক:

• module nibble_info ( … ); থেকে endmodule — একটি module-এর শুরু আর শেষ। নামটি দিয়েই পরে অন্য জায়গায় একে বসানো হবে।
• Port — বন্ধনীর ভেতরের তালিকা। input মানে বাইরে থেকে আসে, output মানে বাইরে যায় (দুই দিকেই চলে এমন inout-ও আছে, যেমন চিপের data pin). Verilog-2001 থেকে port-এর দিক আর type এক জায়গায় লেখা যায়, যেমনটি এখানে।
• [3:0] — একটি vector বা bus: চারটি তার একসাথে, n[3] থেকে n[0]. প্রচলিত রীতি হলো বাঁ দিকের সংখ্যাটি MSB — [7:0] মানে ৮ বিট। একটি অংশ আলাদা করে নেওয়া যায়: n[3:2] মানে ওপরের দুই বিট।
• assign — continuous assignment: বাঁ পাশের তার সবসময় ডান পাশের মানের সমান থাকে। অংশ ২-এ দেখেছেন, এটি একবারের কাজ নয়, একটি স্থায়ী সংযোগ।
• // আর /* … */ — মন্তব্য, C-এর মতোই। প্রতিটি statement শেষ হয় ; দিয়ে।

wire, reg আর logic — নামের বিভ্রান্তি

Verilog-এ সংকেত রাখার দুই প্রধান ধরন আছে, আর এদের নাম নতুনদের সবচেয়ে বেশি বিভ্রান্ত করে:

অর্থাৎ reg শব্দটি কেবল বলে “এই সংকেত procedural block থেকে মান পায়” — hardware-এ সেখানে flip-flop বসবে কি না, তা ঠিক হয় block-টি কেমন লেখা হয়েছে তা দেখে: clock-এর ধারে মান নিলে flip-flop, সব input-এর ওপর সঙ্গে সঙ্গে নির্ভর করলে সাধারণ gate. SystemVerilog-এর logic এই বিভ্রান্তি দূর করতে এসেছে, আর নতুন প্রকল্পে প্রায়ই সব জায়গায় logic লেখা হয়।

সংখ্যা লেখার নিয়ম আর চার রকম মান

Hardware-এ প্রতিটি সংকেতের নির্দিষ্ট বিট-সংখ্যা আছে, তাই Verilog-এ সংখ্যার সাথে তার মাপও লেখা হয়: <বিট>'<ভিত্তি><অঙ্ক>. ভিত্তি b (binary), o (octal), d (decimal), h (hex) — পর্ব ০৪-এর সংখ্যা পদ্ধতি এখানে সরাসরি কাজে লাগে।

খেয়াল করুন, Verilog-এর একটি বিট শুধু 0 আর 1 নয় — চার রকম মান নিতে পারে: 0, 1, x (অজানা — যেমন শুরুতে কেউ মান দেয়নি, বা দুটি চালক দুই মান দিচ্ছে) আর z (high impedance, তার কারও সাথে জোড়া নেই)। Simulation-এ x দেখা গেলে প্রায় সবসময় বুঝবেন কোথাও কিছু জোড়া হয়নি বা শুরুর মান দেওয়া হয়নি — এটি ভুল খোঁজার দারুণ সূত্র। বাস্তব hardware-এ অবশ্য প্রতিটি তারে 0 বা 1-ই থাকে; x কেবল simulator-এর “আমি জানি না” বলার উপায়।

৪ · Operator আর continuous assignment — তারের ওপর হিসাব

Verilog-এর অনেক operator C-এর মতো দেখতে, কিন্তু কয়েকটি একেবারেই hardware-এর নিজস্ব। নিচের টেবিলে প্রতিটির ফল হাতে হিসাব করা — ধরে নিন a = 4'b1010 (১০) আর b = 4'b0110 (৬)। Bitwise operator প্রতিটি বিট-অবস্থানে আলাদা gate বসায় (৪ বিটের AND মানে পাশাপাশি চারটি AND gate):

তিনটি বিষয় এখানে বিশেষভাবে লক্ষ করার মতো। প্রথমত, reduction operator (&a, |a, ^a) C-তে নেই; একটিমাত্র operand-এর সব বিট মিলিয়ে এক বিট ফল দেয়। দ্বিতীয়ত, concatenation আর shift-এর জন্য কোনো gate লাগে না — hardware-এ এগুলো কেবল তার কোথায় জুড়বে তার নির্দেশ, তাই এগুলো “বিনামূল্যে”। তৃতীয়ত, ফলের মাপ বাঁ পাশ ঠিক করে: a + b-এর ফল ৪-বিট তারে রাখলে উপচে পড়া carry চুপচাপ হারিয়ে যায় — পর্ব ০৫-এর overflow, এবার hardware-এর ভাষায়। কোনো error আসে না; কিছু tool কেবল সতর্কবার্তা দেয়।

Logical operator (!, &&, ||) আর তুলনা (==, !=, <, >=) C-এর মতোই এক বিটের সত্য/মিথ্যা দেয়। আর একটি assign-এ conditional operator দিয়েই একটি 2:1 multiplexer লেখা যায়:

module mux2 #(parameter W = 8) (
    input  wire [W-1:0] d0, d1,
    input  wire         sel,
    output wire [W-1:0] y,
    output wire         same
);
    assign y    = sel ? d1 : d0;    // W-bit 2:1 multiplexer
    assign same = (d0 == d1);       // W-bit equality comparator
endmodule

এখানে #(parameter W = 8) একটি parameter — module-এর মাপ একটি নামে রাখা। একই module ৮-বিট, ১৬-বিট বা ৩২-বিট mux হিসেবে বসানো যায়, শুধু বসানোর সময় mux2 #(.W(32)) m (...) লিখে। Parameter synthesis-এর আগেই একটি স্থির সংখ্যা হয়ে যায়; চলার সময় এটি বদলায় না, কারণ চলার সময় hardware-এর তার বাড়ে-কমে না।

৫ · Structural modelling — ছোট module জুড়ে বড় module

পর্ব ১১-এ দেখেছেন, একটি full adder দুটি half adder আর একটি OR gate দিয়ে বানানো যায়, আর চারটি full adder-এর carry পরপর জুড়লে হয় একটি ৪-বিট ripple-carry adder. ঠিক এই ছবিটিকেই Verilog-এ লেখা যায় — একে বলে structural modelling: কোন ছোট module কতগুলো বসবে, আর কোন তার কোথায় জুড়বে। একটি module-কে আরেকটির ভেতরে বসানোকে বলে instantiation, আর বসানো প্রতিটি কপি একটি instance.

module half_adder (
    input  wire a, b,
    output wire sum, carry
);
    assign sum   = a ^ b;
    assign carry = a & b;
endmodule

module full_adder (
    input  wire a, b, cin,
    output wire sum, cout
);
    wire s1, c1, c2;                 // internal wires between the two half adders
    half_adder ha1 (.a(a),  .b(b),   .sum(s1),  .carry(c1));
    half_adder ha2 (.a(s1), .b(cin), .sum(sum), .carry(c2));
    assign cout = c1 | c2;
endmodule

half_adder ha1 ( … ); লাইনের মানে: “half_adder ধরনের একটি instance বসবে, যার নাম ha1”. বন্ধনীর ভেতরে .a(a) লেখার অর্থ — instance-এর a pin জোড়া হবে এই module-এর a তারে। একে বলে named port connection. ক্রম অনুযায়ী (half_adder ha1 (a, b, s1, c1);) লেখাও বৈধ, কিন্তু port-এর ক্রম ভুল হলে নীরবে ভুল circuit তৈরি হয় — তাই বড় নকশায় নাম দিয়ে জোড়াই নিরাপদ রীতি। s1, c1, c2 ভেতরের তার, বাইরে থেকে দেখা যায় না।

module adder4 (
    input  wire [3:0] a, b,
    input  wire       cin,
    output wire [3:0] sum,
    output wire       cout
);
    wire c1, c2, c3;                 // carries between the stages
    full_adder fa0 (.a(a[0]), .b(b[0]), .cin(cin), .sum(sum[0]), .cout(c1));
    full_adder fa1 (.a(a[1]), .b(b[1]), .cin(c1),  .sum(sum[1]), .cout(c2));
    full_adder fa2 (.a(a[2]), .b(b[2]), .cin(c2),  .sum(sum[2]), .cout(c3));
    full_adder fa3 (.a(a[3]), .b(b[3]), .cin(c3),  .sum(sum[3]), .cout(cout));
endmodule

এবার একটি নির্দিষ্ট যোগে প্রতিটি instance-এর তারে কী মান আসে, দেখা যাক: a = 4'b1011 (১১), b = 4'b0110 (৬), cin = 0. Hardware-এ চারটি instance একসাথে বসে আছে; কিন্তু fa1 তার সঠিক উত্তর দিতে পারে কেবল fa0-এর carry পৌঁছানোর পরে — তাই মান “ঢেউয়ের মতো” ডানে থেকে বাঁয়ে যায়:

1wire c1, c2, c3;2full_adder fa0 (a[0], b[0], cin → sum[0], c1);3full_adder fa1 (a[1], b[1], c1  → sum[1], c2);4full_adder fa2 (a[2], b[2], c2  → sum[2], c3);5full_adder fa3 (a[3], b[3], c3  → sum[3], cout);6// ফল: {cout, sum}

এই পাতার runner-এ কোনো Verilog simulator নেই, তাই নিচের JavaScript-টি একটি খুব ছোট “Verilog-ধাঁচের” simulator — আসল Verilog নয়। এতে half_adder আর full_adder হলো function, আর adder4 একটি netlist — instance-এর নাম আর প্রতিটি pin কোন নামের তারে জোড়া, ঠিক উপরের Verilog-এর মতো। এটি event ব্যবহার করে না; instance-গুলো সংকেতের ক্রমে সাজানো বলে একবার ওপর থেকে নিচে হিসাব করলেই চলে। তারপর একটি self-checking testbench সব ২৫৬টি (a, b) জোড়া চালিয়ে উত্তর মেলায়। Run চাপুন:

// Tiny "Verilog-like" netlist simulator (no events): instances + named wires, like adder4.v
const half_adder = (a, b) => ({ sum: a ^ b, carry: a & b });
function full_adder(a, b, cin) {               // ha1 + ha2 + OR, as in full_adder.v
  const ha1 = half_adder(a, b), ha2 = half_adder(ha1.sum, cin);
  return { sum: ha2.sum, cout: ha1.carry | ha2.carry };
}
const adder4 = [                               // fa0..fa3 chained by wires c1, c2, c3
  ["fa0", { a: "a0", b: "b0", cin: "cin", sum: "s0", cout: "c1" }],
  ["fa1", { a: "a1", b: "b1", cin: "c1",  sum: "s1", cout: "c2" }],
  ["fa2", { a: "a2", b: "b2", cin: "c2",  sum: "s2", cout: "c3" }],
  ["fa3", { a: "a3", b: "b3", cin: "c3",  sum: "s3", cout: "cout" }],
];
function simulate(a, b, cin, trace) {
  const w = { cin };                           // the wire table: name -> 0/1
  for (let i = 0; i < 4; i++) { w["a" + i] = (a >> i) & 1; w["b" + i] = (b >> i) & 1; }
  for (const [name, p] of adder4) {            // listed in signal order, so one pass is enough
    const r = full_adder(w[p.a], w[p.b], w[p.cin]);
    w[p.sum] = r.sum; w[p.cout] = r.cout;
    if (trace) console.log(`  ${name}: a=${w[p.a]} b=${w[p.b]} cin=${w[p.cin]} -> sum=${r.sum} cout=${r.cout}`);
  }
  return { sum: w.s0 | w.s1 << 1 | w.s2 << 2 | w.s3 << 3, cout: w.cout };
}
const bin = (v, n) => v.toString(2).padStart(n, "0");
let pass = 0, fail = 0;                        // self-checking testbench: every a, b with cin = 0
for (let a = 0; a < 16; a++) for (let b = 0; b < 16; b++) {
  const r = simulate(a, b, 0, false), got = r.cout << 4 | r.sum;
  if (got === a + b) pass++; else { fail++; console.log(`FAIL: ${a} + ${b} gave ${got}`); }
}
for (const [a, b] of [[3, 5], [9, 7], [15, 15]]) {
  const r = simulate(a, b, 0, false);
  console.log(`a=${bin(a, 4)} b=${bin(b, 4)} -> cout=${r.cout} sum=${bin(r.sum, 4)}  (${a}+${b}=${a + b})`);
}
console.log("trace for a=1011 (11), b=0110 (6), cin=0:");
simulate(0b1011, 0b0110, 0, true);
console.log(`${pass}/${pass + fail} pass, ${fail} errors`);

a=0011 b=0101 -> cout=0 sum=1000  (3+5=8)
a=1001 b=0111 -> cout=1 sum=0000  (9+7=16)
a=1111 b=1111 -> cout=1 sum=1110  (15+15=30)
trace for a=1011 (11), b=0110 (6), cin=0:
  fa0: a=1 b=0 cin=0 -> sum=1 cout=0
  fa1: a=1 b=1 cin=0 -> sum=0 cout=1
  fa2: a=0 b=1 cin=1 -> sum=0 cout=1
  fa3: a=1 b=0 cin=1 -> sum=0 cout=1
256/256 pass, 0 errors

আরও ছোট করে লেখা: generate আর “+” operator

৩২-বিট adder-এ ৩২টি instance লাইন হাতে লেখা ক্লান্তিকর আর ভুলের ঝুঁকি বাড়ায়। Verilog-এর generate loop synthesis-এর আগেই লাইনগুলো “খুলে” লিখে দেয় — loop-টি hardware-এ কোনো loop নয়, N কপি instance:

module adder_n #(parameter N = 32) (
    input  wire [N-1:0] a, b,
    input  wire         cin,
    output wire [N-1:0] sum,
    output wire         cout
);
    wire [N:0] c;                    // c[0] = cin, c[N] = cout
    assign c[0] = cin;
    genvar i;
    generate
        for (i = 0; i < N; i = i + 1) begin : stage
            full_adder fa (.a(a[i]), .b(b[i]), .cin(c[i]), .sum(sum[i]), .cout(c[i+1]));
        end
    endgenerate
    assign cout = c[N];
endmodule

বাস্তবের নকশায় অবশ্য সাধারণত এক লাইনেই লেখা হয়: assign {cout, sum} = a + b + cin;. তখন synthesis tool নিজে ঠিক করে কোন ধরনের adder বসাবে — ছোট আর ধীর ripple, নাকি বড় আর দ্রুত carry-lookahead বা prefix adder — timing-এর লক্ষ্য দেখে।

৬ · Behavioural modelling — always @(*) আর case

Structural লেখায় আপনি gate বা module নিজে সাজান। কিন্তু অনেক সময় “কী করতে হবে” লেখা সহজ, “কীভাবে gate সাজাতে হবে” নয়। যেমন একটি 7-segment display-এর decoder — দশটি অঙ্কের প্রতিটিতে সাতটি বাতির কোনটি জ্বলবে। প্রতিটি বাতির জন্য K-map করে gate বের করা যায় (পর্ব ০৯), কিন্তু একটি টেবিল লিখে দিলে synthesis tool নিজেই সেই সরলীকরণ করে দেয়। এভাবে আচরণ বর্ণনা করাকে বলে behavioural modelling.

Behavioural combinational লেখার মূল হাতিয়ার always @(*) block:

• @(*) — sensitivity list: “block-এর ভেতরে যে সংকেতগুলো পড়া হয়, তার যেকোনোটি বদলালে পুরো block আবার হিসাব হবে”। * মানে সবগুলো, tool নিজে খুঁজে নেয়। Verilog-1995-এ তালিকা হাতে লিখতে হতো (@(a or b or sel)), আর একটি নাম বাদ পড়লে simulation আর আসল hardware ভিন্ন আচরণ করত — তাই ২০০১ সালে @(*) আসে।
• always_comb — SystemVerilog-এর সমতুল্য। এতে tool আরও কড়া পরীক্ষা করে: block-টি সত্যিই combinational কি না, আর ভুল করে latch তৈরি হচ্ছে কি না (অংশ ৭). নতুন SystemVerilog প্রকল্পে এটিই পছন্দের।
• ভেতরে = — blocking assignment. Block জাগলে ভেতরের লাইনগুলো ওপর থেকে নিচে চলে, প্রতিটি = সঙ্গে সঙ্গে মান বসায় — এখানে C-এর মতোই। কিন্তু মনে রাখুন, পুরো block-টি শেষ পর্যন্ত একটি circuit বর্ণনা করে: input থেকে output-এর একটি স্থির সম্পর্ক। Combinational block-এ সবসময় = ব্যবহার করুন।
• যে সংকেত always-এর ভেতরে মান পায়, তাকে reg (বা logic) হিসেবে ঘোষণা করতে হয় — অংশ ৩-এর সেই নামের বিভ্রান্তি। এখানে reg হলেও কোনো register তৈরি হয় না।

4:1 multiplexer আর 3:8 decoder

পর্ব ১২-এর দুটি পরিচিত circuit. case statement C-এর switch-এর মতো, কিন্তু break লাগে না — একটি শাখা মিললে শুধু সেটিই চলে:

module mux4 (
    input  wire [3:0] d,            // four data inputs d[0]..d[3]
    input  wire [1:0] sel,
    output reg        y
);
    always @(*) begin
        case (sel)
            2'b00:   y = d[0];
            2'b01:   y = d[1];
            2'b10:   y = d[2];
            2'b11:   y = d[3];
            default: y = 1'b0;      // only reached if sel has x/z in simulation
        endcase
    end
endmodule

module decoder3to8 (
    input  wire [2:0] a,
    input  wire       en,
    output reg  [7:0] y             // one-hot: exactly one bit is 1 when en = 1
);
    always @(*) begin
        y = 8'b0000_0000;           // default first: every path assigns y
        if (en)
            y = 8'b0000_0001 << a;  // a = 3'd5 gives 8'b0010_0000
    end
endmodule

4:1 mux-টি এক লাইনেও লেখা যায়: assign y = d[sel]; — vector-এর সূচক হিসেবে একটি সংকেত বসালেই multiplexer তৈরি হয়। Decoder-এ লক্ষ করুন y = 8'b0000_0000; লাইনটি — block-এর শুরুতে একটি default মান। এরপর en = 0 হলেও y-এর একটি নির্দিষ্ট মান থাকে। এই অভ্যাসটি অংশ ৭-এর latch-এর ফাঁদ থেকে বাঁচায়। আর 8'b0000_0001 << a: a = 5 হলে 1-কে পাঁচ ঘর বাঁয়ে সরিয়ে 0010_0000 — অর্থাৎ y[5] = 1, ঠিক decoder-এর সংজ্ঞা।

BCD থেকে 7-segment decoder

ক্যালকুলেটর বা দোকানের ডিজিটাল ঘড়ির প্রতিটি অঙ্ক সাতটি দণ্ড (a থেকে g) দিয়ে তৈরি — একে বলে 7-segment display. নিচের decoder একটি BCD অঙ্ক (০–৯) নিয়ে কোন দণ্ড জ্বলবে তা বলে। এখানে ধরা হয়েছে common-cathode display, যেখানে 1 মানে দণ্ড জ্বলবে; বিটের ক্রম {g, f, e, d, c, b, a}:

module bcd_to_7seg (
    input  wire [3:0] bcd,
    output reg  [6:0] seg           // {g,f,e,d,c,b,a}; 1 = segment on
);
    always @(*) begin
        case (bcd)
            4'd0: seg = 7'b011_1111;    // a b c d e f
            4'd1: seg = 7'b000_0110;    //   b c
            4'd2: seg = 7'b101_1011;    // a b   d e   g
            4'd3: seg = 7'b100_1111;    // a b c d     g
            4'd4: seg = 7'b110_0110;    //   b c     f g
            4'd5: seg = 7'b110_1101;    // a   c d   f g
            4'd6: seg = 7'b111_1101;    // a   c d e f g
            4'd7: seg = 7'b000_0111;    // a b c
            4'd8: seg = 7'b111_1111;    // all seven
            4'd9: seg = 7'b110_1111;    // a b c d   f g
            default: seg = 7'b000_0000; // 10..15 are not BCD: blank
        endcase
    end
endmodule

এটি আসলে একটি truth table: ৪টি input, ৭টি output, ১৬টি সারি। ১০–১৫ BCD নয়, তাই সেখানে default দিয়ে সব বন্ধ। আপনার board-এ common-anode display থাকলে সংকেত উল্টো (0 মানে জ্বলে) — তখন শুধু ~seg পাঠালেই হবে।

একটি ছোট ALU — parameter দিয়ে মাপ

পর্ব ১৩-এর ALU-র একটি ছোট সংস্করণ। op তিন বিট, তাই আটটি কাজ; মাপ W একটি parameter, ডিফল্ট ৮ বিট। এখানের op-এর সংকেত (000 = ADD …) এই উদাহরণের নিজস্ব; পর্ব ১৩ বা আসল প্রসেসরের ALU-র encoding আলাদা হতে পারে।

module alu #(parameter W = 8) (
    input  wire [W-1:0] a, b,
    input  wire [2:0]   op,
    output reg  [W-1:0] y,
    output wire         zero
);
    always @(*) begin
        case (op)
            3'b000:  y = a + b;                 // ADD (carry dropped)
            3'b001:  y = a - b;                 // SUB (wraps around)
            3'b010:  y = a & b;
            3'b011:  y = a | b;
            3'b100:  y = a ^ b;
            3'b101:  y = ~a;
            3'b110:  y = a << 1;
            3'b111:  y = (a < b) ? 1 : 0;       // unsigned set-less-than
            default: y = {W{1'b0}};
        endcase
    end
    assign zero = (y == {W{1'b0}});             // flag: result is all zeros
endmodule

Synthesis tool এখান থেকে বানাবে একটি adder, একটি subtractor (বা adder আর inverter — tool দুটিকে একত্র করতে পারে), কয়েকটি bitwise gate-এর সারি, একটি comparator, আর সবার শেষে একটি ৮-input multiplexer যা op দেখে একটি ফল বেছে নেয়। {W{1'b0}} হলো replication — W বিটের শূন্য, তাই W বদলালেও কোড ঠিক থাকে। zero flag একটি assign, যা always block-এর সাথে একসাথে চলে।

এই ALU-র প্রতিটি শাখা ঠিক কী মান দেবে, C দিয়ে একটি স্বাধীন হিসাব চালিয়ে মিলিয়ে নেওয়া যায় — hardware নকশায় এটি একটি প্রচলিত কৌশল: software-এ একটি “reference model” লিখে hardware-এর ফলের সাথে তুলনা। C-এর switch Verilog-এর case-এর মতোই, আর uint8_t-এ cast করা মানে ৮ বিটে কেটে রাখা — ঠিক W = 8-এর মতো:

#include <stdio.h>
#include <stdint.h>

/* Cross-check of alu.v with W = 8: the same case statement, written in C */
static uint8_t alu(uint8_t a, uint8_t b, unsigned op) {
    switch (op) {
    case 0: return (uint8_t)(a + b);      /* 3'b000 ADD (carry is dropped) */
    case 1: return (uint8_t)(a - b);      /* 3'b001 SUB (wraps mod 256)    */
    case 2: return (uint8_t)(a & b);
    case 3: return (uint8_t)(a | b);
    case 4: return (uint8_t)(a ^ b);
    case 5: return (uint8_t)~a;
    case 6: return (uint8_t)(a << 1);
    case 7: return (uint8_t)(a < b ? 1 : 0); /* unsigned set-less-than */
    default: return 0;
    }
}

int main(void) {
    const char *name[8] = {"ADD", "SUB", "AND", "OR", "XOR", "NOT a", "SHL a", "SLTU"};
    const uint8_t A[3] = {0x5A, 0x3C, 0xFF}, B[3] = {0x3C, 0x5A, 0x01};
    printf("op  name    a=5A b=3C   a=3C b=5A   a=FF b=01\n");
    for (unsigned op = 0; op < 8; op++) {
        printf("%u   %-6s", op, name[op]);
        for (int k = 0; k < 3; k++) {
            uint8_t y = alu(A[k], B[k], op);
            printf("   %02X zero=%d", (unsigned)y, y == 0);
        }
        printf("\n");
    }
    return 0;
}

op  name    a=5A b=3C   a=3C b=5A   a=FF b=01
0   ADD      96 zero=0   96 zero=0   00 zero=1
1   SUB      1E zero=0   E2 zero=0   FE zero=0
2   AND      18 zero=0   18 zero=0   01 zero=0
3   OR       7E zero=0   7E zero=0   FF zero=0
4   XOR      66 zero=0   66 zero=0   FE zero=0
5   NOT a    A5 zero=0   C3 zero=0   00 zero=1
6   SHL a    B4 zero=0   78 zero=0   FE zero=0
7   SLTU     00 zero=1   01 zero=0   00 zero=1

৭ · Latch-এর ফাঁদ — অসম্পূর্ণ if আর case

Combinational circuit-এর সংজ্ঞা: output নির্ভর করে শুধু এই মুহূর্তের input-এর ওপর (combinational logic বলতে এটাই বোঝায়)। কোনো স্মৃতি নেই। এখন এই block-টি দেখুন:

always @(*) begin
    if (en)
        q = d;       // en = 0 হলে q-কে কিছুই বলা হয়নি
end

en = 1 হলে q = d. কিন্তু en = 0 হলে? Block-টি জাগে, if মেলে না, q-তে কিছুই লেখা হয় না। Verilog-এর নিয়ম বলে — যে variable-এ মান লেখা হয়নি, সে তার আগের মান ধরে রাখে। “আগের মান ধরে রাখা” মানে স্মৃতি, আর স্মৃতি মানে আর combinational নয়। Synthesis tool তখন লেখার অর্থ রক্ষা করতে একটি latch বসায় — একটি level-sensitive স্মৃতি-উপাদান, যা en = 1 থাকাকালীন d-কে পার হতে দেয় আর en = 0 হলে শেষ মানটি আটকে রাখে (পর্ব ১৫-এ D latch বিস্তারিত)। একে বলে inferred latch — আপনি চাননি, tool অনুমান করে বসিয়েছে।

Latch নিজে খারাপ জিনিস নয়, কিন্তু অনিচ্ছাকৃত latch প্রায় সবসময় ভুল: (১) চেয়েছিলেন gate, পেলেন স্মৃতি; (২) clock ছাড়া স্মৃতি থাকায় timing হিসাব (পর্ব ১৮) কঠিন হয়; (৩) en-এ একটি ছোট glitch-এও ভুল মান আটকে যেতে পারে। একই সমস্যা case-এ কোনো মান বাদ পড়লেও। চলুন একটি অসম্পূর্ণ case চালিয়ে দেখি, input বদলাতে থাকলে y কেমন আচরণ করে (a = 1, b = 0, c = 1 স্থির):

1always @(*) begin2  case (sel)3    2'b00: y = a;4    2'b01: y = b;5    2'b10: y = c;6    // 2'b11: কিছু লেখা নেই!7    default: y = 1'b0;  // ধাপ ৬-এর fix8  endcase9end

এবার একই ধারণা একটি ছোট explainer দিয়ে দেখা যাক। নিচের JavaScript-এ একটি always @(*) block ডেটা হিসেবে লেখা — শাখার তালিকা (শর্ত আর মান) আর একটি ঐচ্ছিক else/default অংশ। Program-টি সব input-এর truth table বানায়, আর যে সারিতে কোনো শাখা মান দেয় না সেখানে লেখে “q_prev” — আগের মান। তারপর সময়ের সাথে একটি input-ধারা চালিয়ে দুই নকশার q পাশাপাশি দেখায়:

// Latch-inference explainer. A combinational always block is written as data:
// a list of branches [condition, value]; "dflt" is the else/default part (or null).
const leaky = { code: "if (en) q = d;",               branches: [[s => s.en === 1, s => s.d]], dflt: null };
const fixed = { code: "if (en) q = d; else q = 1'b0;", branches: [[s => s.en === 1, s => s.d]], dflt: () => 0 };

function evalBlock(blk, s, prev) {             // what does q become for inputs s?
  for (const [cond, val] of blk.branches) if (cond(s)) return { q: val(s), set: true };
  return blk.dflt ? { q: blk.dflt(s), set: true } : { q: prev, set: false };
}
function truthTable(blk) {
  console.log(`== always @(*) ${blk.code}`);
  console.log("   en d | q");
  let holds = 0;
  for (const en of [0, 1])
    for (const d of [0, 1]) {
      const r = evalBlock(blk, { en, d }, "q_prev");
      if (!r.set) holds++;
      console.log(`   ${en}  ${d} | ${r.set ? r.q : "q_prev  <- no assignment: keep old value"}`);
    }
  console.log(holds ? `   ${holds} row(s) need memory -> synthesis infers a LATCH`
                    : "   every row assigns q -> pure combinational logic, no latch");
}
truthTable(leaky);
truthTable(fixed);

const inputs = [[1, 1], [0, 0], [0, 1], [1, 0], [0, 1]];   // (en, d) over time
let qL = 0, qF = 0;
console.log("time  en d | q(leaky) q(fixed)");
inputs.forEach(([en, d], t) => {
  qL = evalBlock(leaky, { en, d }, qL).q;
  qF = evalBlock(fixed, { en, d }, qF).q;
  console.log(`  ${t * 10}`.padEnd(6) + `  ${en}  ${d} |    ${qL}        ${qF}`);
});

== always @(*) if (en) q = d;
   en d | q
   0  0 | q_prev  <- no assignment: keep old value
   0  1 | q_prev  <- no assignment: keep old value
   1  0 | 0
   1  1 | 1
   2 row(s) need memory -> synthesis infers a LATCH
== always @(*) if (en) q = d; else q = 1'b0;
   en d | q
   0  0 | 0
   0  1 | 0
   1  0 | 0
   1  1 | 1
   every row assigns q -> pure combinational logic, no latch
time  en d | q(leaky) q(fixed)
  0     1  1 |    1        1
  10    0  0 |    1        0
  20    0  1 |    1        0
  30    1  0 |    0        0
  40    0  1 |    0        0

৮ · Testbench — নকশাকে পরীক্ষায় বসানো, আর simulation বনাম synthesis

একটি testbench নিজেও একটি Verilog module, কিন্তু এর কোনো port নেই — এটি পুরো একটি “পরীক্ষাগার”। ভেতরে যা পরীক্ষা হবে সেই নকশাকে একটি instance হিসেবে বসানো হয় (প্রচলিত নাম dut — device under test), তারপর একটি initial block সময় ধরে ধরে input দেয় আর output যাচাই করে। এটি কখনো hardware হয় না; শুধু simulator-এ চলে। তাই এখানে এমন সব construct ব্যবহার করা যায় যা synthesis-এ চলে না। নিচে ৪-বিট adder-এর একটি সম্পূর্ণ, self-checking testbench:

`timescale 1ns/1ps
module tb_adder4;
    reg  [3:0] a, b;
    reg        cin;
    wire [3:0] sum;
    wire       cout;
    integer    i, j, errors;

    adder4 dut (.a(a), .b(b), .cin(cin), .sum(sum), .cout(cout));

    initial begin
        $dumpfile("adder4.vcd");          // waveform file for GTKWave
        $dumpvars(0, tb_adder4);
        errors = 0;
        cin    = 1'b0;
        for (i = 0; i < 16; i = i + 1) begin
            for (j = 0; j < 16; j = j + 1) begin
                a = i[3:0];  b = j[3:0];
                #10;                         // wait 10 ns: let the adder settle
                if ({cout, sum} !== i + j) begin
                    $display("FAIL: %0d + %0d -> cout=%b sum=%b", i, j, cout, sum);
                    errors = errors + 1;
                end
                if (i == 9 && j == 7)
                    $display("t=%0d ns  a=%b b=%b -> cout=%b sum=%b", $time, a, b, cout, sum);
            end
        end
        $display("%0d tests, %0d errors", 256, errors);
        $finish;
    end
endmodule

প্রতিটি অংশ কী করে:

• `timescale 1ns/1ps — সময়ের একক: #10 মানে ১০ ns, আর হিসাবের সূক্ষ্মতা ১ ps.
• Input গুলো reg, output গুলো wire — কারণ testbench নিজে initial block থেকে input-এ মান লেখে, আর output চালায় dut.
• initial begin … end — simulation শুরুর মুহূর্তে একবার চলে, ওপর থেকে নিচে (always চলে বারবার)।
• #10; — delay: ১০ ns অপেক্ষা। এই সময়ে simulator dut-এর সব assign হিসাব করে নেয়। Delay না দিলে পুরোনো মান পড়ার ঝুঁকি থাকত।
• দুই স্তরের for loop — সব ২৫৬টি জোড়া, অর্থাৎ exhaustive পরীক্ষা। i[3:0] লিখে ৩২-বিট integer থেকে নিচের ৪ বিট নেওয়া হয়েছে।
• {cout, sum} !== i + j — self-checking: প্রত্যাশিত মান testbench নিজেই হিসাব করে, মানুষকে চোখ দিয়ে দেখতে হয় না। !== (চার-মান তুলনা) ব্যবহার করা হয়েছে যাতে output-এ x বা z এলেও FAIL ধরা পড়ে; সাধারণ !=-এ x এলে ফল হয় x, আর if সেটিকে মিথ্যা ধরে — ভুল চুপচাপ পার পেয়ে যেত।
• $display — C-এর printf-এর মতো; %b binary, %0d দশমিক, $time বর্তমান সময়। $monitor একবার লিখলে তালিকার যেকোনো সংকেত বদলালেই নিজে থেকে একটি লাইন ছাপে — ছোট পরীক্ষায় সুবিধাজনক: initial $monitor("t=%0d a=%b b=%b sum=%b", $time, a, b, sum);
• $dumpfile/$dumpvars — প্রতিটি সংকেতের সময়-বনাম-মান একটি VCD ফাইলে লেখে, যা GTKWave-এর মতো viewer-এ waveform হিসেবে দেখা যায়।
• $finish — simulation শেষ। এটি না থাকলে কিছু testbench (যেমন clock চালানো) চিরকাল চলতে পারে।

নিজের কম্পিউটারে Icarus Verilog দিয়ে চারটি ফাইল (half_adder, full_adder, adder4 আর testbench) একসাথে compile করে চালালে আউটপুট এমন হওয়ার কথা। এটি উদাহরণ — এই পাতায় চালানো হয়নি; সংখ্যাগুলো উপরের JavaScript simulator-এর সাথে মেলে, শেষ লাইনের রূপ Icarus-এর সংস্করণভেদে সামান্য আলাদা হতে পারে:

$ iverilog -o adder4_tb.vvp tb_adder4.v adder4.v full_adder.v half_adder.v
$ vvp adder4_tb.vvp
VCD info: dumpfile adder4.vcd opened for output.
t=1520 ns  a=1001 b=0111 -> cout=1 sum=0000
256 tests, 0 errors
tb_adder4.v:29: $finish called at 2560000 (1ps)

সময়গুলো হিসাব করে দেখুন: (i, j) = (৯, ৭) হলো ৯ × ১৬ + ৭ = ১৫১তম জোড়া (০ থেকে গুনলে), তার আগে ১৫১টি আর নিজের একটি #10 মিলে ১৫২ × ১০ = ১৫২০ ns. আর পুরো ২৫৬টি জোড়ায় ২৫৬ × ১০ = ২৫৬০ ns = ২৫,৬০,০০০ ps — শেষ লাইনে সময় ps-এ (সূক্ষ্মতার এককে) ছাপা হয়।

Simulation বনাম synthesis — কোনটা hardware হয়, কোনটা হয় না

Verilog প্রথমে তৈরি হয়েছিল simulation-এর ভাষা হিসেবে; synthesis পরে এসে তার একটি অংশকে বেছে নিয়েছে। তাই ভাষার সবকিছু hardware-এ রূপান্তরযোগ্য নয়:

Synthesis tool আসলে কী দেয়? একটি netlist — একটি লক্ষ্য-প্রযুক্তির মৌলিক উপাদানের তালিকা আর তাদের সংযোগ। ASIC-এর জন্য সেই উপাদান হলো কারখানার standard cell (NAND2, XOR2, flip-flop …); FPGA-র জন্য LUT, flip-flop আর বিশেষ ব্লক। পথে tool Boolean সরলীকরণ করে আর timing-এর লক্ষ্য মেলাতে কাঠামো বদলায়।

একটু আগাম দেখা: clock আর <=

এই পর্বের সব নকশা combinational — কোনো স্মৃতি নেই। স্মৃতিওয়ালা (sequential) circuit-এর জন্য Verilog-এ আরেক রকম block আছে, যা মডিউল ৩-এ (পর্ব ১৫–১৯) বিস্তারিত শিখবেন। শুধু চেহারাটা চিনে রাখুন:

always @(posedge clk)    // only at the rising edge of the clock
    q <= d;              // non-blocking: q takes d at the clock edge

@(posedge clk) মানে block-টি শুধু clock-এর উঠন্ত ধারে জাগে — অন্য সময় q যা আছে তাই, অর্থাৎ এটি একটি flip-flop. আর <= হলো non-blocking assignment: একই clock ধারের সব <= আগে ডান পাশ পড়ে নেয়, তারপর একসাথে বাঁ পাশে বসায় — যেমন বাস্তবে সব flip-flop একই মুহূর্তে মান নেয়। সংক্ষিপ্ত নিয়ম, যা পর্ব ১৫–১৭-এ বারবার কাজে লাগবে: combinational → always @(*) + =; sequential → always @(posedge clk) + <=. দুটি মেশালে simulation আর hardware-এর অমিলের মতো কঠিন ভুল তৈরি হয়। পর্ব ১৭-এ FSM আর পর্ব ১৯-এর traffic light প্রজেক্টে এই দুই ধরনের block একসাথে ব্যবহার হবে।

৯ · Tool, FPGA আর কাজের জগৎ

Verilog শিখতে দামি software লাগে না। কয়েকটি পরিচিত বিনামূল্যের (open-source) tool:

এই পাতার runner-এ এগুলোর কোনোটি আছে কি না, নিচের bash script খুঁজে দেখে — প্রতিটি পরীক্ষা command -v দিয়ে সুরক্ষিত, তাই না থাকলেও script ভাঙবে না:

# Are open-source Verilog tools installed on this runner? Every check is guarded.
echo "machine: $(uname -m)"
found=0
for tool in iverilog vvp verilator yosys gtkwave; do
  if command -v "$tool" >/dev/null 2>&1; then
    echo "  $tool : found"; found=$((found + 1))
  else
    echo "  $tool : not installed here"
  fi
done
echo "Verilog tools found: $found of 5"
if command -v gcc >/dev/null 2>&1; then
  echo "gcc: found (a C compiler, not a Verilog simulator)"
else
  echo "gcc: not found either"
fi
if [ "$found" -eq 0 ]; then
  echo "=> Run the Verilog on this page on your own computer or in an online simulator."
fi

machine: x86_64
  iverilog : not installed here
  vvp : not installed here
  verilator : not installed here
  yosys : not installed here
  gtkwave : not installed here
Verilog tools found: 0 of 5
gcc: found (a C compiler, not a Verilog simulator)
=> Run the Verilog on this page on your own computer or in an online simulator.

Ubuntu বা Debian-ধাঁচের Linux-এ (Windows-এ WSL দিয়েও) সাধারণত package manager দিয়েই বসানো যায়। এটি উদাহরণ — package-এর নাম ও সংস্করণ distribution ভেদে আলাদা হতে পারে:

$ sudo apt install iverilog gtkwave yosys verilator
$ iverilog -g2012 -o tb.vvp tb_adder4.v adder4.v full_adder.v half_adder.v && vvp tb.vvp
$ gtkwave adder4.vcd                               # waveform
$ verilator --lint-only -Wall alu.v                # warnings: width, latch, unused...
$ yosys -p "synth -top adder4; stat" adder4.v full_adder.v half_adder.v

FPGA-র ভেতরে কী আছে

অংশ ১-এ দেখেছেন, FPGA-তে gate নেই, আছে LUT (look-up table). একটি k-input LUT আসলে ২^k বিটের একটি ছোট মেমরি: k টি input মিলে একটি ঠিকানা, আর সেই ঠিকানায় রাখা বিটটিই output. তাই k টি input-এর যেকোনো Boolean function একটি LUT-এ বসে যায় — শুধু truth table-টি মেমরিতে লিখে দিলেই হলো। ৪-input LUT-এ ১৬ বিট, ৬-input LUT-এ ৬৪ বিট; আধুনিক অনেক FPGA ৬-input বা তার কাছাকাছি LUT ব্যবহার করে। এর সাথে FPGA-তে থাকে:

• Flip-flop — প্রতিটি LUT-এর পাশে সাধারণত এক বা একাধিক; sequential নকশার স্মৃতি (মডিউল ৩)।
• Programmable routing — হাজার হাজার তার আর switch, যা ঠিক করে কোন LUT-এর output কোন LUT-এর input-এ যাবে।
• বিশেষ ব্লক — block RAM (মেমরি), DSP ব্লক (দ্রুত গুণ), clock-এর ব্যবস্থা, আর বাইরের সাথে যোগাযোগের I/O pin.

এই সব উপাদানের প্রতিটি switch আর প্রতিটি LUT-এর বিট কী হবে, তা লেখা থাকে bitstream-এ। বেশিরভাগ FPGA-তে এই configuration SRAM-এ থাকে, তাই বিদ্যুৎ গেলে মুছে যায় আর চালু হওয়ার সময় একটি flash chip থেকে আবার load হয়। নতুন নকশা দিলে একই chip অন্য circuit হয়ে যায় — prototype, ছোট পরিসরের পণ্য আর গবেষণায় এই নমনীয়তাই FPGA-র শক্তি। Microcontroller, SoC আর embedded সিস্টেমের কথা পর্ব ৫৬-এ আসবে।

কাজের জগৎ

HDL জানা থাকলে কয়েক ধরনের কাজের দরজা খোলে: RTL design engineer (Verilog/SystemVerilog-এ block নকশা), design verification engineer (testbench, UVM, coverage — সংখ্যায় সম্ভবত সবচেয়ে বেশি পদ), FPGA engineer (টেলিকম, শিল্প-নিয়ন্ত্রণ, প্রতিরক্ষা, গবেষণা), আর synthesis-পরবর্তী physical design. বাংলাদেশে কয়েকটি প্রতিষ্ঠান বিদেশি chip কোম্পানির জন্য design, verification আর physical design-এর সেবা দেয় বলে জানা যায়, আর বিশ্ববিদ্যালয়গুলোতে VLSI ও FPGA-ভিত্তিক গবেষণাও চলছে; তবে সুযোগের ধরন ও সংখ্যা সময়ের সাথে বদলায় — নিজে খোঁজ নিয়ে সাম্প্রতিক তথ্য যাচাই করুন। প্রস্তুতির সবচেয়ে ভালো প্রমাণ নিজের একটি প্রকল্প — যেমন একটি সরল CPU Verilog-এ লিখে testbench দিয়ে যাচাই করা।

১০ · AI-এর যুগে — Verilog AI দিয়ে, যাচাই simulation দিয়ে

AI-কে একটি 4:1 mux-এর Verilog লিখে দিতে বললে কয়েক সেকেন্ডে উত্তর আসে, আর ছোট নকশায় প্রায়ই ঠিকও হয়। কিন্তু hardware-এ ভুলের দাম software-এর চেয়ে অনেক বেশি — chip একবার তৈরি হলে “patch” দেওয়া যায় না। এই বিষয়ে AI-এর সাধারণ ভুলগুলো:

• Non-synthesizable কোড: নকশার ভেতরে #5 delay, initial দিয়ে মান বসানো, বা testbench-এর construct মিশিয়ে দেওয়া।
• Latch: combinational block-এ else বা default বাদ দেওয়া; একাধিক output-এর মধ্যে কোনোটিকে কোনো শাখায় মান না দেওয়া।
• = আর <= গুলিয়ে ফেলা: clock-চালিত block-এ =, বা combinational block-এ <=.
• বিট-মাপের ভুল: carry হারানো (৪-বিট যোগফল ৪-বিট তারে), signed/unsigned গুলিয়ে তুলনা, [0:3] আর [3:0] উল্টে ফেলা।
• C-এর মতো ভাবা: assign-এর ক্রমে অর্থ খোঁজা, বা hardware-এ চলার সময় বদলানো loop সীমা লেখা।
• বানানো তথ্য: FPGA-র LUT সংখ্যা, chip-এর spec, tool-এর option বা সংস্করণের নাম ভুল বলা।

AI-এর দেওয়া Verilog যাচাইয়ের চেকলিস্ট

• নকশার ফাইলে কোনো # delay, initial বা $-function নেই — সেগুলো শুধু testbench-এ
• প্রতিটি combinational block-এ প্রতিটি output প্রতিটি পথে মান পায় (default/else/default case)
• নিজে একটি testbench চালিয়েছি (Icarus বা online simulator), আর FAIL শূন্য — ছোট নকশায় সব input দিয়ে
• Lint (যেমন verilator --lint-only -Wall) চালিয়ে width, latch আর unused সংকেতের সতর্কবার্তা পড়েছি
• Synthesis (যেমন Yosys stat) চালিয়ে দেখেছি latch বা অপ্রত্যাশিত flip-flop তৈরি হয়নি; chip-এর spec ডেটাশিটে মিলিয়েছি