Instrukcja case w Verilogu: poprawne dekodowanie wielu wariantów

Rozgałęzienie na wiele wariantów

case to w Verilogu płaska konstrukcja wyboru. Podajesz wyrażenie, a ona wybiera pasującą gałąź:

case (expression)
    pattern_1: statement_1;
    pattern_2: statement_2;
    pattern_3: begin
        statement_3a;
        statement_3b;
    end
    default: default_statement;
endcase

Strukturalnie przypomina switch z C, ale:

• Nie ma break: każdą gałąź domyślnie kończy następna.
• Wzorcami mogą być wektory, nie tylko liczby całkowite.
• Syntezator zamienia całość w płaski multiplekser (albo dekoder one-hot, gdy wzorce na to pozwalają).

Przykład: multiplekser 4 na 1

module mux4(
    input  wire [1:0] sel,
    input  wire [7:0] in0, in1, in2, in3,
    output reg  [7:0] out
);
    always @(*) begin
        case (sel)
            2'd0: out = in0;
            2'd1: out = in1;
            2'd2: out = in2;
            2'd3: out = in3;
            default: out = 8'bx;
        endcase
    end
endmodule

module test;
    reg [1:0] sel;
    wire [7:0] out;
    wire [7:0] a = 8'hA0, b = 8'hB0, c = 8'hC0, d = 8'hD0;

    mux4 dut(.sel(sel), .in0(a), .in1(b), .in2(c), .in3(d), .out(out));

    initial begin
        for (integer i = 0; i < 4; i = i + 1) begin
            sel = i[1:0];
            #1 $display("sel=%0d out=%h", sel, out);
        end
        $finish;
    end
endmodule

Ciało case ma cztery jawne wzorce oraz default. Syntezator widzi 2-bitowe wejście odwzorowane na jedną z czterech wartości i tworzy multiplekser 4 na 1. Czysto, płasko i szybko.

Dlaczego potrzebujesz default

W kombinacyjnym case pominięcie default to ta sama pułapka, co if bez else: każda niedopasowana wartość wejścia zostawia out bez przypisania, a syntezator tworzy zatrzask.

Dla 2-bitowego sel powyższe wzorce obejmują wszystkie cztery możliwe wartości, więc teoretycznie default jest zbędny. W praktyce:

1. Syntezator nie zawsze potrafi wykazać, że warianty są wyczerpujące.
2. W symulacji selektor może mieć wartość x albo z, która nie pasuje do żadnego jawnego wariantu.
3. Dodanie nowego wariantu później może zostawić zachowanie domyślne nieokreślone.

Zawsze pisz default. W maszynach stanów i logice multipleksera, gdy wiesz, że wariant domyślny jest nieosiągalny, przypisanie 'x:

default: out = 8'bx;

…mówi syntezatorowi "to wartość dowolna, optymalizuj swobodnie", a w symulacji pokazuje jaskrawe x, jeśli nieosiągalny wariant jednak zostanie osiągnięty. Najlepsze z obu światów.

Maszyna stanów w case

Klasyczne zastosowanie case to logika przejść między stanami w automacie skończonym:

