Klausur-Fragestunde 30.1.2025

20250130/rtech-20250130.txt

@@ -180,3 +180,172 @@ Aufgabe 1:
             `-----'    `-----'
                |          |
                D          E
+
+
+Aufgabe 3: 16-Bit-Rechenwerk
+
+(a) 1025 - 2
+
+Umrechnen nach Binär:
+  1025 = 0000 0100 0000 0001
+     2 = 0000 0000 0000 0010
+
+2er-Komplement von 2:
+
+Umklappen: 1111 1111 1111 1101
+      + 1: 1111 1111 1111 1110
+
+Addieren:
+
+        0000 0100 0000 0001
+      + 1111 1111 1111 1110
+        1111-1-------------
+      1 0000 0011 1111 1111
+      ^
+   paßt nicht ins 16-Bit-Rechenwerk --> fällt weg. Überlauf.
+
+Ergebnis: 0000 0011 1111 1111 = 1023
+
+(b) 4 · 8193
+
+Umrechnen nach Binär:
+
+   4 = 0000 0000 0000 0100
+8193 = 0010 0000 0000 0001
+
+Variante 1: 4mal addieren
+
+       0010 0000 0000 0001
+     + 0010 0000 0000 0001
+       -1---------------1-
+       0100 0000 0000 0010
+     + 0010 0000 0000 0001
+       -------------------
+       0110 0000 0000 0011
+     + 0010 0000 0000 0001
+       11--------------11-
+       1000 0000 0000 0100   <-- negative Zahl, weil vorzeichenbehaftetes 16-Bit-Rechenwerk,
+       ^                         oberstes Bit = 1
+
+Problem: Das Ergebnis ist für ein vorzeichenbehaftetes 16-Bit-Rechenwerk zu groß.
+
+--> Zweierkomplement
+
+Umklappen: 0111 1111 1111 1011
+      + 1: 0000 0000 0000 0001
+           ----------------11-
+           0111 1111 1111 1100
+
+Nach Dezimal umrechnen (mit bc):
+
+ibase=2
+0111111111111100
+32764
+
+Ergebnis: -32764
+
+Probe: 4 * 8193 - 65536 = -32764. Stimmt.
+
+(Auf einem vorzeichenlosen 16-Bit-Rechenwerk wäre das Ergebnis: 4 * 8193 = 32772.)
+
+Aufgabe 4
+
+Bj=C3=83=C2=B6rn M=C3=83=C2=BC=C3=83=C2=9Fig
+Ole-R=C3=83=C2=B8mer-Stra=C3=83=C2=9Fe 42
+12345 Beispielhausen
+
+Vermutlich ist "=C3=83=C2=B6" ein "ö" (für "Björn")
+und "=C3=83=C2=9F" ein "ß" (für "Straße")
+
+Vermutung: UTF-8 ist im Spiel.
+
+"ö" in UTF-8:
+
+  echo -n "ö" | hexdump -C
+  00000000  c3 b6                                             |..|
+  00000002
+
+"ß" in UTF-8:
+
+  echo -n "ß" | hexdump -C
+  00000000  c3 9f                                             |..|
+  00000002
+
+Vermutung: UTF-8 wurde nochmals UTF-8-kodiert.
+
+"ö" --> c3 b6 --> interpretieren als Latin-1 (= ISO 8859-1), nochmals nach UTF-8 kodieren
+                  (Alternative: Latin-9 = ISO 8859-15 --> dasselbe Ergebnis)
+
+  echo -n "ö" | recode latin1..utf8 | hexdump -C
+  00000000  c3 83 c2 b6                                       |....|
+  00000004
+
+  echo -n "ß" | recode latin1..utf8 | hexdump -C
+  00000000  c3 83 c2 9f                                       |....|
+  00000004
+
+(a) UTF-8.
+
+(b) Interpretation als Latin-1, nochmals Umwandlung nach UTF-8.
+
+(c) "ö" und "ß" ersetzen:
+
+  Björn M=C3=83=C2=BCßig
+  Ole-R=C3=83=C2=B8mer-Straße 42
+  12345 Beispielhausen
+
+Rate: "ü"
+
+  echo -n "ü" | recode latin1..utf8 | hexdump -C
+  00000000  c3 83 c2 bc                                       |....|
+  00000004
+
+  Björn Müßig
+  Ole-R=C3=83=C2=B8mer-Straße 42
+  12345 Beispielhausen
+
+Letztes Problem: Wofür steht "=C3=83=C2=B8"?
+Ähnlich "ö", aber mit "B8" statt "B6".
+Wahrscheinlich: ó ò ô ø ...
+
+  echo -n "ø" | recode latin1..utf8 | hexdump -C
+  00000000  c3 83 c2 b8                                       |....|
+  00000004
+
+Lösung:
+
+  Björn Müßig
+  Ole-Rømer-Straße 42
+  12345 Beispielhausen
+
+Aufgabe 5:
+
+(a)
+
+  x0: ähnlich wie Knirps, aber mit Doppelsprüngen:
+      In jedem Taktzyklus kopiert das Program seinen ersten Befehl,
+      also das halbe Programm, um 2 Speicherzellen weiter.
+
+  x1: Dasselbe, aber einmal geteilt.
+      Das Programm führt den Code mit 2 Threads gleichzeitig aus.
+      Dadurch ist es nur noch halb so schnell,
+      weil jeder Thread nur die halbe Rechenzeit bekommt.
+
+  x2: Dasselbe, aber so oft geteilt, wie zulässig, hier: 64mal.
+      Das Programm führt den Code mit 64 Threads gleichzeitig aus.
+      Dadurch ist es nur noch 1/64 so schnell,
+      weil jeder Thread nur 1/64 der Rechenzeit bekommt.
+
+(b) x0 überschreibt nothing; nothing wird zu x0 --> Untentschieden. Wie bei Knirps.
+
+    x1 überschreibt nothing, aber langsamer.
+       nothing führt den dat-Befehl hinter dem "mov 0 2" aus,
+       noch bevor das - langsamere - x1 auch dort einen "mov 0 2" hinschreibt.
+
+(c) Wenn x2 von dwarf getroffen wird,
+    schreiben dahinterliegende Threads von x2 direkt wieder "mov 0 2"
+    über den von dwarf stammenden dat-Befehl. x2 repariert sich selbst.
+
+    Für x1 gilt dies im Prinzip auch,
+    aber die Wahrscheinlichkeit, daß es funktioniert, ist geringer,
+    weil x1 nur 2 Threads hat.