07 Behavioral Modeling

구조화된 절차

• Verilog에는 두 가지 구조화된 절차 문이 있음
• always와 initial은 행동 모델링에서 가장 기본적인 문
• 다른 모든 행동 문은 이러한 문 안에서만 나타날 수 있음

• C와 달리 Verilog는 동시성 프로그래밍 언어임
• Verilog에서 활동 흐름은 순차적이기보다는 병렬로 실행됨
• 각각의 always와 initial 문은 Verilog에서 별개의 활동을 나타냄
• 각 활동 흐름은 시뮬레이션 시간 0에서 시작함
• always와 initial 문은 중첩될 수 없음

initial 문

• initial 블록은 시간 0에서 시작하여 시뮬레이션 중 한 번만 실행되고 다시 실행되지 않음
• 여러 initial 블록이 있는 경우, 각 블록은 시간 0에서 동시에 실행을 시작함
• 각 블록은 다른 블록과 독립적으로 실행을 완료함

module stimulus;
reg x, y, a, b, mi
initial
m = 1'b0; // 단일 문장; 그룹화할 필요가 없음

initial begin
#5 a = 1'b1; // 여러 문장들은 그룹화되어야 함
#25 b = 1'b0;
end

initial begin
#10 x = 1'b0;
#25 y = 1'b1;
end

initial
#50 $finish; // 50나노초 후 시뮬레이션 종료
endmodule

• initial 블록은 일반적으로 초기화, 모니터링, 파형 및 시뮬레이션 전체 기간 동안 한 번만 실행되어야 하는 다른 프로세스에 사용됨

• 변수 선언과 초기화 결합

// clock 변수가 먼저 정의됨
reg clock;

// clock의 값이 0으로 설정됨
initial clock = 0;

// 위의 방법 대신, clock 변수는 선언 시 초기화될 수 있음
// 이것은 모듈 레벨에서 선언된 변수에만 허용됨
reg clock = 0;

• 포트/데이터 선언 및 초기화 결합

module adder (sum, co, a, b, ci);
output reg [7:0] sum = 0; // 8비트 출력 합계 초기화
output reg co = 0; // 1비트 출력 co 초기화
input [7:0] a, b; // 8비트 입력 a, b
input ci; // 입력 ci

// ...
endmodule

• ANSI C 스타일 포트 선언 및 초기화 결합

module adder (
    output reg [7:0] sum = 0, // 8비트 출력 sum 초기화
    output reg co = 0, // 1비트 출력 co 초기화
    input [7:0] a, b, // 8비트 입력 a, b
    input ci // 입력 ci
);
// ... (이후 코드 생략)
endmodule

always 문

• always 문은 시간 0에서 시작하여 always 블록 내의 문을 계속해서 루프 형태로 실행함
• 이 문은 디지털 회로에서 반복적으로 수행되는 활동 블록을 모델링하는 데 사용됨

• 예: 클럭 생성기
• 시간 0에서 시작하여 매 10 시간 단위마다 “clock = ~clock”을 실행함
• 초기화와 시뮬레이션 종료는 initial 문 안에 있어야 함

module clock_gen (output reg clock);

// 시간 0에서 클록 초기화
initial
	clock = 1'b0;

// 매 반 주기마다 클록 토글 (시간 주기 = 20)
always
	#10 clock = ~clock;
initial
	#1000 $finish; // 1000ns 후 시뮬레이션 종료
endmodule

• C 프로그래머들은 always 블록과 무한 루프 사이에 유사성을 찾을 수 있음

절차적 할당

• 절차적 할당은 reg, integer, real 또는 time 변수의 값을 업데이트함
• 변수에 배치된 값은 다른 절차적 할당이 변수에 다른 값을 업데이트할 때까지 변경되지 않음

assignment ::= variable_lvalue = [ delay_or_event_control ] expression

• 절차적 할당의 좌변 <lvalue>은 다음이 될 수 있음
• reg, integer, real, 또는 time 등록 변수 또는 메모리 요소
• 이러한 변수들의 비트(예: addr[0])
• 이러한 변수들의 부분 선택(예: addr[31:16])
• 위의 것들의 연결
• 넷(NET, 즉, 와이어)은 안 됨!!! → always/initial 외부에서 assign 문을 사용해야 함

• 우변은 값으로 평가되는 어떤 표현식도 될 수 있음

• 절차적 할당 문에는 두 가지 유형이 있음: 블로킹과 논블로킹

블로킹 할당

• 블로킹 할당 문은 순차 블록에서 지정된 순서대로 실행됨 (“=” 연산자)

