Hallo zusammen,
in VHDL gibt es nicht so etwas wie Präprozessor, habe ich hier in einem
Beitrag gelesen. Was mache ich denn, wenn bei z.B. FSM bestimmte Zeiten
mit festen Zählerwerten taktfrequenzabhängig realisiere und die
Taktfrequenz versuchsweise ändere und die Zählerwerte nicht immer neu
ausrechnen und eintragen will. In C wird es ja z.B. so gemacht:
1
#define F_CPU 4000000UL // Systemtakt in Hz - Definition als unsigned long beachten
constantBAUD_REAL:integer:=-- hier die Berechnungsformel
Aber ist das sinnvoll und üblich so. Werden da für die Konstanten, die
ich ja nur für Zwischenberechnungen anlege, nicht die FPGA-Ressourcen
verbraucht.
noips schrieb:> Aber ist das sinnvoll und üblich so. Werden da für die Konstanten, die> ich ja nur für Zwischenberechnungen anlege, nicht die FPGA-Ressourcen> verbraucht.
Ja, das ist sinnvoll und üblich. Und FPGA-Ressourcen werden keine
verbraucht. Es sind ja konstante Werte. An diesen Stellen kannst Du
sogar Berechnungen verwenden, die sonst (noch) nicht synthetisierbar
sind: Division, Fließkommazahlen, Wurzel, Winkelfunktionen etc.
Duke
P.S.: Schau Dir auch mal das Konzept der generics an.
Dann ist es also doch so eine Art "Präprozessor", oder? Wenn zuerst die
Berechnungen gemacht werden und die Ausdrücke in den Code vor dem
Kompilieren (oder wie heißt dieser Schritt bei VHDl?) eingesetzt werden.
noips schrieb:> Dann ist es also doch so eine Art "Präprozessor", oder?
Jein. Das macht alles der Synthesizer (z.B. xst oder Synplify). Der
entscheidet ob ein Ausdruck statisch ist, oder nicht.
Duke
noips schrieb:> Dann ist es also doch so eine Art "Präprozessor", oder? Wenn zuerst die> Berechnungen gemacht werden und die Ausdrücke in den Code vor dem> Kompilieren (oder wie heißt dieser Schritt bei VHDl?) eingesetzt werden.
Auch der Präprozessor bei C/C++ macht keine Berechnungen sondern nur
Stringersetzung. Die Berechnungen werden erst vom Compiler ausgeführt
wenn er einen konstamten Ausdruck erkennt.
Lothar Miller schrieb:
> Aber warum probierst du das nicht einfach selber aus?
Wie kann ich durchs Ausprobieren erfahren, ob Ressourcen verbraucht
werden oder nicht? Meine Vermutung: Einen Entwurf mit und ohne diese
constants machen und synthetisieren lassen und dann den Verbrauch an
Ressourcen vergleichen?
noips schrieb:>> Auch der Präprozessor bei C/C++ macht keine Berechnungen sondern nur>> Stringersetzung. Die Berechnungen werden erst vom Compiler ausgeführt>> wenn er einen konstamten Ausdruck erkennt.>> Das steht aber im Widerspruch zu hier> http://www.mikrocontroller.net/articles/AVR-GCC-Tu...
Was da steht ist nicht relevant.
Relevant ist z.B.
http://gcc.gnu.org/onlinedocs/cpp/
Und da steht nichts vom Rechnen. (ausser bei #if)
Du kannst die selber davon überzeugen in dem du den Compiler anweist die
Preprozessorausgabe in eine Datei zu schreiben.
noips schrieb:> Wie kann ich durchs Ausprobieren erfahren, ob Ressourcen verbraucht> werden oder nicht? Meine Vermutung: Einen Entwurf mit und ohne diese> constants machen und synthetisieren lassen und dann den Verbrauch an> Ressourcen vergleichen?
Ja. Das scheint mir ein plausibler Weg. So mache ich das auf jeden Fall
auch immer... ;-)
Gibt es da eigentlich einen ausdrücklichen Präprozessorschritt oder
macht das nicht die Synthese automatisch mit?
Die VHDL-Synthese ist ja eine Art von Simulation eines Ablaufes um
Hardware zu erzeugen, also müssen alle Veriablen und statischen Vektoren
berechnet werden. Worin würden sich generics oder constanten
unterscheiden?
Ich meine, das ist ein Schritt,oder?
Bei VHDL gibts ja eigentlich die Schritte "Analyze" und "Elaborate".
Analyze entspricht dem Compilieren (vergiss das mit dem Präprozessor,
das ist ein ganz spezifisches C-Feature, das bis auf #include fürs
Funktionieren von C nicht nötig ist). Allerdings kann da (z.B. wg.
generics) noch nicht alles aufgelöst werden, d.h. es werden eigentlich
nur Schablonen compiliert.
Das Elaborate ist grob mit dem Linken vergleichbar, macht aber mehr. Es
muss für jede Instanziierung anhand der Configuration die passende
Architecture finden und mit den Generics versorgen. Die Generics können
ja nicht nur bei der Instanziierung selbst (generic map) sondern auch
über die Configuration reinkommen. Und die Generics können wiederum über
Generates andere Instanziierungen nach sich ziehen. Nach dem Elaborate
ist für jeden Ausdruck klar, ob er statisch ist und welchen Wert er dann
immer hat oder nicht. D.h. da sind Generics über die Termevaluierung zu
Konstanten geworden.
Die Synthese kommt erst hinter dem Elaborate, wenn die ganze Hierarchie
feststeht. BTW: xst verschiebt im Log die Bezeichnung der Phasen,
Compiling entspricht dem Analyze und Analyze eigentlich dem Elaborate.
noips schrieb:> Wie kann ich durchs Ausprobieren erfahren, ob Ressourcen verbraucht> werden oder nicht? Meine Vermutung: Einen Entwurf mit und ohne diese> constants machen und synthetisieren lassen und dann den Verbrauch an> Ressourcen vergleichen?
Mit einem diff-Tool (kompare, kdiff3, vimdiff, TortoiseMerge, ...) kann
man schön die Synthesereports vergleichen. Hilft auch um die Auswirkung
von diversen Optionen sichtbar zu machen.
Duke
>BTW: xst verschiebt im Log die Bezeichnung der Phasen,
Die Firma Xilinx macht so einige seltsame Dinge :-)
Bei Altera gibt es das parallele Synthetisieren. Man damit das letzlich
Ergebnis unter mehreren Annahmen erzeugen lassen, u,a, auch für
verschiedene Configurationen.
Thread beobachten
Seitenaufteilung abschalten