Verilog Clocked Logic: 플립플롭, register, 파이프라인

빌딩 블록: D 플립플롭

동기 설계의 모든 것은 한 작은 하드웨어로 귀결됩니다: D 플립플롭. 클럭 입력, 데이터 입력, 데이터 출력을 가집니다. 매 rising 클럭 edge에서 D의 값을 포착해 다음 edge까지 유지합니다. 그게 전부입니다.

Verilog에서:

always @(posedge clk) begin
    q <= d;
end

세 줄, 플립플롭 하나. <=는 non-blocking이며 정확히 실제 플립플롭의 동작입니다(Blocking vs Non-blocking에서 다룸). posedge clk sensitivity가 그것을 순차로 만듭니다.

조합 논리를 사이에 두고 많이 쌓으면 어떤 동기 회로든 만들 수 있습니다.

reset이 있는 register

실제 설계는 항상 reset이 필요합니다 - 전원 인가 시나 요청 시 시스템을 알려진 상태로 만드는 방법.

module reg_with_reset #(
    parameter WIDTH = 8
)(
    input  wire             clk,
    input  wire             reset,
    input  wire [WIDTH-1:0] d,
    output reg  [WIDTH-1:0] q
);
    always @(posedge clk) begin
        if (reset) q <= 0;
        else       q <= d;
    end
endmodule

module test;
    reg clk = 0;
    reg reset = 1;
    reg [7:0] d;
    wire [7:0] q;

    reg_with_reset dut(.clk(clk), .reset(reset), .d(d), .q(q));

    always #5 clk = ~clk;

    initial begin
        d = 8'hA5;
        #20 reset = 0;
        #10 d = 8'h3C;
        #10 d = 8'hFF;
        #20 $finish;
    end

    always @(posedge clk)
        $display("t=%0t reset=%b d=%h q=%h", $time, reset, d, q);
endmodule

이게 synchronous reset 입니다 - reset 조건이 다른 입력처럼 클럭 edge에서 평가됩니다. synthesizer는 데이터 입력에 2-to-1 mux가 있는 플립플롭을 만듭니다: reset이 high일 때는 mux가 0을 공급, 아니면 d를 공급.

대부분의 설계에서 synchronous reset이 옳은 선택입니다. timing이 단순하고, FPGA와 잘 어울리며, reset 신호가 어디서든 올 수 있습니다 - 클럭에 정렬된 소스가 필요 없습니다.

enable이 있는 register

종종 무언가가 알려 줄 때만 갱신되는 register를 원합니다. clocked 블록 안에 if를 쓰고, 빠진 else의 암시적 "이전 값 유지" 동작에 의존하세요.

module reg_with_enable(
    input  wire       clk,
    input  wire       reset,
    input  wire       enable,
    input  wire [7:0] d,
    output reg  [7:0] q
);
    always @(posedge clk) begin
        if (reset)       q <= 8'd0;
        else if (enable) q <= d;
        // else 없음 - q는 이전 값 유지, 이게 FF가 하는 일
    end
endmodule

정석 "load-enabled register"입니다. 어디서나 등장합니다 - 설정 register, 다운스트림이 준비됐을 때만 진행하는 파이프라인 단계, 일시정지/재개하는 카운터 등. 마지막 else 생략은 clocked 블록 안에서 의도적이고 안전합니다: 플립플롭은 이미 이전 값을 기억하므로 "아무 일 안 함"이 "유지"를 의미합니다.

조합 블록에서 같은 코드는 latch를 inferred합니다. 다른 규칙, 같은 문법.

카운터

카운터는 다음 값이 현재 값 더하기 1인 register입니다.

module counter #(
    parameter WIDTH = 4
)(
    input  wire             clk,
    input  wire             reset,
    input  wire             enable,
    output reg  [WIDTH-1:0] count
);
    always @(posedge clk) begin
        if (reset)        count <= 0;
        else if (enable)  count <= count + 1;
    end
endmodule

module test;
    reg clk = 0;
    reg reset = 1;
    reg enable = 0;
    wire [3:0] count;

    counter #(.WIDTH(4)) dut(.clk(clk), .reset(reset), .enable(enable), .count(count));

    always #5 clk = ~clk;

    initial begin
        #12 reset = 0;
        #5  enable = 1;
        #80 $finish;
    end

    always @(posedge clk)
        $display("t=%0t count=%0d", $time, count);
endmodule

카운터는 enable이 high인 모든 클럭 사이클에서 증가합니다. 16 사이클 뒤 0으로 wrap됩니다(4비트로 선언했고 15 + 1이 0으로 overflow). 그 wrap은 N비트 산술에 내재적이고, 실제 하드웨어 카운터의 정확한 동작입니다.

shift register

플립플롭을 쌓으면 shift register가 됩니다. 요령은 모든 shift를 하나의 non-blocking 문장으로 하는 것입니다.

