Es steht in der Aufgabe, dass beim Sprungbefehl, der Register erst in der Ausführen-Phase auf neune Wert gesetzt wird, d.h. S3 wird erst in in Takt 4 anfangen(oder?). Wenn man ohne JUMP-Befehl den Code durchführen würde, würde S3 schon in drittem Takt anfangen. Macht das überhaupt einen Sinn bzw. mir ist die Vorgehensweise des JUMP-Befehls ist nicht ganz klar.



1 mal bearbeitet. Zuletzt am 03.11.2009 21:39 von [EnD]Reitanna.

Wenn ich deine Frage richtig verstanden habe, willst du wissen, was mit den Befehlen passiert die zwischen Sprung-Befehl und Sprung-Ziel liegen. Der Sprungbefehl schreibt in der Ausführen Phase ja in ein entsprechendes Register die Nummer (Zeile,Speicherzelle...) des nächsten Befehls. In der Ausführung wird dieser dann nach dem Sprungbefehl ausgeführt und die anderen eventuell im Programm dazwischenliegenden Befehle nicht mehr, es sei denn ein anderer Sprung führt zu ihnen.
Damit sind zum Beispiel Schleifen möglich, man kann gleichen Code mehrfach ausführen, oder je nach Bedingung nur einen Teil des Codes ausführen. Im Programmspeicher muss jedoch natürlich trotzdem das ganze Programm stehen, denn dieser weiß ja nicht was bei der Ausführung passiert.
Ich hoffe das erklärt dir denn Sinn des Befehls an sich. Wie der Compiler damit umgeht, dass sollst du dir in den Aufgaben ja ein bisschen erarbeiten, also dazu gibt's auch nicht mehr Tipps.
Simon

Es geht hier auch gar nicht darum, den Befehl in S3 "schneller zu erreichen", sondern wirklich darum, wie der Compiler damit umgeht und was mit den dazwischenliegenden Befehlen geschieht...
Normalerweise besteht ein Programm schließlich nicht nur aus ein paar Zeilen, und dann hat im Gesamtkontext gesehen ein Sprungbefehl schon mehr "Sinn" als hier...

Ja, aber das Problem ist, falls man 5-stufigen System betrachtet, passiert die Ausführung des JUMP-Befehls erst in 4ten Takt, d.h. Befehle S2 und S3 werden schon in Takt 2 und 3 starten, und im Takt 4 wird Register gleichzeitig uberschrieben und gelesen - ist das überhaupt möglich? Und falls ja, dann wird im Takt 5 zwei von S3 Befehlen laufen. Oder wird alles gestoppt, bis JUMP-Befehl ausgeführt ist?

Also dieses Register, in dem zu jeder Zeit die Speicheradresse des als nächstes auszuführenden Befehls steht, heißt Befehlszähler (auf Englisch: Program Counter (PC)). Dieser wird nach jedem Takt inkrementiert. Das heißt, immer nachdem ein Befehl von der dem PC entsprechenden Speicheradresse geholt wurde, wird Wert des PC erhöht, so dass danach die Speicheradresse des unmittelbar folgenden Befehls im PC steht.

Mit einem Jump-Befehl lässt sich direkt ein beliebiger Wert in den PC schreiben. Bei diesem Wert handelt es sich also um die Speicheradresse des Befehls, den man als nächstes ausführen möchte anstatt den unmittelbar auf den Jump Befehl folgenden.

Betrachte dazu folgendes Beispielprogrammstück, wobei die S4,...,S9 die Speicheraddressen sind, an denen die Befehle stehen. Anstatt echter Befehle nenne ich die, die nicht der Jump-Befehl sind, einfach Befehl1-5, weil es mir nur um die Demonstration der Werte im PC und der Funktion des Jump-Befehls geht:

S4: Befehl1
S5: Befehl2
S6: JMP S9
S7: Befehl3
S8: Befehl4
S9: Befehl5

Zu Beginn des Programmstücks muss PC=S4 sein, damit Befehl1 überhaupt geholt wird. Die weitere Ausführung (hier noch ohne Berücksichtigung einer Pipeline) sähe dann so aus:

