Rechnerstrukturen 1: Der Sehr Einfache Computer

Transkript

1 Inhaltsverzeichnis 1: Der Sehr Einfache Computer 1 Komponenten Arbeitsweise Instruktionen Beispielprogramm 1: Addition von 2 Zahlen Instruktionen und Daten im Speicher Maschinencode/Assembler-Code Beispielprogramm 2: Berechnung des Quadrats einer Eingabe Beispielprogramm 3: Berechnung des Durchschnitts beliebiger Eingaben : Der Sehr Einfache Computer Bevor wir uns abstrakt mit dem Thema befassen, werden wir einen sehr viel einfacheren Computer konkret kennen lernen, der nur über einen eingeschränkten Satz an Komponenten und Instruktionen verfügt. 1 Alle hier erwähnten Komponenten und Instruktionen kommen auch in echten Computern vor, sind dort aber wesentlich komplexer zusammengefügt. Komponenten Der Sehr Einfache Computer besitzt die folgenden Komponenten zum Vorhalten von Werten, sowie zu deren Ein- und Ausgabe: A (Accumulator): Ein 32-Bit-Register zum Laden von Speicherinhalt. IP (Instruction Pointer): Ein 28-Bit-Register, das die Speicheraddresse enthält, an der der nächste auszuführenden Befehl steht. M (Memory): Ausreichend Speicher für 2 28 Speicherworte von jeweils 32 Bit Länge. M[n] bezeichnet den Speicherinhalt an Adresse n. IN (Input): Eine Eingabewerk für beliebige 32-Bit-Worte OUT (Output): Eine Ausgabewerk für beliebige 32-Bit-Worte Er besitzt auÿerdem drei weitere Komponenten, die wir uns nicht im Detail anschauen werden: Ein Bus-System, das die übrigen Kompnenten verbindet und ansteuert sowie eine Arithmetical Logical Unit (ALU ), die genutzt wird, um Rechenoperationen oder bitweise logische Operationen durchzuführen. Auÿerdem kommt ein Decodierer/Steuerwerk zum Einsatz, um Instruktionen zu interpretieren. Arbeitsweise Der Sehr Einfache Computer führt immer wieder die folgenden Arbeitsschritte durch: 1. Fetch: Hole die Instruktion, die an der Speicheradresse steht, die in IP angegeben ist. 2. Execute: Führe die Instruktion aus und erhöhe IP um 1, wenn es sich bei der ausgeführten Instruktion nicht um eine der Jump-Anweisungen gehandelt haben sollte (s.u.). 1 Die Idee für den sehr einfachen Computer stammt aus dem Kurs Computer Systems Organization von Ray Toal: < Zugri: > 1

2 Instruktionen Instruktionen haben eine Länge von 32-Bit. Die höherwertigsten 4 Bit bilden den Operation Code (oder Opcode). Die restlichen 28 Bit bezeichnen meist eine Speicheradresse, auf die die Anweisung angewendet wird, sie können aber auch leer sein, bzw. werden bei bestimmten Anweisungen ignoriert. Mit 4 Bit lassen sich 2 4 = 16 verschiedene Anweisungen codieren. In der folgenden Tabelle bezeichnet n die 28-Bit-Adresse, die auf den Opcode folgt. Die Mnemonics stellen Kürzel für die Operationen dar, auf die wir später noch eingehen werden. Opcode Verhalten Mnemonic 0 A = M[n] load 1 M[n] = A store 2 A = A + M[n] add 3 A = A - M[n] sub 4 A = A * M[n] mul 5 A = A / M[n] div 6 A = A AND M[n] and 7 A = A OR M[n] or 8 A = A XOR M[n] xor 9 A = NOT A not A OUT = A write B A = IN read C IP = n jmp D IP = n, falls A = 0 jz E IP = n, falls A < 0 jlz F IP = n, falls A > 0 jgz Diese Instruktionen lassen sich wie folgt gruppieren: Speicherinstruktionen (load, store) Die ersten beiden Instruktionen holen Speicherinhalt von der Adresse n in den Akkumulator A, bzw. schreiben den Akkumulatorwert in den Speicher an die Adresse n. Arithmetische Instruktionen (add, sub, mul, div) Die nächsten vier Instruktionen holen einen Wert aus dem Speicher von Adresse n, führen eine einfache mathematische Operation mit dem Akkumulator und dem Speicherwert aus und schreiben das Ergebnis wieder in den Akkumulator. Logische Instruktionen (and, or, xor, not) Die ersten drei dieser vier Instruktionen führen eine bitweise logische Operation mit dem Akkumulator und einem Wert von Speicheradresse n durch und schreiben das Ergebnis wieder in den Akkumulator. Die not-instruktion negiert den Akkumulator und erwartet keinen Operanden. Eingabe/Ausgabe-Instruktionen (write, read) Zwei Instruktionen zum Ausgeben oder Einlesen eines 32-Bit-Wertes. Der Sehr Einfache Computer wartet bei der Instruktion read, bis ein Eingabewert vorliegt und fährt erst dann mit der nächsten Instruktion fort. 2

