Kleiner Wettbewerb zum virtuellen Prozessor

Im IT-Handbuch für Fachinformatiker wird in Kapitel 2, „Mathematische und technische Grundlagen“, ein virtueller Prozessor beschrieben, der die Arbeitsweise eines Computers verdeutlicht. In der Flash-Simulation könnt ihr den Prozessor ausprobieren. Die detaillierte Beschreibung gibt es hier im Open Book.

Wer bis zum 07.02.2012 ein lauffähiges Programm mitsamt Kurzbeschreibung in den Kommentaren zu diesem Beitrag postet, nimmt an einer Verlosung von zwei Exemplaren des IT-Handbuchs teil. Wenn ihr das Buch bereits habt, könnt ihr wahlweise auch mein neues Buch Apache 2.4 bekommen.

Wichtig: Bei Copy&Paste in den Simulator bitte den Zeilenumbruch nach der letzten Zeile entfernen, sonst erscheint eine Fehlermeldung. Der Bug wird in der nächsten Version gefixt.

Über Sascha Kersken

Ich habe seit 1983 Computer-Erfahrung und hatte das Glück, mein Hobby nach dem Abitur und einigen Umwegen zum Beruf zu machen. Ich arbeite bei der dimensional GmbH in Köln als Senior Developer, unter anderem mit PHP und Java. Seit 1996 bin ich zusätzlich als freiberuflicher Dozent in den Bereichen Administration, Programmierung und Webentwicklung mit Schwerpunkt LAMP tätig, außerdem als Fachbuchautor und -übersetzer. Eine andere meiner großen Leidenschaften ist die Belletristik; 2016 erschien im Self-Publishing mein erster Roman "Göttersommer", der Teil 1 einer Trilogie ist.
Dieser Beitrag wurde unter Books, Deutsch, Programming veröffentlicht. Setze ein Lesezeichen auf den Permalink.