• 특정 블록 내의 행동은 begin-end 블록에서 블로킹 문을 사용하면 순차적임. 왜냐하면 그들은 순차적으로만 실행될 수 있기 때문임

reg x, y, z; 
reg [15:0] reg_a, reg_b;
integer count;
// 모든 행동적 명령문은 initial 또는 always 블록 안에 있어야 함
initial
begin
    x = 0; y = 1; z = 1; // 스칼라 변수에 대한 할당
    count = 0; // 정수 변수에 대한 할당
    reg_a = 16'b0; reg_b = reg_a; // 벡터 초기화
    #15 reg_a[2] = 1'b1; // 지연이 있는 비트 선택 할당
    #10 reg_b[15:13] = {x, y, z}; // 연결 결과 할당
to    // 벡터의 일부 선택
    count = count + 1; // 정수에 대한 할당 (증가)
end

논블로킹 할당

• 논블로킹 할당은 할당을 스케줄링할 수 있게 해주면서 순차 블록 내에서 후속 문의 실행을 차단하지 않음
• <= 연산자는 논블로킹 할당을 지정하는 데 사용됨

reg x, y, z; 
reg [15:0] reg_a, reg_b;
integer count;

// 모든 행동적 명령문은 initial 또는 always 블록 안에 있어야 함
initial begin
    x = 0; y = 1; z = 1; // 스칼라 할당
    count = 0; // 정수 변수에 대한 할당
    reg_a = 16'b0; reg_b = reg_a; // 벡터 초기화

    reg_a[2] <= #15 1'b1; // 지연을 가진 비트 선택 할당
    reg_b[15:13] <= #10 {x, y, z}; // 연결 결과 할당
    // 벡터의 부분 선택
    count <= count + 1; // 정수에 대한 할당 (증가)
end

• 같은 always 블록 내에서 블로킹 및 논블로킹 할당을 혼합하는 것은 강력히 권장되지 않음

• 논블로킹 할당의 응용
• 공통 이벤트 이후 발생하는 여러 동시 데이터 전송을 모델링하는 방법으로 사용됨

• 각 클럭의 positive edge에서,

always @ (posedge clock)
begin
    reg1 <= #1 in1;
    reg2 <= @(negedge clock) in2 ^ in3;
    reg3 <= #1 reg1; // reg1의 이전 값
end

• 따라서 reg1, reg2, 및 reg3의 최종 값은 할당이 처리되는 순서에 따라 달라지지 않음

• 블로킹 할당을 사용하여 논블로킹 할당 구현

// 예시 1: 블로킹 문을 사용하는 두 개의 동시적 always 블록
always @ (posedge clock)
    a = b;
always @ (posedge clock)
    b = a;

• a = b는 b = a 이전에 실행되거나, 그 반대의 경우가 될 수 있으며, 이는 시뮬레이터 구현에 따라 다름
• 따라서, 레지스터 a와 b의 값은 바뀌지 않지만 동일해짐

// 예시 2: 논블로킹 문을 사용하는 두 개의 동시적 always 블록
always @ (posedge clock)
    a <= b;
always @ (posedge clock)
    b <= a;

• 클럭의 positive edge에서, 모든 RHS의 값이 read되며 RHS 표현식이 평가되어 임시 변수에 저장됨
• 쓰기 작업 중, 임시 변수의 값이 LHS에 할당됨
• 읽기와 쓰기 작업을 분리함으로써, 레지스터 a와 b의 값이 순서에 상관없이 올바르게 바뀌는 것이 보장됨

• 블로킹 할당을 사용한 논블로킹 할당 구현

// 임시 변수와 블로킹 할당을 사용하여 논블로킹 할당의 동작을 에뮬레이트함
always @ (posedge clock)
begin
    // 읽기 작업 - 임시 변수에 우변 표현식의 값을 저장함
    temp_a = a;
    temp_b = b;
    // 쓰기 작업 - 임시 변수의 값을 좌변 변수에 할당함
    a = temp_b;
    b = temp_a;
end

• 디지털 디자인에 있어, 공통 이벤트 이후 동시 데이터 전송에는 논블로킹 할당이 매우 권장됨
• 블로킹 할당은 최종 결과가 할당 평가 순서에 따라 달라질 수 있기 때문에 잠재적으로 경쟁 상태를 일으킬 수 있음
• 논블로킹 할당은 최종 결과가 순서에 의존하지 않기 때문에 동시 데이터 전송을 효과적으로 모델링하는 데 사용될 수 있음
💡
always @(posedge clock) → 논블로킹 할당 사용
always @(*) → 블로킹 할당 사용

