SystemVerilog 테스트벤치 완벽 가이드: Verilog를 넘어서

🚀 SystemVerilog 테스트벤치 완벽 가이드

Verilog를 넘어서 — 현대적 검증 환경 구축을 위한 필수 기능 총정리

Verilog만으로 테스트벤치를 작성하고 계신가요? SystemVerilog는 OOP, 병렬 처리, 랜덤 검증, Assertion 등 현대적 검증에 필수적인 강력한 기능들을 제공합니다. 이 글에서는 각 기능의 개념부터 실전 코드 예제까지, 테스트벤치 작성에 필요한 모든 것을 정리합니다.

📋 목차

1. Verilog vs SystemVerilog
2. fork-join 병렬 실행
3. OOP (클래스와 객체)
4. 고급 데이터 타입
5. 랜덤화와 제약조건
6. 프로세스 간 통신
7. Interface
8. Clocking Block
9. Assertion (SVA)
10. Functional Coverage
11. Program Block
12. 실전 팁

⚡ 1. Verilog vs SystemVerilog

먼저 Verilog와 SystemVerilog의 주요 차이점을 비교합니다.

기능	Verilog	SystemVerilog
병렬 실행	제한적 (always만)	fork-join, join_any, join_none
OOP	❌ 없음	✅ class, 상속, 다형성
랜덤화	$random만	rand, constraint, randomize()
데이터 타입	reg, wire, integer	logic, bit, enum, struct, queue
Assertion	❌ 없음	✅ SVA (property, assert)
Coverage	❌ 없음	✅ covergroup, coverpoint
IPC	❌ 없음	✅ mailbox, semaphore
Interface	❌ 없음	✅ interface, modport

🔀 2. fork-join 병렬 실행

🔀 Concurrent Execution

fork-join은 여러 프로세스를 동시에 실행하고 동기화하는 구문입니다.

세 가지 변형

구문	동작	사용 시점
join	모든 프로세스 완료 대기	모든 작업 완료 필요
join_any	하나라도 완료되면 진행	타임아웃, 경쟁 조건
join_none	대기 없이 즉시 진행	백그라운드 모니터링

📊 fork-join 실행 다이어그램 Time → 0 10 20 30 40 50 60 │ │ │ │ │ │ │ Main ●━━━━━fork━━━━━━━━━━━━━━━━━━━━━━join━━━━● │ │ Thread 1 ├─────████████████████──────┤ (30 units) Thread 2 ├─────████████────────────────┤ (15 units) Thread 3 ├─────████████████████████──┤ (40 units) │ │ └──────────────────────────────┘ join: 모든 완료 대기 join_any: Thread 2 완료(15) 시점에 진행 join_none: fork 직후 즉시 진행

📄 SystemVerilog: fork-join 예제

initial begin $display("[%0t] Start", $time); fork // Thread 1: 드라이버 begin #20; $display("[%0t] Driver done", $time); end // Thread 2: 모니터 begin #10; $display("[%0t] Monitor done", $time); end // Thread 3: 타임아웃 begin #100; $display("[%0t] Timeout!", $time); end join_any // 첫 번째 완료 시 진행 (Monitor @ 10) disable fork; // 나머지 스레드 종료! $display("[%0t] All threads terminated", $time); end

⚠️ disable fork 주의

disable fork는 현재 스코프의 모든 자식 스레드를 종료합니다.
의도치 않은 종료를 피하려면 fork...join을 별도 task로 감싸세요.

🎯 3. OOP (클래스와 객체)

🎯 Object-Oriented Programming

SystemVerilog의 클래스는 검증 컴포넌트를 구조화하는 핵심입니다.

📌 OOP 핵심 개념

• 캡슐화: 데이터와 메소드를 하나의 단위로 묶음
• 상속: 기존 클래스를 확장하여 새 클래스 생성
• 다형성: virtual 함수로 런타임 동작 결정
• 재사용: 한번 작성한 클래스를 여러 곳에서 사용

📄 SystemVerilog: Transaction 클래스

class Transaction; // 프로퍼티 (데이터 멤버) typedef enum { READ, WRITE, IDLE } op_type; rand op_type opcode; rand bit [7:0] addr; rand bit [31:0] data; // 제약조건 constraint c_addr { addr inside {[8'h00:8'h7F]}; // 유효 주소 범위 } // 생성자 function new(string name = "Transaction"); this.name = name; endfunction // 메소드 virtual function void print(); $display("[%s] op=%s addr=0x%h data=0x%h", name, opcode.name(), addr, data); endfunction // 복사 메소드 virtual function Transaction copy(); Transaction t = new(); t.opcode = this.opcode; t.addr = this.addr; t.data = this.data; return t; endfunction local string name; endclass

