k230-Anwendung_ReTI

Page 1

page-01.png

Kapitel 2 – Kodierung

  1. Kodierung von Zeichen
  2. Kodierung von Zahlen
  3. Anwendung: ReTI

Albert-Ludwigs-Universität Freiburg
Prof. Dr. Armin Biere
Institut für Informatik

Page 2

page-02.png

Realisierung von ReTI

  • P (Programmspeicher): Zellen mit Adressen 0–3, enthält Befehle
  • S (Datenspeicher): Zellen mit Adressen 0–3, enthält Daten
  • CPU-Register:
    • ACC (Akkumulator)
    • IN1 (Indexregister 1)
    • IN2 (Indexregister 2)
    • PC (Befehlszähler)
  • Befehle: load, store

Page 3

page-03.png

Unterschiede abstrakter/realer ReTI

  • ein Speicher für Daten und Befehle bei realer Maschine
  • ist endlich (Größe ). Für ist Inhalt der -ten Speicherzelle.
  • Speicherzellen können Elemente aus aufnehmen.
  • CPU-Register PC, ACC, IN1 und IN2 können nur Elemente aufnehmen.
  • So ein (also Bitvektor der Länge 32) heißt Wort.
  • Ein Wort kann als Binärzahl (z. B. Adresse im ), Zweierkomplementzahl oder Bitstring interpretiert werden.
  • Befehle sind ebenfalls Wörter aus .

Page 4

page-04.png

Notation

ü

  ( Register oder Speicherzelle, )   bedeute

Beispiel:

  ( Register oder Speicherzelle, )   bedeute

wird als Zweierkomplement-Zahl interpretiert.

Page 5

page-05.png

Befehlsformate

Zur Erinnerung: Befehlssatz von ReTI besteht aus Compute-, Load-, Store- und Jump-Befehlen.
Sie werden als Wörter aus kodiert.

Notation: Sei .

ü

Allgemeines Instruktionsformat:

Bits 31–30 29–26 25–24 23–0
Feld Typ Modus/Funktion/Compare/Source Destination Immediate

Page 6

page-06.png

Kodierungschema einer Instruktion

Typ (Bits 31–30):

T Typ
0 1 Load
1 0 Store
0 0 Compute
1 1 Jump

S / D – Register:

S / D Register
0 0 PC
0 1 IN1
1 0 IN2
1 1 ACC

Instruktionsformate:

31–30 29–28 27–26 25–24 23–0
Load 0 1 M * D i
Store 1 0 M S D i
Compute 0 0 MI F D i
Jump 1 1 C * i

Page 7

page-07.png

Load-Befehle: Kodierungsprinzip

Bits 31–30 29–28 27–26 25–24 23–0
0 1 M * D i
  • M – Modus
  • * – irrelevant; bei LOAD kein Source Register
  • D – Destination Register
  • i – Immediate Parameter (24 Bits / 3 Bytes) Konstante im Befehl

Synonym: "Befehl" und "Instruktion"

Page 8

page-08.png

Load-Befehle: Kodierung

Typ Modus Befehl Wirkung
0 1 0 0 LOAD D i ;
0 1 0 1 LOADIN1 D i ;
0 1 1 0 LOADIN2 D i ;
0 1 1 1 LOADI D i ;

Ausnahme: Wenn dann fällt "" weg!

Page 9

page-09.png

Store-Befehle Kodierungsprinzip

Bits 31–30 29–28 27–26 25–24 23–0
1 0 M S D i
  • M – Modus
  • S – Source Register (nur bei MOVE)
  • D – Destination Register (nur bei MOVE)
  • i – Immediate absolute Addresse oder Indexregister Offset

Page 10

page-10.png

Store-Befehle Kodierung

Typ Modus Befehl Wirkung
1 0 0 0 STORE i ;
1 0 0 1 STOREIN1 i ;
1 0 1 0 STOREIN2 i ;
1 0 1 1 MOVE S D ;

Ausnahme: Wenn dann fällt "" weg!

Page 11

page-11.png

Compute-Befehle: Prinzip

Bits 31–30 29 28–26 25–24 23–0
0 0 MI F D i
  • MI – "Compute Memory" / "Compute Immediate"
  • F – Funktion (braucht Platz von M und S)
  • kein explizites Source Register bzw. Annahme
  • D – Destination Register
  • i – Immediate Parameter

Page 12

page-12.png

Compute-Befehle Kodierung

Immediate-Befehle (MI = 0):

Typ MI F Befehl Wirkung
0 0 0 010 SUBI D i ;
0 0 0 011 ADDI D i ;
0 0 0 100 OPLUSI D i ;
0 0 0 101 ORI D i ;
0 0 0 110 ANDI D i ;

Memory-Befehle (MI = 1):

Typ MI F Befehl Wirkung
0 0 1 010 SUB D i ;
0 0 1 011 ADD D i ;
0 0 1 100 OPLUS D i ;
0 0 1 101 OR D i ;
0 0 1 110 AND D i ;

Ausnahme: Wenn dann fällt "" weg!

Page 13

page-13.png

Bitstring-Operationen

Und-Operation:
0 0 0
0 1 0
1 0 0
1 1 1

Oder-Operation:
0 0 0
0 1 1
1 0 1
1 1 1

Exklusiv-Oder-Operation:
0 0 0
0 1 1
1 0 1
1 1 0

Beispiel OPLUS:

gives

thus

Page 14

page-14.png

Sprungbefehle: Prinzip

Bits 31–30 29–27 26–24 23–0
1 1 C * i
  • C – Condition
Bedingung
000 nie
001
010
011
100
101
110
111 immer

Page 15

page-15.png