지연 기반 타이밍 제어

• 타이밍 제어는 절차적 문이 실행될 시뮬레이션 시간을 지정하는 방법을 제공함

• 지연 기반 타이밍 제어는 문이 발견되고 실행될 때까지의 시간 간격을 지정함
• 지연은 '#' 기호로 지정됨

delay3 ::= # delay_value | # ( delay_value [ , delay_value [ , delay_value ] ] )
delay2 ::= # delay_value | # ( delay_value [ , delay_value ] )
delay_value ::= unsigned_number
	| parameter_identifier 
	| specparam_identifier 
	| mintypmax_expression

• 숫자, 식별자 또는 mintypmax_expression으로 지정할 수 있음

• 일반 지연 제어
• 절차적 할당의 왼쪽에 non-zero 지연이 지정됨

// 매개변수 정의
parameter latency = 20;
parameter delta = 2;
// 레지스터 변수 정의
reg x, y, z, p, g;

initial
begin
	x = 0; // 지연 제어 없음
	#10 y = 1; // 숫자로 지연 제어. y=1의 실행을 10 시간 단위만큼 지연
	#latency z = 0; // 식별자로 지연 제어. 20의 지연
	#(latency + delta) p = 1; // 표현식으로 지연 제어
	#y x = x + 1; // 식별자로 지연 제어. y의 값 취하기
	#(4:5:6) g = 0; // 최소, 일반, 최대 지연 값. 게이트 레벨 모델링 장에서 논의됨.
end

• 할당 내 지연 제어
• 할당 연산자의 오른쪽에 지연을 할당함

// 레지스터 변수 정의
reg x, y, z;

// 내부 할당 지연
initial 
begin
	x = 0; z = 0;
	y = #5 x + z; // time=0에 x와 z의 값을 취하고, x + z를 계산한 후, 5 시간 단위를 기다린 후 그 값을 y에 할당함
end

// 임시 변수와 일반적인 지연 제어를 사용한 동등한 방법
initial 
begin
	x = 0; z = 0;
	temp_xz = x + z;
	#5 y = temp_xz; // 현재 시간에 x + z의 값을 취하고 임시 변수에 저장함. 0과 5 사이에 x 및 z가 변경되더라도, 시간 5에 y에 할당된 값에는 영향을 미치지 않음
end

• 제로 지연 제어
• 문이 해당 시뮬레이션 시간의 다른 모든 문들 이후에 마지막으로 실행되도록 하는 방법임
• 경쟁 상황을 제거하는 데 사용됨

initial 
begin
	x = 0;
	y = 0;
end

initial
begin
	#0 x = 1; //제로 지연 제어
	#0 y = 1;
end

• #0 사용은 권장되지 않는 방법임

이벤트 기반 타이밍 제어

• 이벤트는 문이나 문의 블록 실행을 트리거하는 데 사용될 수 있습니다.

• 일반 이벤트 제어 ('@' 기호)
• 신호 값의 변경이나 신호 값의 양수 또는 음수 전환시 문을 실행할 수 있음

@(clock) q = d; // clock 신호가 값이 변경될 때마다 실행됨
@(posedge clock) q = d; // clock 신호가 긍정적인 변화(0에서 1, x 또는 z에서 1로)를 할 때 실행됨

@(negedge clock) q = d; // clock 신호가 부정적인 변화(1에서 0, x 또는 z에서 0으로)를 할 때 실행됨

q <= @(posedge clock) d; // d는 즉시 평가되고 clock의 긍정적인 에지에서 q에 할당됨

• 명명된 이벤트 제어
• Verilog는 이벤트를 선언하고 그 이벤트의 발생을 트리거하고 인식하는 기능을 제공함
• 명명된 이벤트는 event 키워드로 선언됨
• 이벤트는 -> 기호로 트리거되고, 이벤트의 트리거는 @ 기호로 인식됨

// 이것은 마지막 데이터 패킷이 도착한 후 데이터를 저장하는 데이터 버퍼의 예임
event received_data; // received_data라는 이벤트 정의
always @(posedge clock) // 각 긍정적인 클럭 엣지에서 확인
begin
    if(last_data_packet) // 이것이 마지막 데이터 패킷인 경우
        ->received_data; // received_data 이벤트를 트리거
end

always @(received_data) // received_data 이벤트의 트리거를 기다림
// 이벤트가 트리거되면, 받은 데이터의 네 패킷을 데이터 버퍼에 저장
// 연결 연산자 { } 사용
data_buf = {data_pkt[0], data_pkt[1], data_pkt[2], data_pkt[3]};