17 Kommentare zu Kleiner Wettbewerb zum virtuellen Prozessor

  1. Ramon Kukla sagt:

    Muesste man das Buch dazu nicht schon haben? Also so im Hinblick auf mehr Details zum Prozessor? 😉

  2. Die Beschreibung ist auf der Simulator-Seite verlinkt, da das Buch ja als kostenloses Open Book im Netz gelesen oder heruntergeladen werden kann. Aber danke für den Hinweis; ich werde den Blogpost auch noch um einen Link auf die Beschreibung ergänzen.

  3. Ramon Kukla sagt:

    Der „described“-Link geht auch ins Leere (404 – Not Found).

  4. Oha, vielen Dank! Der Link bezog sich noch auf die Vorauflage, die inzwischen gegen die aktuelle ausgetauscht wurde. Dabei wurde ein neues URL-Schema eingeführt. Auch dieser Link ist jetzt gefixt.

  5. Ramon Kukla sagt:

    Also… Koennen die Register einfach ueber die GUI vor Programablauf gesetzt werden, oder soll das nur ueber den Code geschehen?

  6. Bisher leider nur über Code; eine GUI-Editiermöglichkeit für Register, Speicher und Stack ist fürs nächste Update eingeplant (zurzeit bei mir lokal im Test; ich hoffe, dass es in den nächsten Tagen live geht).

  7. Steffen sagt:

    Hi, super Aufgabe 😉
    Mir ist nur kein größeres Programm eingefallen 🙁
    Reicht diese Fakultätsfunktion bereits? :

    MOV A 5 ; Falultät von 5 (hier austauschen)
    MOV B 1 ; B initialisieren mit 1
    LBL fak ; Fakultäts Sprungmarke
    CMP A 1 : Schauen ob er schon fertig ist mit der Berechnung
    JA runfak; Wenn nicht berechne weiter
    HLT ; Programm beenden (Ergebnis liegt in B)
    LBL runfak; Berechnung
    MUL B A ; Multiplikation von A und B
    DEC A ; A —
    JMP fak ; Fuehre die rekursion weiter

    hoffentlich klappts ! Ich wäre am Apache Buch sehr interessiert 🙂

    Danke und Gruß
    Steffen

  8. Flo sagt:

    Mist, ähnlicher Gedanke wie Steffen.
    Folgender Algorithmus berechnet den Binomialkoeffizient (n über k):

    MOV A 19 ; Laden des Werts für n (im Beispiel 19)
    MOV B 8 ; Laden des Werts für k (im Beispiel 8)
    CMP A B ; A und B vergleichen,
    JBE ende ; falls A kleiner ist ans Ende springe
    MOV $1 A ; A in $1 speichern
    SUB $1 B ; B von $1 abziehen
    CMP $1 B ; Vergleichen von $1 und B
    JAE b_kleiner ; Wenn B kleiner ist, kann der Schritt übersprungen werden
    MOV B $1 ; Falls nicht, speichere den kleineren Wert ($1) in B *
    LBL b_kleiner
    MOV $0 A ; Dann A und B in in $0 und $1 speichern
    MOV $1 B
    LBL iteration
    DEC A ; In jedem Durchgang die Werte in A und B dekrementieren
    DEC B
    MUL $0 A ; und mit $0 und $1 multiplizieren
    MUL $1 B
    CMP B 1 ; wenn B == 1 ist, ist das Spiel (fast) zu Ende
    JA iteration
    DIV $0 $1 ; Die Werte werden noch dividiert und anschließend steht in $0 das Ergebnis
    MOV $1 0 ; $1 wird noch aufgeräumt
    LBL ende

    *Grund: (n über k) ist identisch zu (n über n-k) und hier fällt die Wahl auf den kürzeren Weg

    Lustiges Spielzeug, der virtuelle Prozessor 🙂

    Schönen Gruß und danke für die nette Idee,
    Flo

  9. Hallo Flo, hallo Steffen,

    vielen Dank für die beiden Einsendungen schon mal :). Die Programme laufen fehlerfrei durch, machen den beschriebenen Job und sind auch noch ausführlich kommentiert. Großartig :). Ich drücke euch schon mal den Daumen fürs Gewinnen (und freue mich natürlich trotzdem auf weitere spannende Einsendungen ;)).

  10. Ramon Kukla sagt:

    Hier mein Beitrach 🙂 Ich dachte erst an die Tuerme von Hanoi, das war mir dann aber doch zu aufwaendig. Also habe ich was gemacht mit dem man die (rechnerische) Dauer einer Dateiuebertragung berechnen kann. Der Code sollte erklaerend sein. Fuer mich, als jemand der es auch schoen mag, war es eine Herausforderung, da ich viele Dinge nicht so schoen umsetzen konnte. In erster Linie geht es da um die Eingabevalidierung. Aber naja 😉 Wenn ich das Glueck habe wuerde ich super gerne das Apache-Buch nehmen. Das wuerde mir sehr gelegen kommen.

    MOV $0, 2 ; Bandbreite in MBit/s eintragen
    MOV $1, 10 ; Groesse der Datei in X eintragen
    MOV $2, 1 ; X, Masseinheit, fuer Datei (0 = Kilobyte, 1 = Megabyte, 2 = Gigabyte) eintragen
    MOV $3, 0 ; Resultat
    MOV $11, 8192 ; Ein Kilobyte in Bit
    MOV $12, 8388608 ; Ein Megabyte in Bit
    MOV $13, 8589934592 ; Ein Gigabyte in Bit
    CMP $2, 1; Masseinheit mit 1 vergleichen
    JA giga ; wenn groesser 1, dann Giga
    JE mega ; wenn gleich 1, dann Mega. Sonst Kilo (optimaler Fall)
    MUL $1, $11 ; Rechne Datenmenge (Kilo) nach Bit um
    JMP calc
    LBL giga
    MUL $1, $13 ; Rechne Datenmenge (Giga) nach Bit um
    JMP calc
    LBL mega
    MUL $1, $12 ; Rechne Datenmenge (Mega) nach Bit um
    JMP calc
    LBL calc
    MUL $0, 1024000 ; Rechne Bandbreite in Bit um
    DIV $1, $0 ; Berechne Uebertragunszeit (Menge durch Geschwindigkeit)
    PUSH $1 ; Resultat (in Sekunden) auf den Stack legen

  11. Hallo Ramon,

    auch ein schönes Programm, das ein praktisches Problem löst :).

  12. Ramon Kukla sagt:

    Naja, das Problem, dass eventuell zu wenig Bandbreite zur Verfuegung steht, bleibt ja 🙂 Ich kann mir das jetzt nur bestaetigen lassen 😉

  13. Andy Wenk sagt:

    Hey,

    für’s erst Mal rumprobieren hats Spass gemacht. Weil ich gerade dieses herrliche Video über Natur und Algorithmen gesehen habe (http://vimeo.com/9953368), hier ein ein simples Programm um die Fibonacci Reihe zu berechnen:

    MOV A 0 ;initial Wer for Register A
    MOV B 1 ; initial Wer for Register B
    PUSH A ; zeige A (0)
    LBL fib ; setze Sprungmarke
    ADD A B ; addiere A und B (0 + 1, 1 +1, 1 + 2, 2 + 3 …)
    PUSH A ; zeige A (1, 2, 3, 5, 8, 13 …)
    MOV $0 A ; Wert von Register A, in welchem die Berechnung aus A + B steht, merken
    MOV A B ; Wert von B nach A schieben
    MOV B $0 ; das Ergebnis aus der Berechnung A + B, welches in $0 steht, nach B schreiben
    CMP B 100 ; Abbruchbedingung der Schleife
    JAE end ; wenn der vergleich false ergibt, sprich wenn B > 100 ist, zu Sprungmarke end springen
    JMP fib ; ansonsten wieder zu Sprungmarke fib und weiter rechnen
    LBL end ; setze Sprungmarke end
    HLT ; Programm beenden

    Das Programm von Ramon ist aber schon spannender 😉

    Cheers

    Andy

  14. Marco Rausch sagt:

    Hallo Sascha und liebe Leser,

    danke für den VProcessor! Durch den VProcessor habe ich zum ersten Mal die Maschinensprache richtig verstanden, und das auf spielerische Art.

    Für den Wettbewerb habe ich mir eine Abbildung der Modulo-Operation für ganze positive Zahlen überlegt.

    Grüße,
    Marco

    —————————————-

    MOV $0 15; Laden des 1. Operanden
    MOV $1 7; Laden des 2. Operanden
    MOV $2 -1; Ergebnis mit Vorbelegung
    CMP $0 $1; Vergleich beider Operanden
    JB below; Bedingte Sprunganweisung below
    JE equal; Bedingte Sprunganweisung equal
    JA above; Bedingte Sprunganweisung above
    LBL below; Falls 1. Op kleiner als 2. Op
    MOV $2 $0; Divisonsrest immer gleich dem 1. Operand
    HLT; Programm beenden
    LBL equal; Falls 1. Op gleich 2. Op
    MOV $2 0; Divisonsrest immer gleich 0
    HLT; Programm beenden
    LBL above; Falls 1. Op groesser als 2. Op
    MOV a $0; 1. Op in Register A schreiben
    MOV b $1; 2. Op in Register B schreiben
    LBL loop; Sprungmarke für Berechnungsschleife
    SUB a b; Subtraktion des 2. Op vom 1. Op
    CMP a 0; Vergleich der Differenz mit 0
    JA above1; Bedingte Sprunganweisung above1
    JB below1; Bedingte Sprunganweisung below1
    LBL above1; Falls Zwischenergebnis groesser 0
    PUSH a; Schiebe Zwischenergebnis auf Stack
    JMP loop; Führe Differenzbildung erneut durch
    LBL below1; Falls Zwischenergebnis kleiner 0
    POP $2; Schreibe Divisonsrest vom Stack in Ergebnis
    HLT; Programm beenden

  15. So, damit ist der Wettbewerb abgeschlossen! Vielen Dank für die fünf wirklich sehr schönen Einsendungen. Habe soeben die Glücksfee gebeten, die Gewinner zu ziehen — gewonnen haben Flo und Ramon, und sie wurden bereits per E-Mail benachrichtigt.

  16. Ramon Kukla sagt:

    Sehr cool. Ich freue mich! Danke 😉

Schreibe einen Kommentar