상속 예제

📄 SystemVerilog: 클래스 상속

// 기본 클래스 상속 class BurstTransaction extends Transaction; rand int burst_len; constraint c_burst { burst_len inside {[1:16]}; } // 부모 메소드 오버라이드 virtual function void print(); super.print(); // 부모 메소드 호출 $display(" burst_len=%0d", burst_len); endfunction endclass // 사용 예 initial begin Transaction tr; BurstTransaction btr = new(); btr.randomize(); btr.print(); // 다형성: 부모 타입 변수에 자식 객체 할당 tr = btr; tr.print(); // BurstTransaction의 print() 호출! end

📊 4. 고급 데이터 타입

📊 Advanced Data Types

주요 데이터 타입

타입	설명	예시
logic	4-state (0,1,X,Z), reg/wire 대체	`logic [7:0] data;`
bit	2-state (0,1), 시뮬레이션 빠름	`bit [31:0] addr;`
enum	열거형, 가독성 향상	`enum {IDLE, RUN} state;`
struct	구조체, 관련 데이터 그룹화	`struct {bit[7:0] a,b;} pkt;`
queue [$]	동적 배열, FIFO 용도	`int q[$];`
[key]	연관 배열, 해시맵	`int mem[string];`

📄 SystemVerilog: Queue 활용

// Queue: 동적 FIFO int q[$]; // 빈 큐 선언 initial begin // 삽입 q.push_back(10); // 뒤에 추가: [10] q.push_back(20); // [10, 20] q.push_front(5); // 앞에 추가: [5, 10, 20] // 조회 $display("Size: %0d", q.size()); // 3 $display("First: %0d", q[0]); // 5 // 추출 int val = q.pop_front(); // val=5, q=[10, 20] // 검색/삭제 q.delete(0); // 인덱스 0 삭제: [20] end

📄 SystemVerilog: 연관 배열 (Associative Array)

// 연관 배열: 키-값 매핑 (해시맵) int score[string]; // string 키, int 값 initial begin // 삽입 score["Alice"] = 95; score["Bob"] = 87; score["Carol"] = 92; // 조회 $display("Bob's score: %0d", score["Bob"]); // 존재 확인 if (score.exists("Dave")) $display("Dave exists"); else $display("Dave not found"); // 전체 순회 foreach (score[name]) $display("%s: %0d", name, score[name]); // 삭제 score.delete("Bob"); end

🎲 5. 랜덤화와 제약조건

🎲 Constrained Random Verification

CRV(Constrained Random Verification)는 현대 검증의 핵심입니다. 수동 테스트 대신 제약조건 내에서 랜덤 시나리오를 자동 생성합니다.

📄 SystemVerilog: 랜덤화 예제

class Packet; rand bit [7:0] header; rand bit [15:0] length; rand bit [3:0] priority; randc bit [1:0] channel; // 순환 랜덤 (0,1,2,3 각각 한번씩) // 제약조건 1: 범위 constraint c_length { length inside {[64:1518]}; // Ethernet 프레임 크기 } // 제약조건 2: 특정 값 constraint c_header { header inside {8'h01, 8'h02, 8'h04, 8'h08}; } // 제약조건 3: 가중치 분포 constraint c_priority { priority dist { 0 :/ 10, // 10% 확률 [1:3] :/ 20, // 1,2,3 각각 20/3% [4:7] :/ 30, // 4~7 각각 30/4% [8:15] :/ 40 // 8~15 각각 40/8% }; } // 제약조건 4: 조건부 (implication) constraint c_small_high_priority { (length < 128) -> (priority > 8); // 작은 패킷은 높은 우선순위 } endclass // 사용 initial begin Packet pkt = new(); repeat (10) begin if (!pkt.randomize()) $error("Randomization failed!"); $display("hdr=%h len=%0d pri=%0d ch=%0d", pkt.header, pkt.length, pkt.priority, pkt.channel); end // 인라인 제약조건 추가 pkt.randomize() with { length == 1024; // 이번만 length 고정 }; end

💡 랜덤화 팁

rand vs randc: rand는 매번 독립적, randc는 모든 값을 한번씩 순환
soft constraint: soft 키워드로 우선순위 낮은 제약 설정
constraint mode: constraint_name.constraint_mode(0)으로 비활성화

📬 6. 프로세스 간 통신

📬 Inter-Process Communication

병렬 프로세스 간 데이터 전달을 위한 Mailbox와 Semaphore를 제공합니다.

📬 Mailbox