module shift_register #(
    parameter WIDTH = 4
)(
    input  wire             clk,
    input  wire             reset,
    input  wire             in,
    output reg  [WIDTH-1:0] out
);
    always @(posedge clk) begin
        if (reset) out <= 0;
        else       out <= {out[WIDTH-2:0], in};
    end
endmodule

module test;
    reg clk = 0;
    reg reset = 1;
    reg in = 0;
    wire [3:0] out;

    shift_register #(.WIDTH(4)) dut(.clk(clk), .reset(reset), .in(in), .out(out));

    always #5 clk = ~clk;

    initial begin
        #12 reset = 0;
        in = 1; #10;
        in = 0; #10;
        in = 1; #10;
        in = 1; #10;
        in = 0; #40 $finish;
    end

    always @(posedge clk)
        $display("t=%0t in=%b out=%b", $time, in, out);
endmodule

본문은 out <= {out[WIDTH-2:0], in} - 현재 out의 하위 비트와 새 in을 concatenate해 전체를 대입합니다. non-blocking이라 RHS가 LHS 갱신 전 옛 out을 읽습니다. 효과는 단일 클럭 사이클의 깔끔한 N비트 shift입니다.

shift-register 패턴의 가장 작은 형태입니다. LFSR, serial transmitter, deserializer - 매 클럭에 플립플롭 체인을 통해 데이터가 이동하는 어떤 설계로도 일반화됩니다.

파이프라인

파이프라인은 조합 논리로 분리된 register 체인입니다. 각 단계는 이전 단계의 데이터를 처리해 다음 단계에 공급합니다.

module pipelined_add(
    input  wire        clk,
    input  wire        reset,
    input  wire [7:0]  a, b, c, d,
    output reg  [9:0]  result
);
    reg [8:0] stage1_ab, stage1_cd;
    reg [9:0] stage2;

    always @(posedge clk) begin
        if (reset) begin
            stage1_ab <= 0;
            stage1_cd <= 0;
            stage2    <= 0;
            result    <= 0;
        end else begin
            // Stage 1: 두 병렬 덧셈.
            stage1_ab <= a + b;
            stage1_cd <= c + d;
            // Stage 2: 두 부분합 결합.
            stage2    <= stage1_ab + stage1_cd;
            // Stage 3: 출력으로 전달.
            result    <= stage2;
        end
    end
endmodule

module test;
    reg clk = 0;
    reg reset = 1;
    reg [7:0] a, b, c, d;
    wire [9:0] result;

    pipelined_add dut(.clk(clk), .reset(reset), .a(a), .b(b), .c(c), .d(d), .result(result));

    always #5 clk = ~clk;

    initial begin
        a = 0; b = 0; c = 0; d = 0;
        #12 reset = 0;
        a = 10; b = 20; c = 30; d = 40; #10;
        a = 1;  b = 2;  c = 3;  d = 4;  #10;
        a = 5;  b = 5;  c = 5;  d = 5;  #40;
        $finish;
    end

    always @(posedge clk)
        $display("t=%0t a=%0d b=%0d c=%0d d=%0d result=%0d", $time, a, b, c, d, result);
endmodule

3단, 3 사이클 latency, 그러나 파이프라인이 가득 차면 매 사이클 새 결과. latency가 3 클럭인 건 데이터가 세 플립플롭을 지나기 때문이고, 처리량이 클럭당 1 연산인 건 세 단계가 다른 입력에 대해 동시에 일하기 때문입니다.

이게 고성능 설계가 처리량 목표를 달성하는 방법입니다: 단계를 짧게 유지하고, 더 깊이 파이프라이닝하고, 병렬성이 일을 하게 합니다.

asynchronous reset (필요할 때)

가끔 reset을 위해 클럭 edge를 기다릴 수 없을 때가 있습니다 - 칩이 전원이 내려가고 있거나, 클럭이 게이트되어 있거나, 외부 워치독이 라인을 끌어내리고 있을 때. 그런 경우엔

always @(posedge clk or negedge reset_n) begin
    if (~reset_n) q <= 0;
    else          q <= d;
end

sensitivity list가 이제 클럭 edge 와 reset edge 둘 다 가집니다. 플립플롭이 둘 중 어디든 즉시 반응합니다. reset_n은 관례상 active-low(low일 때 assert)이라 검사가 ~reset_n입니다.

비동기 reset은 trade-off가 있습니다: timing 분석이 어렵고, de-assertion에서 조심히 다루지 않으면 metastability를 일으킬 수 있고, 모든 FPGA 아키텍처에서 이식 가능하지 않습니다. 기본으로 synchronous reset을, 설계가 요구할 때만 async를 쓰세요.

다음에 볼 내용

이제 어떤 동기 datapath든 만들 수 있습니다. 다음 문서 - Finite State Machines - 는 clocked register와 case 문을 결합해 표준 FSM idiom을 만들어 냅니다: 모든 컨트롤러, 프로토콜 엔진, 결정 블록의 일꾼.