Schlüsselwörter: Pipeline, Multiplizierer

Ein herausragender Vorteil von Hardwarebeschreibungssprachen ist die Parallelität der Befehlsausführung. Mehrere Anweisungen können mehrere Signaldaten parallel innerhalb desselben Taktzyklus verarbeiten.

Wenn Daten jedoch seriell eingegeben werden, zeigt die Parallelität der Befehlsausführung ihren Vorteil nicht. Darüber hinaus können in vielen Fällen einige Berechnungen nicht innerhalb von ein oder zwei Taktzyklen abgeschlossen werden. Wenn jedes seriell eingegebene Datum warten muss, bis die vorherige Berechnung abgeschlossen ist, bevor die nächste Berechnung beginnt, ist die Effizienz recht niedrig. Pipelining ist die Lösung für die geringe Effizienz serieller Datenberechnung bei mehreren Zyklen.

Pipeline

Die Grundidee des Pipelining besteht darin, einen wiederholten Prozess in mehrere Teilprozesse zu zerlegen, die jeweils von einer dedizierten Funktionseinheit implementiert werden. Mehrere Verarbeitungsprozesse sind zeitlich versetzt und durchlaufen die Funktionsstufen nacheinander, sodass jeder Teilprozess parallel zu anderen Teilprozessen ausgeführt werden kann.

Angenommen, der Prozess des Wäschewaschens in einem Waschsalon ist in 4 Phasen unterteilt: Wäsche sammeln, waschen, trocknen und in Schränke packen. Jede Phase dauert eine halbe Stunde, sodass das Waschen einer Ladung Wäsche 2 Stunden dauert.

Betrachten Sie den Worst Case: Der Waschsalon hat nur eine Waschmaschine, einen Trockner und einen Schrank. Wenn jede halbe Stunde eine Charge Kleidung angeliefert wird und Sie jedes Mal 2 Stunden warten müssen, bis die vorherige Charge fertig gewaschen ist, dann dauert das Waschen von 4 Chargen Kleidung 8 Stunden.

Das Diagramm sieht wie folgt aus:

Rüsten Sie die Ausstattung dieses Waschsalons auf, indem Sie insgesamt 4 Sätze Wäscheausrüstung einführen und das Personal auf 4 Personen erhöhen, wobei jede für eine Stufe des Wäscheprozesses verantwortlich ist. Daher kann jede Charge Kleidung von derselben Person zügig in verschiedene Waschmaschinen gegeben werden. Da die Zeitpunkte versetzt sind, kann jede Charge Kleidung von denselben Personen mit unterschiedlichen Geräten und in unterschiedlichen Zeitfenstern (einer halben Stunde) gewaschen, getrocknet und in Schränke verpackt werden. Das Diagramm sieht wie folgt aus.

Es ist zu sehen, dass das Waschen von 4 Chargen Kleidung nur 3.5 Stunden dauert, was die Effizienz deutlich verbessert.

Tatsächlich ist der erste Satz Wäscheausrüstung nach 2 Stunden mit dem Waschprozess fertig und steht still. Wenn zu diesem Zeitpunkt eine 5. Charge Kleidung eingegeben wird, kann der erste Satz Ausrüstung wieder mit der Arbeit beginnen. Analog dazu können die 4 Sätze Wäscheausrüstung, solange kontinuierlich Kleidungschargen eingegeben werden, den Reinigungsprozess für alle Kleidung kontinuierlich abschließen. Mit Ausnahme der ersten Charge, die 2 Stunden dauert, wird danach alle halbe Stunde eine Charge Kleidung gewaschen und abgeschlossen.

Je mehr Chargen Kleidung es gibt, desto deutlicher ist die eingesparte Zeit. Wenn es N Chargen Kleidung gibt, beträgt die benötigte Zeit (4+N) halbe Stunden.

Natürlich hat der aufgerüstete Wäscheprozess auch Nachteile. Die Zunahme von Ausrüstung und Personal erhöht die Investitionskosten, verringert den verbleibenden Platz im Waschsalon und lässt den Arbeitszustand beschäftigter erscheinen.

