12 User-Defined Primitives

UDP(User-Defined Primitive) 정의의 구성 요소

• 사용자 정의 프리미티브(UDP) 정의는 primitive 키워드로 시작합니다.

// UDP 이름 및 터미널 목록
primitive <udp_name> (<output_terminal_name>, <input_terminal_names>);
// 터미널 선언
output <output_terminal_name>;
input <input_terminal_names>;
// 순차적 UDP의 경우 선택적으로 reg 선언
reg <output_terminal_name>; (optional; only for sequential UDP)
// 순차적 UDP 초기화 (선택적)
initial <output_terminal_name> = <value>;
// UDP 상태 테이블
table
<table_entries>
endtable
// UDP 정의 종료
endprimitive

UDP 규칙

• UDP 정의는 특정 규칙을 따릅니다.
• UDP는 스칼라 입력(1-비트) 터미널만 받을 수 있습니다.
• 다중 입력 터미널이 허용됩니다.
• UDP는 하나의 스칼라 출력 터미널만 가질 수 있습니다.
• 출력 터미널은 터미널 목록에서 항상 먼저 나타나야 합니다.
• 다중 출력 터미널은 허용되지 않습니다.
• 출력 터미널은 output 키워드로 선언됩니다.
• 순차적 UDP는 상태를 저장하므로 출력 터미널은 reg로도 선언되어야 합니다.
• 입력은 input 키워드로 선언됩니다.
• 순차적 UDP에서 상태는 initial 문으로 초기화될 수 있습니다(선택적).
• 출력에는 reg로 선언된 1-비트 값이 할당됩니다.
• 상태 테이블 항목은 0, 1, x 값을 포함할 수 있습니다.
• UDP는 z 값을 처리하지 않습니다. z 값은 x 값으로 취급됩니다.
• UDP는 모듈과 동일한 수준에서 정의됩니다.
• UDP는 모듈 내부에서 정의할 수 없으며 모듈 내에서만 인스턴스화될 수 있습니다.
• UDP는 inout 포트를 지원하지 않습니다.

조합형 UDP 정의

• 상태 테이블은 UDP 정의에서 가장 중요한 부분입니다.

// UDP 이름 및 터미널 목록
primitive udp_and (out, a, b);
// 선언
output out; // 조합형 UDP의 경우 reg로 선언되어서는 안 됩니다.
input a, b; // 입력 선언
// 상태 테이블 정의; 키워드 table로 시작
// a b : out;
0 0 : 0;
0 1 : 0;
1 0 : 0;
1 1 : 1;
endtable
endprimitive

상태 테이블 항목

• 조합형 UDP의 상태 테이블의 각 항목은 <input1> <input2> ... <inputn> : <output>; 형식을 가집니다.
1. <input#>은 입력 목록에서와 동일한 순서로 나타나야 합니다.
2. 입력과 출력은 ":"으로 구분됩니다.
3. 상태 테이블 항목은 ";"로 끝납니다.
4. 입력의 모든 가능한 조합이 명시적으로 지정되어야 합니다.
5. 특정 조합이 발생하고 해당 항목이 테이블에 없는 경우, 출력은 x가 됩니다.

primitive udp_or(out, a, b);
output out;
input a, b;
table
// a b : out;
0 0 : 0;
0 1 : 1;
1 0 : 1;
1 1 : 1;
endtable
endprimitive

Don't Cares에 대한 축약 표현

• Don't Care를 나타내기 위해 ? 기호가 사용됩니다.
• ? 기호는 자동으로 0, 1, 또는 x로 확장됩니다.

primitive udp_or(out, a, b);
output out;
input a, b;
table
    // a b : out;
    0 0 : 0;
    1 ? : 1; // ?는 0, 1, x로 확장됨
    ? 1 : 1; // ?는 0, 1, x로 확장됨
    ? ? : x; // ?는 0, 1, x로 확장됨
		0 x : x;
	  x 0 : x;
endtable
endprimitive