FIFO 큐 기반 메시지 전달
• put(): 데이터 삽입
• get(): 데이터 추출 (블로킹)
• try_get(): 논블로킹

🔐 Semaphore

공유 자원 접근 제어
• get(): 키 획득 (블로킹)
• put(): 키 반환
• try_get(): 논블로킹

📄 SystemVerilog: Mailbox 예제 (Generator-Driver)

class Generator; mailbox #(Transaction) mbx; function new(mailbox #(Transaction) m); this.mbx = m; endfunction task run(int count); repeat (count) begin Transaction tr = new(); tr.randomize(); mbx.put(tr); // 메일박스에 전송 $display("[GEN] Sent transaction"); end endtask endclass class Driver; mailbox #(Transaction) mbx; virtual my_if vif; task run(); Transaction tr; forever begin mbx.get(tr); // 메일박스에서 수신 (블로킹) drive_transaction(tr); end endtask task drive_transaction(Transaction tr); @(posedge vif.clk); vif.addr <= tr.addr; vif.data <= tr.data; $display("[DRV] Driving addr=%h", tr.addr); endtask endclass // 테스트벤치에서 연결 initial begin mailbox #(Transaction) mbx = new(); // 공유 메일박스 Generator gen = new(mbx); Driver drv = new(mbx); fork gen.run(10); // 10개 트랜잭션 생성 drv.run(); // 드라이버 실행 join_any end

🔌 7. Interface

🔌 Interface & Modport

Interface는 관련 시그널들을 하나로 묶어 연결을 단순화합니다.

📄 SystemVerilog: Interface 정의 및 사용

// Interface 정의 interface axi_lite_if (input logic clk, rst_n); // Write Address Channel logic [31:0] awaddr; logic awvalid; logic awready; // Write Data Channel logic [31:0] wdata; logic wvalid; logic wready; // Modport: DUT (Slave) 관점 modport SLAVE ( input clk, rst_n, input awaddr, awvalid, wdata, wvalid, output awready, wready ); // Modport: Testbench (Master) 관점 modport MASTER ( input clk, rst_n, output awaddr, awvalid, wdata, wvalid, input awready, wready ); endinterface // DUT 연결 module my_slave (axi_lite_if.SLAVE bus); always_ff @(posedge bus.clk) begin bus.awready <= bus.awvalid; end endmodule // Testbench module tb; logic clk = 0, rst_n = 0; always #5 clk = ~clk; // Interface 인스턴스 axi_lite_if axi_if (.clk(clk), .rst_n(rst_n)); // DUT 연결 my_slave dut (.bus(axi_if)); initial begin #10 rst_n = 1; @(posedge clk); axi_if.awaddr <= 32'h1000; axi_if.awvalid <= 1; end endmodule

⏱️ 8. Clocking Block

⏱️ Clocking Block

Clocking Block은 테스트벤치와 DUT 간 타이밍 경쟁 조건을 방지합니다.

📄 SystemVerilog: Clocking Block

interface my_if (input logic clk); logic [7:0] data; logic valid; logic ready; // Clocking Block 정의 clocking cb @(posedge clk); default input #1step output #1ns; // 샘플/드라이브 스큐 output data, valid; // TB가 드라이브 input ready; // TB가 샘플 endclocking modport TB (clocking cb); // TB는 clocking 통해서만 접근 endinterface // Driver에서 사용 class Driver; virtual my_if.TB vif; task drive(bit [7:0] d); vif.cb.data <= d; // clocking block 통해 드라이브 vif.cb.valid <= 1; @(vif.cb); // 다음 클럭 대기 wait (vif.cb.ready == 1); // ready 샘플 vif.cb.valid <= 0; endtask endclass

💡 Clocking Block 장점

• Race Condition 방지: 입력 샘플과 출력 드라이브 타이밍 분리
• 코드 가독성: 타이밍 의도가 명확히 드러남
• 재사용성: 인터페이스에 정의하면 모든 컴포넌트에서 공유

✅ 9. SystemVerilog Assertions (SVA)

✅ Assertions

SVA는 설계 속성을 선언적으로 검증합니다. 프로토콜 위반을 자동 감지합니다.

📄 SystemVerilog: Assertion 예제

