verilog sequentiell

[verilog_sequentiell (Gast)]

Hallo,

Wieviel sequentielle Anweisungen darf man innerhalb eines always blocks 
angeben?

Für mein verständnis sollte der untenstehende always block einen 
undefinierten wert ausgeben.
ich erhalte in der simulation den wert 23.
Ist das korrekt, würde das im FPGA ebenso funktionieren und wenn ja 
wieviel sequentielle logik kann man denn in so einen block einbringen?

module gate(out, in1, in2);
input [7:0] in1;
input [7:0] in2;
output [7:0] out;
reg [7:0] out;

always @(in1 or in2) begin
    out = in1 + in2;
    out = out + 1;
    out = in1 + out;
end
endmodule


module main;
    reg [7:0] in1;
    reg [7:0] in2;
    wire  [7:0] out;
    
    gate dut_gate(out,in1,in2);
    
  initial 
    begin
        $monitor("%d",out);
      $display("Hello, World");
      
      #10 in1 = 10; in2 = 2;
      
      $finish ;
    end
endmodule

[Vancouver (Gast)]

verilog_sequentiell schrieb:
> Für mein verständnis sollte der untenstehende always block einen
> undefinierten wert ausgeben.

Und warum erwartest Du das? Du verwendest das Blocking Assignment, das 
Ergebnis 23 ist völlig korrekt.

Eine Beschränkung der Anzahl der Statements in einem always-Kontext ist 
zumindest mir nicht bekannt.

[verilog_sequentiell (Gast)]

> Eine Beschränkung der Anzahl der Statements in einem always-Kontext ist
> zumindest mir nicht bekannt.

Nun bis das Ergebnis korrekt anliegt vergeht zeit. Was ist wenn ich ein 
hundert mal den Ausdruck "out = out + 1;" reinschreiben würde?
Würde es dann nicht zu timing problemen kommen?
Ich meine im FPGA laufen die dinge parallel ab und nicht wie im 
prozessor seuentiell.

[Vancouver (Gast)]

Die Designsoftware erzeugt im FPGA eine Schaltungsstruktur, die dasselbe 
Ergebnis liefert wie dein always-Statement. Das bedeutet nicht, dass 
diese Struktur sequenziell rechnet (Achtung Reizthema: FPGA werden nicht 
programmiert). Wenn Du 100mal out+1 hinschreibst, wird bei der 
Logiksynthese ein Addierer erzeugt, der out+100 berechnet. Das ergibt 
sich einfach aus der Logikoptimierung auf Gatterebene.
Natürlich können Deine Anweisungs so komplex werden, dass ein riesiges 
und damit langsames Gatternetzwerk herausskommt, aber das führt nur 
dazu, dass Du den Takt im FPGA entsprechend langsam machen musst. Die 
Anzahl der Statements im Always-Block wird dadurch nicht begrenzt

[Duke Scarring (Gast)]

verilog_sequentiell schrieb:
> Würde es dann nicht zu timing problemen kommen?
Nö, wenn Du lange genug wartest, ist alles ok.
Die Durchlaufzeit spuckt Dir der Synthesizer mit aus.

Erst wenn ein Takt ins Spiel kommt, will man i.d.R. das das Ergebnis zur 
nächsten Flanke stabil am Eingang der nächsten FF-Stufe anliegt.

Duke

[verilog_sequentiell (Gast)]

Danke das war sehr verständlich. Mal angenommen ich möchte meinen Takt 
nicht herunter takten wollen und mein design darf an manchen stellen 
auch gern asynchron werden, ist folgendes möglich?
Wie lang nun die ausführung dauert hängt nun doch sicherlich nur noch 
von dem speedgrade und der taktung des fpga und meiner logiktiefe.

module gate(out, in1, in2);
input [7:0] in1;
input [7:0] in2;
output [7:0] out;

reg [7:0] out;

reg [7:0] out1;
reg [7:0] out2;
reg [7:0] out3;
//..
reg [7:0] outn;

always @(in1 or in2) begin
    out1 = in1 + in2;
    out1 = out1 + 1;
end

always @(out1) begin
    out2 = out1 + out1;
end

always @(out2) begin
    out3 = out2 + out2;
end

always @(out3) begin
    outn = out3 + out3;
end

// ...

always @(outn) begin
    out = outn + outn;
end
endmodule


module main;
    reg [7:0] in1;
    reg [7:0] in2;
    wire  [7:0] out;
    
    gate dut_gate(out,in1,in2);
    
  initial 
    begin
        $monitor("%d",out);
      $display("Hello, World");
      
      #10 in1 = 10; in2 = 2;
      
      $finish ;
    end
endmodule

[Vancouver (Gast)]

Das Ergebnis Deiner Berechnung ist (in1+in2+1)*2^n, also zwei Additionen 
und ein Shift. Das geht sehr schnell und die Logiksynthese wird das auch 
so umformen.

Asnychronität im Design ist kaum in den Griff zu bekommen, die 
Ergebnisse sind mitunter nicht vorhersehbar. Bei einer großen Logiktiefe 
verwendest Du besser Pipelineregister, um den kritischen Pfad zu 
reduzieren.
In Deinem Code fehlt übrigens der Takt. Getaktet und gepipelinet sähe 
das so aus (ungetestet, vermutlich falsche Syntax):

always @(posedge clk) begin
  out1 <= in1+in2+1;
  out2 <= out1 + out1;
  out3 <= out2 + out2;
...
  out  <= outn+outn;
end

Damit hast Du nach n Takten das erste Ergebnis (out). Aber wie gesagt, 
Pipelining wäre bei diesem Design nicht erforderlich