06 Dataflow Modeling

지속적인 할당 (Continuous Assignments)

• 지속적인 할당은 데이터플로우 모델링에서 가장 기본적인 구문으로, 넷에 값을 주입하는데 사용됨
• 이 할당은 회로의 설명에서 게이트를 대체함

continuous_assign ::= assign I drive_strength 1 | delay3 1
list _of_net_assignments;
list_of_net_assignments ::= net_assignment { , net_assignment }
net_assignment ::= net_lvalue = expression

• 지속적인 할당은 다음과 같은 특성을 가짐
• 지속적인 할당은 항상 활성화되어 있음
• 왼쪽 항은 항상 스칼라 또는 벡터 넷이어야 함 (연결될 수 있음)
• 오른쪽 항은 레지스터나 넷, 또는 함수 호출이 될 수 있음
• 할당에 대해 시간 단위로 지연 값을 지정할 수 있습니다.

// 지속적인 할당. out은 넷(net)임. i1과 i2 역시 넷임
assign out = i1 & i2;

// 벡터 넷을 위한 지속적인 할당. addr은 16비트 벡터 넷임 
// addr1과 addr2는 16비트 벡터 레지스터임
assign addr[15:0] = addr1_bits[15:0] ^ addr2_bits[15:0];

// 연결(Concatenation). 왼쪽 피연산자는 스칼라 넷과 벡터 넷의 연결임
assign {c_out, sum[3:0]} = a[3:0] + b[3:0] + c_in;

• 암묵적 지속적 할당
• 넷이 선언될 때 지속적인 할당이 넷에 대체될 수 있음

// 일반 지속적 할당
wire out;
assign out = in1 & in2;

// 암시적 지속적 할당을 사용하여 동일한 효과를 얻음
wire out = in1 & in2;

• 첫 번째 섹션: "일반 지속적 할당"에 관한 것으로, out이라는 이름의 wire(넷)을 선언하고 이 wire에 in1과 in2의 AND 논리 연산 결과를 지속적으로 할당함
• 두 번째 섹션은: "암시적 지속적 할당"을 설명하고 있음. 이는 in1과 in2의 AND 논리 연산 결과를 out이라는 wire에 할당하는 것인데, 이는 첫 번째 섹션의 코드와 동일한 작업을 수행하나, 좀 더 간결한 구문을 사용하여 이를 한 줄로 표현하고 있음

• 암묵적 넷 선언
• 지속적인 할당 왼쪽에 신호 이름이 사용되면, 그 신호 이름에 대해 암묵적 넷 선언이 유추됨

// 지속적 할당. out은 넷(net)임
wire i1, i2;
assign out = i1 & i2; // out이 와이어(wire)로 선언되지 않았음에 주의
// 그러나 시뮬레이터에 의해 out에 대한 암시적인 와이어 선언이 수행됨

• 첫 번째 주석: out이 넷(net)이라고 설명하고 있음
• i1과 i2에 대해 wire 타입으로 선언이 이루어졌음
• assign out = i1 & i2; 이 부분은 out이라는 넷(net)에 i1과 i2의 AND 논리 연산 결과를 지속적으로 할당하고 있음
• 두 번째 주석: out이 명시적으로 wire로 선언되지 않았지만, 시뮬레이터가 out에 대해 암시적으로 wire 선언을 수행한다는 점을 지적하고 있음

• 명시적 선언이 권장됨

게이트 딜레이

• 정규 할당 딜레이는 연속 할당 구문에서 딜레이 값을 할당하는 것임
• 딜레이 값은 assign 키워드 후에 지정됨

assign #10 out = in1 & in2; // 지속적 할당에서의 딜레이

• 관성 딜레이
• 할당 구문의 딜레이보다 짧은 입력 펄스는 출력을 전파하지 않음 (예: 글리치/노이즈)
• 관성 딜레이는 또한 게이트 딜레이에 적용되며, 5장에서 논의됨

• 암묵적 지속 할당 딜레이는 넷에 딜레이와 할당을 모두 지정하는 것

// 암시적 지속적 할당 딜레이
wire #10 out = in1 & in2;

// 다음과 동일함
wire out;
assign #10 out = in1 & in2;

• 넷 선언 딜레이는 넷에 지속적인 할당을 두지 않고 넷에 대해 딜레이를 지정하는 것

//넷(net) 딜레이
wire #10 out;
assign out = in1 & in2;

//위 구문은 아래와 동일한 효과를 가짐
wire out;
assign #10 out = in1 & in2;

