Differenza tra Behavioral, RTL e gate Livello

Question

Sto cercando di comprendere appieno le differenze tra i livelli di astrazione di Verilog, ottengo quello che dice la descrizione di ogni livello, ma non riesco ancora a ottenerlo sul gioco.

Per questo caso, io incollare alcuni codici Verilog e quello che penso su di loro:

1. Il seguente codice è in Behavioral Livello.

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

2. Questa (solo un esempio) si trova in Porta Livello

   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. Non so se questo codice è in RTL o Porta di livello (mi aspetto che la parola chiave da sempre rendono questo RTL e non Porta Livello)

   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 
   

so già che initial begin e end non sono sintetizzabili e vengono utilizzati solo per il test. Ora ho 2 domande

1. Terzo (e secondo) il codice è RTL o gate-Leve? Quale sarebbe un buon esempio di codice RTL? Ho trovato questo RTL Code Example ma è davvero RTL? Per me sembra livello comportamentale.

2. Cosa significa Verilog netlist? È uguale al livello di gate o ha una definizione di base di contesto?

Sono confuso, perché in alcuni siti web non so se stanno dicendo 'questo è un codice Verilog che utilizza porte logiche' o 'questo è un codice Verilog in cancello di livello'

sarò molto felice se qualcuno che vuole spiegare maggiori informazioni su questo argomento :)

Answer 1

RTL: Register-Transfer-livello, una funzionalità di astrazione hardware scritto con always blocchi e assign dichiarazioni che sono sintetizzabili (può essere tradotto in livello di gate). Pure RTL non istanzia i sottomoduli. RTL potrebbe contenere sotto-moduli per guidare il sintetizzatore. RTL strutturale (ofter ancora chiamato RTL) è un modulo che contiene altri moduli RTL. Esempio: FSM (Finite-State-Machine)

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 

Behavioral: imita la funzionalità desiderata del hardware, ma non necessariamente sintetizzabili. Non ci sono regole rigide finché il codice genera il comportamento desiderato. La linea guida è di mantenerla semplice e leggibile. I comportamenti sono spesso usati per rappresentare blocco analogico, codice segnaposto (RTL/gates non pronto) e codice di testbench. Esempio: generatore di clock, celle di ritardo.

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

La differenza chiave tra RTL e Behavioral è la capacità di sintetizzare. È comportamentale se si visualizza il ritardo #, le dichiarazioni wait, i cicli while, le informazioni force/release o il riferimento gerarchico. Tecnicamente ci sono alcune rare eccezioni scusabili, ma questa è fuori ambito se questa domanda.

Gate-Level (alias Strutturale): logica descritta solo da porte e moduli. N. always blocchi o assign dichiarazioni. Questo è un rappresentante delle porte reali nell'hardware.

Verilog Netlist è una raccolta di moduli Verilog utilizzati nel design. Può essere uno o più file. Può essere un mix di RTL, comportamentale e strutturale. Di solito è per lo più strutturale, soprattutto per i disegni di grandi dimensioni.

Answer 2

1. livello comportamentale.
2. RTL livello (non deve essere livello di gate, ma livello primitivo.
3. Un misto di lavoro del modulo/banco di prova, il tutto racchiuso in un unico modulo. Non il miglior approccio al design con Verilog, ma sarebbe . OK per un esempio di insegnamento In realtà, questo esempio è in realtà due moduli:

testbench, che può essere considerata comportamentale, anche se utilizza RTL codifica per istanziare il modulo che sta per essere testato per regs e fili che il banco prova guida:

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 

L'unità in prova (UUT) in fase di sperimentazione, che si tratta di un modulo come questo (che è chiaramente un livello RTL modulo in realtà- livello -Gate):

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 

E 'la mia comprensione che un modulo di livello RTL è un modulo in cui le equazioni logiche sono date in modo esplicito. Il modulo comportamentale ha processi (in Verilog usando i blocchi always, sebbene le equazioni logiche possano essere usate all'interno di quei blocchi). Qualsiasi progetto Verilog non banale avrà entrambi.