3 Jump-Instruktionen (jmp, jz, jlz, jgz) Diese Instruktionen setzen den Instruction Pointer IP auf eine neue Speicheradresse und bewirken damit, dass die Programmausführung an einem anderen Punkt fortgeführt wird. Drei von ihnen werden konditional ausgeführt. Der Sprung an eine andere Programmstelle wird nur vollzogen, wenn der Wert im Akkumulator A die Bedingung erfüllt. Ansonsten wird der Instruction Pointer IP schlicht um 1 erhöht Beispielprogramm 1: Addition von 2 Zahlen Mit den oben beschriebenen Instruktionen können wir nun ein kleines Programm schreiben. Die folgenden hexadezimal geschriebenen 32-Bit-Wörter setzen ein Programm um, das die Zahlen 23 und 42 addiert und das Ergebnis ausgibt. C A A Wir gehen davon aus, dass das Programm im Speicher an der Stelle 0x0 beginnt. Der Speicher M sieht dann wie in Abb. 1 beschrieben aus: Abbildung 1: Beispielprogramm 1 im Speicher Gehen wir zusätzlich davon aus, dass der Instruction Pointer IP zunächst den Wert 0 enthält, dann ist der Programmablauf wie folgt: (Auswirkungen einer Instruktion werden jeweils in der Zeile darunter sichtbar) Schritt IP A OUT IN Instruktion 1 0x C jmp 0x3 2 0x load 0x1 3 0x4 0x2A add 0x2 4 0x5 0x A write 5 0x6 0x41 0x41 -?? Oder ausführlicher: 1. Fetch: Instruktion C wird aus dem Speicher von Stelle M[0x0] geholt. Execute: C bezeichnet die jmp-instruktion, bezeichnet die Speicheradresse 0x3. Folglich wird der Instruction Pointer IP auf den Wert 0x3 gesetzt. 2. Fetch: Instruktion wird aus dem Speicher von Stelle M[0x3] geholt. 3

4 Execute: 0 bezeichnet die load-instruktion, bezeichnet die Speicheradresse 0x1. Folgich wird A auf den Wert von M[0x1] = 2A (dezimal: 42) gesetzt. IP wird wie bei jeder gewöhnlichen Anweisung um 1 erhöht auf 0x4. 3. Fetch: Instruktion wird aus dem Speicher von Stelle M[0x4] geholt. Execute: 2 bezeichnet die add-instruktion, bezeichnet die Speicheradresse 0x2. Folglich wird der Inhalt von M[0x2] = 0x17 auf den vorhandenen Akkumulatorwert addiert. A = 0x2A + 0x A = 0x41 Der Instruction Pointer IP wird wie bei jeder gewöhnlichen Anweisung um 1 erhöht auf 0x5. 4. Fetch: Instruktion A wird aus dem Speicher von Stelle M[0x5] geholt. Execute: A bezeichnet die write-instruktion. Folglich wird der Inhalt des Akkumulators A = 0x41 in das Ausgabewerk OUT geschrieben. Der Rest der Instuktion wird bei einer write-operation nicht benötigt und ignoriert. Der Instruction Pointer IP wird wie gewohnt um 1 erhöht. 5. (Der Sehr Einfache Computer würde jetzt fortfahren den Inhalt des IP = 0x6 als Speicheradresse einer Instruktion zu verstehen, würde diese vom Speicher holen und ausführen. Da wir nicht deniert haben, was an dieser Stelle steht, lässt sich der weitere Programmablauf nicht vorhersehen.) Instruktionen und Daten im Speicher Das Beispielprogramm 1 bestand einfach aus einer Reihe von Speicherwörtern. Diese wurden teilweise als Instruktionen verstanden, teilweise als Werte. Der Programmablauf legt fest, welche Speicherinhalte Instruktionen darstellen und welche Werte. (Prinzipiell würde nichts dagegen sprechen, dass ein Speicherwort ob durch einen Fehler oder mit Absicht in demselben Programmablauf einmal als Wert und einmal als Instruktion verstanden wird.) Abbildung 2: Beispielprogramm 1 im Speicher mit Instruktionen Maschinencode/Assembler-Code Das Beispielprogramm führt eigentlich eine sehr einfache Aufgabe aus. Der Maschinencode dafür ist aber nur mühsam zu verstehen. Statt die Speicherinhalte direkt auszuschreiben wäre es sehr viel einfacher, wenn wir zur Denition des Programms direkt die Mnemonics verwenden könnten: 4