• 정규 할당 딜레이가 권장됨

표현식, 피연산자, 연산자

• 표현식은 결과를 생성하기 위해 연산자와 피연산자를 결합하는 구조입니다.

// 표현식의 예
a^b
addr1[20:17] + addr2[20:17]
in1 | in2

• 피연산자는 모든 데이터 타입 중 하나가 될 수 있음
• 예를 들어, 상수, 정수, 넷, 레지스터, 시간, 함수 호출 등

integer count, final_count; // count와 final_count를 정수형 변수로 선언함
final_count = count + 1 // count는 정수형 피연산자

real a, b, c;
c = a - b; // a와 b는 실수형 피연산자

reg [15:0] reg1, reg2;
reg [3:0] reg_out;
reg_out = reg1[3:0] ^ reg2[3:0]; // reg1[3:0]과 reg2[3:0]은 부분 선택 레지스터 피연산자

reg ret_value;
ret_value = calculate_parity (A, B); // calculate_parity는 함수 타입의 피연산자입니다.

• 연산자는 원하는 결과를 생성하기 위해 피연산자에 작용함

연산자 유형

• Verilog는 많은 다른 유형의 연산자를 제공함
• 예를 들어, 산술, 논리, 관계, 동등, 비트별, 축소, 시프트, 연결, 또는 조건부 연산자 (C와 유사한 일부)

산술 연산자

• 이항 연산자 (피연산자 두 개)
• 곱하기 (*), 나누기 (/), 더하기 (+), 빼기 (-), 제곱 (**), 및 나머지 (%)

A = 4'b0011; B = 4'b0100; // A와 B는 레지스터 벡터
D = 6; E = 4; F = 2 // D와 E는 정수
A * B // A와 B를 곱함. 결과는 4'b1100
D / E // D를 E로 나눔. 결과는 1입니다. 소수 부분은 버림
A + B // A와 B를 더함. 결과는 4'b0111
B - A // B에서 A를 뺌. 결과는 4'b0001
F = E**F; // E의 F 제곱임. 결과는 16

• 피연산자 비트 중 어떤 값이 x이면, 전체 표현식의 결과는 x임

in1 = 4'b101x;
in2 = 4'b1010;
sum = in1 + in2; // sum은 4'bx 값으로 평가될 것임

• 나머지 연산자는 두 숫자를 나눈 나머지를 생성함

13 % 3 // 1로 평가됨
16 % 4 // 0으로 평가됨
-7 % 2 // -1로 평가됨. 첫 번째 피연산자의 부호를 가져옴
7 % -2 // +1로 평가됨. 첫 번째 피연산자의 부호를 가져옴

 

• 단항 연산자 (피연산자 하나)
• + 및 - 연산자도 단항연산자로 작동할 수 있고 더 높은 우선 순위를 가짐

-4 // 음수 4
+5 // 양수 5

• 정수 또는 실수 유형에만 음수를 사용하는 것이 좋음
• 디자이너들은 <sss>’<base><nnn> 유형의 음수를 피해야 함. 왜냐하면 그것들은 부호 없는 2의 보수 수로 변환되기 때문임

// 정수 또는 실수 사용을 권장
-10 / 5 // -2로 평가됨
// <sss>'‹base>‹nnn> 타입의 숫자 사용하지 않기
-'10 / 5 // (2의 보수 10) / 5와 동일함. 즉, (2^32 - 10)/5
// 4294967286/5 = 858993457
// 여기서 32는 기본 머신 워드 폭임
// 이는 부정확하고 예기치 않은 결과로 평가됨

• 음수에 대해 signed 레지스터나 넷 (예, reg/wire signed)을 사용해야 함

논리 연산자

• 논리 연산자는 논리 AND (&&), OR (||), NOT (!)임
• 논리 연산자는 항상 1비트 값, 0(거짓), 1(참), 또는 x(모호한 상태)로 평가됨
• 피연산자 비트 중 어느 것이 x 또는 z이면 x (모호한 조건)과 동일하게 취급되며, 일반적으로 거짓으로 처리됨
• 논리 연산자는 변수 또는 표현식을 피연산자로 취함

// 논리 연산
A = 3; B = 0;
A & B // 0으로 평가됨. (logical-1 && logical-0)와 동일함
A | B // 1로 평가됨. (logical-1 || logical-0)와 동일함
!A // 0으로 평가됨. (logical-1의 NOT)과 동일함
!B // 1로 평가됨. (logical-0의 NOT)과 동일함