Ähnlich wie beim Waschprozess kann auch der Datenverarbeitungspfad als Produktionslinie betrachtet werden. Jede digitale Verarbeitungseinheit auf dem Pfad kann als eine Stufe betrachtet werden, die Verzögerung einführt.

Das Pipeline-Design unterteilt den Pfad systematisch in digitale Verarbeitungseinheiten (Stufen) und fügt Register zwischen den Verarbeitungseinheiten ein, um Zwischendaten vorübergehend zu speichern. Die unterteilten Einheiten können stufenweise parallel ausgeführt werden, ohne sich gegenseitig zu beeinflussen. Daher kann das Pipeline-Design letztendlich den Datendurchsatz verbessern, das heißt, die Datenverarbeitungsgeschwindigkeit erhöhen.

Der Nachteil des Pipeline-Designs besteht darin, dass jede Verarbeitungsstufe zusätzliche Register benötigt, um Zwischenberechnungszustände zu speichern, und mehrere parallel ausgeführte Befehle zwangsläufig den Stromverbrauch erhöhen.

Als Nächstes wird ein Multiplizierer entworfen und ein Vergleich zwischen der Verwendung und Nichtverwendung des Pipeline-Designs angestellt.


Allgemeines Multiplizierer-Design

Einführung

Vielleicht wird sich jemand fragen: Ist es nicht schneller und einfacher, direkt das Multiplikationszeichen*zu verwenden, um zwei Zahlen zu multiplizieren?

Wenn Sie diesen Zweifel haben, bedeutet das, dass Ihr Verständnis von Hardwarebeschreibungssprachen noch unzureichend ist. Wie bereits erwähnt, beschreibt Verilog Hardware-Schaltungen. Wenn das Multiplikationszeichen direkt verwendet wird, um den Multiplikationsvorgang durchzuführen, bildet der Compiler diesen Multiplikationsausdruck während der Kompilierung auf einen Standard-Multiplizierer ab, dessen Struktur jedoch unbekannt ist.

Zum Beispiel kann im FPGA-Design ein IP-Core direkt aufgerufen werden, um einen Hochleistungs-Multiplizierer zu erzeugen. Bei kleiner Bitbreite kann das Ergebnis innerhalb eines Zyklus ausgegeben werden; bei großer Bitbreite kann es ebenfalls auf Pipeline-Weise ausgegeben werden. Unter der Voraussetzung, dass die Anforderungen erfüllt werden können, können Sie vorsichtig verwenden*oder direkt das IP aufrufen, um die Multiplikationsoperation durchzuführen.

Aber Multiplizierer-IP hat auch viele Mängel, wie Bitbreitenbeschränkungen, unbekanntes Timing usw. Insbesondere die Verwendung des Multiplikationszeichens kann für die Unsicherheit des digitalen Designs eine große versteckte Gefahr bergen.

In vielen Fällen wird die Multiplikation mit Konstanten in Form von Verschieben und Addieren implementiert, zum Beispiel:

Beispiel

A = A<<1 ;       // A * 2 vervollständigen
A = (A<<1) + A ;   // entspricht A * 3
A = (A<<3) + (A<<2) + (A<<1) + A ; // entspricht A * 15

Ein Schieberegister und ein Addierer können die Operation der Multiplikation mit 3 abschließen. Die Multiplikation mit 15 erfordert jedoch 3 Schieberegister und 3 Addierer (natürlich kann die Multiplikation mit 15 auch durch Verschieben und Subtrahieren erfolgen).

Manchmal kann eine digitale Schaltung die Addition mehrerer Variablen nicht gleichzeitig innerhalb eines Zyklus abschließen. Daher ist in der Digitaltechnik die sicherste Additionsoperation, nur 2 Datenwerte gleichzeitig zu addieren; das schlechteste Design ist, 4 oder mehr Datenwerte gleichzeitig zu addieren.