// Immediate Assertion (즉시 검사) always @(posedge clk) begin assert (data !== 'x) else $error("Data is X!"); end // Concurrent Assertion (시퀀스 기반) // Property 정의: req 후 1~3 사이클 내 ack property p_req_ack; @(posedge clk) disable iff (!rst_n) req |-> ##[1:3] ack; // req가 1이면, 1~3 사이클 후 ack endproperty // Assertion 인스턴스 assert property (p_req_ack) else $error("ACK timeout!"); // Cover: 해당 시나리오가 발생했는지 확인 cover property (p_req_ack); // 복잡한 시퀀스 sequence s_write_burst; wr_en ##1 data_valid[*4] ##1 !wr_en; // wr_en, 4번 data, wr_en 해제 endsequence property p_burst_complete; @(posedge clk) s_write_burst |-> ##1 done; // burst 후 done 신호 endproperty

💡 SVA 연산자 정리

##N: N 사이클 후
##[M:N]: M~N 사이클 사이
|->: Overlapping implication (같은 사이클)
|=>: Non-overlapping implication (다음 사이클)
[*N]: N번 연속 반복
[*M:N]: M~N번 반복

📊 10. Functional Coverage

📊 Functional Coverage

Covergroup은 테스트가 얼마나 많은 시나리오를 커버했는지 측정합니다.

📄 SystemVerilog: Covergroup 예제

class Coverage; bit [7:0] addr; bit [1:0] cmd; bit [31:0] data; covergroup cg @(posedge clk); // Coverpoint 1: 주소 범위 cp_addr: coverpoint addr { bins low = {[0:63]}; bins mid = {[64:191]}; bins high = {[192:255]}; illegal_bins reserved = {8'hFF}; // 금지 영역 } // Coverpoint 2: 명령 타입 cp_cmd: coverpoint cmd { bins read = {2'b00}; bins write = {2'b01}; bins rmw = {2'b10}; // Read-Modify-Write } // Cross Coverage: addr × cmd 조합 cx_addr_cmd: cross cp_addr, cp_cmd; // Coverpoint 3: 데이터 특수값 cp_data: coverpoint data { bins zero = {32'h0}; bins all_ones = {32'hFFFF_FFFF}; bins others = default; } endgroup function new(); cg = new(); endfunction function void sample(bit[7:0] a, bit[1:0] c, bit[31:0] d); addr = a; cmd = c; data = d; cg.sample(); // 수동 샘플링 endfunction function void report(); $display("Coverage: %.2f%%", cg.get_coverage()); endfunction endclass

📦 11. Program Block

program 블록은 테스트벤치와 DUT를 타이밍적으로 분리합니다.

📌 Program vs Module

Module: 하드웨어 모델링, Delta Cycle에서 먼저 실행
Program: 테스트벤치 전용, Reactive Region에서 실행

💡 Program 내 시그널 변경은 해당 타임스텝에서 DUT에 영향 없음
→ Race Condition 방지

📄 SystemVerilog: Program Block 예제

program test (my_if.TB vif); initial begin $display("[PROGRAM] Test starting..."); // 리셋 시퀀스 vif.cb.valid <= 0; repeat (5) @(vif.cb); // 테스트 시퀀스 for (int i = 0; i < 10; i++) begin vif.cb.data <= i; vif.cb.valid <= 1; @(vif.cb); end $display("[PROGRAM] Test complete!"); end endprogram

🎯 12. 실전 팁

✅ 모범 사례

1. 계층적 구조: Generator → Driver → Monitor → Scoreboard
2. Interface 사용: 포트 연결 단순화, 재사용성 향상
3. Clocking Block: 타이밍 문제 사전 방지
4. Constrained Random: 수동 테스트 → CRV 전환
5. Coverage Driven: 커버리지 목표 설정 후 테스트
6. Assertion: 프로토콜 검증은 SVA로

❌ 안티패턴

1. #delay 남발: 절대 시간 대신 클럭 이벤트 사용
2. 글로벌 변수: 클래스로 캡슐화
3. 하드코딩: 파라미터/랜덤화 활용
4. fork 후 release 누락: disable fork 필수
5. Coverage 없이 진행: 목표 없는 테스트

📌 핵심 요약

기능	키워드	용도
병렬 실행	fork-join	Driver, Monitor 동시 실행
OOP	class	Transaction, Component 구조화
랜덤화	rand, constraint	CRV 테스트 자동화
IPC	mailbox	컴포넌트 간 통신
Assertion	property, assert	프로토콜 자동 검증
Coverage	covergroup	테스트 완료도 측정

다음 단계: 이 기능들을 체계화한 것이 UVM (Universal Verification Methodology)입니다. SystemVerilog 기본기를 익힌 후 UVM으로 발전시키세요!

📚 참고 자료

• SystemVerilog LRM: IEEE 1800-2017
• 추천 서적: "SystemVerilog for Verification" - Chris Spear
• 온라인: Verification Academy, ASIC World

이 블로그 검색

SoC Design