Bedingungskodierung nach Schema

Bedingung
000 nie
001
010
011
100
101
110
111 immer
  • nur "" wird abgefragt
  • nur "" wird abgefragt
  • nur "" wird abgefragt

Andere Abfragen durch Kombinationen wie zum Beispiel ist "" oder "" also ""

Page 16

page-16.png

Sprungbefehle: Kodierung

Typ Befehl Wirkung
1 1 JUMP i

Unbedingte Sprünge werden durch ausgedrückt.
Bei hat der Befehl keine Auswirkung außer Inkrementieren des Befehlszählers ⇒ NOP-Befehl (No Operation).

Page 17

page-17.png

Zusätzliche Befehle

Zusätzliche Befehle sind durchaus sinnvoll und bei anderen Architekturen evtl. schon als Grundbefehl vorhanden.
Nicht vorhandene Befehle müssen hier durch Befehlsfolgen "simuliert" werden.
Beispiel: Multiplikation, vgl. Kapitel 1.

Page 18

page-18.png

Zusammenfassung

Zusammenfassung des Befehlssatzes der ReTI auf der nächsten Folie ...

Page 19

page-19.png

Load-Befehle – :

Befehl Wirkung
0100 LOAD D i ; falls
0101 LOADIN1 D i
0110 LOADIN2 D i
0111 LOADI D i

Store-Befehle – MOVE: :

Befehl Wirkung
1000 STORE i ;
1001 STOREIN1 i
1010 STOREIN2 i
1011 MOVE S D ; falls

Compute-Befehle – :

Befehl Wirkung
000010 SUBI D i ; falls
000011 ADDI D i
000100 OPLUSI D i
000101 ORI D i
000110 ANDI D i
001010 SUB D i ; falls
001011 ADD D i
001100 OPLUS D i
001101 OR D i
001110 AND D i

Jump-Befehle:

Befehl Wirkung
11000 NOP
11001 JUMP>i
11010 JUMP=i
11011 JUMP≥i
11100 JUMP<i
11101 JUMP≠i
11110 JUMP≤i
11111 JUMP i

Kodierung S, D:

S, D Register
0 0 PC
0 1 IN1
1 0 IN2
1 1 ACC

Hinweis zu den LOAD- und Compute-Befehlen (hier in verallgemeinerter Form): Zielregister steht in .

Page 20

page-20.png

Ein ReTI-Programm sieht folgendermaßen aus:

P = 0111 0011 0000 0000 0000 0000 0000 0001  73000001
    1100 0000 0000 0000 0000 0000 0000 0000  c0000000
    0000 1111 0000 0000 0000 0000 0000 0001  0f000001
    1000 0000 0000 0000 0000 0000 0000 0011  80000003

Frage: Welche der Aussagen über das Programm sind wahr?
a. Der PC ist nach Ausführung des Programms um 3 erhöht.
b. Das Programm besteht aus LOADI, NOP, ADDI, STORE.
c. Nach Ausführung steht in Speicherzelle 3 eine 2.
d. Das Programm verwendet alle Register.

Page 21

page-21.png

Assembler, Disassembler, Emulator für ReTI

Tool Beschreibung
asreti Assembler (ReTI Assembler nach ReTI Code)
decbin dekodiert Binary (Code/Data) nach Hexadecimal
disreti Disassembler (ReTI Code to ReTI assembler)
emreti Emulator führt ReTI Code aus
enchex Kodiert Hexadecimal Data nach Binary
ranreti Generiert zufälliges ReTI Assembler Program

Source Code: https://github.com/arminbiere/reticode

Clonen mit git@github.com:arminbiere/reticode.git
Kompilieren mit ./configure && make
Linux/Unix: d.h. zum Beispiel auf Ubuntu problemlos.
Windows Subsystem for Linux (WSL) also Ubuntu App.
MacOS wird auch unterstützt.

Page 22

page-22.png

tutorial.reti:

LOADI IN2 42
MOVE IN2 ACC
STOREIN2 6
JUMP 0

Disassembler-Output:

$ ./asreti tutorial.reti | ./decbin | ./enchex | ./disreti
LOADI IN2 42
; 00000000 7200002a
MOVE IN2 ACC
; 00000001 bb000000
STOREIN2 6
; 00000002 a0000006
JUMP 0
; 00000003 f8000000

Emulator-Output:

$ ./asreti tutorial.reti | ./emreti -s
STEPS PC CODE IN1 IN2 ACC INSTRUCTION ACTION
1 00000000 7200002a 00000000 00000000 00000000 LOADI IN2 42 IN2 = 0x2a
2 00000001 bb000000 00000000 0000002a 00000000 MOVE IN2 ACC ACC = IN2 = 0x2a
3 00000002 a0000006 00000000 0000002a 0000002a STOREIN2 6 M(0x30) = 0x2a
4 00000003 f8000000 00000000 0000002a 0000002a JUMP 0 PC = PC + [0x0] = 3 + 0 = 3
00000003 f8000000 00000000 0000002a 0000002a <infinite-loop>

Memory-Dump:

ADDRESS DATA BYTES ASCII UNSIGNED SIGNED
00000030 0000002a 2a 00 00 00 *... 42 42

ranreti-Beispiel:

$ ./ranreti 42 10
; ranreti 42 10
STOREIN1 7834349
; 00000000 91778aed
AND IN1 0xb7f8a5
; 00000001 39b7f8a5
LOADIN2 IN1 11519397
; 00000002 69afc5a5
STOREIN2 6407231
; 00000003 a161c43f
STOREIN2 1977004
; 00000004 ae1e2aac
LOADI IN1 5603196
; 00000005 79557f7c