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 ;-)
Wow ich hätte nicht gedacht das es Leute gibt, die VHDL/FPGA hobbymäßig betreiben. Finde ich aber gut...
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.
Thread beobachten
Seitenaufteilung abschaltenBitte melde dich an um einen Beitrag zu schreiben. Anmeldung ist kostenlos und dauert nur eine Minute.
Bestehender Account
Schon ein Account bei Google/GoogleMail? Keine Anmeldung erforderlich!
Mit Google-Account einloggen
Mit Google-Account einloggen
Noch kein Account? Hier anmelden.