// 알 수 없는 값
A = 2'b0x; B = 2'b10;
A & B // x로 평가됨. (x && logical-1)과 동일함

// 표현식
(a == 2) && (b == 3) // a == 2 와 b == 3 이 모두 참인 경우 1로 평가됨
                      // 둘 중 하나라도 거짓이면 0으로 평가됨

• 논리 연산을 그룹화하기 위해 괄호를 사용하는 것은 가독성을 높이기 위해 강력히 추천됨

관계 연산자

• 피연산자에 알려지지 않은 (즉, x) 비트 또는 z 비트가 있으면, 표현식은 x 값을 가짐

• 이 연산자들은 C 프로그래밍 언어에서의 해당 연산자와 완전히 동일한 기능을 함

// A = 4, B = 3
// Y = 4'b1010, X = 4'b1101, Z = 4'b1xxx
A < B // 논리적으로 0으로 평가됨
A > B // 논리적으로 1으로 평가됨
Y > X // 논리적으로 1로 평가됨
Y < Z // x로 평가됨

• Y < Z에서 Z는 'x'를 포함하고 있기 때문에, 결과는 'x'로 평가되며 이는 값이 알려지지 않았음을 의미함

동등 연산자

• 동등 연산자는 논리적 동등 (==), 부등 (!=), 케이스 동등 (===), 케이스 부등 (!==)임
• 케이스 동등 연산자 (===, !==)는 비트 단위로 피연산자를 비교하고 x와 z를 포함한 모든 비트를 비교함 (즉, x 결과는 나오지 않음)



// A = 4, B = 3
// X = 4'b1010, Y = 4'b1101
// Z = 4'b1xxz, M = 4'b1xxz, N = 4'b1xxx
A == B // 논리적 0을 결과로 함
X != Y // 논리적 1을 결과로 함
X == Z // x를 결과로 함
Z == M // 논리적 1을 결과로 함 (모든 비트가 일치, x와 z 포함)
Z == N // 논리적 0을 결과로 함 (가장 낮은 유효 비트가 일치하지 않음)
M !== N // 논리적 1을 결과로 함

비트 연산자