module traffic_light(
    input  wire       clk,
    input  wire       reset,
    output reg  [1:0] light    // 00=red, 01=yellow, 10=green
);
    localparam RED    = 2'd0;
    localparam GREEN  = 2'd1;
    localparam YELLOW = 2'd2;

    reg [1:0] state;
    reg [3:0] timer;

    always @(posedge clk) begin
        if (reset) begin
            state <= RED;
            timer <= 4'd0;
        end else if (timer == 4'd0) begin
            case (state)
                RED:    begin state <= GREEN;  timer <= 4'd6; end
                GREEN:  begin state <= YELLOW; timer <= 4'd2; end
                YELLOW: begin state <= RED;    timer <= 4'd5; end
                default: begin state <= RED;   timer <= 4'd0; end
            endcase
        end else begin
            timer <= timer - 4'd1;
        end
    end

    always @(*) light = state;
endmodule

module test;
    reg clk = 0;
    reg reset = 1;
    wire [1:0] light;
    traffic_light dut(.clk(clk), .reset(reset), .light(light));

    always #5 clk = ~clk;

    initial begin
        #12 reset = 0;
        #200 $finish;
    end

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

Blok case (state) to logika przejść. Każda gałąź decyduje, jaki będzie następny stan i jak długo w nim pozostać. default jest tu nieosiągalny (RED/GREEN/YELLOW obejmują wszystkie potrzebne wartości w przestrzeni 2 bitów), ale stanowi siatkę bezpieczeństwa: jeśli state jakimś cudem przyjmie wartość 2'd3, automat czysto wraca do RED zamiast tworzyć zatrzask.

Artykuł Maszyny stanów omawia ten wzorzec dokładniej.

Kilka wzorców w jednej gałęzi

Możesz wypisać kilka wzorców korzystających z jednej instrukcji, oddzielając je przecinkami:

case (opcode)
    4'h0, 4'h1, 4'h2: result = a + b;
    4'h3, 4'h4:       result = a - b;
    4'h8:             result = a & b;
    default:          result = 8'd0;
endcase

Tutaj dwa opcode oznaczają "odejmij", a trzy "dodaj". Syntezator łączy wzorce przez OR w komparatorze.

casez i casex: dopasowanie z dowolnymi bitami

Czasem chcesz dopasować wzorzec z częścią bitów nieokreśloną, na przykład "każdy opcode zaczynający się od 010":

casez (opcode)
    8'b010?_????: instruction = ALU_OP;
    8'b110?_????: instruction = LOAD_OP;
    8'b1110_????: instruction = JUMP_OP;
    default:      instruction = UNKNOWN;
endcasez

casez traktuje ? (oraz z) we wzorcu jako wartości dowolne. Każdy ? pasuje do 0 i do 1. Przydaje się przy dekodowaniu formatów instrukcji, w których niektóre pozycje bitów są nieużywane w pewnych klasach opcode.

casex rozszerza to i jako dowolne traktuje także x. casex jest niebezpieczne, bo niezainicjowane sygnały (które w symulacji mają wartość x) pasują do każdego wariantu, co daje zaskakujące zachowanie. Większość współczesnych przewodników stylu zaleca casez i zabrania casex.

W SystemVerilogu masz jeszcze case inside, najczystszą wersję ze wszystkich, bo przyjmuje zakresy i listy. Zwykły Verilog kończy się jednak na casez.

case a łańcuch if/else if

Obie konstrukcje wyrażają decyzje wielowariantowe, ale syntezują się do innego sprzętu:

• case to płaski wybór. Syntezator może utworzyć dekoder one-hot, zrównoważone drzewo multiplekserów albo inne płaskie struktury. Czas obliczenia jest stały.
• if/else if to łańcuch priorytetów. Syntezator tworzy kaskadę, w której każdy poziom dodaje opóźnienie. Wolniej, logarytmicznie.

Funkcjonalnie się pokrywają. Stylistycznie: używaj case, gdy warunki dotyczą wartości jednego wyrażenia. Używaj if/else if, gdy istnieje prawdziwy priorytet albo gdy warunki dotyczą różnych sygnałów.

// Better as case:
if      (sel == 2'd0) out = a;
else if (sel == 2'd1) out = b;
else if (sel == 2'd2) out = c;
else                  out = d;

// Better as if/else if:
if      (urgent_event)  next_state = HANDLE_URGENT;
else if (timer_expired) next_state = TIMEOUT;
else if (data_ready)    next_state = PROCESS;
else                    next_state = state;

Pierwsze trzy warunki pytają o to samo: "jaka jest wartość sel?". case czyta się tu naturalniej i syntezuje bardziej płasko. Drugie trzy to niezależne zdarzenia z oczywistym priorytetem, więc lepiej pasuje if/else if.

Co dalej

Ostatni artykuł w tym rozdziale, Pętle for, omawia for w Verilogu i zaskakujące zjawisko, które zachodzi, gdy użyjesz tej pętli w kodzie syntezowalnym. Potem przechodzimy na dobre do logiki sekwencyjnej i automatów skończonych.