• 이벤트 OR 제어
• 여러 신호 또는 이벤트 중 하나의 전환으로 문이나 문의 블록 실행을 트리거할 수 있음
• OR로 표현된 이벤트 또는 신호 목록은 감도 목록으로도 알려져 있음

// 비동기 재설정이 있는 레벨 감지 래치
always @(reset, clock, d)
 
// reset, clock 또는 d가 변경될 때까지 기다림
change
begin
    if (reset)
        q = 1'b0; // reset 신호가 높은 경우, q를 0으로 설정
    else if (clock)
        q = d; // clock이 높은 경우, 입력을 래치
end

• Verilog는 감도 목록에서 신호를 놓치지 않도록 @* 및 @(*)라는 두 가지 특수 기호를 제공함

레벨 감지 타이밍 제어

• Verilog는 레벨 감지 타이밍 제어를 허용함

• 특정 조건이 참이 될 때까지 문이나 문의 블록 실행을 기다리는 기능임

• wait 키워드는 레벨 감지 구조에 사용됨

always
    wait (count_enable) #20 count = count + 1;

1. count_enable의 값이 계속 모니터링됨
2. count_enable이 0이면 문은 실행되지 않음
3. 논리 1이면, 20 시간 단위 후에 count = count+1이 실행됨
4. count_enable이 1로 유지되면, count는 매 20 시간 단위마다 증가함

• 조건문은 특정 조건에 따라 결정을 내리는 데 사용됨 (if-else)
• 문이 실행될지 여부를 결정하는 데 사용됨

• statement1, 2, …, default_statement 각각은 단일 또는 블록일 수 있음

case (expression)
	alternative1: statement1; 
	alternative2: statement2;
	alternative3: statement3;
	...
	default: default_statement;
endcase

• 많은 수의 멀티플렉서임



// ALU 제어 신호에 따라 명령문을 실행함
reg [1:0] alu_control;
...
...
case (alu_control)
    2'd0 : y = x + z;  // alu_control이 '00'일 때, y는 x와 z의 합임
    2'd1 : y = x - z;  // alu_control이 '01'일 때, y는 x에서 z를 뺀 값임
    2'd2 : y = x * z;  // alu_control이 '10'일 때, y는 x와 z의 곱임
    default : $display("Invalid ALU control signal");  // 그 외의 경우, 잘못된 ALU 제어 신호를 출력함
endcase

module mux4_to_1 (out, i0, i1, i2, i3, s1, s0);
    // I/O 다이어그램에서의 포트 선언
    output out;
    input i0, i1, i2, i3;
    input s1, s0;
    reg out;

    always @(s1 or s0 or i0 or i1 or i2 or i3)
    case ({s1, s0}) // 제어 신호의 연결에 기반하여 전환함
        2'd0 : out = i0;  // 제어 신호가 '00'이면, 출력은 i0임
        2'd1 : out = i1;  // 제어 신호가 '01'이면, 출력은 i1임
        2'd2 : out = i2;  // 제어 신호가 '10'이면, 출력은 i2임
        2'd3 : out = i3;  // 제어 신호가 '11'이면, 출력은 i3임
        default: $display ("Invalid control signals");  // 그 외의 경우, 잘못된 제어 신호 메시지를 출력함
    endcase
endmodule

• case는 표현식에서 0, 1, x 및 z 값을 비교함

module demultiplexer1_to_4 (out0, out1, out2, out3, in, s1, s0);
    // I/O 다이어그램에서의 포트 선언
    output out0, out1, out2, out3;
    reg out0, out1, out2, out3;  // 출력을 위한 레지스터
    input in;  // 입력 신호
    input s1, s0;  // 제어 신호

    always @(s1 or s0 or in)
    case ({s1, s0}) // 제어 신호에 따라 분기
        2'b00 : begin 
            out0 = in; 
            out1 = 1'bz; 
            out2 = 1'bz; 
            out3 = 1'bz;  // '00'일 때 첫 번째 출력 활성화
        end
        2'b01 : begin 
            out0 = 1'bz; 
            out1 = in; 
            out2 = 1'bz; 
            out3 = 1'bz;  // '01'일 때 두 번째 출력 활성화
        end
        2'b10 : begin 
            out0 = 1'bz; 
            out1 = 1'bz; 
            out2 = in; 
            out3 = 1'bz;  // '10'일 때 세 번째 출력 활성화
        end
        2'b11 : begin 
            out0 = 1'bz; 
            out1 = 1'bz; 
            out2 = 1'bz; 
            out3 = in;  // '11'일 때 네 번째 출력 활성화
        end
        // 알 수 없는 신호에 대한 처리. 선택 신호가 x이면 출력은 x, z이면 출력은 z입니다.
        // 하나가 x이고 다른 하나가 z이면, x가 우선 순위를 갖습니다.
        2'bx0, 2'bx1, 2'bxz, 2'bxx, 2'b0x, 2'b1x, 2'bzx :
        begin
            out0 = 1'bx; 
            out1 = 1'bx; 
            out2 = 1'bx; 
            out3 = 1'bx;  // 알 수 없는 상태를 출력
        end
        2'bz0, 2'bz1, 2'bzz, 2'b0z, 2'b1z :
        begin
            out0 = 1'bz; 
            out1 = 1'bz; 
            out2 = 1'bz; 
            out3 = 1'bz;  // 고립 상태를 출력
        end
        default: 
            $display("Unspecified control signals");  // 그 외의 경우, 명시되지 않은 제어 신호에 대한 메시지 출력
    endcase
