============================= Befehlsformat und Befehlssatz ============================= ---- VIDEO ------------------------------ https://www.youtube.com/embed/IX8cKhKqmGs ----------------------------------------- Befehlsformat ============= Ein Befehl für die Mini-ALU besteht aus 8 Bits. Und haben die Struktur ---- TIKZ ---------------------------- \begin{tikzpicture} \input{memory.tex} \DrawMemArray{0}{3} \DrawMemCellContent{0}{Op} \DrawMemCellContent{1}{X} \DrawMemCellContent{2}{Y} \DrawMemCellContent{3}{Z} \end{tikzpicture} -------------------------------------- Dabei bezeichnen Op, X, Y, Z jeweils zwei Bits eines Befehls von Links nach Rechts. Bei `10011011` gilt beispielsweise ---- TIKZ ---------------------------- \begin{tikzpicture} \input{memory.tex} \DrawMemArray{0}{3} \DrawMemCellContent{0}{10} \DrawMemCellContent{1}{01} \DrawMemCellContent{2}{10} \DrawMemCellContent{3}{11} \end{tikzpicture} -------------------------------------- also Op=`10`, X=`01`, Y=`10` und Z=`11`. Damit wir das bei einem Bitmuster einfacher ablesen können, schreiben wir es in Zweiergruppen auf. Also hier zum Beispiel als `10 01 10 11`. Opcode und Operanden -------------------- Das mit Op bezeichnet Bitmuster ist der sogenannte _Opcode_. Damit wird der Befehlstyp festgelegt. Die anderen Bitmuster in X, Y und Z werden beim Befehl als Argumente bzw. Operanden verwendet. Mit dem Opcode `10` wird beispielsweise das Register X mit dem Register Y addiert und das Ergebnis in Register Z geschrieben. Befehlssatz =========== Im Befehlssatz wird beschrieben, welche Opcodes verwendet werden können und welcher Befehl damit ausgeführt wird. Bei der Mini-ALU werden alle möglichen Werte als Opcode als Befehl unterstützt (es gibt also 4 Befehlsarten): ---- LATEX --------------------------------------------------------------------- \begin{array}{ll} \text{Op} & \text{Effekt} \\ 00 & \bigl(u(\text{%}00) + u(\text{XY})\bigr) \bmod 2^8 \to u(\text{%}Z) \\ 01 & \bigl(u(\text{%}Z)\cdot 2^4 + u(\text{XY})\bigr) \bmod 2^8 \to u(\text{%}Z) \\ 10 & \bigl(u(\text{%}Y) + u(\text{%}X)\bigr) \bmod 2^8 \to u(\text{%}Z) \\ 11 & \bigl(u(\text{%}Y) - u(\text{%}X)\bigr) \bmod 2^8 \to u(\text{%}Z) \\ \end{array} -------------------------------------------------------------------------------- Ein Beispiel "Programm" zum Mitmachen ===================================== Auf der ersten Seite dieser Session habe ich geschrieben, dass man $1+2$ mit `000001010000101010011011` berechnen kann. Was ist damit nun gemeint? Diese Folge von Einsen und Nullen besteht aus 3 Befehlen, die wir so aufschreiben (und dann in der Reihenfolge) eingeben können: ---- CODE (type=txt) ----------------- 00 00 01 01 00 00 10 10 10 01 10 11 -------------------------------------- Die gehen wir jetzt der Reihe nach durch: - Beim Befehl `00 00 01 01` gilt Op=`00`, X=`00`, Y=`01` und Z=`01`. Im Befehlssatz kann man jetzt nachschauen was beim Befehl mit Opcode `00` ausgeführt wird. Bei der Beschreibung ersetzten wir mit der Methode "Suchen und Ersetzen" die Platzhalter X, Y und Z und erhalten ---- LATEX ----------------------------------------------------------- \bigl(u(\text{%}00) + u(\text{0001})\bigr) \bmod 2^8 \to u(\text{%}01) ---------------------------------------------------------------------- Beachtet, dass hier XY mit dem aus X und Y zusammengesetzten Muster ersetzt wurde. Also wird dieser Befehl folgendes ausführen: ---- LATEX ----------------------------------------------------------- 1 \to u(\text{%}01) ---------------------------------------------------------------------- Dabei habe ich die linke Seite vereinfacht: `%00` ist das Zero-Register also ist immer $u(\text{%}00) = 0$ und laut Definition ist $u(\text{0001})=1$. Dann kann man auch $(0 + 1) \bmod 2^8 = 1$ schreiben. Damit nach der Operation die Gleichung gilt muss in `%01` das Bitmuster `00 00 00 01` geschrieben werden. - Beim Befehl `00 00 10 10` wird (versucht das analog nachzuvollziehen) das Bitmuster `00 00 00 10` in `%10` geschrieben. - Beim Befehl `10 01 10 11` wird die Operation ---- LATEX ------------------------------------------------------------------- \bigl(u(\text{%}10) + u(\text{%}01)\bigr) \bmod 2^8 \to u(\text{%}11) ------------------------------------------------------------------------------ also Register 2 mit Register 1 addiert und das Ergebnis in Register 3 geschrieben. Aufgaben ======== Ich kämpfe noch damit die Aufgaben in Moodle als Test einzuarbeiten. Wer jetzt schon anfängt sollte sich das also mit Papier und Bleistift notieren.. - Was passiert beim Befehl `01 11 11 01`? - Wie kann man in Register 1 das Bitmuster `11 11 11 11` laden. - Wie kann man $255 - 4$ berechnen, so dass das Ergebnis in Register 3 steht? - Beschreibe den Inhalt der Register und der Status Flags nach dem folgends Programm ausgeführt wurde: ---- CODE (type=txt) ----------------- 00 10 00 01 00 00 01 10 11 10 01 11 -------------------------------------- Und außerdem: - Welche Rechnung wurde im letzten Befehl ausgeführt, wenn man die Bitmuster als Unsigned-Integer interpretiert? - Welche Rechnung wurde im letzten Befehl ausgeführt, wenn man die Bitmuster als Signed-Integer interpretiert? - Beschreibe den Inhalt der Register und der Status Flags nach dem folgends Programm ausgeführt wurde: ---- CODE (type=txt) ----------------- 00 10 00 01 00 00 01 10 11 10 01 00 -------------------------------------- - Wie kann man den Inhalt von Register 1 in das Register 2 kopieren? Ausblick: Mini-ULM ================== In der nächsten Session werden wir damit beginnen, die ULM zu programmieren. Genauer gesagt, die __Mini-ULM__, die einen kleineren Befehlssatz als die ULM hat (und auch weniger Speicher und Register). Aber die Funktionsweise ist im Prinzip die Gleiche. Aber das wichtigste: Das Format das bei den Befehlen verwendet wird ist analog zu den Befehlen hier! :links: Mini-ULM -> http://www.mathematik.uni-ulm.de/numerik/hpc/ss20/mathsoft/mini-ulm.html