Pętla for w Verilogu: rozwijana podczas kompilacji

Podobna do pętli z programowania

Pętla for w Verilogu to kopia tej z C:

for (i = 0; i < 8; i = i + 1) begin
    // body
end

Te same trzy części: inicjalizacja, warunek, inkrementacja. Ciało wykonuje się ponownie, dopóki warunek jest spełniony.

W testbenchu działa to dokładnie tak, jak można się spodziewać po programowaniu. Symulator przechodzi przez kolejne iteracje po kolei:

module testbench_for;
    integer i;
    initial begin
        for (i = 0; i < 4; i = i + 1)
            $display("iteration i=%0d", i);
        $finish;
    end
endmodule

Cztery iteracje, cztery linie wyjścia. Bez niespodzianek.

Niespodzianka pojawia się, gdy umieścisz pętlę for w kodzie syntezowalnym.

Rozwijanie

Pętla for w syntezowalnym bloku always nie staje się w sprzęcie pętlą wykonywaną w czasie działania. Syntezator rozwija ją na etapie elaboracji, czyli zamienia ją w N kopii ciała, gdzie N to liczba iteracji:

module count_ones(
    input  wire [7:0] data,
    output reg  [3:0] count
);
    integer i;
    always @(*) begin
        count = 0;
        for (i = 0; i < 8; i = i + 1) begin
            if (data[i]) count = count + 1;
        end
    end
endmodule

module test;
    reg [7:0] d;
    wire [3:0] c;
    count_ones dut(.data(d), .count(c));

    initial begin
        d = 8'b0000_0000; #1 $display("data=%b count=%0d", d, c);
        d = 8'b1111_1111; #1 $display("data=%b count=%0d", d, c);
        d = 8'b1010_1100; #1 $display("data=%b count=%0d", d, c);
        d = 8'b0010_0001; #1 $display("data=%b count=%0d", d, c);
        $finish;
    end
endmodule

To wygląda jak pętla. W symulacji symulator faktycznie wykonuje osiem iteracji. W syntezie pętla jest rozwijana w osiem równoległych sprawdzeń od data[0] do data[7], które dzieją się jednocześnie. Syntezator widzi:

count = 0;
if (data[0]) count = count + 1;
if (data[1]) count = count + 1;
if (data[2]) count = count + 1;
...
if (data[7]) count = count + 1;

…a potem zamienia tę sekwencję w drzewo sumatorów. W działaniu oznacza to "spójrz na wszystkie 8 bitów naraz i policz, ile z nich to 1", w jednym kombinacyjnym przebiegu.

Wniosek: pętla for w syntezowalnym Verilogu nie jest darmowa. Pętla z 64 iteracjami staje się w sprzęcie 64 kopiami ciała. Jeśli ciało jest złożone, właśnie powstaje duży blok kombinacyjny. Używaj pętli, gdy N jest małe (od kilku do kilkudziesięciu). Przy większych liczbach zwykle potrzebujesz taktowanego licznika i maszyny stanów.

Wymagane są stałe granice

Syntezator może rozwinąć pętlę tylko wtedy, gdy zna N na etapie elaboracji. Oznacza to, że granice pętli muszą być stałymi:

// Works - bound is constant
for (i = 0; i < 8; i = i + 1) ...

// Works - bound is a parameter
for (i = 0; i < WIDTH; i = i + 1) ...

// Doesn't synthesize - bound depends on a runtime signal
for (i = 0; i < dynamic_count; i = i + 1) ...

Ostatnia forma może działać w symulacji, ale syntezator ją odrzuci. Jeśli naprawdę potrzebujesz pętli z liczbą iteracji znaną dopiero w czasie działania, zbuduj ją z taktowanej maszyny stanów i rejestru licznika. Sprzęt nie ma pętli o zmiennej liczbie przebiegów w takim sensie jak oprogramowanie.

generate for a proceduralne for

Osobną, ale pokrewną konstrukcją jest generate for, która używa genvar i znajduje się poza blokami always:

genvar i;
generate
    for (i = 0; i < 8; i = i + 1) begin : g
        bit_inverter inv(.x(in[i]), .y(out[i]));
    end
endgenerate

