Różnica między Behavioral, RTL i Gate Level

Question

Próbuję w pełni zrozumieć różnice między poziomami abstrakcji Verilog, dostaję to, co opis każdego poziomu mówi, ale wciąż nie mogę go dostać w grze.

w tym przypadku, będę wklejać jakieś kody Verilog i co myślę o nich:

1. Poniższy kod jest w Behavioral Level.

   always @ (a or b or sel) 
       begin 
       y = 0; 
       if (sel == 0) begin 
        y = a; 
       end else begin 
       y = b; 
       end 
   end 
   

2. To (tylko przykład) jest Brama Level

   module test(clk, ready, next, Q); 
       input clk, enable, next; 
       output Q; 
   
       \**SEQGEN** reg_1 (.clear(1'b0), .next_state(next), .clocked_on(clk), .Q(Q), .synch_enable(enable)); 
   
   endmodule 
   

3. ja nie wiem, czy ten kod jest w RTL lub bramy Level (I oczekują, że zawsze kluczowe aby ten RTL i nie Brama Level)

   module dff_from_nand(); 
       wire Q,Q_BAR; 
       reg D,CLK; 
   
       nand U1 (X,D,CLK) ; 
       nand U2 (Y,X,CLK) ; 
       nand U3 (Q,Q_BAR,X); 
       nand U4 (Q_BAR,Q,Y); 
   
       // Testbench of above code 
       initial begin 
       $monitor("CLK = %b D = %b Q = %b Q_BAR = %b",CLK, D, Q, Q_BAR); 
       CLK = 0; 
       D = 0; 
       #3 D = 1; 
       #3 D = 0; 
       #3 $finish; 
       end 
   
       always #2 CLK = ~CLK; 
   
   endmodule 
   

już wiem, że initial begin i end nie są syntezowalne i używane tylko do testowania. Teraz mam 2 pytania:

1. Trzeci (i drugi) kod to RTL lub Gate-Leve? Jaki byłby dobry przykład kodu RTL? Znalazłem to RTL Code Example, ale czy to naprawdę RTL? Dla mnie wygląda na poziom behawioralny.

2. Co oznacza netlista Verilog? Czy jest taki sam jak poziom bramki lub ma definicję podstawy kontekstu?

Jestem zdezorientowany, ponieważ w niektórych witrynach nie wiem, czy oni mówią „to jest kod Verilog, która jest za pomocą bramek logicznych” lub „to jest kod Verilog w bramie poziomie”

będę bardzo szczęśliwy, jeśli ktoś, kto chce wyjaśnić więcej szczegółów na ten temat :)

Answer 1

RTL: rejestracja-Transfer poziomu, to funkcjonalność abstrakcji sprzętu pisemnej z always bloków i assign sprawozdania, które są synthesizable (można przełożyć na poziomie bramy). Pure RTL nie tworzy instancji submodułów. RTL może zawierać podmoduły do ​​obsługi syntezatora. Strukturalny RTL (jeszcze nazywany RTL) to moduł zawierający inne moduły RTL. Przykład: FSM (Finite-stanowy do kawy)

always @* begin 
    next_state = state; 
    if (count>0) next_count = count - 1; 
    case (state) 
    IDLE : 
    if(do_start) begin 
     next_state = START; 
     next_count = 2; 
    end 
    START : 
    if (do_wait) begin 
     next_count = count; 
    end 
    else if (count==0) begin 
     next_state = RUN; 
     next_count = count_from_input; 
    end 
    RUN : 
    if (do_stop) begin 
     next_state = IDLE; 
    end 
    if (do_wait) begin 
     next_count = count; 
    end 
    else if (count==0) begin 
     next_state = IDLE; 
    end 
    endcase 
end 
always @(posedge clk, negedge rst_n) begin 
    if (!rst_n) begin 
    count <= 0; 
    state <= IDLE; 
    end 
    else begin 
    count <= next_count; 
    state <= next_state; 
    end 
end 

behawioralne: naśladuje pożądaną funkcjonalność sprzętu, ale niekoniecznie syntezowalnych. Nie ma ścisłych reguł, o ile kod generuje pożądane zachowanie. Wytyczną jest, aby była prosta i czytelna. Behawioralne są często używane do reprezentowania bloku analogowego, kodu miejsca (RTL/bramki nie są gotowe) i kodu testbench. Przykład: generator zegara, komórki opóźniające.

always begin 
    if (!clk_en && clk==1'b1) begin 
    wait (clk_en); 
    end 
    #5 clk = ~clk; 
end 

Kluczową różnicą między RTL i Behavioral jest możliwość syntezy. Jest to zachowanie, jeśli widzisz # Opóźnienie, wait, Oświadczenia,/, oświadczenia lub odniesienia hierarchiczne. Technicznie istnieją pewne rzadkie usprawiedliwione wyjątki, ale to jest poza zakresem, jeśli to pytanie.

Gate-Level (znany również jako Structural): Logika opisana tylko przez bramki i moduły. Nie ma bloków always lub instrukcji assign. To jest przedstawiciel prawdziwych bramek w sprzęcie.

Verilog Netlist to kolekcja modułów Verilog używanych w projekcie. Może to być jeden lub wiele plików. Może to być mieszanka RTL, Behavioural i Structural. Zazwyczaj jest to głównie konstrukcja, zwłaszcza w przypadku dużych projektów.

Answer 2

1. poziomie zachowań.
2. poziom RTL (nie muszą być brama poziom, ale poziom prymitywne.
3. mieszany działa moduł/Testbench, wszystko zamknięte w jednym module. Nie jest to najlepsze podejście do projektowania z Verilog, ale byłoby OK dla przykładu nauczania W rzeczywistości ten przykład jest w rzeczywistości dwoma modułami:

Testbench, który można uznać za behawioralny, nawet jeśli używa kodowania RTL do utworzenia instancji modułu, który ma być testowany do regs i przewody, które napędza testbench:

module testbench_dff; 
    wire Q,Q_BAR; 
    reg D,CLK; 

    // Instantiate the unit under test 
    dff_from_nand uut (.CLK(CLK), .D(D), .Q(Q), .Q_BAR(Q_BAR)); 

    // Testbench 
    initial begin 
    $monitor("CLK = %b D = %b Q = %b Q_BAR = %b",CLK, D, Q, Q_BAR); 
    CLK = 0; 
    D = 0; 
    #3 D = 1; 
    #3 D = 0; 
    #3 $finish; 
    end 

    always #2 CLK = ~CLK; 

endmodule 

Jednostka badanego (testowany egzemplarz) są testowane, który to moduł tak (co jest oczywiście poziom RTL poziom -gate moduł actually-):

module dff_from_nand (
    input wire CLK, 
    input wire D, 
    output wire Q, 
    output wire Q_BAR 
); 

    wire X,Y; 
    nand U1 (X,D,CLK) ; 
    nand U2 (Y,X,CLK) ; 
    nand U3 (Q,Q_BAR,X); 
    nand U4 (Q_BAR,Q,Y); 
endmodule 

To moja zrozumienie, że moduł poziomie RTL jest moduł, w którym podano równania logiczne. Moduł behawioralny ma procesy (w Verilog używające bloków always, chociaż równania logiczne mogą być używane wewnątrz tych bloków). Każdy nietrywialny projekt Verilog będzie miał oba.