UDP(User-Defined Primitive) 원시체 인스턴스화

• UDP는 Verilog 게이트 원시체와 마찬가지로 인스턴스화됩니다.

// 1비트 전체 덧셈기를 정의합니다.
module fulladd(sum, c_out, a, b, c_in);
    output sum, c_out;
    input a, b, c_in;

    // 내부 넷
    wire s1, c1, c2;

    // 논리 게이트 원시체 인스턴스화
    xor (s1, a, b);        // Verilog 원시체 사용
    xor (sum, s1, c_in);   // Verilog 원시체 사용
    udp_and (c1, a, b);    // UDP 사용
    udp_and (c2, s1, c_in);// UDP 사용
    udp_or (c_out, c2, c1);// UDP 사용
endmodule

primitive udp_or(out, a, b);
output out;
input a, b;
table
    // a b : out;
    1 ? : 1; // ?는 0, 1, x로 확장됨
    ? 1 : 1; // ?는 0, 1, x로 확장됨
    ? ? : x; // ?는 0, 1, x로 확장됨
		0 x : x;
		x 0 : x;
endtable
endprimitive

조합형 UDP 예시

4대1 멀티플렉서

• 4대1 멀티플렉서를 원시체로 정의합니다.

primitive mux4_to_1 (out, i0, i1, i2, i3, s1, s0);
    output out;
    input i0, i1, i2, i3, s1, s0;
    table
        // i0 i1 i2 i3 s1 s0 : out
        1  ?  ?  ?  0  0  :  1;
        0  ?  ?  ?  0  0  :  0;
        ?  1  ?  ?  0  1  :  1;
        ?  0  ?  ?  0  1  :  0;
        ?  ?  1  ?  1  0  :  1;
        ?  ?  0  ?  1  0  :  0;
        ?  ?  ?  1  1  1  :  1;
        ?  ?  ?  0  1  1  :  0;
        ?  ?  ?  ?  x  ?  :  x;
        ?  ?  ?  ?  ?  x  :  x;
    endtable
endprimitive

• 입력 수가 증가함에 따라 상태 테이블이 매우 빠르게 커질 수 있음을 주의해야 합니다.

순차적 UDP

• 순차적 UDP는 조합형 UDP와 다릅니다.
• 순차적 UDP의 출력은 항상 reg로 선언됩니다.
• 초기화문을 사용하여 순차적 UDP의 출력을 초기화할 수 있습니다.
• 포맷: <input1> <input2> ... <inputN> : <current_state> : <next_state>;
• 상태 테이블의 입력은 입력 레벨 또는 에지 전환에 따라 다를 수 있습니다.
• 현재 상태는 출력 레지스터의 현재 값입니다.
• 다음 상태는 입력과 현재 상태에 따라 계산됩니다.
• 다음 상태는 출력 레지스터의 새 값이 됩니다.
• 알려지지 않은 출력 값을 피하기 위해 입력의 모든 가능한 조합을 명시해야 합니다.

• 입력 레벨과 입력의 에지 전환에 민감한 경우 각각 레벨-민감형(level-sensitive)과 에지-민감형(edge-sensitive) 순차적 UDP라고 합니다.

레벨-민감형 순차적 UDP

• 레벨-민감형 UDP는 입력 레벨에 따라 상태가 변경됩니다.
• 래치는 레벨-민감형 UDP의 가장 일반적인 예시입니다.

// UDP를 사용하여 레벨-민감형 래치 정의
primitive latch(q, d, clock, clear);
    output q;
    reg q; // 내부 저장소 생성을 위해 reg로 선언
    input d, clock, clear;
    // 순차적 UDP 초기화
    initial q = 0; // 출력을 0으로 초기화
    // 상태 테이블
    table
        // d clock clear : q : q+
        ?  ?  1  :  ?  :  0 ; // 클리어 조건
        ?  0  ?  :  ?  :  - ; // 클록이 0이면 원래 상태 유지
        1  1  ?  :  ?  :  1 ; // 래치 q = 데이터 = 1
        0  1  ?  :  ?  :  0 ; // 래치 q = 데이터 = 0
    endtable