5 0 jmp 0x3 1 0x2A 2 0x17 3 load 0x1 4 add 0x2 5 write Das ist schon etwas besser, aber die Adressierung der Speicherbereiche durch Zahlen ist immer noch schwer nachzuvollziehen. Schön wäre es, wenn wir für diese Speicherbereiche Bezeichnungen oder Label vergeben könnten, die man sich besser merken kann. Auÿerdem wäre es praktisch, wenn wir den Speicherinhalt auch in dezimaler Form angeben könnten. 0 jmp start 1 x: 42 2 y: 23 3 start: load x 4 add y 5 write Das obige Beispiel würde man als den Assembler-Code für das Beispielprogramm 1 bezeichnen. Assembler-Code verwendet typischerweise Merkwörter oder Mnemonics für die Angabe von Instruktionen und Label zur Bezeichnung von Speicherbereichen, die Instruktionen oder Werte enthalten, wobei in den meisten Fällen eine einzelne Zeile Assembler-Code direkt in einen Ausdruck Maschinencode übertragen werden kann. Es gibt verschiedene Arten von Programmen, die mit Maschinencode und Assembler- Code interagieren: Ein Assembler hat die Aufgabe, Assembler-Code in Maschinencode zu übersetzen. Ein Compiler hat die Aufgabe, den Code einer höheren Programmiersprache (wie etwa C oder Java) in Maschinencode zu übersetzen. Ein Disassembler hat die Aufgabe Maschinencode in Assembler-Code zu übersetzen (etwa um ihn lesbar zu machen) Im Folgenden werden wir Programme für den Sehr Einfachen Computer in Assembler- Code formulieren. Dessen Syntax lässt sich etwa wie folgt denieren: Zeilen haben die Struktur: [label:] Zahl mnemonic [label] [; Kommentar] Sie bestehen also aus: (optional) einem Label gefolgt von :, das den Speicherbereich der Zeile bezeichnet. verpichtend: entweder dem Merkwort einer einfachen Instruktion ohne Operand ( read, write, not) oder dem Merkwort einer der übrigen Instruktion gefolgt von einem Label als Operand oder einer einfachen Zahl, die den Inhalt des Speicherbereichs direkt angibt. (dezimal, z.b.:10 oder hexadezimal, z.b.: 0xA) (optional) einem beliebigen Kommentar zur Zeile, eingeleitet mit ;. 5

