guten Morgen,
ich hab das Wochenende damit verbracht, Information über die Verwendung
von pipeline Strukturen zu finden. Das war nicht ganz zufriedenstellend,
weshalb ich nun mal euch um Rat frage.
Letzte Woche habe ich oft gehört "hab ich gepipelined gemacht", "ist
noch nicht als Pipeline" etc.
Wie und welche Schwierigkeiten sich dadurch ergeben ist mir überhaupt
nicht klar. Warum so einigermaßen. Vielleicht. Halbwissen
wahrscheinlich.
Und zwar ist mein Kenntnisstand so: Wenn eine Berechnung, oder sonstwie
geartete Operation relativ viele Logikstufen beinhaltet, oder besser
gesagt so viele Logikstufen hat, daß die benötigte Durchlaufzeit nicht
mit einer gewünschten Taktrate vereinbar ist, merkt man sich
Zwischenergebnisse, die schnell genug abgearbeitet sind. Dadurch ergeben
sich ein paar Takte Latenz vom Anfang bis zum Ende, aber am Ausgang der
'pipeline' eine Aktualisierungsrate mit dem hohen Takt. Schön das könnte
auch aus Wiki sein (wenn das den Kern überhaupt trifft)
Da ich mich in die wundersame fpga Welt reinknie, würde ich solche
Sachen erst mal trocken versuchen bevor ich auf ein Design treffe wo es
nötig wäre und ich es nicht kann.
Könnt ihr mir ein kompaktes Beispiel aufzeigen, wo etwas als pipeline
realisiert wird? Speziell die Notation ist mir auch noch schleierhaft.
Eine Dummie Erklärung noch als Bonus? Oder Eure eigenen Worte?
Und dann noch eine Frage: Wenn ich durch eine Pipeline sagen wir 3 Takte
Latenzt habe und die Ausgangsdaten werden noch an anderer Stelle
verrechnet bzw. mit denen passiert was - sieht man dann zu, daß alles
was damit im Design zu tun hat durch x Flip Flops verzögert wird, damit
eine Zuordnung möglich ist? Ich denke z.B. an Samples aus einem A/D
Wandler die durch die Fiktive Pipeline gehen.
Bei Prozessoren ergibt sich das Stichwort Pipeline Stall - die Reaktion
auf eine nicht geplante Abarbeitung überfordert meine Phantasie.
Wahrscheinlich muss man sich darum aber auch erst mal keine Sorgen
machen und sieht das Thema als eine Methode an, den globalen Takt zu
erhöhen.
Daß ich versuchen sollte mit dem einen Takt auszukommen habe ich während
meine Recherche am Wochenende Mantra-ähnlich begriffen.
Wenn mir Leute beim lichten des Nebels helfen, wäre ich sehr dankbar!
schönen Gruß!
Hi,
ich hab das Gefühl, dass du das Pipelining-Prinzip bereits verstanden
hast.
Die hauptsächliche Verwendung dürfte bei Prozessoren sein, die die
Verarbeitungsrate durch Pipelining erhöhen. Die Gründe dafür sind recht
vielfältig. Jedenfalls kann man durch Pipelining im besten Fall pro Takt
1 Ergebnis ausliefern wenn die Pipeline dann mal gefüllt ist. In
aktuellen Prozessoren ist der Takt so hoch, dass Pipelinestufen auch mal
nur dazu dienen das Signal von einem Ort im Prozessor woanders
hinzubekommen.
Du hattest geschrieben, ob man andere Daten verzögert um sie
gleichzeitig mit den gepipelinenten Daten aus dem FPGA zu bekommen.
Mmmhh prinzipiell könnte sowas Sinn machen, wenn deine
Pipelinebearbeitung immer gleich lang dauert. Dann könnte man andere
Daten die schneller fertig sind in ein Schieberegister
zwischenspeichern.
Was aber, wenn wie bei einer Prozessorpipeline die
Verarbeitungsgeschwindigkeit z.B. durch Stalls langsamer als üblich
abläuft? Dann kann man höchstens andere Daten in ein SRAM schreiben und
wieder auslesen, wenn benötigt. Naja das driftet dann komplett in
Prozessordesign ab.
Wo wird was als Pipeline realisiert? Entweder manuell, wenn man z.B.
einen Prozessor baut, z.B. auch superskalar (mehr als ein Ergebnis pro
Takt möglich) oder auch automatisch, wenn das Synthesetool etwas
pipelined baut. Wie das geht und was dann für Probleme auftauchen kann
ich dir nicht sagen. Man kann solche Automatismen aber abschalten und
das macht man vor allem dann wenn man sich nicht sicher ist ob das Tool
korrekt arbeitet, bei schwierigen Designs und wenn man alles in der Hand
behalten möchte.
Wenn du noch Fragen hast: hab mich mal sehr ausführlich mit
Prozessordesign beschäftigt in meiner Diplomarbeit.
In dem Zusammenhang kann ich das Buch Computer Architecture: A
Quantitative Approach von Hennessy und Patterson empfehlen:
http://www.amazon.de/Computer-Architecture-Quantitative-Approach-Kaufmann/dp/012383872X/ref=sr_1_2?s=books-intl-de&ie=UTF8&qid=1326696559&sr=1-2
Danke erst mal für die Antwort.
Das wie ist mir auch ein Rästel. Verwendet man da zum beschreiben eine
bestimmte Notation oder wird die Pipeline als Statemachine realisiert?
Pipeline stall überschreitet wahrscheinlich den Umfang eines Forums,
aber wenn möglich berichtet mir ruhig mehr davon.
Prinzipiell sollte man sich mit Hardwarebeschreibung auskennen, also
VHDL, evtl. Verilog und natürlich SystemC wenn man viel mit Testbenches
usw. macht.
In VHDL beschreibt sich Hardware relativ einfach und einigermaßen
verständlich für meine Begriffe. Im Prozessordesign verwendet man
typischerweise RTL-Beschreibungen (= register transfer logic), d.h.
direkt auf Hardware-Ebene ohne zu viel Hochsprachen-Bla-Bla.
State machine ist bestimmt eine gute Idee. Wie es sonst aussehen muss:
In einer Pipeline sind in jeder Pipeline-Stufe am Ende Register=Flip
Flops vorhanden die das Stufenergebnis zwischenspeichern.
Überlegung ins blaue (bin derzeit nicht aktiv am coden, also vielleicht
bisschen ungenau):
Man könnte also für jede Pipeline - Stufe einen getakteten VHDL-Process
machen der die Register der letzten Stufe einliest und einen
Switch/If/IF ELSE-Verzweigung nutzt um die Zielregister dann zu
beschreiben.
Pipeline Stall: Ja sehr umfangreich, aber in Kürze:
Wenn die Logik am Eingang der Pipeline nicht nachkommt sie zu füttern:
schlecht. Wenn die Prozessorpipeline einen Sprungbefehl verarbeitet,
dann muss ein Teil der Pipeline verschmissen werden: aufwändig.
Wenn eine Pipeline-Stufe länger braucht als 1 Takt stallt das natürlich
auch.
Bei Prozessoren wird das dann kompliziert weil einiges aus SRAMs gelesen
werden muss was oft/immer nicht in einem Takt funktioniert...
Frank schrieb:> Pipeline als Statemachine realisiert?
Eher nicht.
Eine pipeline hat eine mehrdimensionale Rautenstruktur über Zeit und
Fläache. Im einfachsten Fall ist sie 1D, also nur über eine Zeit- und
eine Flächenebene = Linie.
Beispiel:
Du wills einen komplizierten Filter ausrechnen und muss t je Takt einen
Wert liefern. Der Filer braucht aber die letzten 16 Werte. Entweder, Du
machst das mit dem 16fachen Takt oder der 16fachen Struktur:
du schreibst also hin:
ERG = WERT1 * Koeff1 + WERT2 * Koeff2 ... + ... WERT16 * Koeef16.
Das Ganze geht aber dann nur noch mit 10 MHz :-)
Also schreibst Du es in mehreren Takten:
Taktstufe 1
Wert1_t1 = Wert1
Koeff1_t1 = Koeef1
...
Wert16_t1 = Wert16
Koeff16_t1 = Koeef16
Taktstufe 2:
Ergebnis1_t2 = Wert1_t1 * Koeff1_t1;
...
Ergebnis16_t2 = Wert16_t1 * Koeff16_t1;
Taktstufe 3:
Summe1_t3 = Ergebnis1_t2 + Ergebnis2_t2 + Ergebnis3_t2 + Ergebnis4_t2
...
Summe4_t3 = Ergebnis13_t2 + Ergebnis14_t2 + Ergebnis15_t2 +
Ergebnis16_t2
Taktstufe 4:
Gesamt_t4 = Summe1_t3 + Summe2_t3 + Summe3_t3 + Summe4_t3
genausso schleppst Du die Summe der Koeefizienten parallel mit
da diese eine Mul wegnier haben, brauchst Du einen Tatk weniger. Damit
die Zeiten passen, musst Du einmal einen Wert einfach in die nächste
Zeitebene übergeben, z.B. Koeffizientensumme_t4 = Koeffizientensumme_t3.
Am Ende kannst du den filterwert bilden:
Filter_t5 = Gesamt_t4 / Koeffizientensumme_t4
Deine pipeline kann mit jedem Takt neue Daten erhalten und wirf mit
jedem Takt einen Filterwert aus - nur 5 Takte verspätet.
Wie notiere ich denn die 'Taktstufen'? Mir geht es da um die
Beschreibung einer solchen pipeline in vhdl Syntax. Kann man so was
pseudocode-mäßig machen?
Würde mich freuen.
Aber irgendwelche Zustandssignale, sei's Pipeline voll jetzt kommen
Werte, oder eben in Bezug zur Stall Geschichte benötigt man doch schon.
Oder?
danke Euch
also die Arbeit musst du schon selber machen. In den meisten Büchern
wird über Implementierungsdetails meist nicht viel verraten. In
Patentschriften gleich zweimal nicht und in Forschungspapieren geht es
meist um eine kleine Kleinigkeit die genau beschrieben wird, aber nur
vom Algorithmus her, Implementierung findet man da auch nicht.
Überleg dir erst mal den Algorithmus (ohne VHDL), dann zeichne diesen
von mir aus als Zustandsautomat oder als Vorgangsbeschreibung. Eine
andere Möglichkeit ist es auch dir zu Überlegen wie man das Problem
zerlegen kann, z.B. Pipelinestufe 1 soll addieren. Stufe 2 soll
multiplizieren. Dann kann man die einzelnen Bereiche für sich genau
überlegen, ist dann bei feingranularer Zerlegung auch kein Problem mehr.
Wenn du dann das kleinste Teil in VHDL beschrieben hast, musst du es
dann mit den anderen Modulen vereinen. Dann merkst du automatisch ob du
noch Hilfssignale vergessen hast.
ok danke dir dann ist der thread auch zu Ende. Ich war irgendwie der
Annahme, daß das quasi Lehrinhalt an den Hochschulen ist, so wie man
z.B. lernt, wie diverse Speicher beschrieben werden. Ich hoffe du
verstehst wie ich das meine.
Daher ist mir der der Unterschied zwischen 'kann ich'-ich weiß ja grob
worums geht und 'kann ich realisieren' bewusst geworden. Ich versuche
mich mal da ran zu arbeiten.
schönen Gruß
Naja, so direkt lernt man das erst im Arbeitsleben denke ich. An der
Hochschule lernst du vielleicht bissl VHDL und etwas Architektur. Aber
eine VHDL Syntax für Pipelines direkt gibts natürlich nicht. Du denkst
da wahrscheinlich viel zu sehr in Software. Eine Pipeline auf einem FPGA
ist nix weiter als FlipFlops in Reihe geschaltet. Und ein FlipFlop
beschreibt man mit einem Prozess, der auf einen Takt reagiert. Natürlich
musst du dann noch Steuersignale beachten und evtl. mit durch die
Pipeline nehmen, damit du am Ende weißt, wann die Daten gültig sind und
die Pipeline anhalten kannst, falls es hinten staut (FIFO voll oder so).
Frank schrieb:> Wie notiere ich denn die 'Taktstufen'?
Genau so, wie ich es oben gemacht habe.
Du schreibst alles in einen Prozess, oder teilst zwischen Kombinatorik
und FFs auf. Wichtig ist, das eine Zeitebene immer nur genau auf die
davor zugreift. Daher das t1, t2 an den Var-Namen.
Beispiel x1 x2 x2 + kk, aufgeteilt in 2 Prozesse:
Kombinatorisch: Rechnungen beschreiben
x1_t1_new <= x1; -- Eingang lesen
x2_t1_new <= x2; -- Eingang lesen
kk_t1_new <= kk; -- Eingang lesen
xx_t2_new <= x2_t1 * x2_t1; -- erster Rechenschritt
kk_t2_new <= kk_t1; -- mitschleppen
pr_t3_new <= xx_t2 * x1_t2; -- produkt bilden
kk_t3_new <= kk_t2; -- mitschleppen
su_t4_new <= pr_t3 + kk_t3; -- summe bilden
Synchron: (alle Variablen pauschal in die nächste Zeitebene
weiterschieben)
x1_t1 <= x1_t1_new;
x2_t1 <= x2_t1_new;
kk_t1 <= kk_t1_new;
xx_t1 <= xx_t1_new; -- gibt es zeitlich noch nicht
pr_t1 <= pr_t1_new; -- gibt es zeitlich noch nicht
su_t1 <= su_t1_new; -- gibt es zeitlich noch nicht
x1_t2 <= x1_t2_new;
x2_t2 <= x2_t2_new;
kk_t2 <= kk_t2_new;
xx_t2 <= xx_t2_new;
pr_t2 <= pr_t2_new; -- gibt es zeitlich noch nicht
su_t2 <= su_t2_new; -- gibt es zeitlich noch nicht
x1_t3 <= x1_t3_new; -- wird nicht mehr gebraucht
x2_t3 <= x2_t3_new;
kk_t3 <= kk_t3_new;
xx_t3 <= xx_t3_new; -- wird nicht mehr gebraucht
pr_t3 <= pr_t3_new; -- gibt es erstmals hier
su_t3 <= su_t3_new; -- gibt es zeitlich noch nicht
su_t4 <= su_t4_new;
die meisten werden nicht benötigt, weil die Variablen später nicht mehr
verwendet werden.
Schon sehr viel klarer, vielen Dank.
Lernen im Arbeitsleben ist so eine Sache. Das steht bei mir leider nicht
zur Debatte, ich versuche mich in der Freizeit etwas da rein zu knien
und zu verstehen.
Mein Mentor seid ihr ;-)
Hallo noch einmal,
kann man es so sagen, daß die z.B. im Buch vhdl-Synthese gezeigte
RTL-Struktur aus Wolke und Register ganz genau dieser ominösen pipeline
entspricht?
Logik-Register-Logik-Register-Logik-...
Eingang und Ausgang müssten sich dann eben mit anderen Blöcken
verständigen und synchronisieren.
Wenn ja, hat sich das Wochenende gelohnt. Wenn nein - Mist.
Frank schrieb:> kann man es so sagen, daß die z.B. im Buch vhdl-Synthese gezeigte> RTL-Struktur aus Wolke und Register ganz genau dieser ominösen pipeline> entspricht?
Ich weiß zwar nicht genau, welche du meinst...
> Logik-Register-Logik-Register-Logik-...
... aber das im Prinzip eine Pipeline-Struktur (wenn auch eine sehr
einfache).
Ich verstehe aber nicht genau, wo jetzt dein Problem liegt.
Irgendwie gehst du da zu akademisch ran. Auch eine
Hintereinanderschaltung von Flip-Flops ohne Logik dazwischen ist eine
Pipeline Struktur. Denn das Ergebnis bzw. das Eingangssignal erscheint
erst nach ein paar Takten am Ausgang. Mehr sagt der Begriff "Pipeline"
gar nicht aus.