Wenn das Design eine Operation enthält, die 4 Datenwerte gleichzeitig addiert, dann ist dieser Teil des Designs gefährlich und kann Timing-Verletzungen verursachen.

An diesem Punkt wird ein Pipeline-Multiplizierer mit konfigurierbaren Entwurfsparametern und steuerbarem Timing erforderlich.

Entwurfsprinzip

Ähnlich wie bei der Dezimalmultiplikation ist der Prozess der Multiplikation von 13 und 5 unten dargestellt:

Daraus ist ersichtlich, dass der Multiplikand entsprechend dem entsprechenden Bit des Multiplikators verschoben und akkumuliert wird, wodurch der Multiplikationsprozess abgeschlossen wird.

Unter der Annahme, dass pro Zyklus nur eine Akkumulation abgeschlossen werden kann, entspricht die minimale Anzahl an Taktzyklen für eine Multiplikation genau der Bitbreite des Multiplikators. Daher wird empfohlen, die Zahl mit der kleineren Bitbreite als Multiplikator zu verwenden, wodurch die Berechnungsdauer kürzer ist.

Multiplizierer-Entwurf

In Anbetracht dessen, dass jede Multiplikationsoperation nur ein Ergebnis ausgeben kann (nicht gepipelinetes Design), lautet der Designcode wie folgt.

Beispiel