endprimitive

에지-민감형 순차적 UDP

// 에지-민감형 순차적 UDP 정의
primitive edge_dff(q, d, clock, clear);
    output reg q; // 출력을 reg로 선언
    input d, clock, clear;
    table
        // clock clear : q : q+
        ? 1 : ? : 0 ; // clear가 1일 때 출력 = 0
        (10) : ? : - ; // clear의 음의 에지 무시
        (10) 0 : ? : 1 ; // clock의 음의 에지에서 데이터 래치
        (10) 0 : ? : 0 ; // clock의 음의 에지에서 데이터 래치
        (1x) 0 : ? : - ; // clock이 불확실한 상태로 전환될 때 q 유지
        ... // 추가 규칙
    endtable
endprimitive

순차적 UDP 예시

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-플립플롭
primitive t_ff(q, clk, clear);
    output reg q;
    input clk, clear;
    table
        // clk clear : q : q+
        ? 1 : ? : 0; // 비동기 클리어 조건
        ? (10) : ? : -; // clear의 음의 에지 무시
        (10) 0 : ? : ~q; // clk의 음의 에지에서 토글
        ... // 추가 규칙
    endtable
endprimitive

UDP 테이블 축약 기호

table
    ? ? 1 : ? : 0 ;      // clear가 1일 경우, 출력 q = 0
    ? ? (10) : ? : - ;   // clock의 하강 에지에서 q 유지
    1 (10) 0 : ? : 1 ;   // d가 1이고, clock의 하강 에지에서 clear가 0일 때, 출력 q = 1
    0 (10) 0 : ? : 0 ;   // d가 0이고, clock의 하강 에지에서 clear가 0일 때, 출력 q = 0
    ? (1x) 0 : ? : - ;   // clock이 불확실 상태에서 clear가 0일 때 q 유지
    ? (0?) 0 : ? : - ;   // clock이 0에서 불확실 상태로 전환될 때 q 유지
    ? (x1) 0 : ? : - ;   // clock이 불확실 상태에서 1로 전환될 때 q 유지
    (??) ? 0 : ? : - ;   // clock이 어떤 상태 변화를 보여도 clear가 0일 때 q 유지
endtable

• ? 기호는 무관심(Don't care) 상태를 나타내며, 어떤 값이든 될 수 있음을 의미합니다.

• (10)은 clock 신호가 1에서 0으로 변하는 하강 에지를 나타냅니다.

• (1x), (0?), (x1)은 clock 신호가 불확실한 상태(예: 1에서 불확실(x) 또는 불확실(x)에서 1)로 변하는 것을 나타냅니다.

• (??)는 clock 신호가 어떤 값으로든 변할 수 있음을 나타냅니다.

• -는 상태가 변경되지 않음을 의미합니다. 즉, 현재 상태 q를 유지한다는 것을 의미합니다.

table
    // d clock clear : q : q+
    ? ? 1 : ? : 0 ; // clear가 1이면 출력 q = 0
    ? ? f : ? : - ; // clear의 음의 에지 무시

    1 f 0 : ? : 1 ; // clock의 음의 에지에서 데이터 래치
    0 f 0 : ? : 0 ; // clock의 음의 에지에서 데이터 래치

    ? (1x) 0 : ? : - ; // clock이 불확실 상태로 전환될 때 q 유지

    ? p 0 : ? : - ; // clock의 양의 에지 무시
    * ? 0 : ? : - ; // d가 변경되어도 clock이 안정적이면 q 유지
endtable

• 이 테이블은 입력 d, clock, clear에 따라 출력 q가 어떻게 변화하는지를 정의합니다.

• (1x)는 clock이 불확실한 상태로 전환될 때를 의미하며, 여기서도 는 상태 변경 없음을 나타냅니다.