endmodule

 

casex, casez 키워드

• casez는 모든 z 값을 don’t care로 처리함
• z가 있는 모든 비트 위치는 해당 위치에서 '?'로도 표현될 수 있음

• casex는 모든 x 및 z 값을 관심 없음으로 처리함

• case 표현식과 case 대안에서 non-x 또는 -z 위치만 비교할 수 있도록 함

reg [3:0] encoding;  // 4비트 인코딩 값을 저장하는 레지스터
integer next_state;  // 다음 상태 값을 저장할 정수형 변수

casex (encoding)  // 로직 값 x는 돈케어 비트를 나타냄
    4'b1xxx : next_state = 3;  // 첫 번째 비트가 1이면 next_state를 3으로 설정
    4'bx1xx : next_state = 2;  // 두 번째 비트가 1이면 next_state를 2로 설정
    4'bxx1x : next_state = 1;  // 세 번째 비트가 1이면 next_state를 1로 설정
    4'bxxx1 : next_state = 0;  // 네 번째 비트가 1이면 next_state를 0으로 설정
    default : next_state = 0;  // 위 조건에 맞지 않는 경우 next_state를 0으로 설정
endcase

• 예) encoding=4’b10xz 설정은 next_state=3이 실행되게 함

While 루프

• 네 가지 유형의 반복문: while, for, repeat, forever

• while 루프는 while 표현식이 참이 아닐 때까지 실행됨
• while 표현식이 참이 아닐 때 루프를 입력하면 루프가 전혀 실행되지 않음

// 예시 1: 카운트를 0부터 127까지 증가. 카운트가 128이 되면 종료
// 카운트 변수를 표시
integer count; // 정수형 변수 count 선언

initial 
begin // 초기 블록 시작
    count = 0; // count를 0으로 초기화
    while (count < 128) // count가 127일 때까지 반복문 실행
                        // 카운트가 128이 되면 반복문 탈출
    begin
        $display ("Count = %d", count); // 현재 카운트 값을 출력
        count = count + 1; // count를 1 증가
    end
end

For 루프

• for 루프에는 세 부분이 있음
• 초기 조건
• 종료 조건이 참인지 확인
• 제어 변수의 값 변경을 위한 절차적 할당

integer count;
initial
	for (count = 0; count < 128; count = count + 1)
    $display("Count = %d", count);  // for 루프를 사용하여 0부터 127까지 카운트하며 각 단계에서 카운트 값을 출력함

// 배열 요소 초기화
`define MAX_STATES 32
integer state[0: `MAX_STATES - 1];  // 0부터 31까지의 요소를 가진 정수 배열 state 선언
integer i;

initial begin
    for (i = 0; i < 32; i = i + 2)  // 모든 짝수 인덱스를 0으로 초기화함
        state[i] = 0;

    for (i = 1; i < 32; i = i + 2)  // 모든 홀수 인덱스를 1로 초기화함
        state[i] = 1;
end

Repeat 루프

• repeat 구조는 루프를 고정된 횟수로 실행함
• repeat 구조는 일반 논리 표현식에 대한 루프로 사용할 수 없습니다.
• repeat에는 숫자, 변수 또는 신호 값이 포함되어야 합니다.

integer count;
initial begin
    count = 0;
    repeat (128) // 128번 반복함
    begin
        $display("Count = %d", count); // 현재 카운트 값을 출력함
        count = count + 1; // 카운트를 1 증가시킴
    end
end