6 Beispielprogramm 2: Berechnung des Quadrats einer Eingabe Das nächste Beispielprogramm nimmt jeweils eine Zahl als Input entgegen, bildet das Quadrat und gibt dieses ans Ausgabewerk weiter. Auf eine Eingabe des Werts 2 sollte das Programm also reagieren mit 4, auf eine Eingabe von 3 mit 9, auf 4 mit 16, etc. Während das Verhalten von Beispielprogramm 1 nach Programmende nicht mehr beschreibbar war, soll Beispielprogramm 2 nach einmaligem Output erneut für seine Aufgabe bereitstehen. Das folgende Programm hat dieses Verhalten: 0 jmp start ; Überspringe den Datenbereich 1 input: 0 ; Speicherbereich für die eingegebene Zahl 2 start: read ; lies eine Eingabe nach A 3 store input ; speichere A im Speicherbereich input 4 mul input ; Multipliziere A mit Inhalt von input 5 write ; Schreibe das Ergebnis nach OUT 6 jmp start ; Beginne von vorn Betrachten wir wieder den Programmablauf Schritt für Schritt. Wir gehen dbaei davon aus, dass der Nutzer die folgenden Eingaben macht: 4, dann 13. M[input] bezeichnet den Speicherbereich, der mit dem Label input: versehen ist. Schritt IP A OUT IN M[input] Instruktion 1 0x x0 C jmp start 2 0x x4 0x0 B read 3 0x3 0x x store input 4 0x4 0x x mul input 5 0x5 0x x4 A write 6 0x6 0x10 0x10-0x4 C jmp start 7 0x2 0x10-0xD 0x4 B read 8 0x3 0xD - - 0x store input 9 0x4 0xD - - 0xD mul input 10 0x5 0xA xD A write 11 0x6 0xA9 0xA9-0xD C jmp start Das Programm läuft oenbar unendlich lange weiter (wenn man nicht den Stecker zieht.) Die folgenden Abbildungen zeigen, wie das Programm im Speicher aussieht und wie der Speicher (im Beispiel der Eingabe der Werte 4 und 13) durch die Instruktion store input geändert wird. Beispielprogramm 2 im Speicher: Beispielprogramm 2 im Speicher mit Instruktionen: 6

7 Beispielprogramm 2 nach Schritt 3: Beispielprogramm 2 nach Schritt 8: Beispielprogramm 3: Berechnung des Durchschnitts beliebiger Eingaben Zuletzt betrachten wir ein etwas komplexeres Programm, das je nach Eingabe verschiedene Aktionen durchführt. Das Programm soll sich wie folgt verhalten: Lese solange Zahlen aus dem Eingabewerk, bis eine Null gelesen wird. Wenn eine Null gelesen wurde, gib den Durchschnitt der bisher gelesenen Zahlen aus. Vorüberlegung: Der Durchschnitt von n Zahlen ist die Summe dieser Zahlen geteilt durch ihre Anzahl n. Um den Durchschnitt zu berechnen brauchen wir also einen Programmteil, der die Zahlen addiert und ihre Summe und Anzahl vorhält, solange keine 0 gelesen wird. einen Programmteil, der nur bei Einlesen einer Null aktiviert wird und dann die Summe durch die Anzahl dividiert und das Ergebnis ausgibt Implementierung: Das folgende Programm hat das beschriebene Verhalten: 0 jmp start ; Überspringe den Datenbereich 1 sum: 0 ; Speicher für die Summe der gelesenen Zahlen 2 number: 0 ; Speicher für die aktuell gelesene Zahl 3 count: 0 ; Speicher für die Anzahl der gelesenen Zahlen 4 incr: 1 ; Der Wert, um den count jeweils erhöht wird 5 null: 0 ; Ein Speicherbereich mit dem Wert 0 6 start: read ; Lese IN nach A ein 7 jz eval ; Wenn eine Null gelesen wurde, springe zum Label eval 8 store number ; Keine Null gelesen, schreibe A nach number 9 load sum ; Hole die bisherige Summe nach A 10 add number ; Addiere die gelesene Zahl auf A 11 store sum ; Schreibe die neue Summe von A nach sum 12 load count ; Hole die bisherige Anzahl von Elementen nach A 7

8 13 add incr ; erhöhe die Anzahl in A um 1 14 store count ; Schreibe die neue Anzahl von A nach count 15 jmp start ; Springe wieder zu start um die nächste Zahl einzulesen 16 eval: load sum ; Hole die bisherige Summe aus dem Speicher nach A 17 div count ; Dividiere A durch die Anzahl 18 write ; Schreibe das Ergebnis nach OUT 19 load null ; Hole den Wert 0 nach A 20 store sum ; Setze sum, number und count auf 0 zurück 21 store number 22 store count 23 jmp start ; beginne von vorn 8