To tworzy 8 instancji bit_inverter (więcej w artykule Tworzenie instancji modułów). Jest to konstrukcja strukturalna: mówisz "zrób 8 kopii tego podmodułu", a nie opisujesz zachowania.

Krótkie rozróżnienie:

• Proceduralne for (wewnątrz always): rozwija instrukcje w obrębie jednego bloku behawioralnego.
• for w generate (poza always): powiela całe konstrukcje strukturalne, czyli instancje, instrukcje assign, nazwane bloki.

Użyj tej, która pasuje do tego, co powielasz.

Gdzie for błyszczy: operacje na wektorach

Pętle sprawdzają się najlepiej, gdy wykonujesz tę samą operację na każdym bicie wektora. Liczenie jedynek, parzystość, odwracanie bajtów, generowanie tablic przeglądowych:

module reverse_bytes(
    input  wire [31:0] in,
    output reg  [31:0] out
);
    integer i;
    always @(*) begin
        for (i = 0; i < 32; i = i + 1) begin
            out[i] = in[31 - i];
        end
    end
endmodule

module test;
    reg  [31:0] x;
    wire [31:0] y;
    reverse_bytes dut(.in(x), .out(y));

    initial begin
        x = 32'hDEAD_BEEF; #1 $display("in=%h out=%h", x, y);
        x = 32'h0000_0001; #1 $display("in=%h out=%h", x, y);
        $finish;
    end
endmodule

32 iteracje, każda z przypisaniem jednego bitu, a to czyta się dużo łatwiej niż 32 ręcznie wypisane przypisania. Syntezator czysto je rozwija.

while, repeat, forever

Poza for Verilog ma trzy inne konstrukcje pętli, głównie do testbenchy:

// Run until a condition fails
while (~done) begin
    @(posedge clk);
    cycles = cycles + 1;
end

// Run N times - simpler than for when you don't need a counter
repeat (8) @(posedge clk);

// Run forever - clock generators, monitoring loops
always #5 clk = ~clk;
forever begin
    @(posedge clk);
    $display("count=%0d", count);
end

while, repeat i forever są syntezowalne tylko w wąskich przypadkach (zwłaszcza repeat ze stałą liczbą i taktowanym ciałem). W testbenchach to przydatne narzędzia, a w syntezowalnym RTL lepiej wybrać for z licznikiem plus jawną maszynę stanów.

Proceduralne for w testbenchach

W testbenchu pętle for zachowują się jak w programowaniu. Używaj ich swobodnie:

module sweep_test;
    reg [7:0] a, b;
    wire [8:0] sum;

    assign sum = a + b;

    initial begin
        for (integer i = 0; i < 4; i = i + 1) begin
            for (integer j = 0; j < 4; j = j + 1) begin
                a = i;
                b = j;
                #1 $display("%0d + %0d = %0d", a, b, sum);
            end
        end
        $finish;
    end
endmodule

Zagnieżdżone pętle przechodzą przez każdą kombinację dwóch 2-bitowych wejść. Symulator wykonuje iteracje po kolei. Rozwijanie nie ma znaczenia, bo testbenchy nie są syntezowane.

Typowe błędy

Pętla for w kodzie syntezowalnym z niestałą granicą. Syntezator ją odrzuci. Jeśli granica jest znana dopiero w czasie działania, zbuduj licznik i maszynę stanów.

Zapominanie, że ciało pętli staje się równoległym sprzętem. Pętla z 64 iteracjami i mnożarką w ciele to 64 równoległe mnożarki, czyli prawdopodobnie nie to, czego chcesz. Przy szerokich ścieżkach danych zbuduj jedną mnożarkę i podawaj jej dane sekwencyjnie.

Mieszanie integer i i reg o nazwie i. To dwa różne zakresy, a wewnątrz pętli wygrywa integer. Wybieraj jasne nazwy, żeby uniknąć pomyłek.

Co dalej

Znasz już wszystkie konstrukcje proceduralne, jakie oferuje Verilog. Następny rozdział łączy je we wzorce, które projektanci układów cyfrowych naprawdę stosują: Logika taktowana, czyli przerzutniki, rejestry i potoki, oraz Maszyny stanów, czyli standardowy idiom każdego kontrolera z kilkoma trybami pracy.