module data_buffer(data_start, data, clock);
    parameter cycles = 8; // 반복할 사이클 수를 정의함
    input data_start; // 데이터 시작 신호 입력
    input [15:0] data; // 16비트 데이터 입력
    input clock; // 클록 신호 입력
    reg [15:0] buffer[0:7]; // 8개의 16비트 레지스터로 구성된 버퍼
    integer i;

    always @(posedge clock) // 클록의 positive edge에서 항상 실행
    begin
        if (data_start) // 데이터 시작 신호가 참(true)일 때
        begin
            i = 0;
            repeat (cycles) // 다음 8개 클록 사이클에서 데이터를 저장함
            begin
                @(posedge clock) // 다음 클록의 positive edge까지 대기
                buffer[i] = data; // positive edge에서 데이터 래치
                i = i + 1; // 인덱스를 1 증가시킴
            end
        end
    end
endmodule

Forever 루프

• forever 루프는 일반적으로 타이밍 제어 구조와 함께 사용됨

// 예제 1: 클록 생성
// always 블록 대신 영원히 반복하는 루프 사용
reg clock; // 클록 신호를 위한 레지스터 정의

initial begin
    clock = 1'b0; // 클록을 0으로 초기화
    forever #10 clock = ~clock; // 20 시간 단위의 주기를 가진 클록 (10 시간 단위마다 클록 값을 반전)
end

// 예제 2: 클록의 positive edge에서 두 레지스터 값을 동기화
reg clock; // 클록 신호를 위한 레지스터
reg x, y; // 동기화할 두 개의 레지스터 x와 y
initial
    forever @(posedge clock) x = y; // 클록의 positive edge마다 x에 y 값을 할당

블록 유형

• 블록에는 순차 블록과 병렬 블록 두 가지 유형이 있음

• 순차 블록 (begin-end)
• 순차 블록의 문은 지정된 순서대로 처리됨
• 지연이나 이벤트 제어가 지정된 경우, 이는 블록 내 이전 문이 실행을 완료한 시뮬레이션 시간을 기준으로 함

// 예시 1: 지연 없는 순차 블록
reg x, y; 
reg [1:0] Z, w;
initial begin
    x = 1'b0; // x를 0으로 초기화
    y = 1'b1; // y를 1로 초기화
    z = {x, y}; // z에 x와 y의 연결(concatenation) 값을 할당
    w = {y, x}; // w에 y와 x의 연결 값을 할당
end

// 예시 2: 지연이 있는 순차 블록
reg x, y; 
reg [1:0] Z, w;
initial begin
    x = 1'b0; // 시뮬레이션 시간 0에 완료
    #5 y = 1'b1; // 시뮬레이션 시간 5에 완료
    #10 z = {x, y}; // 시뮬레이션 시간 15에 완료 (5 + 10의 지연으로 인해)
    #20 w = {y, x}; // 시뮬레이션 시간 35에 완료 (15 + 20의 지연으로 인해)
end

• 병렬 블록 (fork-join)
• 병렬 블록의 문은 동시에 실행됨
• 문의 순서는 각 문에 할당된 지연 또는 이벤트 제어에 의해 제어됨
• 지연이나 이벤트 제어가 지정되면, 이는 블록이 시작된 시간을 기준으로 함

// 예시 1: 지연이 있는 병렬 블록
reg x, y; 
reg [1:0] z, w;
initial fork
    x = 1'b0; // 시뮬레이션 시간 0에 완료
    #5 y = 1'b1; // 시뮬레이션 시간 5에 완료
    #10 z = {x, y}; // 시뮬레이션 시간 10에 완료
    #20 w = {y, x}; // 시뮬레이션 시간 20에 완료
join

// 병렬 블록에서 의도적으로 만든 경쟁 상태
reg x, y; 
reg [1:0] z, w;
initial fork
    x = 1'b0;
    y = 1'b1;
    z = {x, y}; // x와 y의 현재 값에 따라 z 결정
    w = {y, x}; // y와 x의 현재 값에 따라 w 결정
join
// 경쟁 상태 발생!

블록의 특별한 기능들

• 중첩된 블록
• 블록은 중첩될 수 있으며 순차 블록과 병렬 블록이 혼합될 수 있음

• 명명된 블록
• 로컬 변수는 명명된 블록에 대해 선언될 수 있음
• 명명된 블록은 디자인 계층의 일부 (계층적 이름 참조)
• 명명된 블록은 비활성화될 수 있음

// 명명된 블록 예제
module top;
initial
begin: block1 // 'block1'이라는 이름의 순차 블록
    integer i; // 'i'는 정적이며 'block1'에 로컬한 정수임
    // 'i'는 계층적 이름을 사용하여 접근할 수 있음. 예: top.block1.i
    ... 
end