Hole Befehl1 aus PC=S4; PC:=PC+1=S5; Führe Befehl1 aus;
Hole Befehl2 aus PC=S5; PC:=PC+1=S6; Führe Befehl2 aus;
Hole "JMP S9" aus PC=S6; PC:=PC+1=S7; Führe "JMP S9" aus, d.h. setze PC:=S9;
Hole Befehl5 aus PC=S9; PC:=PC+1=S10; Führe Befehl5 aus;

Man sieht also, dass durch den Jump Befehl die Ausführung von Befehl3 und Befehl4 nicht stattgefunden hat. Man könnte sich fragen, warum man sie dann nicht ganz weg lässt, weil der Jump-Befehl ja immer stattfindet. Aber es kann trotzdem Sinn machen, diese beiden Befehle dort vor Befehl5 an den Speicheradressen S7 und S8 stehen zu haben. Denn es könnte ja auch irgendwo im restlichen Programm einen "JMP S7" oder "JMP S8" Befehl geben, wodurch dann die Befehle 3-5... oder 4-5... hintereinander abgearbeitet würden.


Mit der mehrstufigen Pipeline aus der Aufgabenstellung kommt es bei Jump-Befehlen nun zu dem Problem, dass der Wert des PC erst am Ende der Operation-Ausführen-Phase des Jump-Befehls die Speicheradresse enthält, an der der Befehl steht, zu dem man springen will. Vorher wurde dummerweise schon in jedem Takt, seitdem der Jump-Befehl geholt wurde, der PC stur erhöht und die entsprechenden nachfolgenden Befehle in die Pipeline geschoben. Und in diesem Pipeline-Modell soll ein Befehl nicht mehr zurück gerufen werden können, wenn er einmal in der Pipeline ist. Daher muss man sich eine Lösung mit NOP-Befehlen (gesprochen no-op = keine Operation) überlegen.

Deinen Einwand, dass ja im Takt der Operation-Ausführen-Phase des Jump-Befehls auf PC geschrieben wird, während die Befehl-Holen-Phase GLEICHZEITIG von PC liest, finde ich durchaus berechtigt. Das ist nicht ganz klar, denn in der Aufgabenstellung steht dazu nur "WÄHREND der Operation-Ausführen-Phase...". Ich würde aber davon ausgehen, dass das Lesen während der Befehl-Holen-Phase eher früh und das Schreiben während der Operation-Ausführen-Phase eher spät im Takt stattfindet. Man sollte auf jeden Fall nicht davon ausgehen, dass die gleichzeitig zur Operation-Ausführen-Phase des Jump-Befehls stattfindende Befehl-Holen-Phase bereits den neuen gewünschten Wert des PC bekommt, und entsprechend ein NOP mehr einfügen.

Danke für die Erklärung :)

Linus Feiten schrieb:
-------------------------------------------------------
> Deinen Einwand, dass ja im Takt der
> Operation-Ausführen-Phase des Jump-Befehls auf PC
> geschrieben wird, während die Befehl-Holen-Phase
> GLEICHZEITIG von PC liest, finde ich durchaus
> berechtigt. Das ist nicht ganz klar, denn in der
> Aufgabenstellung steht dazu nur "WÄHREND der
> Operation-Ausführen-Phase...". Ich würde aber
> davon ausgehen, dass das Lesen während der
> Befehl-Holen-Phase eher früh und das Schreiben
> während der Operation-Ausführen-Phase eher spät
> im Takt stattfindet. Man sollte auf jeden Fall
> nicht davon ausgehen, dass die gleichzeitig zur
> Operation-Ausführen-Phase des Jump-Befehls
> stattfindende Befehl-Holen-Phase bereits den neuen
> gewünschten Wert des PC bekommt, und entsprechend
> ein NOP mehr einfügen.


Ja, das ist zugegeben, nicht ganz exakt beschrieben. Aber so wie Linus es sagt, ist es gemeint.
Die Berechnung der neuen Sprungadresse dauert eine gewisse Zeit, da es eine nunmal eine arithmetische Operation ist. Es sollte aber sicher gestellt sein, dass zu Beginn der "Befehl-Holen"-Phase die Adresse korrekt im PC steht.