• 비트 연산자는 부정 (~), AND (&), OR (|), XOR (^), XNOR (^~, ~^)임
• 한 피연산자가 다른 피연산자보다 짧으면 길이가 긴 피연산자의 길이에 맞추어 0으로 비트 확장됨 (예: 4'b1111 & 2'b11 → 4'b0011)



// X = 4'b1010, Y = 4'b1101
// Z = 4'b10x1
~X 
// 비트 단위 NOT 연산. 결과는 4'b0101
X & Y // 비트 단위 AND 연산. 결과는 4'b1000
X | Y // 비트 단위 OR 연산. 결과는 4'b1111
X ^ Y // 비트 단위 XOR 연산. 결과는 4'b0111
X ^~ Y // 비트 단위 XNOR 연산. 결과는 4'b1000
X & Z // 결과는 4'b10x0

• X & Z: X와 Z의 비트 단위 AND 연산. 하지만, Z의 비트 중에는 'x'(알 수 없는 값)가 있기 때문에, 해당 위치에 대한 결과 역시 'x'가 됨. 따라서 1010 AND 10x1은 10x0을 결과로 함
• 비트 연산자 ~, &, |을 논리 연산자 !, &&, ||와 구분하는 것이 중요함

// X = 4'b1010, Y = 4'b0000
X | Y // 비트 단위 연산. 결과는 4'b1010
X || Y // 논리 연산. 1 || 0과 동등함. 결과는 1.

감소 & 쉬프트 연산자

• 감소 연산자는 AND (&), NAND (~&), OR (|), NOR (~|), XOR (^), XNOR (~^, ^~)임
• 감소 연산자는 단일 피연산자만 취하고, 단일 벡터 피연산자에 비트 단위 연산을 수행하여 1비트 결과를 생성함

// X = 4'b1010

&X // 1 & 0 & 1 & 0에 해당함. 결과는 1'b0
|X // 1 | 0 | 1 | 0에 해당함. 결과는 1'b1
^X // 1 ^ 0 ^ 1 ^ 0에 해당함. 결과는 1'b0
// 감소 xor 또는 xnor는 벡터의 짝수 또는 홀수 패리티 생성에 사용될 수 있음

• 쉬프트 연산자는 오른쪽 쉬프트 (>>), 왼쪽 쉬프트 (<<), 산술 오른쪽 쉬프트 (>>>), 산술 왼쪽 쉬프트 (<<<)임
• 쉬프트 연산은 원형으로 돌아가지 않음

// X = 4'b1100
Y = X >> 1; // Y는 4'b0110임. 오른쪽으로 1비트 이동함. MSB 위치에는 0이 채워짐
Y = X << 1; // Y는 4'b1000임. 왼쪽으로 1비트 이동함. LSB 위치에는 0이 채워짐
Y = X << 2; // Y는 4'b0000임. 왼쪽으로 2비트 이동함
integer a, b, c; // signed 데이터 타입임
a = 0;
// 111…..1110110 (-10) >>> 3
b = -10; // 11111...10110 이진수임
c = a + b >>> 3; // 산술 shift로 인해 결과는 -2(10진수)임

연결 & 복제 연산자

• 연결 연산자 ({, })는 여러 피연산자를 이어붙이는 메커니즘을 제공함
• 피연산자는 크기가 지정되어야 함

// A = 1'b1, B = 2'b00, C = 2'b10, D = 3'b110

Y = {B, C} // 결과 Y는 4'b0010
Y = {A, B, C, D, 3'b001} // 결과 Y는 11'b10010110001
Y = {A, B[0], C[1]} // 결과 Y는 3'b101

• 동일한 번호의 반복적인 연결은 복제 상수를 사용하여 표현할 수 있음

reg A;
reg [1:0] B, C;
reg [2:0] D;
A = 1'b1; B = 2'b00; C = 2'b10; D = 3'b110;

Y = { 4{A} } // 결과 Y는 4'b1111
Y = { 4{A}, 2{B} } // 결과 Y는 8'b11110000
Y = { 4{A}, 2{B}, C} // 결과 Y는 10'b1111000010

조건 연산자

• 조건 연산자 (?:)는 세 개의 피연산자를 취함
• 동작은 멀티플렉서와 유사함



// 3상태 버퍼의 기능 모델링
assign addr_bus = drive_enable ? addr_out : 36'bz;

// 2대1 멀티플렉서의 기능 모델링
assign out = control ? in1 : in0;

• 조건 연산은 중첩될 수 있음

assign out = (A == 3) ? ( control ? x: y): ( control ? m : n);

연산자 우선순위

• Verilog는 표현식의 부분을 구분하기 위해 괄호가 사용되지 않는 경우, 자체 우선순위를 강제합니다.
• 모호함을 피하기 위해 괄호를 사용하는 것을 적극 권장합니다.

4-to-1 멀티플렉서

• 논리 방정식

// 데이터 플로우를 사용한 4-to-1 멀티플렉서 모듈. 논리 방정식
// 게이트 레벨 모델과 비교
module mux4_to_1 (out, i0, il, i2, i3, s1, s0);

// I/0 다이어그램에서 포트 선언
output out;
input i0, il, i2, i3;
input s1, s0;

// out을 위한 논리 방정식 
assign out = (~s1 & ~s0 & i0) | 
							(~s1 & s0 & i1) |
							(s1 & ~s0 & i2) |
							(s1 & s0 & i3);
endmodule

• 조건 연산자

// 데이터 플로우를 사용한 4-to-1 멀티플렉서 모듈. 조건부 연산자 사용
// 게이트 레벨 모델과 비교
module multiplexer4_to_1 (out, i0, i1, i2, i3, s1, s0);

// I/O 다이어그램에서 포트 선언 output out;
input io, il, i2, i3;
input s1, s0;

// 중첩된 조건부 연산자 사용
assign out = s1 ? (s0 ? i3 : i2) : (s0 ? i1 : i0);
endmodule

4비트 풀 애더

• 데이터플로우 연산자

// 데이터플로우 구문을 사용하여 4비트 풀 애더를 정의함
module fulladd4 (sum, c_out, a, b, c_in);

// I/O 포트 선언
output [3:0] sum;
output c_out;
input[3:0] a, b;
input c_in;

// 전체 덧셈기의 기능을 지정함
assign {c_out, sum} =a + b + c_in;
endmodule

리플 카운터

• 4비트 리플 카운터



// 리플 카운터
module counter (Q, clock, clear);

// 입/출력 포트
output [3:0] Q; 
input clock, clear;

// T 플립플롭 인스턴스화
T_FF tff0 (Q[0], clock, clear);
T_FF tff1 (Q[1], Q[0], clear);
T_FF tff2 (Q[2], Q[1], clear);
T_FF tff3 (Q[3], Q[2], clear);

endmodule

• T-플립플롭



// 엣지 트리거 I-플립플롭. 매 클록 사이클마다 토글됨.
module I_FF (q, clk, clear);

// 입/출력 포트들
output q;
input clk, clear;

// 엣지 트리거 D-플립플롭 인스턴스화
// q의 보수가 되돌아옴.
// qbar는 필요하지 않음. 연결되지 않은 포트.
edge_dff ff1(q, , ~q, clk, clear);

endmodule

• 엣지 트리거 D-플립플롭



// 엣지 트리거 D 플립플롭
module edge_dff(q, qbar, d, clk, clear);

// 입력 및 출력
output q, qbar; // q는 일반 출력, qbar는 q의 반전 출력
input d, clk, clear; // d는 데이터 입력, clk는 클록 신호, clear는 비동기 리셋

// 내부 변수
wire s, sbar, r, rbar, cbar; // 내부적으로 사용되는 연결 선

// 데이터 플로우 문
// clear 신호의 반전 생성
assign cbar = ~clear; // clear 신호의 반전

// 입력 래치; 레벨 감지임을 주목. Edge-sensitive 플립플롭은 3개의 SR 래치를 사용하여 구현됨
// 다음은 각 래치의 동작을 정의하는 논리 연산입니다.
assign sbar = ~(rbar & s), // sbar 는 rbar와 s의 AND 연산의 NOT 결과
      s = ~(sbar & cbar & ~clk), // s는 sbar, cbar, clk의 NOT의 AND 연산의 NOT 결과
      r = ~(rbar & ~clk & s), // r는 rbar, clk의 NOT, s의 AND 연산의 NOT 결과
      rbar = ~(r & cbar & d); // rbar는 r, cbar, d의 AND 연산의 NOT 결과

// 출력 래치
// 다음은 출력 래치의 상태를 결정하는 논리 연산입니다.
assign q = ~(s & qbar); // q는 s와 qbar의 AND 연산의 NOT 결과
assign qbar = ~(q & r & cbar); // qbar는 q, r, cbar의 AND 연산의 NOT 결과

endmodule

• 스티뮬러스

// 상위 레벨 스티뮬러스 모듈
module stimulus;

// 입력을 자극하기 위한 변수 선언
reg CLOCK, CLEAR; // CLOCK과 CLEAR 신호를 위한 레지스터
wire [3:0] Q; // 4비트 출력 Q를 위한 와이어

initial
    // 시뮬레이션 동안의 값 변화를 모니터링하기 위한 시스템 태스크
    $monitor($time, " Count = %b Clear = %b", Q[3:0], CLEAR);

// 설계 블록 'counter'의 인스턴스 생성
counter c1(Q, CLOCK, CLEAR);

// Clear 신호에 대한 스티뮬러스
initial begin
    CLEAR = 1'b1; // 초기에 CLEAR를 높은 상태로 설정
    #34 CLEAR = 1'b0; // 34 시간 단위 후에 CLEAR를 낮은 상태로 변경
    #200 CLEAR = 1'b1; // 200 시간 단위 후에 다시 CLEAR를 높은 상태로 변경
    #50 CLEAR = 1'b0; // 50 시간 단위 후에 CLEAR를 다시 낮은 상태로 변경
end

initial begin
    // 클럭 신호가 10 시간 단위마다 토글되도록 설정
    CLOCK = 1'b0; // 초기에 CLOCK를 낮은 상태로 설정
    forever #10 CLOCK = ~CLOCK; // 무한 루프 내에서 10 시간 단위마다 CLOCK 상태 토글
end

// 시간 400에서 시뮬레이션 종료
initial begin
    #400 $finish; // 400 시간 단위 후에 시뮬레이션 종료
end

endmodule

1. 이 코드는 stimulus라는 모듈을 정의하며, 이는 테스트 환경에서 DUT(테스트 대상 디바이스)인 counter 모듈을 시험하기 위한 것임
2. CLOCK과 CLEAR는 입력 제어 신호로, 이들은 DUT의 동작을 제어하는 데 사용됨
3. 시뮬레이션 시작 시, CLEAR 신호가 활성화되어 초기 상태를 설정하고, 특정 시간 경과 후에 변경되어 DUT의 반응을 테스트함
4. CLOCK 신호는 지속적으로 토글되며, 이는 DUT에 클럭 입력을 제공함
5. $monitor 시스템 태스크는 신호의 변화를 감지하여 콘솔에 출력함. 이를 통해 시뮬레이션 동안 Q 및 CLEAR의 상태를 추적할 수 있음
6. 시뮬레이션은 전체 동작을 검증한 후에 종료됨