initial
fork: block2 // 'block2'라는 이름의 병렬 블록
    reg i; // 'i'는 정적이며 'block2'에 로컬한 레지스터임
    // 'i'는 계층적 이름을 사용하여 접근할 수 있음. 예: top.block2.i
    ...
    ...
join

• 명명된 블록 비활성화
• disable 키워드는 명명된 블록의 실행을 종료하는 방법을 제공함
• 블록을 비활성화하면 실행 제어가 블록 바로 다음의 문장으로 전달됨
• disable은 C의 break 문과 매우 유사함

// 예시: 'flag' (벡터 변수)에서 값이 1인 첫 번째 비트 찾기
reg [15:0] flag;
integer i; // 카운트를 유지하기 위한 정수
initial begin
    flag = 16'b 0010_0000_0000_0000;
    i = 0;
    begin: block1 // while 내의 주요 블록은 'block1'이라 명명됨
    while(i < 16)
    begin
        if (flag[i])
        begin
            $display ("값이 TRUE인 비트를 요소 번호 %d에서 발견했습니다", i);
            disable block1; // 'block1'을 비활성화함. 참인 값을 찾았기 때문
        end
        i = i + 1;
    end 
    end
end

제너레이트 블록

• 제너레이트 문은 Verilog 코드를 시뮬레이션 시작 전에 동적으로 생성할 수 있게 함
• 이것은 매개변수화된 모델의 생성을 촉진함
• 모든 생성 인스턴스는 모듈 범위로 코딩되어 generate-endgenerate 키워드가 필요함

• 생성된 인스턴스는 다음 중 하나 이상일 수 있음
• 모듈
• 사용자 정의 프리미티브, Verilog 게이트 프리미티브
• 지속적인 할당
• 초기 및 항상 블록

• 제너레이트 문은 다음 Verilog 데이터 유형을 생성 범위 내에 선언할 수 있습니다:
• net, reg, integer, real, time, realtime, event

• 생성된 데이터 유형에는 고유 식별자 이름이 있으며 계층적으로 참조될 수 있음

• 태스크와 함수 선언은 생성 범위 내에서 허용되지만 생성 루프 내에서는 허용되지 않음

• 일부 모듈 선언 및 모듈 항목은 생성 문에서 허용되지 않음
• 매개변수, 로컬 매개변수
• 입력, 출력, inout 선언
• 지정 블록

• 제너레이트 문을 만드는 세 가지 방법
• 제너레이트 루프
• 제너레이트 조건부
• 제너레이트 케이스

제너레이트 루프

• 제너레이트 루프를 사용하면 다음 중 하나 이상을 여러 번 인스턴스화할 수 있습니다:
• 변수 선언
• 모듈
• 사용자 정의 프리미티브
• 게이트 프리미티브
• 지속적인 할당
• 초기 및 항상 블록

// 이 모듈은 두 개의 N비트 버스 간의 비트별 XOR을 생성함

module bitwise_xor;
// 파라미터 선언. 이것은 재정의될 수 있음
parameter N = 32; // 기본적으로 32비트 버스
// 포트 선언
output [N-1:0] out; 
input [N-1:0] i0, i1;

// 임시 루프 변수 선언. 이 변수는 generate 블록의 평가에만 사용됨
// 이 변수는 Verilog 디자인의 시뮬레이션 중에는 존재하지 않음
genvar j;

// 단일 루프로 비트 단위의 XOR 생성
generate 
    for (j=0; j<N; j=j+1) 
    begin: xor_loop
        xor g1 (out[j], i0[j], i1[j]);
    end // generate 블록 내의 for 루프의 끝
endgenerate // generate 블록의 끝

// 대체 스타일로서,
// xor 게이트는 always 블록으로 대체될 수 있음
// reg [N-1:0] out;
// generate 
//    for (j=0; j<N; j=j+1) 
//    begin: bit_xor
//        always @(i0[j] or i1[j]) 
//            out[j] = i0[j] ^ i1[j];
//    end
// endgenerate
endmodule

• 시뮬레이터는 제너레이트 루프의 코드를 풀어 헤침
• genvar은 제너레이트 블록을위한 키워드임
• xor_loop[0].g1, xor_loop[31].g1과 같이 액세스됨

제너레이트 조건문

• 제너레이트 조건문은 if-else 제너레이트 구조와 같아서 다음과 같은 Verilog 구조를 허용함
• 모듈
• 사용자 정의 프리미티브
• 게이트 프리미티브
• 지속적인 할당
• 초기 및 항상 블록

