실행 가능한 Verilog 문서: Testbench 기초

Q: Verilog testbench에서 클럭은 어떻게 생성하나요?

표준 패턴은 한 줄입니다: always #5 clk = ~clk;(앞서 reg clk = 0;로 선언). 5 시뮬레이션 시간 단위마다 clk을 토글하여 10 단위 주기(timescale이 ns라면 100 MHz 클럭)를 만듭니다. #5는 반주기 - clk이 high인 시간 절반, low인 시간 절반.

Q: Verilog의 DUT란?

DUT는 Design Under Test - testbench가 동작시키는 모듈입니다. 관례는 testbench에서 DUT 인스턴스를 dut 또는 udut로 명명하는 것: mymodule dut(.clk(clk), .reset(reset), .in(in), .out(out));. 이름은 라벨일 뿐이고, 중요한 건 인스턴스화되었고 포트가 testbench 신호에 연결되어 있으며 testbench가 그 신호를 구동한다는 점입니다.

Q: Verilog 시뮬레이션은 얼마나 길게 돌려야 하나요?

검증하고 싶은 모든 것을 충분히 동작시킨 뒤 $finish. 대부분의 testbench는 명시적 시간 제한(#1000 $finish)을 설정해 결코 오지 않는 이벤트를 기다리며 hang하지 않게 합니다. 그 안에서 자극을 구동하고, DUT가 안정되게 두고, 이상적으로는 출력이 기대와 일치하지 않으면 FAIL을 출력하는 자체 검증 if를 포함하세요.

testbench가 실제로 무엇인가

testbench는 그냥 Verilog 모듈입니다. synthesizable 모듈과의 차이는 안쪽에 있는 것입니다.

port가 없음 - 시뮬레이션 계층의 최상위.
DUT를 인스턴스화 함.
initial과 always 블록으로 DUT의 입력을 구동 함.
$display, $monitor 또는 VCD dump로 DUT의 출력을 관찰 함.
$finish로 시뮬레이션을 종료 함.

그게 일 전부입니다. "testbench"라는 특별한 키워드는 없습니다 - testbench인지를 아는 방법은 그것이 무엇을 하는지 읽어 보는 것입니다.

표준 골격

// Design under test: 테스트할 작은 모듈.
module adder(
    input  wire [7:0] a,
    input  wire [7:0] b,
    output wire [8:0] sum
);
    assign sum = a + b;
endmodule

// testbench: 이 파일의 나머지.
module test;
    // -----------------------------------------------------------------
    // 1. DUT를 구동하고 출력을 관찰할 신호.
    // -----------------------------------------------------------------
    reg  [7:0] a;
    reg  [7:0] b;
    wire [8:0] sum;

    // -----------------------------------------------------------------
    // 2. DUT 인스턴스화.
    // -----------------------------------------------------------------
    adder dut(.a(a), .b(b), .sum(sum));

    // -----------------------------------------------------------------
    // 3. 자극 + 라이프사이클.
    // -----------------------------------------------------------------
    initial begin
        $dumpfile("dump.vcd");
        $dumpvars(0, test);

        // 흥미로운 입력 조합 몇 가지 구동.
        a = 8'd0;   b = 8'd0;   #1 $display("%0d + %0d = %0d", a, b, sum);
        a = 8'd1;   b = 8'd2;   #1 $display("%0d + %0d = %0d", a, b, sum);
        a = 8'd200; b = 8'd100; #1 $display("%0d + %0d = %0d", a, b, sum);
        a = 8'hFF;  b = 8'h01;  #1 $display("%h + %h = %h",   a, b, sum);

        $finish;
    end
endmodule

이게 전체 패턴입니다. 다섯 섹션, 복붙하기 쉽고 적용하기 쉬움.

조합 DUT(가산기 같은)에는 클럭이 필요 없습니다. 순차 DUT에는 필요한데, 그게 다음 단계입니다.

순차 DUT를 위한 클럭 생성

DUT에 clk 입력이 있다면 testbench가 그것을 만들어야 합니다. 표준 한 줄.

reg clk = 0;
always #5 clk = ~clk;

5 시간 단위마다 clk을 토글합니다. 각 토글이 클럭 주기의 반이므로 전체 주기는 10 단위입니다(한 사이클 = high 5 + low 5). timescale이 1ns / 1ps(대부분 시뮬레이터 기본)라면 100 MHz 클럭입니다.

모델링하려는 것에 맞춰 반주기를 고르세요. 같은 timescale에서 10 MHz 클럭이라면 #50. 200 MHz라면 #2.5(또는 timescale 변경).

reset 시퀀스

동기 설계는 시간 0 이후 몇 사이클 동안 high로 유지되었다가 풀리는 reset이 필요합니다. 관례적 모양.

reg reset = 1;     // assert로 시작

initial begin
    // 몇 클럭간 reset 유지.
    #20 reset = 0;
end

reset을 시간 20까지 high로 유지한 뒤 떨어뜨립니다. reset이 떨어질 무렵 클럭이 몇 사이클 돌아 모든 플립플롭이 reset 값을 포착했고 설계는 알려진 상태입니다.

active-low reset(reset 대신 reset_n)이라면 초기값을 뒤집으세요.

reg reset_n = 0;   // active-low: 0이 assert

initial begin
    #20 reset_n = 1;
end

완전한 순차 testbench

클럭, reset, 자극을 결합한 모습.

module counter(
    input  wire       clk,
    input  wire       reset,
    input  wire       enable,
    output reg  [3:0] count
);
    always @(posedge clk) begin
        if (reset)       count <= 4'd0;
        else if (enable) count <= count + 4'd1;
    end
endmodule

module test;
    // -- DUT 신호 --
    reg  clk = 0;
    reg  reset = 1;
    reg  enable = 0;
    wire [3:0] count;

    // -- DUT 인스턴스 --
    counter dut(.clk(clk), .reset(reset), .enable(enable), .count(count));

    // -- 클럭 생성기 (10 단위 주기) --
    always #5 clk = ~clk;

    // -- 자극 --
    initial begin
        $dumpfile("dump.vcd");
        $dumpvars(0, test);

        #20 reset = 0;        // 2 사이클 후 reset 해제
        #5  enable = 1;       // 카운팅 시작
        #80 enable = 0;       // 일시 정지
        #20 enable = 1;       // 재개
        #20 $finish;          // 총 시뮬레이션: ~145 단위
    end

    // -- 매 rising edge에서 모니터링 --
    always @(posedge clk) begin
        $display("t=%0t reset=%b enable=%b count=%0d",
                 $time, reset, enable, count);
    end
endmodule

4비트 카운터의 완전한 testbench입니다. Run을 누르면 카운터가 reset에서 나와 enable되는 동안 증가하고, enable이 떨어지면 멈추고, 다시 올라가면 재개되었다가 정지하는 것을 봅니다.

구조에서 주목할 세 가지.

세 개의 별개 활동 위치: 클럭 생성기(always 하나), 자극(initial 하나), 모니터(또 다른 always). 각각 한 가지 일.
자극 블록의 # 지연은 시간 단위 기준 - 클럭 사이클이 아닙니다. 클럭 주기가 10 단위라면 #10이 정확히 한 사이클. 일부 testbench는 대신 @(posedge clk)를 써서 주기와 무관하게 한 사이클씩 진행.
모니터는 always @(posedge clk) 블록의 $display. 매 사이클 출력. 더 정교한 출력은 $monitor(다음에 다룸)로 전환.

사이클 기반 자극

가끔 "N 사이클 대기"가 "N 시간 단위 대기"보다 읽기 좋습니다.

initial begin
    @(posedge clk);     // 다음 클럭 edge까지 대기
    reset = 0;

    repeat (5) @(posedge clk);   // 5 사이클 더 대기
    enable = 1;

    repeat (8) @(posedge clk);
    enable = 0;

    repeat (10) @(posedge clk);
    $finish;
end

@(posedge clk)는 다음 rising 클럭 edge까지 차단합니다. repeat (N) @(posedge clk);는 N 사이클 대기합니다. 이 스타일은 클럭 주기와 무관합니다 - 클럭 주파수를 바꿔도 사이클 측면에서 같은 일을 합니다.

초기 testbench에는 # 지연이 단순합니다. 여러 클럭 속도로 돌 수 있는 프로덕션 testbench에는 사이클 기반이 더 안전합니다.

자체 검증 테스트

지금까지의 testbench는 일어난 일을 출력하고 출력을 읽는 건 여러분 몫이었습니다. 자체 검증 testbench는 대신 출력을 검사 하고 pass/fail을 보고합니다.

initial begin
    #1;
    a = 10; b = 20;
    #1;
    if (sum !== 30) begin
        $display("FAIL: 10 + 20 = %0d (expected 30)", sum);
        $finish;
    end
    a = 250; b = 5;
    #1;
    if (sum !== 255) begin
        $display("FAIL: 250 + 5 = %0d (expected 255)", sum);
        $finish;
    end

    $display("PASS");
    $finish;
end

안전을 위해 !==(case-inequality 연산자)를 쓰세요 - 한쪽 피연산자에 unknown 비트가 있어도 x를 반환하지 않습니다. 패턴: 입력 구동, 안정 대기, 기대치 대조, pass/fail 보고.

자체 검증은 regression 스위트에서 무가치합니다: 수천 개 테스트가 무인으로 돌고 실패만이 주목을 받습니다.

다음에 볼 내용

이제 어떤 모듈에도 충분한 testbench 모양을 갖췄습니다. 다음 문서들은 testbench 안에 들어가는 도구를 다룹니다: 풍부한 텍스트 출력을 위한 Display and Monitor, 그래픽 파형 디버깅을 위한 Dumpfile and VCD, 그리고 시뮬레이션 시간이 실제 시간과 어떻게 연결되는지 정확히 제어하는 Timescale and Delays.

자주 묻는 질문

Verilog의 testbench란?

testbench는 Verilog 모듈입니다 - 보통 port가 없는 - 그 유일한 목적은 design under test(DUT)를 동작시키는 것입니다. DUT를 인스턴스화하고, 클럭을 생성하고, initial과 always 블록으로 자극을 구동하고, $display/$monitor로 출력을 관찰하고, 선택적으로 VCD 파형을 dump하고, $finish로 시뮬레이션을 종료합니다.

Verilog testbench에서 클럭은 어떻게 생성하나요?

표준 패턴은 한 줄입니다: always #5 clk = ~clk;(앞서 reg clk = 0;로 선언). 5 시뮬레이션 시간 단위마다 clk을 토글하여 10 단위 주기(timescale이 ns라면 100 MHz 클럭)를 만듭니다. #5는 반주기 - clk이 high인 시간 절반, low인 시간 절반.

Verilog의 DUT란?

DUT는 Design Under Test - testbench가 동작시키는 모듈입니다. 관례는 testbench에서 DUT 인스턴스를 dut 또는 u_dut로 명명하는 것: my_module dut(.clk(clk), .reset(reset), .in(in), .out(out));. 이름은 라벨일 뿐이고, 중요한 건 인스턴스화되었고 포트가 testbench 신호에 연결되어 있으며 testbench가 그 신호를 구동한다는 점입니다.

Verilog 시뮬레이션은 얼마나 길게 돌려야 하나요?

검증하고 싶은 모든 것을 충분히 동작시킨 뒤 $finish. 대부분의 testbench는 명시적 시간 제한(#1000 $finish)을 설정해 결코 오지 않는 이벤트를 기다리며 hang하지 않게 합니다. 그 안에서 자극을 구동하고, DUT가 안정되게 두고, 이상적으로는 출력이 기대와 일치하지 않으면 FAIL을 출력하는 자체 검증 if를 포함하세요.