Verilog for-Schleifen: Zur Compile-Zeit aufgerollt

Die Software-Ähnlichkeit

Verilogs for-Schleife ist eine Kopie der von C:

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

Dieselben drei Teile: Initialisierer, Bedingung, Inkrement. Der Body läuft erneut, solange die Bedingung gilt.

In einer Testbench verhält sich das genauso, wie du es aus Software erwartest. Der Simulator geht jede Iteration der Reihe nach durch:

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

Vier Iterationen, vier Ausgabezeilen. Keine Überraschungen.

Die Überraschung kommt, wenn du eine for-Schleife in synthetisierbaren Code einfügst.

Das Aufrollen

Eine for-Schleife in einem synthetisierbaren always-Block wird in Hardware nicht zu einer Laufzeit-Schleife. Der Synthesizer rollt sie zur Elaborationszeit auf - er expandiert die Schleife in N Kopien des Bodys, wobei N die Iterationszahl ist:

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

Das sieht aus wie eine Schleife. In der Simulation iteriert der Simulator tatsächlich acht Mal. In der Synthese wird die Schleife in acht parallele Checks von data[0] bis data[7] aufgerollt, die alle gleichzeitig passieren. Der Synthesizer sieht:

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;

… und macht aus der Folge dann einen Addierbaum. Das Laufzeitverhalten ist "schau dir alle 8 Bits gleichzeitig an und zähle, wie viele 1 sind", in einem einzigen kombinatorischen Durchlauf.

Die Implikation: Eine for-Schleife in synthetisierbarem Verilog ist nicht kostenlos. Eine 64-Iterationen-Schleife wird in Hardware zu 64 Kopien des Bodys. Ist der Body komplex, hast du gerade einen großen kombinatorischen Block gebaut. Nimm Schleifen, wenn N klein ist (eine Handvoll bis ein paar Dutzend). Für größere Zähler willst du meist einen getakteten Counter und einen Automaten.

Konstante Grenzen sind Pflicht

Der Synthesizer kann die Schleife nur aufrollen, wenn er N zur Elaborationszeit kennt. Das bedeutet, die Schleifengrenzen müssen Konstanten sein:

// Funktioniert - Grenze ist konstant
for (i = 0; i < 8; i = i + 1) ...

// Funktioniert - Grenze ist ein Parameter
for (i = 0; i < WIDTH; i = i + 1) ...

// Synthetisiert nicht - Grenze hängt von einem Laufzeitsignal ab
for (i = 0; i < dynamic_count; i = i + 1) ...

Die letzte Form funktioniert vielleicht noch in der Simulation, aber der Synthesizer lehnt sie ab. Wenn du wirklich eine laufzeitgesteuerte Schleife brauchst, baust du sie mit einem getakteten Automaten und einem Counter-Register - Hardware hat keine variabel begrenzten Schleifen wie Software.

generate for vs prozedurales for

Ein separates, aber verwandtes Konstrukt ist generate for, das einen genvar benutzt und außerhalb von always-Blöcken lebt:

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

Das stanzt 8 Instanzen von bit_inverter aus (behandelt in Modul-Instanziierung). Es ist strukturell - du sagst "mache 8 Kopien dieses Submoduls" - nicht verhaltensmäßig.

Kurze Unterscheidung:

• Prozedurales for (innerhalb von always) - rollt Anweisungen innerhalb eines einzelnen Verhaltensblocks auf.
• Generate for (außerhalb von always) - repliziert ganze strukturelle Konstrukte: Instanzen, assign-Anweisungen, benannte Blöcke.

Nimm das, was zu dem passt, was du replizierst.

Wo for glänzt: Vektor-Operationen

Schleifen sind am stärksten, wenn du dieselbe Operation auf jedes Bit eines Vektors anwendest. Population Count, Parität, Byte-Umkehr, Erzeugung von Lookup-Tabellen:

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 Iterationen, jede mit einer Bit-Zuweisung - viel lesbarer, als 32 von Hand geschriebene Wire-Zuweisungen zu tippen. Der Synthesizer rollt sauber auf.

while, repeat, forever

Neben for hat Verilog drei weitere Schleifenkonstrukte - meist für Testbenches:

// Laufen, bis eine Bedingung fehlschlägt
while (~done) begin
    @(posedge clk);
    cycles = cycles + 1;
end

// N-mal laufen - einfacher als for, wenn man keinen Counter braucht
repeat (8) @(posedge clk);

// Endlos laufen - Taktgeneratoren, Monitoring-Schleifen
always #5 clk = ~clk;
forever begin
    @(posedge clk);
    $display("count=%0d", count);
end

while, repeat und forever sind nur in engen Fällen synthetisierbar (insbesondere repeat mit konstantem Zähler und getaktetem Body). In Testbenches sind sie nützlich; in synthetisierbarem RTL bevorzugst du eine gezählte for-Schleife plus expliziten Automaten.

Prozedurales for in Testbenches

In einer Testbench verhalten sich for-Schleifen so, wie Software es tut. Nutze sie frei:

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

Verschachtelte Schleifen probieren jede Kombination zweier 2-Bit-Eingänge durch. Der Simulator führt die Iterationen sequentiell aus. Keine Sorgen wegen Aufrollens - Testbenches synthetisieren nicht.

Häufige Fehler

Eine for-Schleife in synthetisierbarem Code mit nicht-konstanter Grenze nutzen. Der Synthesizer lehnt sie ab. Ist die Grenze zur Laufzeit variabel, baue einen Counter und einen Automaten.

Vergessen, dass der Schleifenrumpf zu paralleler Hardware wird. Eine 64-Iterationen-Schleife mit einem Multiplizierer im Body ergibt 64 parallele Multiplizierer - vermutlich nicht das, was du willst. Für breite Datenpfade baue einen einzigen Multiplizierer und füttere ihn sequentiell.

integer i und ein reg namens i mischen. Die beiden sind unterschiedliche Scopes; innerhalb der Schleife gewinnt der integer. Wähle klare Namen, um Verwirrung zu vermeiden.

Wie es weitergeht

Du hast jetzt jedes prozedurale Konstrukt gesehen, das Verilog anbietet. Das nächste Kapitel führt alles zu den Mustern zusammen, die Digital-Designer tatsächlich ausliefern: Getaktete Logik - Flip-Flops, Register und Pipelines - und Endliche Automaten - das Standardidiom für jeden Controller mit mehreren Betriebsmodi.