module multiplier (product, a0, a1);
// 파라미터 선언. 이것은 재정의될 수 있음
parameter a0_width = 8; // 기본적으로 8비트 버스
parameter a1_width = 8; // 기본적으로 8비트 버스

// 로컬 파라미터 선언.
// 이 파라미터는 defparam 또는 모듈 인스턴스 # 문으로 수정할 수 없음
localparam product_width = a0_width + a1_width;

// 포트 선언
output [product_width-1:0] product;
input [a0_width-1:0] a0;
input [a1_width-1:0] a1;

// 조건부로 곱셈기의 유형을 인스턴스화함
// 인스턴스화 시점의 a0_width 및 a1_width 파라미터 값에 따라 적절한 곱셈기가 인스턴스화됨
generate
    if (a0_width < 8) || (a1_width < 8)
        // 만약 a0의 너비나 a1의 너비가 8 미만이면, cla 곱셈기를 사용함
        cla_multiplier #(a0_width, a1_width) mul_instance (product, a0, a1);
    else
        // 그렇지 않으면, 트리 곱셈기를 사용함
        tree_multiplier #(a0_width, a1_width) mul_instance (product, a0, a1);
endgenerate // generate 블록의 끝
endmodule

제너레이트 case문

• 제너레이트 케이스는 다음과 같은 Verilog 구조가 조건부로 인스턴스화되도록 허용합니다:
• 모듈
• 사용자 정의 프리미티브
• 게이트 프리미티브
• 지속적인 할당
• 초기 및 항상 블록

module adder (co, sum, a0, a1, ci);
// 파라미터 선언. 이것은 재정의될 수 있음
parameter N=4; // 기본적으로 4비트 버스

// 포트 선언
output [N-1:0] sum;
output co;
input [N-1:0] a0, a1;
input ci;

// 버스의 너비에 따라 적절한 가산기를 인스턴스화함
// 이는 인스턴스화 시점에 재정의될 수 있는 파라미터 N에 기반함
generate
    case (N)
        // 1비트와 2비트 가산기를 위한 특별한 경우들
        1: adder_1bit adder1(co, sum, a0, a1, ci); //1비트 구현체
        2: adder_2bit adder2(co, sum, a0, a1, ci); //2비트 구현체

        // 기본값은 N비트 용량 선형 가산기임
        default: adder_cla #(N) adder3(co, sum, a0, a1, ci);
    endcase
endgenerate // generate 블록의 끝
endmodule

예제 #1

• 4대1 멀티플렉서

// 4대1 멀티플렉서. 포트 목록은 I/O 다이어그램에서 정확하게 가져왔음
module mux4_to_1 (out, i0, i1, i2, i3, s1, s0);
// I/O 다이어그램에서의 포트 선언
output out;
input i0, i1, i2, i3; 
input s1, s0;

// 출력을 레지스터로 선언
reg out;

// 입력 신호가 변경될 경우 출력 신호 out을 다시 계산함
// out을 다시 계산하게 만드는 모든 입력 신호는 always @(...) 민감도 목록에 들어가야 함
always @(s1 or s0 or i0 or i1 or i2 or i3)
begin
    case ({s1, s0}) // s1과 s0의 조합에 따라 분기
        2'b00: out = i0;  // s1s0이 00이면 out은 i0
        2'b01: out = i1;  // s1s0이 01이면 out은 i1
        2'b10: out = i2;  // s1s0이 10이면 out은 i2
        2'b11: out = i3;  // s1s0이 11이면 out은 i3
        default: out = 1'bx; // 그 외의 경우, out은 정의되지 않은 상태(x)
    endcase
end
endmodule

예제 #2

• 4비트 카운터
• 데이터 플로우 또는 게이트 레벨 디자인은 리플 캐리, 동기식 카운터, 플립플롭, 인버터 등을 고려해야 함
• 행동 수준의 디자인은 매우 높은 수준의 추상화만을 요구함

// 4비트 이진 카운터
module counter (Q, clock, clear);
// 입/출력 포트
output [3:0] Q; 
input clock, clear;

// 출력을 레지스터로 정의
reg [3:0] Q;

// clear의 긍정 에지 또는 clock의 부정 에지에서 동작
always @(posedge clear or negedge clock)
begin
    if (clear)
        Q = 4'd0; // clear 신호가 활성화되면 Q를 0으로 리셋
    // 비블로킹 할당은 플립플롭과 같은 순차 논리 생성에 권장됩니다
    else
        Q = Q + 1; // Q의 값을 1 증가. 4비트 값이므로 모듈로 16 연산은 필요하지 않으며 자동으로 오버플로우됨.
end
endmodule