Updates

• 9. Februar 2022

Ich habe in meinem diesjährigen Urlaub ein Projekt umgesetzt, das ich eigentlich anders geplant hatte - ich wollte meine eigene CPU from scratch bauen...

Ich habe bereits früher Links zu einem Thema gesammelt, das mich schon viele Jahre interessiert und beschäftigt hat: Aus einfachen TTL-Schaltkreisen eine eigene CPU bauen zu können und darauf aufbauend dann einen simplen Computer zu konstruieren. Im Internet gibt es dazu unzählige Anleitungen, von denen ich einige unten in einer Linksammlung zusammengefasst habe.

Ich habe auch damit geliebäugelt, diese Bauanleitungen konkret umzusetzen. Da ich mich ebenfalls seit iniger Zeit für FPGAs interessiere, kam mir die Idee, diese Eigenbau-CPU nicht in TTL-Schaltkreisen zu realisieren, sondern innerhalb eines FPGA.

Da die diversen FPGA-Entwickler- und -Schnupper-Boards aber auch heute noch einen - für mich - zu hohen Anschaffungswiderstand aufweisen, habe ich mit mir selbst folgendes Abkommen abgeschlossen: sobald das erste Assemblerprogramm auf einer simulierten Eigenbau-CPU erfolgreich und korrekt läuft, darf ich darüber nachdenken, ein solches Entwickler-Board anzuschaffen. Nun habe ich bereits einige Male begonnen, einen solchen Simulator zu erstellen, bin aber jedesmal wieder bereits über der ALU abgestorben.

Bereits deren Umsetzung war so komplex, dass ich irgendwann die Lust verloren habe - schließlich mache ich das in meiner Freizeit und ich muss dabei das Gefühl haben, dass es mir Spaß macht...

Dieses Mal habe ich wieder begonnen wie immer: Ich habe zunächst das Internet durchforstet, um herauszufinden, ob es zu diesem Thema neue Literatur oder Projekte gibt. Dabei stolperte ich über einen Artikel, bei dem ich neue Hoffnung fasste, was die Eigenbau-Idee anging:

Hier wird ein RISC-CPU beschrieben, die wirklich die einfachste mögliche darstellt: Sie verfügt über genau eine Operation, die in wenigen Teilschritten beschrieben ist:

1. Lese Adresse, auf die PC zeigt nach temp ein
2. Lese Adresse, auf die temp zeigt nach operand ein
3. erhöhe PC um 1
4. Lese Adresse, auf die PC zeigt nach temp ein
5. erhöhe PC um 1
6. schreibe operand nach Adresse in temp

Zwei Kunstgriffe, um daraus eine vollwertige turing-vollständige CPU zu bauen werden in dem Original-Artikel noch benannt: Es wird eine einfache Arithmetik-Logik-Einheit an einer bestimmten Adresse im Arbeitsspeicher eingeblendet, so dass ein Schreiben an (oder Lesen aus) eine der ALU-Adressen bestimmte Rechenoperationen auslöst. Weiterhin ist der Programmzähler keine extra Baugruppe, sondern wird an einer bestimmten Adresse im Arbeitsspeicher gehalten. Dadurch ist es Code, der auf dieser CPU ausgeführt wird möglich, diese spezielle Speicherstelle zu überschreiben und man kann somit Sprünge und Verzweigungen im Code realisieren.

Wer das Original-Dokument mit den oben angegebenen Teilschritten vergleicht, wird feststellen, dass meine Implementierung vom Original abweicht. Ich habe an mehreren Stellen des Originaldokument Ungvenauigkeiten und Fehler gefunden, die erst bei der praktischen Simulation zu Tage treten. Ein weiteres Problem neben dem Zeitpunkt der Erhöhung des Programmzählers ist die Beschreibung des bedingten Verzweigungen im Original-Dokument: Meine Simulation zeigte, dass das beschriebene Prinzip zwar korrekt ist, allerdings noch ein Offset berücksichtigt werden muss, damit es tatsächlich in der Praxis funktioniert.

Ich habe sehr schnell gemerkt, dass das Schreiben von Programmen - auch von sehr kleinen - mit reinem Maschinen-Code extrem mühselig ist und - wäre ich dabei geblieben - auf gar keinen Fall zu schnellen Resultaten geführt hätte. Vielleicht hätte der damit verbundene Frust eventuell sogar dazu geführt, dass ich auch dieses Projekt wieder frühzeitig aufgegeben hätte.

Allerdings wurde im Original-Dokument auch auf einen Makro-fähigen Assembler verwiesen, was mich an meine schönen ersten Programmierversuche auf dem KC 85/4 mit dem Modul M027 erinnert hat. Und so fasste ich den Entschluss, für meine CPU einen eigenen Makro-fähigen Assembler zu schreiben.

Damit war es mir möglich, entsprechende Makros zu schreiben, die mir erlaubten, über die im Original-Dokument besprochenen und angedeuteten Möglichkeiten und Fähigkeiten dieser Architektur hinauszugehen: Der Simulator wurde um die angesprochenen Probleme bereinigt und der Assembler beherrscht Makros, die die Implementierung eines Stacks ermöglichen, so dass auch Unterprogrammaufrufe in Assemblercode möglich sind.

Ich habe den bisherigen Stand in einem Projekt auf GitLab veröffentlicht: In dem Projekt sind sowohl der Simulator als auch der Assembler enthalten.

Aktualisierung vom 9. Februar 2022

Links

Artikel, die hierher verlinken

Kommentar hinzufügen (via ) Kommentare ansehen (via )

Kommentar hinzufügen (via ) Kommentare ansehen (via )