Schlüsselwörter: Wettlauf, Hazard, Programmierstandards

Ursachen

In digitalen Schaltungen haben sowohl die Signalübertragung als auch Zustandsübergänge gewisse Verzögerungen.

  • In kombinatorischen Logikschaltungen, wenn Änderungen von Eingangssignalen über verschiedene Pfade zu demselben Gatterebenen-Schaltungspunkt propagieren, geschieht dies zeitlich früher oder später. Diese durch die Reihenfolge verursachte Zeitdifferenz wird als Wettlauf bezeichnet.
  • Aufgrund des Vorhandenseins von Wettläufen benötigt das Ausgangssignal einige Zeit, um den erwarteten Zustand zu erreichen. Während der Übergangsperiode können kurzzeitige fehlerhafte Ausgaben wie Spitzenimpulse auftreten. Dieses Phänomen wird als Hazard bezeichnet.
  • Ein Wettlauf führt nicht zwangsläufig zu einem Hazard, aber ein Hazard beinhaltet immer einen Wettlauf.
  • For example, for the given logicF = A & A'die Schaltung in der unteren linken Abbildung dargestellt.

    Due to the presence of the inverter circuit, the signalA'-Ausbreitungszeit zum Eingang des AND-Gatters relativ zum SignalAverzögert, was dazu führen kann, dass das endgültige AusgangsergebnisFdes AND-Gatters einen Glitch-Impuls aufweist. Wie in der unteren rechten Abbildung gezeigt.

    Tatsächlich können in realen Hardwareschaltungen, solange die Verzögerungen an den Eingängen einer Gatterschaltung unterschiedlich sind, Wettläufe und Hazards auftreten.

    Zum Beispiel können bei einem einfachen AND-Gatter, wenn die Eingangssignalquellen nicht unbedingt durch denselben Signalübergang erzeugt werden, aufgrund des Hardwareprozesses und anderer Verzögerungsschaltungen ebenfalls Wettläufe und Hazards auftreten, wie in der folgenden Abbildung gezeigt.

    Beurteilungsmethoden

    Algebraische Methode

    In einem logischen Ausdruck hält man eine Variable fest und ersetzt alle übrigen verbleibenden Variablen durch 0 oder 1. Wenn der endgültige logische Ausdruck vereinfacht werden kann zu

    Y = A + A'

    oder

    Y = A · A'

    in der Form, dann kann festgestellt werden, dass diese Logik Wettlauf und Hazard aufweist.

    Zum Beispiel kann der logische AusdruckY = AB + A'Cunter der Bedingung vonB=C=1zuY = A + A'vereinfacht werden. Offensichtlich wirdAdie Zustandsänderung zwangsläufig dazu führen, dass die Schaltung Wettlauf und Hazard aufweist.

    Karnaugh-Diagramm-Methode

    Wenn zwei tangierende Karnaugh-Schleifen vorhanden sind und der Berührungspunkt nicht von anderen Karnaugh-Schleifen umschlossen wird, können Wettlauf und Hazard auftreten.

    Zum Beispiel weist die untere linke Abbildung Wettlauf und Hazard auf, während die untere rechte Abbildung keine aufweist.

    Tatsächlich ist ein Karnaugh-Diagramm im Wesentlichen eine Analyse des logischen Ausdrucks, aber es ermöglicht eine intuitive Beurteilung.

    Zum Beispiel kann der logische Ausdruck in der oberen linken Abbildung zuY = A'B' + AC, wennB=0undC=1dieser logische Ausdruck auch alsY = A' + Aausgedrückt werden kann. Daher existieren Wettlauf und Hazard definitiv.

    Der logische Ausdruck in der oberen rechten Abbildung kann zuY = A'B' + AB, offensichtlichBob er gleich1oder0ist, wird dieser Ausdruck niemals zuY = A' + A. Daher weist diese Logik keinen Wettlauf und Hazard auf.

    Es ist zu beachten, dass das Karnaugh-Diagramm eine umlaufende Nachbarschaft aufweist. Wie in der folgenden Abbildung dargestellt, sind, obwohl es scheint, dass die beiden Karnaugh-Schleifen nicht tangierend sind, m6 und m4 tatsächlich ebenfalls benachbart, sodass die durch das folgende Karnaugh-Diagramm dargestellte digitale Logik ebenfalls Wettlauf und Hazard erzeugt.

    Für andere komplexere Fälle sind möglicherweise Methoden wie "computergestützte Analyse + Experiment" erforderlich.

    Beseitigungsmethoden

    Für digitale Schaltungen gibt es hauptsächlich 4 gängige Methoden, um Wettlauf und Hazard zu vermeiden.

    1) Fügen Sie einen Filterkondensator hinzu, um schmale Impulse auszufiltern

    Bei dieser Methode muss am Ausgang ein kleiner Kondensator parallel geschaltet werden, um die Amplitude des Spike-Impulses unter die Schwelle der Gatterschaltung zu dämpfen.

    Obwohl diese Methode einfach ist, erhöht sie die Übergangszeit der Ausgangsspannung und kann die Wellenform leicht beeinträchtigen.

    2) Ändern Sie die Logik, um redundante Terme hinzuzufügen

    Fügen Sie mithilfe des Karnaugh-Diagramms eine Karnaugh-Schleife zwischen den beiden tangierenden Kreisen hinzu und beziehen Sie sie in den logischen Ausdruck ein.

    Wie in der folgenden Abbildung gezeigt, fügen Sie für die digitale LogikY = A'B' + ACden redundanten TermB'Chinzu, die Schaltungslogik kann dann alsY = A'B' + AC + B'Causgedrückt werden. Zu diesem Zeitpunkt weist die Schaltung keinen Wettlauf und Hazard mehr auf.

    3) Verwenden Sie eine taktsynchrone Schaltung und nutzen Sie Flipflops für die Taktzyklusverzögerung

    In synchronen Schaltungen treten Signaländerungen an der Taktflanke auf. Für den D-Eingang eines Flipflops gilt: Solange ein Glitch nicht an der steigenden Taktflanke auftritt bzw. die Daten-Setup- und Hold-Zeiten nicht erfüllt, schadet er dem System nicht. Daher kann der D-Eingang eines D-Flipflops als unempfindlich gegenüber Glitches betrachtet werden. Mithilfe dieser Eigenschaft kann das Verzögern eines Signals der kombinatorischen Logik um Taktzyklen unter Taktflankenansteuerung Wettlauf und Hazard beseitigen.

    Eine Verzögerung um einen Taktzyklus verringert das Auftreten von Wettlauf und Hazard mit einer gewissen Wahrscheinlichkeit. Experimente zeigen, dass die sicherste Dauer der Zyklusverzögerung 3 Taktzyklen beträgt, wodurch das Auftreten von Wettlauf und Hazard wirksam reduziert werden kann.

    Natürlich müssen Sie letztendlich je nach Ihren Entwurfsanforderungen eine angemessene Taktzyklusverzögerung auf die Signale anwenden.

    Um zu veranschaulichen, dass das Anwenden einer Zyklusverzögerung auf Signale Wettlauf und Hazard beseitigen kann, erstellen wir das folgende Codemodell.

    Beispiel

    module competition_hazard
        (
          input             clk ,
          input             rstn ,
          input             en ,
          input             din_rvs ,
          output reg        flag
        );

        wire    condition = din_rvs & en ;  //Kombinationslogik
        always @(posedge clk or negedge !rstn) begin
            if (!rstn) begin
                flag   <= 1'b0 ;
            end
            else begin
                flag   <= condition ;
            end
        end

    endmodule

    Die Testbench wird wie folgt beschrieben:

    Beispiel

    `timescale 1ns/1ns

    module test ;
        reg          clk, rstn ;
        reg          en ;
        reg          din_rvs ;
        wire         flag_safe, flag_dgs ;

        //Takt- und rstn-Erzeugung
        initial begin
            rstn              = 1'b0 ;
            clk               = 1'b0 ;
            #5 rstn           = 1'b1 ;
            forever begin
                #5 clk = ~clk ;
            end
        end

        initial begin
            en        = 1'b0 ;
            din_rvs   = 1'b1 ;
            #19 ;      en        = 1'b1 ;
            #1 ;       din_rvs   = 1'b0 ;
        end

        competition_hazard u_dgs
         (
          .clk              (clk           ),
          .rstn             (rstn          ),
          .en               (en            ),
          .din_rvs          (din_rvs       ),
          .flag             (flag_dgs      ));

        initial begin
            forever begin
                #100;
                if ($time >= 1000)  $finish ;
            end
        end

    endmodule // test

    Die Simulationsergebnisse sind wie folgt:

    Wie aus der Abbildung ersichtlich ist, tritt ein Spike-Impuls am Signal condition auf. Dies liegt daran, dass die Signale din_rvs und en beide asynchron zum internen Takt des Moduls sind, sodass ihre Verzögerungen beim Erreichen der internen Gatterschaltung unterschiedlich sind, was Wettlauf und Hazard verursachen kann.

    Obwohl das endgültige Simulationsergebnis flag immer 0 ist, was das gewünschte Ergebnis zu sein scheint, ist dieser Spike-Impuls in einer tatsächlichen Schaltung zeitlich sehr nahe an der Taktflanke, sodass er vom Takt erfasst werden und ein falsches Ergebnis erzeugen kann.

    Als Nächstes verbessern wir das Modell durch Hinzufügen einer Taktzyklus-Verzögerungslogik wie folgt:

    Beispiel

    module clap_delay
        (
          input             clk ,
          input             rstn ,
          input             en ,
          input             din_rvs ,
          output reg        flag
        );

        reg                  din_rvs_r ;
        reg                  en_r ;
        always @(posedge clk or !rstn) begin
            if (!rstn) begin
                din_rvs_r      <= 1'b0 ;
                en_r           <= 1'b0 ;
            end
            else begin
                din_rvs_r      <= din_rvs ;
                en_r           <= en ;
            end
        end

        wire                 condition = din_rvs_r & en_r ;
        always @(posedge clk or negedge !rstn) begin
            if (!rstn) begin
                flag   <= 1'b0 ;
            end
            else begin

                flag   <= condition ;
            end
        end // always @ (posedge clk or negedge !rstn)

    endmodule

    Instanziieren Sie dieses Modul in die obige Testbench, und die folgenden Simulationsergebnisse werden erzielt.

    Wie aus der Abbildung ersichtlich ist, wird das Signal condition nicht mehr durch Spike-Impulse gestört, und flag ist in den Simulationsergebnissen wie erwartet 0.

    Tatsächlich ist, wenn das Eingangssignal sehr nahe an der Taktflanke liegt, die Taktabtastung des Eingangssignals weiterhin unsicher, aber Spike-Impulse treten nicht auf. Das Eingangssignal um 2 weitere Taktzyklen zu verzögern, ist ein besserer Ansatz und bietet eine bessere Unterdrückung von Wettlauf und Hazard.

    4) Verwenden Sie einen Gray-Code-Zähler

    Bei einem inkrementierenden Mehrbit-Zähler weist der Zählwert manchmal mehrere Bitübergänge auf.

    Wenn beispielsweise die Zählervariable counter von 5 auf 6 zählt, gehen die entsprechenden Binärzahlen von 4'b101 nach 4'b110 über. Aufgrund der Verzögerung jedes Bits kann der Übergangsprozess von counter wie folgt sein:4'b101 -> 4'b111 -> 4'b110. Wenn die folgende Logikbeschreibung vorhanden ist, kann das Signal cout einen kurzen Spike-Impuls aufweisen, was offensichtlich dem Design widerspricht.

    cout = counter[3:0] == 4'd7 ; 

    Der Gray-Code-Zähler hingegen hat nur ein Datenbit, das sich zwischen benachbarten Zählwerten ändert, sodass er Wettlauf und Hazard effektiv vermeiden kann.

    Glücklicherweise sind Zähler in Verilog-Designs meist synchrone Designs. Selbst wenn die Möglichkeit besteht, dass beim Zählen mehrere Bits gleichzeitig umschlagen, können unter der Wirkung taktgesteuerter Flip-Flops Wettlauf und Hazard zu 100% beseitigt werden, solange die Timing-Anforderungen zwischen den Signalen erfüllt sind.

    Zusammenfassung

    Im Allgemeinen werden das Hinzufügen von Filterkondensatoren und logischer Redundanz zur Beseitigung von Wettläufen und Hazards im Verilog-Design nicht berücksichtigt.

    Die Verwendung von Gray-Code-Zählern zum Zählen wird meist in Hochgeschwindigkeits-Taktszenarien eingesetzt, um die Signalumschaltrate zu reduzieren und dadurch die Leistungsaufnahme zu verringern.

    Die Verwendung von Flip-Flops, um asynchrone Signale in einer taktsynchronisierten Schaltung um Taktzyklen zu verzögern, ist eine häufig verwendete Methode im Verilog-Design.

    Darüber hinaus gibt es beim Verilog-Codieren einige Punkte zu beachten, um Wettläufe und Hazards zu beseitigen; Einzelheiten finden Sie im nächsten Unterabschnitt.


    Verilog-Codierungsstandards

    Wenn Sie beim Programmieren die folgenden Punkte stärker beachten, können auch die meisten Wettlauf- und Hazard-Probleme vermieden werden.

    • 1) Verwenden Sie beim Modellieren sequenzieller Schaltungen nicht blockierende Zuweisungen.
    • 2) Verwenden Sie beim Modellieren kombinatorischer Logik blockierende Zuweisungen.
    • 3) Verwenden Sie beim Modellieren sequenzieller und kombinatorischer Logik im selben always-Block nicht blockierende Zuweisungen.
    • 4) Verwenden Sie nicht sowohl blockierende als auch nicht blockierende Zuweisungen im selben always-Block.
    • 5) Weisen Sie dieselbe Variable nicht in mehreren always-Blöcken zu.
    • 6) Vermeiden Sie die Erzeugung von Latches.

    Nachfolgend analysieren wir die oben genannten Vorsichtsmaßnahmen einzeln.

    1) Verwenden Sie bei der Modellierung sequenzieller Schaltungen nicht blockierende Zuweisungen

    Früher wurde bei der Diskussion der nicht blockierenden Zuweisung festgestellt, dass in sequenziellen Schaltungen nicht blockierende Zuweisungen Wettlaufsituationen beseitigen können.

    Zum Beispiel können, wie im folgenden Code beschrieben, Wettlaufsituationen auftreten, weil die Reihenfolge der blockierenden Zuweisungen an a und b nicht bestimmt werden kann.

    always @(posedge clk) begin
        a = b ;
        b = a ;
    end

    Wenn nicht blockierende Zuweisungen verwendet werden, werden die Zuweisungsoperationen gleichzeitig ausgeführt, sodass keine Wettlaufsituationen eingeführt werden, wie im folgenden Code beschrieben.

    always @(posedge clk) begin
        a <= b ;
        b <= a ;
    end

    2) Verwenden Sie bei der Modellierung kombinatorischer Logik blockierende Zuweisungen

    Wenn wir beispielsweise die kombinatorischen Logikfunktionen C = A&B, F = C&D implementieren wollen, lauten die nicht blockierenden Zuweisungsanweisungen wie folgt.

    Beide Zuweisungsanweisungen weisen gleichzeitig zu. In F <= C & D wird der alte Wert des Signals C verwendet, daher ist die Logik zu diesem Zeitpunkt falsch; der Logikwert von F ist nicht gleich A&B&D.

    Darüber hinaus muss Signal C Speicherfähigkeit besitzen, aber es wird nicht vom Takt getrieben, daher kann C zu einem Latch synthetisiert werden, was Wettlaufsituationen verursacht.

    always @(*) begin
        C <= A & B ;
        F <= C & D ;
    end

    Ändern Sie den Code wie folgt. Die Operation F = C & D muss nach C = A & B erfolgen; zu diesem Zeitpunkt ist der Logikwert von F gleich A&B&D, was dem Design entspricht.

    always @(*) begin
        C = A & B ;
        F = C & D ;
    end

    3) Verwenden Sie bei der Modellierung sequenzieller und kombinatorischer Logik im selben always-Block nicht blockierende Zuweisungen

    Obwohl sequenzielle Schaltungen kombinatorische Logik umfassen können, können weiterhin ähnliche Probleme wie in Regel 1 erwähnt auftreten, wenn nicht blockierende Zuweisungen für Zuweisungsoperationen verwendet werden.

    Um beispielsweise die Logikfunktion eines AND-Gatters unter Taktsteuerung zu implementieren, siehe den Code unten.

    Beispiel

    always @(posedge clk or negedge rst_n)
        if (!rst_n) begin
            q <= 1'b0;
        end
        else begin
            q <= a & b;  //Selbst wenn kombinatorische Logik vorhanden ist, schreiben Sie sie nicht als: q = a & b
         end
    end

    4) Verwenden Sie nicht sowohl blockierende als auch nicht blockierende Zuweisungen im selben always-Block

    Wenn die kombinatorische Logik in einem always-Block sowohl blockierende als auch nicht blockierende Zuweisungen enthält, können unerwartete Ergebnisse auftreten, wie im folgenden Code beschrieben.

    An diesem Punkt wird, nachdem Signal C die blockierende Zuweisung abgeschlossen hat, Signal F mit einer nicht blockierenden Zuweisung zugewiesen; das Simulationsergebnis kann korrekt sein.

    Wenn Signal F jedoch andere Lasten hat, kann der aktuelle Wert von F nicht sofort weitergegeben werden; der Gültigkeitszeitpunkt der Daten liegt weiterhin an der nächsten Triggerflanke. Dann muss F Speicherfähigkeit besitzen und kann zu einem Latch synthetisiert werden, was Race Conditions verursachen kann.

    always @(*) begin
        C = A & B ;
        F <= C & D ;
    end

    Wie im folgenden Code beschrieben, wird aus Simulationssicht Signal C mit einer nicht blockierenden Zuweisung zugewiesen und wird erst an der nächsten Triggerflanke gültig. Obwohl F = C & D eine blockierende Zuweisung ist, ist Signal C keine blockierende Zuweisung, daher verwendet die Logik von F weiterhin den alten Wert von C.

    always @(*) begin
        C <= A & B ;
        F = C & D ;
    end

    Analysieren wir nun, was passieren würde, wenn eine sequenzielle Schaltung sowohl blockierende als auch nicht blockierende Zuweisungen enthält, wie im folgenden Code gezeigt.

    Wenn der Reset synchron zum Takt ist, dann wird Signal q, das aufgrund des Resets 0 ist, erst im nächsten Taktzyklus gültig.

    Wenn q aufgrund der Signale a oder b 0 wird, ist es im aktuellen Taktzyklus gültig.

    Wenn q andere Lasten hat, ist das Timing von q besonders chaotisch, was offensichtlich nicht den Designanforderungen entspricht.

    Beispiel

    always @(posedge clk or negedge rst_n)
        if (!rst_n) begin  //Angenommen, Reset ist synchron mit dem Takt
            q <= 1'b0;
        end
        else begin
            q = a & b;  
        end
    end

    Es sollte beachtet werden, dass viele Compiler diesen Schreibstil unterstützen, und die obige Analyse basiert auf Simulation. In der Praxis, wenn blockierende und nicht blockierende Zuweisungen gemischt werden, ist das Timing der synthetisierten Schaltung gestört, was der Analyse und dem Debugging nicht zuträglich ist.

    5) Weisen Sie dieselbe Variable nicht in mehreren always-Blöcken zu

    Anders als in der Sprache C erlaubt Verilog nicht, dieselbe Variable in mehreren always-Blöcken zuzuweisen. Zu diesem Zeitpunkt hat das Signal mehrere Treiber, was verboten ist. Natürlich dürfen auch assign-Anweisungen nicht dieselbe Variable mehrmals für eine Verbindung zuweisen. Aus Signalsicht wird bei mehreren Treibern dieselbe Signalvariable in einem sehr kurzen Zeitraum mehrmals mit unterschiedlichen Werten belegt, was zu Wettlaufsituationen führen kann.

    Aus syntaktischer Sicht melden viele Compiler auch einen Fehler, wenn sie mehrere Treiber erkennen.

    6) Vermeiden Sie die Erzeugung von Latches

    Eine detaillierte Analyse finden Sie im nächsten Kapitel:《Latch vermeiden》。

    Quellcode-Download

    Herunterladen