module    mult_low
    #(Parameter N=4,
      Parameter M=4)
     (
      input                     clk,
      input                     rstn,
      input                     data_rdy ,  // Dateneingabe-Freigabe
      input [N-1:0]             mult1,      // Multiplikand
      input [M-1:0]             mult2,      // Multiplikator

      output                    res_rdy ,   // Datenausgabe-Freigabe
      output [N+M-1:0]          res         // Multiplikationsergebnis
      );

    // Zähler berechnen
    reg [31:0]           cnt ;
    // Zähler für Multiplikationszyklen
    wire [31:0]          cnt_temp = (cnt == M)? 'b0 : cnt + 1'b1 ;
    always @(posedge clk or negedge rstn) begin
        if (!rstn) begin
            cnt    <= 'b0 ;
        end
        else if (data_rdy) begin    // Zählung starten, wenn Daten aktiviert sind
            cnt    <= cnt_temp ;
        end
        else if (cnt != 0 ) begin  // verhindern, dass die Eingangsfreigabedauer zu kurz ist
            cnt    <= cnt_temp ;
        end
        else begin
            cnt    <= 'b0 ;
        end
    end

    //multiplizieren
    reg [M-1:0]          mult2_shift ;
    reg [M+N-1:0]        mult1_shift ;
    reg [M+N-1:0]        mult1_acc ;
    always @(posedge clk or negedge rstn) begin
        if (!rstn) begin
            mult2_shift    <= 'b0 ;
            mult1_shift    <= 'b0 ;
            mult1_acc      <= 'b0 ;
        end
        else if (data_rdy && cnt=='b0) begin  // Initialisierung
            mult1_shift    <= {{(N){1'b0}}, mult1} << 1 ;  
            mult2_shift    <= mult2 >> 1 ;  
            mult1_acc      <= mult2[0] ? {{(N){1'b0}}, mult1} : 'b0 ;
        end
        else if (cnt != M) begin
            mult1_shift    <= mult1_shift << 1 ;  // Multiplikand mit 2 multipliziert
            mult2_shift    <= mult2_shift >> 1 ;  // Multiplikator nach rechts verschieben, um die Beurteilung zu erleichtern
            // prüfen, ob das entsprechende Bit des Multiplikators 1 ist; falls 1, akkumulieren
            mult1_acc      <= mult2_shift[0] ? mult1_acc + mult1_shift : mult1_acc ;
        end
        else begin
            mult2_shift    <= 'b0 ;
            mult1_shift    <= 'b0 ;
            mult1_acc      <= 'b0 ;
        end
    end

    // Ergebnisse
    reg [M+N-1:0]        res_r ;
    reg                  res_rdy_r ;
    always @(posedge clk or negedge rstn) begin
        if (!rstn) begin
            res_r          <= 'b0 ;
            res_rdy_r      <= 'b0 ;
        end  
        else if (cnt == M) begin
            res_r          <= mult1_acc ;  // das Ergebnis am Ende der Multiplikationszyklen ausgeben
            res_rdy_r      <= 1'b1 ;
        end
        else begin
            res_r          <= 'b0 ;
            res_rdy_r      <= 'b0 ;
        end
    end

    assign res_rdy       = res_rdy_r;
    assign res           = res_r;

endmodule

testbench

Beispiel

`timescale 1ns/1ns

module test ;
    Parameter    N = 8 ;
    Parameter    M = 4 ;
    reg          clk, rstn;
 
   //Takt
    always begin
        clk = 0 ; #5 ;
        clk = 1 ; #5 ;
    end

   // Zurücksetzen
    initial begin
        rstn      = 1'b0 ;
        #8 ;      rstn      = 1'b1 ;
    end

    // keine Pipeline
    reg                  data_rdy_low ;
    reg [N-1:0]          mult1_low ;
    reg [M-1:0]          mult2_low ;
    wire [M+N-1:0]       res_low ;
    wire                 res_rdy_low ;

    // eine Task für periodischen Stimulus verwenden
    task mult_data_in ;  
        input [M+N-1:0]   mult1_task, mult2_task ;
        begin
            wait(!test.u_mult_low.res_rdy) ;  //nicht Ausgabezustand
            @(negedge clk ) ;
            data_rdy_low = 1'b1 ;
            mult1_low = mult1_task ;
            mult2_low = mult2_task ;
            @(negedge clk ) ;
            data_rdy_low = 1'b0 ;
            wait(test.u_mult_low.res_rdy) ; //den Ausgabezustand testen
        end
    endtask

    //Treiber
    initial begin
        #55 ;
        mult_data_in(25, 5 ) ;
        mult_data_in(16, 10 ) ;
        mult_data_in(10, 4 ) ;
        mult_data_in(15, 7) ;
        mult_data_in(215, 9) ;
    end

    mult_low  #(.N(N), .M(M))
    u_mult_low
    (
      .clk              (clk),
      .rstn             (rstn),
      .data_rdy         (data_rdy_low),
      .mult1            (mult1_low),
      .mult2            (mult2_low),
      .res_rdy          (res_rdy_low),
      .res              (res_low));

   //Simulationsende
   initial begin
      forever begin
         #100;
         if ($time >= 10000)  $finish ;
      end
   end

endmodule // test

Die Simulationsergebnisse sind wie folgt.

Wie aus der Abbildung ersichtlich ist, erhalten die beiden Eingabedaten nach einer Verzögerung von 4 Zyklen das korrekte Multiplikationsergebnis. Einschließlich der Verzögerungszeit der Zwischendaten-Eingabe dauert die Berechnung von 4 Multiplikationen etwa 20 Taktzyklen.

Design eines Pipeline-Multiplizierers

Als Nächstes werden die Zwischenzustände des Multiplikationsausführungsprozesses gespeichert, um den Pipeline-Betrieb zu ermöglichen. Der Entwurfscode lautet wie folgt.

Die Codedatei für einen einzelnen Akkumulationsberechnungsvorgang lautet wie folgt (mult_cell.v):

Beispiel

module    mult_cell
    #(Parameter N=4,
      Parameter M=4)
    (
      input                     clk,
      input                     rstn,
      input                     en,
      input [M+N-1:0]           mult1,      // Multiplikand
      input [M-1:0]             mult2,      // Multiplikator
      input [M+N-1:0]           mult1_acci, // vorheriges Akkumulationsergebnis

      output reg [M+N-1:0]      mult1_o,     // gespeicherter Wert nach Verschiebung des Multiplikanden
      output reg [M-1:0]        mult2_shift, // gespeicherter Wert nach Verschiebung des Multiplikators
      output reg [N+M-1:0]      mult1_acco,  // aktuelles Akkumulationsergebnis
      output reg                rdy );

    always @(posedge clk or negedge rstn) begin
        if (!rstn) begin
            rdy            <= 'b0 ;
            mult1_o        <= 'b0 ;
            mult1_acco     <= 'b0 ;
            mult2_shift    <= 'b0 ;
        end
        else if (en) begin
            rdy            <= 1'b1 ;
            mult2_shift    <= mult2 >> 1 ;
            mult1_o        <= mult1 << 1 ;
            if (mult2[0]) begin
                // akkumulieren, wenn das entsprechende Bit des Multiplikators 1 ist
                mult1_acco  <= mult1_acci + mult1 ;  
            end
            else begin
                mult1_acco  <= mult1_acci ; // beibehalten, wenn das entsprechende Bit des Multiplikators 1 ist
            end
        end
        else begin
            rdy            <= 'b0 ;
            mult1_o        <= 'b0 ;
            mult1_acco     <= 'b0 ;
            mult2_shift    <= 'b0 ;
        end
    end

endmodule

Top-Level-Instanziierung

Mehrere Modulinstanziierungen führen mehrere Akkumulationen aus. Die Codedatei ist wie folgt (mult_man.v):

Beispiel

module    mult_man
    #(Parameter N=4,
      Parameter M=4)
    (
      input                     clk,
      input                     rstn,
      input                     data_rdy ,
      input [N-1:0]             mult1,
      input [M-1:0]             mult2,

      output                    res_rdy ,
      output [N+M-1:0]          res );

    wire [N+M-1:0]       mult1_t [M-1:0] ;
    wire [M-1:0]         mult2_t [M-1:0] ;
    wire [N+M-1:0]       mult1_acc_t [M-1:0] ;
    wire [M-1:0]         rdy_t ;

    // Die erste Instanziierung entspricht einer Initialisierung; die generate-Anweisung kann nicht verwendet werden
    mult_cell      #(.N(N), .M(M))
    u_mult_step0
    (
      .clk              (clk),
      .rstn             (rstn),
      .en               (data_rdy),
      .mult1            ({{(M){1'b0}}, mult1}),
      .mult2            (mult2),
      .mult1_acci       ({(N+M){1'b0}}),
      //Ausgabe
      .mult1_acco       (mult1_acc_t[0]),
      .mult2_shift      (mult2_t[0]),
      .mult1_o          (mult1_t[0]),
      .rdy              (rdy_t[0]) );

    // Mehrere Modulinstanziierungen verwenden die generate-Anweisung
    genvar               i ;
    generate
        for(i=1; i<=M-1; i=i+1) begin: mult_stepx
            mult_cell      #(.N(N), .M(M))
            u_mult_step
            (
              .clk              (clk),
              .rstn             (rstn),
              .en               (rdy_t[i-1]),
              .mult1            (mult1_t[i-1]),
              .mult2            (mult2_t[i-1]),
              // Das vorherige Akkumulationsergebnis wird als Eingabe für die nächste Akkumulation verwendet
              .mult1_acci       (mult1_acc_t[i-1]),
              //Ausgabe
              .mult1_acco       (mult1_acc_t[i]),                                      
              .mult1_o          (mult1_t[i]),  // Zustandsübertragung der Multiplikandenverschiebung
              .mult2_shift      (mult2_t[i]),  // Zustandsübertragung der Multiplikatorverschiebung
              .rdy              (rdy_t[i]) );
        end
    endgenerate

    assign res_rdy       = rdy_t[M-1];
    assign res           = mult1_acc_t[M-1];

endmodule

testbench

Fügen Sie die folgende Simulationsbeschreibung zum Testbench des nicht gepipelineten Multiplizierer-Designbeispiels hinzu, um die Simulationsergebnisse der gepipelineten Multiplikationsoperation zu erhalten.

Die 2 Datenkanäle werden kontinuierlich und seriell eingegeben, und ein selbstprüfendes Modul ist enthalten, um die Korrektheit der Multiplikationsergebnisse automatisch zu ermitteln.

Beispiel

    reg          data_rdy ;
    reg [N-1:0]  mult1 ;
    reg [M-1:0]  mult2 ;
    wire                 res_rdy ;
    wire [N+M-1:0]       res ;

    //Treiber
    initial begin
        #55 ;
        @(negedge clk ) ;
        data_rdy  = 1'b1 ;
        mult1  = 25;      mult2      = 5;
        #10 ;      mult1  = 16;      mult2      = 10;
        #10 ;      mult1  = 10;      mult2      = 4;
        #10 ;      mult1  = 15;      mult2      = 7;
        mult2      = 7;   repeat(32)    #10   mult1   = mult1 + 1 ;
        mult2      = 1;   repeat(32)    #10   mult1   = mult1 + 1 ;
        mult2      = 15;  repeat(32)    #10   mult1   = mult1 + 1 ;
        mult2      = 3;   repeat(32)    #10   mult1   = mult1 + 1 ;
        mult2      = 11;  repeat(32)    #10   mult1   = mult1 + 1 ;
        mult2      = 4;   repeat(32)    #10   mult1   = mult1 + 1 ;
        mult2      = 9;   repeat(32)    #10   mult1   = mult1 + 1 ;
    end

    // Eingabedaten für eine bequeme spätere Überprüfung verschieben
    reg  [N-1:0]   mult1_ref [M-1:0];
    reg  [M-1:0]   mult2_ref [M-1:0];
    always @(posedge clk) begin
        mult1_ref[0] <= mult1 ;
        mult2_ref[0] <= mult2 ;
    end

    genvar         i ;
    generate
        for(i=1; i<=M-1; i=i+1) begin
            always @(posedge clk) begin
            mult1_ref[i] <= mult1_ref[i-1];
            mult2_ref[i] <= mult2_ref[i-1];
            end
        end
    endgenerate
   
    // Selbstprüfung
    reg  error_flag ;
    always @(posedge clk) begin
        # 1 ;
        if (mult1_ref[M-1] * mult2_ref[M-1] != res && res_rdy) begin
            error_flag <= 1'b1 ;
        end
        else begin
            error_flag <= 1'b0 ;
        end
    end

    //Modulinstanziierung
    mult_man  #(.N(N), .M(M))
     u_mult
     (
      .clk              (clk),
      .rstn             (rstn),
      .data_rdy         (data_rdy),
      .mult1            (mult1),
      .mult2            (mult2),
      .res_rdy          (res_rdy),
      .res              (res));

Simulationsergebnisse

Die Simulationsergebnisse der ersten paar Dutzend Taktzyklen sind wie folgt.

Wie aus der Abbildung ersichtlich ist, bleibt das Prüfsignal des Simulationsergebnisses error_flag auf 0, was anzeigt, dass das Multiplizierer-Design korrekt ist.

Daten werden unter Taktsteuerung kontinuierlich seriell eingegeben. Nach einer Verzögerung von 4 Taktzyklen werden auch die Multiplikationsausgabeergebnisse kontinuierlich in jedem Taktzyklus ohne zusätzliche Verzögerung ausgegeben, wodurch ein Pipeline-Betrieb realisiert wird.

Im Vergleich zu allgemeinen Multiplizierern, die keine Pipelines verwenden, wurde die Multiplikationseffizienz stark verbessert.

Die vom Pipeline-Multiplizierer verwendeten Registerressourcen sind jedoch auch etwa 4-mal so groß wie die des vorherigen nicht gepipelineten.

Daher muss bei einem digitalen Entwurf, ob ein Pipeline-Design verwendet wird, sowohl hinsichtlich der Ressourcen als auch der Effizienz abgewogen werden.

Quellcode-Download

Herunterladen