{"id":11150,"date":"2015-06-21T08:10:41","date_gmt":"2015-06-21T06:10:41","guid":{"rendered":"http:\/\/www.bernd-leitenberger.de\/blog\/?p=11150"},"modified":"2015-06-21T08:12:04","modified_gmt":"2015-06-21T06:12:04","slug":"mein-81624-bit-prozessor","status":"publish","type":"post","link":"https:\/\/www.bernd-leitenberger.de\/blog\/2015\/06\/21\/mein-81624-bit-prozessor\/","title":{"rendered":"Mein 8\/16\/24 Bit Prozessor"},"content":{"rendered":"<p>Heute mal eine Neuigkeit: in der Reihe &#8222;Wir wissen es besser als die Industrie&#8220; heute ein Konzept f&uuml;r einen Prozessor. Ich habe das mal angefangen f&uuml;r einen 32 Bit Risc Prozessor, aber in der Klasse habe wenig Erfahrung in Bezug auf Befehlssatz. Die habe ich in der 8 und 16 Bit Klasse und inspiriert durch die Unzul&auml;nglichkeiten der fr&uuml;hen 8 und 16 Bitter von Intel habe mich an das Design eines eigenen Prozessors gemacht. es sollte ein 8 Bitter sein,\u00a0 aber es ist ein 16\/24 Bitter geworden. Dazu sp&auml;ter mehr. Ich will den Artikel auch nutzen ein paar Dinge zu erkl&auml;ren die vielleicht den einen oder anderen interessieren.<\/p>\n<p>Der Grundgedanke war das der Befehlssatz symmetrisch sein Darunter versteht man dass die Register gleichberechtigt sind. Also z.B. jedes Ziel und Quelle einer Rechenoperation sein kann. Das war beim <a href=\"\/8080.shtml\">8080<\/a>\/Z80 nicht der Fall. Alle 8 Bit Rechenoperationen nutzten dort als einen der Operanden den Akkumulator und dort landete auch das Ergebnis. Ein solches &#8222;unsymmetrisches&#8220; Modell macht dann zahlreiche Kopieraktionen in den Registern notwendig, wenn man das Ergebnis z. B. noch braucht. Wenn man wei&szlig; wie Befehle dekodiert werden, dann ergibt sich beim symmetrischen Modell eine Problematik. Nehmen wir 16 Register bei einem unsymmetrischen Prozessor k&ouml;nnte der Opcode des Befehls ADD A,Reg z.B. so aussehen:<!--more--><\/p>\n<p>0100.RRRR<\/p>\n<p>Das Befehlswort wird eingelesen, der Prozessor stellt anhand der Maske 0100 in den obersten 4 Bit fest das es ein ADD-Befehl ist und in den unteren 4 Bits steht das Quellregister. F&uuml;r 16 Register braucht man 4 Bits (ein Nibble). Wenn der Befehlssatz symmetrisch ist s&auml;he der Befehl so aus : Add Reg1,Reg2 und man braucht 8 Bits f&uuml;r die Angabe der beiden Quellregister (wenn man die Dreiadressadressierung nimmt sogar 12 Bits). Damit braucht man zwei Byte f&uuml;r einen Befehl. 16 Register ist auch die Zahl die ich vorhergesehen habe.<\/p>\n<p>Nun haben 8 Bitter mit 64 Kbyte maximal adressierbarem Speicher keinen sehr gro&szlig;en Adressbereich. Wer wie ich seine ersten Erfahrungen mit einem 8-Bit Rechner gemacht hat wie einem C64, Armstrad oder Sincailr Spectrum. Der wei&szlig; &#8211; man kann damit einiges machen. Das geht aber nur weil viele Befehle nur ein Byte lang sind. Hier w&auml;ren sie nun zwei Byte lang und das ist schon ein gro&szlig;es Manko. der Speicher eines 8-Bit Systems sollte eher gr&ouml;&szlig;er als kleiner sein. Da kam ich auf die zweite &Auml;nderung: es gibt einen getrennten Daten- und Codebereich, ebenso zwei Adressbereiche. Das macht in meinem Fall zwar ein 64-poliges Geh&auml;use notwendig, aber es gibt einige Vorteile:<\/p>\n<ul>\n<li>Mindestens doppelt so gro&szlig;er Speicher<\/li>\n<li>Paralleler Transfer (zwei Datenbusse) erh&ouml;ht die Geschwindigkeit<\/li>\n<li>Besserer Prefetch m&ouml;glich<\/li>\n<li>Keine Hardware notwendig zum Trennen von Daten und Codezugriffen.<\/li>\n<\/ul>\n<p>In meinem Fall habe ich jeweils 16 Bit Adressen f&uuml;r Daten und Code. Als ich mich an das Aufstellen der Codes machte (siehe unten) stellte sich raus, das die meisten Befehle nun zwei oder drei Bytes lang sind, die Ein-Byte Befehle sind in der Minderheit denn sie kommen nur bei keinem Parameter vor oder nur einem Parameter. Ich habe mich f&uuml;r eine Ma&szlig;nahme entscheiden die den Prozessor kr&auml;ftig auf Trab bringt: Anstatt einzelner Bytes sind Befehle immer drei Bytes lang. Ben&ouml;tigt man nur zwei Bytes, dann enth&auml;lt das letzte Byte den NOP Befehl, das Bitmuster f&uuml;r 0. Die Befehle ohne Parameter die eigentlich in ein Byte reinpassen habe ich in zwei geschoben so sind zum einen viele Opcodes frei und zum anderen ist das Befehlsformat einheitlicher.<\/p>\n<p>Anders als bei anderen Prozessoren hat NOP\u00a0 aber nicht die Bedeutung einige Takte nichts zu tun, sondern ist ein F&uuml;llbyte das bei der Ausf&uuml;hrung ignoriert wird also keine Zeitverz&ouml;gerung generiert, dekodiert werden immer die gesamten 3 Byte. Der Vorteil wird deutlich wenn man sich ansieht, wie viele Takte bestimmte 8080 Befehle haben:<\/p>\n<table>\n<tbody>\n<tr>\n<th>Aktion<\/th>\n<th>Mnemonic 8080<\/th>\n<th>Takte 8080<\/th>\n<th>Takte Mein Prozessor<\/th>\n<\/tr>\n<tr>\n<td>Lade Register mit Register<\/td>\n<td>Mov Reg,Reg<\/td>\n<td>4<\/td>\n<td>4<\/td>\n<\/tr>\n<tr>\n<td>Lade Register mit 16 Bit Konstante<\/td>\n<td>LXI Reg<\/td>\n<td>10<\/td>\n<td>4<\/td>\n<\/tr>\n<tr>\n<td>Lade Register mit 8 Bit Inhalt der Adresse die in einem zweiten Register steht<\/td>\n<td>Mov Reg,M<\/td>\n<td>7<\/td>\n<td>nicht verf&uuml;gbar<\/td>\n<\/tr>\n<tr>\n<td>Lade Register mit 16 Bit Inhalt der Adresse die in einem zweiten Register steht<\/td>\n<td>LHLD<\/td>\n<td>16<\/td>\n<td>10<\/td>\n<\/tr>\n<tr>\n<td>Lade Adresse mit dem Inhalt des Registers<\/td>\n<td>STAX<\/td>\n<td>10<\/td>\n<td>7<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p>Diese Unterschiede kommen dadurch zustande:<\/p>\n<p>Bei einem Befehl der nur interne Register beim 8080 benutzt, gibt es folgenden Taktablauf:<\/p>\n<ul>\n<li>Lege Adresse\u00a0auf den Adressbus<\/li>\n<li>Pr&uuml;fe ob Daten auf dem Datenbus anliegen<\/li>\n<li>Lese Daten ein<\/li>\n<li>F&uuml;hre Operation aus<\/li>\n<\/ul>\n<p>Bei dem zweiten Befehl LXI muss nun nochmals die Adresse auf den Bus gelegt werden, erneut gewartet werden bis die Daten anliegen und dann kann man das erste niedrigwertige Byte holen, nach einem erneuten Anlegen der Adresse+1 wiederholt sich das Spiel. Das sind pro Lesezyklus immer 3 Takte mehr, also zehn Takte.<\/p>\n<p>Pro Lesezyklus eines Bytes oder Schreiben eines Bytes verl&auml;ngert sich die Ausf&uuml;hrung um 3 Takte. Bei meinem Prozessor ist nun aber das ganze Befehlswort schon im Prozessor, er transferiert nicht 8 Bit sondern 24 Bit &uuml;ber den Code-Datenbus. Das bedeutet beim zweiten Befehl entfallen die Zugriffe auf den Speicher. Beim Befehl LHLD braucht man einen weiteren Zugriff, diesmal auf den Code-Datenbus. Da dieser aber 16 Bit auf einmal transferiert, braucht man nur 3 weitere Takte anstatt 6.<\/p>\n<p>Das ist die erste Ma&szlig;nahme um Geschwindigkeit aufzunehmen. Die zweite ist, dass man bei dem starren Befehlsformat sehr einfach eine Pipeline implementieren kann. Zusammen mit einem kleinen Buffer von zwei Bytes f&uuml;r Daten und sechs f&uuml;r Code kann man die Geschwindigkeit deutlich erh&ouml;hen. Dier mal ein kleines Zeitdiagramm f&uuml;r den Fall eines Speicherzugriffs auf den Datenbereich (7 Takte ohne Beschleunigung)<\/p>\n<table>\n<tbody>\n<tr>\n<th>Takt<\/th>\n<th>1<\/th>\n<th>2<\/th>\n<th>3<\/th>\n<th>4: Zyklus 2 beginnt<\/th>\n<th>5<\/th>\n<th>6<\/th>\n<th>7: Zyklus 3 beginnt<\/th>\n<th>8<\/th>\n<\/tr>\n<tr>\n<td>Buseinheit Code<\/td>\n<td>Adresse auf Bus<\/td>\n<td>Warte auf Daten<\/td>\n<td>Hole Daten<\/td>\n<td>Adresse auf Bus<\/td>\n<td>Warte Auf Daten<\/td>\n<td>Hole Daten<\/td>\n<td>Adresse auf Bus<\/td>\n<td>Warte auf Daten<\/td>\n<\/tr>\n<tr>\n<td>Ausf&uuml;hrungseinheit<\/td>\n<td><\/td>\n<td><\/td>\n<td><\/td>\n<td>F&uuml;hre aus<\/td>\n<td><\/td>\n<td><\/td>\n<td>F&uuml;hre aus<\/td>\n<td><\/td>\n<\/tr>\n<tr>\n<td>Buseinheit Daten<\/td>\n<td><\/td>\n<td><\/td>\n<td><\/td>\n<td><\/td>\n<td>Adresse auf Bus<\/td>\n<td>Warte auf Daten<\/td>\n<td>Hole Daten<\/td>\n<td><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p>Der allererste Zyklus auf einer neuen Adresse (bei einer Verzweigung oder Sprung dauert immer 4 Takte, der folgende unabh&auml;ngig von der Anzahl der Speicherzugriffe immer 3 Takte. Ausnahme sind einige Befehle, die intern sehr lange brauchen. Das sind Multiplikation und Division diese profitieren von der integrierten dreistufigen Pipeline. Als man diese im 80286 einf&uuml;hrte sank die Ausf&uuml;hrungszeit der DIV\/Mul Operationen stark, denn die werden intern als Mikroprogramm ausgef&uuml;hrt und brauchen keine Speicherzugriffe au&szlig;er beim Start so von 80-168 je nach Adressierung bei 8086 auf 17-28 beim 286. Dies war der Grund warum der Norton -Sysinfo einen so hohen SI-Wert f&uuml;r IBM-AT kompatible Rechner ausgab, denn dort steckten genau diese Operationen in einer Schleife (ein IBM-AT wurde z.B. 8,8-fach schneller als ein 8088 mit 5 MHz angezeigt anstatt rund 2,5 mal wie es richtig war).<\/p>\n<p>Eine &auml;hnliche Strategie gab es auch beim 8086 der eine 6 Byte Qeue hatte und einen automatischen Fetch d.H. w&auml;hrend der Ausf&uuml;hrungszeit las der Prozessor schon mal vorrauschauend die n&auml;chsten Bytes. Gerade diese Eigenschaft bremste den 8088 stark aus, weil durch den 8-Bit-Bus der Fetch nur noch selten angewandt werden konnte.<\/p>\n<p>Kurzum: Dieser Prozessor ist deutlich schneller als andere 8-Bitter aber auch einfache 16-Bitter wie der 8086. (W&uuml;rde man synchrones DRAM unterst&uuml;tzen, so w&auml;re die Regelzeit eines Zyklus sogar nur 2 Takte und bei aufeinderfolgendem Code\/Daten sogar nur noch 1 Takt.<\/p>\n<p>Adressiert wird der Code und die Daten wortweise. Bei dem Code ist ein Wort 3 Bytes lang wobei drei denkbare F&auml;lle m&ouml;glich sind:<\/p>\n<ul>\n<li>Drei Byte Wort (enth&auml;lt Adresse oder drei Register)<\/li>\n<li>Zwei Byte Wort (die meisten Befehle) + NOP<\/li>\n<\/ul>\n<p>Drei NOP Bytes (Speicherzustand beim Reset, da der den Code 0 hat).<\/p>\n<p>Nimmt man an das normaler 8 Bit Code im Mittel zwei Byte lang ist (es gibt viele ein-Byte-Befehle aber auch zwei und drei Byte Befehle) so bietet diese L&ouml;sung 100% mehr effektiven Speicher obwohl der Codebereich 192 KByte betr&auml;gt. Man kann auch Befehle einsparen weil mehr interne Register zur Verf&uuml;gung stehen und alle mit 16 Bit rechnen.<\/p>\n<p>Als ich den Instruktionssatz aufgestellt hatte, fiel mir was auf &#8211; es gibt gar keine 8 Bit Befehle. Alle Register sind, weil sie auch Adressen aufnehmen 16 Bit breit. Die Operationen bisher also auch immer 8 Bit. Wenn ich mir die arithmetischen Operationen ansehe, so sehe ich keine echte Notwendigkeit f&uuml;r 8 Bit. Bei Rechnungen reichen sie meist nicht aus, sie sind wegen dem 16-Bit Datenbus auch nicht schneller. Es gibt noch zwei Operationen bei denen k&ouml;nnte byteweise Operationen notwendig sein. Das eine sind Ein\/Ausgabebefehle, das zweite sind Vergleiche, die braucht man z.B. bei einer Stringsuche. Daf&uuml;r gibt es mehrere L&ouml;sungen.<\/p>\n<p>Man k&ouml;nnte einen Befehl Compare Byte \/ Output \/ Input Byte einf&uuml;hren. Das zweite ist es bei Ein\/Ausgabeoperationen einfach die oberen 8 Bit nicht zu verdrahten und bei Strings hilft einfach eine Konvention: man speichert immer zwei Bytes ab, nutzt also Unicode, das ist allerdings doch sehr platzverschwendend. So w&auml;re ein Compare Byte Befehl nicht schlecht. Den Platz gibt es: im ersten Byte sind noch 164 Opcodes unbelegt, das ist so viel, dass man sogar alle arithmetischen Befehle mit 8 Bit integrieren k&ouml;nnte.<\/p>\n<p>Ansonsten habe ich mich am 8080\/Z80 Befehlssatz orientiert. Ich habe nicht alle Befehle &uuml;bernommen, nur die die ich f&uuml;r sinnvoll hielt. Anstatt dem Befehl PUSH Flags k&ouml;nnte man nat&uuml;rlich auch den EXX Befehl des Z80 nehmen. Ich bin bei dem PUSH geblieben bei so eine Interruptroutine h&ouml;here Priorit&auml;t eine nieder priore unterbrechen kann. Stackoperationen dauernd leider relativ lange. Man k&ouml;nnte auch einen 256 Wort Stack auf dem Chip nutzen. Alternativ, das weiter unten auch ein kleiner Cahce angedacht ist einen externen Speicher der f&uuml;r Cache und Stack gedacht ist.<\/p>\n<p>Weiter ging ich bei den Adressierungsoperationen. Da gibt es ja eine Menge wie ich seit dem Studium der Befehlss&auml;tze von MicroVAX, NS32032 und Z8000 wei&szlig;. Ich habe mich auf einige sinnvolle Erweiterungen der drei Basisadressierungen des 8080 entschieden:<\/p>\n<p>Allgemein gilt: Die Schreibweise Lad Reg1,Reg2 hei&szlig;t: Lade das Register1 mit dem Inhalt von Register2. Folgende Adressierungsarten gibt es:<\/p>\n<ul>\n<li>Register zu Register: Ld Reg,Reg &#8211; Kopieraktionen in Registern. In meinem Prozessor weil alle Register gleichberechtigt sind weniger oft n&ouml;tig als im 8080, da dieser oft Ergebnisse aus dem Akku in andere Register &uuml;bernehmen musste.<\/li>\n<li>Direkt: Eine konstante folgt in Byte 2+3. Das kann eine konstante f&uuml;r eine Rechnung sein oder eine Adresse auf die man im folgenden einfach &uuml;ber das register zugreifen kann. Eine direkte Adressierung ist nur mit einer konstante als Quelle nicht als Ziel m&ouml;glich.<\/li>\n<li>Indirekt: Es gibt zwei M&ouml;glichkeiten, beide haben ein Klammerpaar als Symbol (): Indrekt aus einem Register oder indirekt aus einer Adresse.\n<ul>\n<li>Ld Reg1,(Reg2): Lade das Register1 mit dem Wert den Du an der Adresse findest die im Register2 steht. Ist dort z.B. die Adresse 4000, dann wird das Wort aus Speicherzelle 4000 geholt.<\/li>\n<li>Ld (Adr),Reg: Speichere in der Adresse die angegeben ist den Inhalt des Registers (hier Adresse als Ziel).<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n<p>Das wars beim 8080. Der Z80 f&uuml;hrte noch die indizierte Adressierung ein. Die Variante hier gibt es auch: Mit einer Konstante die zu einem Basisregister addiert wird. Dies ist ganz n&uuml;tzlich wenn man Datenstrukturen hat bei denen Teile immer an einem bestimmten Offset beginnen. Bei einem <a href=\"\/cpm.shtml\">CP\/M<\/a> Verzeichniseintrag beginnt z.B. die FAT immer bei Offset 16. Dies ist die Instruktion Ld Reg, (Reg)+C beziehungsweise Ld (reg)+C,Reg, Die Indizierte Adressierung ist auf 12 Bits Offset beschr&auml;nkt, das sind 4096 Bytes.<\/p>\n<p>Flexibler ist die mit einem Basisregister und einem Offsetregister. Das erste bleibt konstant, das zweite wird erh&ouml;ht. Der Vorteil ein Offsetregister anstatt dem Basisregister direkt zuer hohen ist dass man bei so bei einem erneuten Durchlauf das Basisregister nicht laden muss und vor allem bei einer Kopieraktion man nur ein Offsetregister erh&ouml;hen muss. Das ist ist die Instruktion Ld reg, (reg+reg) bzw. Ld (reg+reg),reg.<\/p>\n<p>Speziell f&uuml;r Pointer braucht man die doppelte indirekte Adressierung: ld reg,((reg)). Dabei steht in Reg eine Adresse. Anstatt den Wert nun aus der Adresse zu holen wird dieser erneut als Adresse\u00a0 angesehen wo sich der Wert befindet. Zeigervariablen haben als Wert die Adresse der Variablen auf die sie zeigen.<\/p>\n<p>Verbesserungsm&ouml;glichkeiten: Sinnvoll beim Einsatz einer Pipeline ist ein kleiner Cache. Zwar kenne ich keinen 8-Bitter der einen hat, doch die TMS 9995 CPU hat einen 128 Byte Workspace auf dem Chip (die Architektur des Vorg&auml;ngers TMS 9900 war ausgelegt auf nur wenige Register in der CPU aber eines war ein verschiebbarer Zeiger auf 256 Byte im RAM die dann als Register genutzt werden konnten, da RAM nicht so schnell wurde wie man das bei TI annahm bekam der Nachfolger daher sein internes schnelles RAM spendiert). 256 Worte, das sind 768 Byte belegen bei 3 Transistoren (so bei der 8080) pro Bit rund 18432 Transistoren &#8211; das ist eine Menge gemessen an den 8200 die eine einfache<a href=\"\/z80.shtml\"> Z80 CPU<\/a> hat, doch vergleichen mut den 68000 einer MC68000 oder 134.000 eines 80286 ist es wenig. Der Vorteil ist dass man im Cache dekodierte Anweisungen speichern kann. Ohne Speicherzugriff sinkt dann die Ausf&uuml;hrungszeit auf einen Takt pro Befehl.<\/p>\n<p>So nun noch zur Titelzeile. Fr&uuml;her hat man sich sehr um Bezeichnungen herumgestritten, also wann eine CPU ein 8 Bitter oder 16 Bitter ist. Folgende Kriterien gab es:<\/p>\n<ul>\n<li>Die Breite der internen Register &#8211; die Menge an Daten die man auf einmal verarbeiten konnte<\/li>\n<li>Die Breite des Datenbusses &#8211; wie viele Bits man pro Takt einladen konnte<\/li>\n<li>Wie breit waren Adressen &#8211; gibt den adressierbaren Speicher an.<\/li>\n<\/ul>\n<p>Alle Angaben konnte man diskutieren, vor allem weil bis zur 32 Bit Generation es so war, das die Breite von Registern f&uuml;r normale Operationen nicht f&uuml;r Adressen ausreichte, sonst w&auml;re der Arbeitsspeicher zu klein gewesen. Einige Beispiele:<\/p>\n<ul>\n<li>Die I<a href=\"\/4004.shtml\">ntel 4004<\/a> hatte Operationen nur f&uuml;r 4 Bit. Der Datenbereich wurde aber &uuml;ber 8 Bit Adressiert und dann noch &uuml;ber Bankswitching 5 St&uuml;ck davon = 1280 Adressen zu je 4 Bit. Das Rom wurde &uuml;ber 12 Bit adressiert und war byteorientiert.<\/li>\n<li>Der <a href=\"\/8008.shtml\">8008<\/a> war ein 8 Bit Prozessor mit nur 8 Bit Operationen auf den Registern. Der Adressbereich war aber 14 Bit = 16 KByte<\/li>\n<li>Der <a href=\"\/8080.shtml\">8080<\/a> hatte einen 64 Kbyte Adressbereich und konnte erstmals Adressen auch in Registern berechnen, das bedeutet einige Rechenoperationen (Addition, Subtraktion, Erh&ouml;hen und erniedrigen) gingen mit 16 Bit.<\/li>\n<li>Der TMS 9900 ist hier der einzige Prozessor mit sauberen Kennzahlen: 16 Bit breite Register, 16 Bit Datenbus, 16 Bit Adressbus &#8211; leider byteorientiert h&auml;tte man Worte genommen so w&auml;ren es immer 128 kb gewesen.<\/li>\n<li>Der <a href=\"\/8086.shtml\">Intel 808<\/a>6 hat Register von 16 Bit Breite, 16 Bit Datenbus, aber 20 Bit Adressbus, Die Adressierung erfolgt durch Addition von Segmentregistern zu Basisregistern. Damit ist der Adressbus segmentiert wie beim 4004. Beim 8088 war auch der Datenbus 8 Bit breit. Beide wurden von Intel als 8\/16 Bitter bezeichnet weil sie 8- und 16-Bit Befehle ausf&uuml;hrten, das gilt aber auch f&uuml;r den 8080.<\/li>\n<li>Der MC6800 hat Register von 32 Bit Breilte, 16 Bit Datenbus und 24 Bit Adressbus. Er ist am komplexesten. Er war schon f&uuml;r eine 32 Bit Erweiterung ausgelegt, so warne die Register 32 Bit breit, ebenso konnte der Assembler 32 Bit lange Zahlen als Operanden akzeptieren. Der Adressbus war aber auf 24 Bit beschnitten. Die ALU rechnet mit nur 16 Bit- Motorola bezeichnet die CPU daher als 16\/2 Bit CPU.<\/li>\n<\/ul>\n<p>Heute k&ouml;nnte man nach demselben System eine aktuelle Intel CPU als 64\/256 Bit CPU bezeichnen mit AVX2 wird daraus eine 64\/512 Bit CPU &#8230; Meine m&uuml;sste man nach der Breite der Register, die man meistens als Kriterium nimmt als 16 Bit CPU bezeichnen. Dieses Kriterium ist auch meistens das beste, denn mit der Registerbreite stehen auch die Befehle, so haben 16 Bit CPUs eben Befehle um 16 Bit Daten zu verarbeiten und meistens noch weitergehende (Multiplikation, Division) als 8-Bitter. Die Ausnahme ist der MC68000 der weil der 68020 als Nachfolger geplant war breitere Register hat als er intern in einem Rutsch bearbeiten kann, so in etwa vergleichbar mit den 8080.<\/p>\n<p>F&uuml;r einen 16-Bitter w&auml;re der Adressbereich von 192 KByte Code und 128 KByte Daten recht klein. Das k&ouml;nnte man durch Segmentregister und einige Befehle &auml;ndern. Nur w&uuml;rde ich dann einen linearen Adressbereich anstreben, indem man z.B. die 16 Bit breiten Segmentregister als oberste 16 Bit nimmt. Zusammen mit Befehlen die Segmentregister erh&ouml;hen und erniedrigen m&uuml;sste man so auch durch &uuml;ber 64 KWorte gro&szlig;e Datenstrukturen gehen k&ouml;nnen. Die Beschr&auml;nkung auf 64 KByte pro Datenstruktur war das was ich bei der Programmierung unter DOS immer als gr&ouml;&szlig;te Einschr&auml;nkung empfand.<\/p>\n<p>Bedingt durch Pipeline, RISC Datenformat und Prefetch-Buffer m&uuml;sste mein Prozessor deutlich schneller als normale 9-Bitter aber auch 16-Bitter sein. Selbst ohne Cache hat er Features die ein 80296 noch nicht hat, in dieser Geschwindigkeitsklasse w&auml;re er dann einzuordnen.<\/p>\n<h3>Befehlssatz:<\/h3>\n<table>\n<colgroup>\n<col \/>\n<col \/>\n<col \/>\n<col \/> <\/colgroup>\n<tbody>\n<tr>\n<td><b>Befehl<\/b><\/td>\n<td><b>Byte 1<\/b><\/td>\n<td><b>Byte 2<\/b><\/td>\n<td><b>Byte 3<\/b><\/td>\n<\/tr>\n<tr>\n<td><b>Arithmetrik<\/b><\/td>\n<td><b><br \/>\n<\/b><\/td>\n<td><b><br \/>\n<\/b><\/td>\n<td><b><br \/>\n<\/b><\/td>\n<\/tr>\n<tr>\n<td>Adc Reg,(Reg)<\/td>\n<td>0000.0001<\/td>\n<td>RRRR.RRRR<\/td>\n<td><\/td>\n<\/tr>\n<tr>\n<td>Adc Reg,Reg<\/td>\n<td>0000.0010<\/td>\n<td>RRRR.RRRR<\/td>\n<td><\/td>\n<\/tr>\n<tr>\n<td>Add Reg,(Reg)<\/td>\n<td>0000.0011<\/td>\n<td>RRRR.RRRR<\/td>\n<td><\/td>\n<\/tr>\n<tr>\n<td>Add Reg,Reg<\/td>\n<td>0000.0100<\/td>\n<td>RRRR.RRRR<\/td>\n<td><\/td>\n<\/tr>\n<tr>\n<td>And Reg,(Reg)<\/td>\n<td>0000.0101<\/td>\n<td>RRRR.RRRR<\/td>\n<td><\/td>\n<\/tr>\n<tr>\n<td>And Reg,Reg<\/td>\n<td>0000.0110<\/td>\n<td>RRRR.RRRR<\/td>\n<td><\/td>\n<\/tr>\n<tr>\n<td>Sbc reg,(Reg)<\/td>\n<td>0000.0111<\/td>\n<td>RRRR.RRRR<\/td>\n<td><\/td>\n<\/tr>\n<tr>\n<td>Sbc reg,Reg<\/td>\n<td>0000.1000<\/td>\n<td>RRRR.RRRR<\/td>\n<td><\/td>\n<\/tr>\n<tr>\n<td>Sub Reg,(Reg)<\/td>\n<td>0000.1001<\/td>\n<td>RRRR.RRRR<\/td>\n<td><\/td>\n<\/tr>\n<tr>\n<td>Sub Reg,Reg<\/td>\n<td>0000.1010<\/td>\n<td>RRRR.RRRR<\/td>\n<td><\/td>\n<\/tr>\n<tr>\n<td>Xor reg,(Reg)<\/td>\n<td>0000.1011<\/td>\n<td>RRRR.RRRR<\/td>\n<td><\/td>\n<\/tr>\n<tr>\n<td>Xor reg,Reg<\/td>\n<td>0000.1100<\/td>\n<td>RRRR.RRRR<\/td>\n<td><\/td>\n<\/tr>\n<tr>\n<td>Or Reg,(Reg)<\/td>\n<td>0000.1101<\/td>\n<td>RRRR.RRRR<\/td>\n<td><\/td>\n<\/tr>\n<tr>\n<td>Or Reg,Reg<\/td>\n<td>0000.1110<\/td>\n<td>RRRR.RRRR<\/td>\n<td><\/td>\n<\/tr>\n<tr>\n<td>Cmp reg,Reg<\/td>\n<td>0000.1111<\/td>\n<td>RRRR.RRRR<\/td>\n<td><\/td>\n<\/tr>\n<tr>\n<td>Cmp reg,(Reg)<\/td>\n<td>0001.0000<\/td>\n<td>RRRR.RRRR<\/td>\n<td><\/td>\n<\/tr>\n<tr>\n<td>Idiv Reg,Reg<\/td>\n<td>0001.0001<\/td>\n<td>RRRR.RRRR<\/td>\n<td><\/td>\n<\/tr>\n<tr>\n<td>Imul Reg,reg<\/td>\n<td>0001.0010<\/td>\n<td>RRRR.RRRR<\/td>\n<td><\/td>\n<\/tr>\n<tr>\n<td>Mul Reg,reg<\/td>\n<td>0001.0011<\/td>\n<td>RRRR.RRRR<\/td>\n<td><\/td>\n<\/tr>\n<tr>\n<td>Div Reg,Reg<\/td>\n<td>0001.0100<\/td>\n<td>RRRR.RRRR<\/td>\n<td><\/td>\n<\/tr>\n<tr>\n<td><b>Un&auml;re Arithmetrik<\/b><\/td>\n<td><\/td>\n<td><\/td>\n<td><\/td>\n<\/tr>\n<tr>\n<td>Dec (reg)<\/td>\n<td>0001.0101<\/td>\n<td>RRRR.0000<\/td>\n<td><\/td>\n<\/tr>\n<tr>\n<td>Dec Reg<\/td>\n<td>0001.0101<\/td>\n<td>RRRR.0001<\/td>\n<td><\/td>\n<\/tr>\n<tr>\n<td>Inc (reg)<\/td>\n<td>0001.0101<\/td>\n<td>RRRR.0010<\/td>\n<td><\/td>\n<\/tr>\n<tr>\n<td>Inc Reg<\/td>\n<td>0001.0101<\/td>\n<td>RRRR.0011<\/td>\n<td><\/td>\n<\/tr>\n<tr>\n<td>Neg Reg<\/td>\n<td>0001.0101<\/td>\n<td>RRRR.0100<\/td>\n<td><\/td>\n<\/tr>\n<tr>\n<td>Not Reg<\/td>\n<td>0001.0101<\/td>\n<td>RRRR.0101<\/td>\n<td><\/td>\n<\/tr>\n<tr>\n<td>Rotiere Links mit Carry<\/td>\n<td>0001.0101<\/td>\n<td>RRRR.0110<\/td>\n<td><\/td>\n<\/tr>\n<tr>\n<td>Rotiere links ohne Carry<\/td>\n<td>0001.0101<\/td>\n<td>RRRR.0111<\/td>\n<td><\/td>\n<\/tr>\n<tr>\n<td>Rotiere rechts mit Carry<\/td>\n<td>0001.0101<\/td>\n<td>RRRR.1000<\/td>\n<td><\/td>\n<\/tr>\n<tr>\n<td>Rotiere rechts ohne Carry<\/td>\n<td>0001.0101<\/td>\n<td>RRRR.1001<\/td>\n<td><\/td>\n<\/tr>\n<tr>\n<td>Schiebe links mit Carry<\/td>\n<td>0001.0101<\/td>\n<td>RRRR.1010<\/td>\n<td><\/td>\n<\/tr>\n<tr>\n<td>Schiebe links ohne Carry<\/td>\n<td>0001.0101<\/td>\n<td>RRRR.1011<\/td>\n<td><\/td>\n<\/tr>\n<tr>\n<td>Schiebe rechts mit Carry<\/td>\n<td>0001.0101<\/td>\n<td>RRRR.1100<\/td>\n<td><\/td>\n<\/tr>\n<tr>\n<td>Schiebe rechts ohne Carry<\/td>\n<td>0001.0101<\/td>\n<td>RRRR.1101<\/td>\n<td><\/td>\n<\/tr>\n<tr>\n<td><b>Spr&uuml;nge<\/b><\/td>\n<td><\/td>\n<td><\/td>\n<td><\/td>\n<\/tr>\n<tr>\n<td>Jp (Reg)<\/td>\n<td>0001.0101<\/td>\n<td>RRRR.1110<\/td>\n<td><\/td>\n<\/tr>\n<tr>\n<td>Call (reg)<\/td>\n<td>0001.0101<\/td>\n<td>RRRR.1111<\/td>\n<td><\/td>\n<\/tr>\n<tr>\n<td>Call Cond<\/td>\n<td>0001.0110<\/td>\n<td>AAAA.AAAA<\/td>\n<td>AAAA.AAAA<\/td>\n<\/tr>\n<tr>\n<td>Call Short,Cond<\/td>\n<td>0001.0111<\/td>\n<td>AAAA.AAAA<\/td>\n<td><\/td>\n<\/tr>\n<tr>\n<td>Call Short<\/td>\n<td>0001.1000<\/td>\n<td>AAAA.AAAA<\/td>\n<td><\/td>\n<\/tr>\n<tr>\n<td>Call Adr<\/td>\n<td>0001.1001<\/td>\n<td>AAAA.AAAA<\/td>\n<td>AAAA.AAAA<\/td>\n<\/tr>\n<tr>\n<td>Call (Adr)<\/td>\n<td>0001.1010<\/td>\n<td>AAAA.AAAA<\/td>\n<td>AAAA.AAAA<\/td>\n<\/tr>\n<tr>\n<td>Interrupt Adr<\/td>\n<td>0001.1011<\/td>\n<td>AAAA.AAAA<\/td>\n<td><\/td>\n<\/tr>\n<tr>\n<td>Jp Cond,Adr<\/td>\n<td>0001.1100<\/td>\n<td>AAAA.AAAA<\/td>\n<td>AAAA.AAAA<\/td>\n<\/tr>\n<tr>\n<td>Jp Short Cond,Adr<\/td>\n<td>0001.1101<\/td>\n<td>AAAA.AAAA<\/td>\n<td><\/td>\n<\/tr>\n<tr>\n<td>Jp Adr<\/td>\n<td>0001.1110<\/td>\n<td>AAAA.AAAA<\/td>\n<td>AAAA.AAAA<\/td>\n<\/tr>\n<tr>\n<td>Jp (Adr)<\/td>\n<td>0001.1111<\/td>\n<td>AAAA.AAAA<\/td>\n<td>AAAA.AAAA<\/td>\n<\/tr>\n<tr>\n<td>Decrement Reg Jumpz,Short<\/td>\n<td>0010.RRRR<\/td>\n<td>AAAA.AAAA<\/td>\n<td><\/td>\n<\/tr>\n<tr>\n<td>Ret<\/td>\n<td>0101.1010<\/td>\n<td>0000.1011<\/td>\n<td><\/td>\n<\/tr>\n<tr>\n<td>Ret Cond<\/td>\n<td>0101.1010<\/td>\n<td>0000.1100<\/td>\n<td><\/td>\n<\/tr>\n<tr>\n<td>IRet cond<\/td>\n<td>0101.1010<\/td>\n<td>0000.1101<\/td>\n<td><\/td>\n<\/tr>\n<tr>\n<td>Iret Cond<\/td>\n<td>0101.1010<\/td>\n<td>0000.1110<\/td>\n<td><\/td>\n<\/tr>\n<tr>\n<td><b>Ladebefehle<\/b><\/td>\n<td><\/td>\n<td><\/td>\n<td><\/td>\n<\/tr>\n<tr>\n<td>Ld (Adr),Reg<\/td>\n<td>0011.RRRR<\/td>\n<td>AAAA.AAAA<\/td>\n<td>AAAA.AAAA<\/td>\n<\/tr>\n<tr>\n<td>Ld Reg,(Adr)<\/td>\n<td>0001.RRRR<\/td>\n<td>AAAA.AAAA<\/td>\n<td>AAAA.AAAA<\/td>\n<\/tr>\n<tr>\n<td>Ld Reg,Konstant<\/td>\n<td>0010.RRRR<\/td>\n<td>AAAA.AAAA<\/td>\n<td>AAAA.AAAA<\/td>\n<\/tr>\n<tr>\n<td>Ld (Reg+C),reg<\/td>\n<td>0011.RRRR<\/td>\n<td>RRRR.CCCC<\/td>\n<td>CCCC.CCCC<\/td>\n<\/tr>\n<tr>\n<td>Ld Reg,(Reg+C)<\/td>\n<td>0100.RRRR<\/td>\n<td>RRRR.CCCC<\/td>\n<td>CCCC.CCCC<\/td>\n<\/tr>\n<tr>\n<td>Ld Reg,Reg<\/td>\n<td>0101.0000<\/td>\n<td>RRRR.RRRR<\/td>\n<td><\/td>\n<\/tr>\n<tr>\n<td>Ld (reg),Reg<\/td>\n<td>0101.0001<\/td>\n<td>RRRR.RRRR<\/td>\n<td><\/td>\n<\/tr>\n<tr>\n<td>Ld Reg,(reg)<\/td>\n<td>0101.0010<\/td>\n<td>RRRR.RRRR<\/td>\n<td><\/td>\n<\/tr>\n<tr>\n<td>Ld Reg,(Reg)+Reg<\/td>\n<td>0101.0011<\/td>\n<td>RRRR.RRRR<\/td>\n<td>RRRR.0000<\/td>\n<\/tr>\n<tr>\n<td>Ld (Reg)+Reg,Reg<\/td>\n<td>0101.0011<\/td>\n<td>RRRR.RRRR<\/td>\n<td>RRRR.0001<\/td>\n<\/tr>\n<tr>\n<td>Ld Reg,((Reg))<\/td>\n<td>0101.0100<\/td>\n<td>RRRR.RRRR<\/td>\n<td><\/td>\n<\/tr>\n<tr>\n<td>Ld ((Reg)),Reg<\/td>\n<td>0101.0101<\/td>\n<td>RRRR.RRRR<\/td>\n<td><\/td>\n<\/tr>\n<tr>\n<td><b>Stackoperationen<\/b><\/td>\n<td><\/td>\n<td><\/td>\n<td><\/td>\n<\/tr>\n<tr>\n<td>Pop Flags<\/td>\n<td>0101.1010<\/td>\n<td>0000.0000<\/td>\n<td><\/td>\n<\/tr>\n<tr>\n<td>Pop Instruction Pointer<\/td>\n<td>0101.1010<\/td>\n<td>0000.0001<\/td>\n<td><\/td>\n<\/tr>\n<tr>\n<td>Pop Reg<\/td>\n<td>0101.1010<\/td>\n<td>0001.RRRR<\/td>\n<td><\/td>\n<\/tr>\n<tr>\n<td>Pop Stackpoointer<\/td>\n<td>0101.1010<\/td>\n<td>0000.0010<\/td>\n<td><\/td>\n<\/tr>\n<tr>\n<td>Push Flags<\/td>\n<td>0101.1010<\/td>\n<td>0000.0011<\/td>\n<td><\/td>\n<\/tr>\n<tr>\n<td>Push Instruction Pointer<\/td>\n<td>0101.1010<\/td>\n<td>0000.0100<\/td>\n<td><\/td>\n<\/tr>\n<tr>\n<td>Push Reg<\/td>\n<td>0101.1010<\/td>\n<td>0010.RRRR<\/td>\n<td><\/td>\n<\/tr>\n<tr>\n<td>Push Stackpointer<\/td>\n<td>0101.1010<\/td>\n<td>0000.0101<\/td>\n<td><\/td>\n<\/tr>\n<tr>\n<td><b>Ein\/Ausgabe<\/b><\/td>\n<td><\/td>\n<td><\/td>\n<td><\/td>\n<\/tr>\n<tr>\n<td>In Reg,Adr<\/td>\n<td>0110.RRRR<\/td>\n<td>AAAA.AAAA<\/td>\n<td>AAAA.AAAA<\/td>\n<\/tr>\n<tr>\n<td>Out Reg,Adr<\/td>\n<td>0111.RRRR<\/td>\n<td>AAAA.AAAA<\/td>\n<td>AAAA.AAAA<\/td>\n<\/tr>\n<tr>\n<td>In Rg,(Reg)<\/td>\n<td>0101.1011<\/td>\n<td>RRRR.RRRR<\/td>\n<td><\/td>\n<\/tr>\n<tr>\n<td>Out (reg),Reg<\/td>\n<td>0101.1100<\/td>\n<td>RRRR.RRRR<\/td>\n<td><\/td>\n<\/tr>\n<tr>\n<td>Sonstiges<\/td>\n<td><\/td>\n<td><\/td>\n<td><\/td>\n<\/tr>\n<tr>\n<td>Di<\/td>\n<td>0101.1010<\/td>\n<td>0000.0110<\/td>\n<td><\/td>\n<\/tr>\n<tr>\n<td>EI<\/td>\n<td>0101.1010<\/td>\n<td>0000.0111<\/td>\n<td><\/td>\n<\/tr>\n<tr>\n<td>Halt<\/td>\n<td>0101.1010<\/td>\n<td>0000.1000<\/td>\n<td><\/td>\n<\/tr>\n<tr>\n<td>Nop<\/td>\n<td>0000.0000<\/td>\n<td><\/td>\n<td><\/td>\n<\/tr>\n<tr>\n<td>Set InterruptMask,Reg<\/td>\n<td>0101.1010<\/td>\n<td>0011.RRRR<\/td>\n<td><\/td>\n<\/tr>\n<tr>\n<td>Read Reg,InterruptMask<\/td>\n<td>0101.1010<\/td>\n<td>0100.RRRR<\/td>\n<td><\/td>\n<\/tr>\n<tr>\n<td>Complement Carry<\/td>\n<td>0101.1010<\/td>\n<td>0000.1001<\/td>\n<td><\/td>\n<\/tr>\n<tr>\n<td>Set Carry Flag<\/td>\n<td>0101.1010<\/td>\n<td>0000.1010<\/td>\n<td><\/td>\n<\/tr>\n<tr>\n<td>Frei f&uuml;r Erweiterungen<\/td>\n<td>0101.1011<\/td>\n<td>1111.1111<\/td>\n<td><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p><img loading=\"lazy\" decoding=\"async\" src=\"http:\/\/vg05.met.vgwort.de\/na\/5092ea4e11524a298279dd16565ef364\" width=\"1\" height=\"1\" alt=\"\"\/><\/p>\n","protected":false},"excerpt":{"rendered":"<p>Heute mal eine Neuigkeit: in der Reihe &#8222;Wir wissen es besser als die Industrie&#8220; heute ein Konzept f&uuml;r einen Prozessor. Ich habe das mal angefangen f&uuml;r einen 32 Bit Risc Prozessor, aber in der Klasse habe wenig Erfahrung in Bezug auf Befehlssatz. Die habe ich in der 8 und 16 Bit Klasse und inspiriert durch [&hellip;]<\/p>\n","protected":false},"author":169,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_jetpack_newsletter_access":"","_jetpack_dont_email_post_to_subs":false,"_jetpack_newsletter_tier_id":0,"_jetpack_memberships_contains_paywalled_content":false,"_jetpack_memberships_contains_paid_content":false,"footnotes":""},"categories":[4],"tags":[3903],"class_list":["post-11150","post","type-post","status-publish","format-standard","hentry","category-computer","tag-prozessor","entry"],"a3_pvc":{"activated":false,"total_views":2351,"today_views":0},"jetpack_featured_media_url":"","jetpack-related-posts":[{"id":18612,"url":"https:\/\/www.bernd-leitenberger.de\/blog\/2026\/03\/28\/galileos-cds-teil-2\/","url_meta":{"origin":11150,"position":0},"title":"Galileos CDS \u2013 Teil 2","author":"Bernd Leitenberger","date":"28. M\u00e4rz 2026","format":false,"excerpt":"So, heute geht es weiter mit Teil 2 \u00fcber Galileos CDS, dieser Beitrag schlie\u00dft nahtlos an den ersten Beitrag von gestern an, wie man schon an der ersten Textzeile sieht. Nach der Einleitung im ersten Teil geht es heute weiter damit warum der RCA 1802 genutzt wurde und was seine\u2026","rel":"","context":"In &quot;Raumfahrt&quot;","block_context":{"text":"Raumfahrt","link":"https:\/\/www.bernd-leitenberger.de\/blog\/category\/raumfahrt\/"},"img":{"alt_text":"","src":"https:\/\/vg07.met.vgwort.de\/na\/191e4b0728de42829cf656027b84dc82","width":350,"height":200},"classes":[]},{"id":18610,"url":"https:\/\/www.bernd-leitenberger.de\/blog\/2026\/03\/27\/galileos-cds-teil-1\/","url_meta":{"origin":11150,"position":1},"title":"Galileos CDS &#8211; Teil 1","author":"Bernd Leitenberger","date":"27. M\u00e4rz 2026","format":false,"excerpt":"Hall\u00f6chen, es wird Zeit das ich mich mal wieder melde. Es gab zwei Gr\u00fcnde, warum ich mich so rar gemacht habe. Das eine ist das es gerade nicht so viel aktuelles gibt, au\u00dfer einem Update zu Artemis, zu dem ich vielleicht noch etwas schreibe. W\u00e4hrend Trump das ganze Programm nach\u2026","rel":"","context":"In &quot;Raumfahrt&quot;","block_context":{"text":"Raumfahrt","link":"https:\/\/www.bernd-leitenberger.de\/blog\/category\/raumfahrt\/"},"img":{"alt_text":"","src":"https:\/\/vg07.met.vgwort.de\/na\/4fb81c7bafbd4d9d88b5695abdb33d29","width":350,"height":200},"classes":[]},{"id":18614,"url":"https:\/\/www.bernd-leitenberger.de\/blog\/2026\/03\/29\/galileos-cds-teil-3\/","url_meta":{"origin":11150,"position":2},"title":"Galileos CDS &#8211; Teil 3","author":"Bernd Leitenberger","date":"29. M\u00e4rz 2026","format":false,"excerpt":"So nun zum dritten Teil \u00fcber das prim\u00e4re Computersystem von Galileo, das CDS. Nachdem sich die ersten beiden Teile nur mit dem RCA 1802, warum er gew\u00e4hlt wurde und seiner Architektur befassten geht es heute um das Computersystem selbst. Der Artikel schlie\u00dft so an seine beiden Vorg\u00e4nger gestern und vorgestern\u2026","rel":"","context":"In &quot;Raumfahrt&quot;","block_context":{"text":"Raumfahrt","link":"https:\/\/www.bernd-leitenberger.de\/blog\/category\/raumfahrt\/"},"img":{"alt_text":"","src":"https:\/\/vg07.met.vgwort.de\/na\/6e7f572a246b4ac395de9c260733b707","width":350,"height":200},"classes":[]},{"id":18676,"url":"https:\/\/www.bernd-leitenberger.de\/blog\/2026\/05\/31\/die-glorreichen-10-programmiersprachen\/","url_meta":{"origin":11150,"position":3},"title":"Die glorreichen 10 \u2013 Programmiersprachen","author":"Bernd Leitenberger","date":"31. Mai 2026","format":false,"excerpt":"Ich wollte mal eine Reihe in dieser Rubrik \u00fcber Programmiersprachen machen. Zuerst dachte ich daran eine Liste nach meinen pers\u00f6nlichen Favoriten zu erstellen. Anfangs bef\u00fcrchtete ich, dass ich gar nicht auf 10 komme, aber es sind tats\u00e4chlich mehr, wenngleich ich in vielen Sprachen nur kleine Programme verfasst habe oder mich\u2026","rel":"","context":"In &quot;Die Glorreichen 10&quot;","block_context":{"text":"Die Glorreichen 10","link":"https:\/\/www.bernd-leitenberger.de\/blog\/category\/allgemein\/die-glorreichen-10\/"},"img":{"alt_text":"","src":"https:\/\/vg09.met.vgwort.de\/na\/4073c4f9dc6943a08702cdde13605d43","width":350,"height":200},"classes":[]},{"id":18683,"url":"https:\/\/www.bernd-leitenberger.de\/blog\/2026\/06\/01\/die-glorreichen-10-programmiersprachen-2\/","url_meta":{"origin":11150,"position":4},"title":"Die glorreichen 10 \u2013 Programmiersprachen (2)","author":"Bernd Leitenberger","date":"1. Juni 2026","format":false,"excerpt":"Der heutige Teil schlie\u00dft nahtlos an den ersten Teil an, der gestern erschien. Es geht um 10 Kriterien anhand derer man Programmiersprachen kategorisieren kann. Maschinennah oder universell, aber komplex Als eine maschinennahe Sprache bezeichnet man eine Sprache, die nahe den M\u00f6glichkeiten von Prozessoren ist. Das Paradebeispiel ist C. Alle Prozessoren\u2026","rel":"","context":"In &quot;Die Glorreichen 10&quot;","block_context":{"text":"Die Glorreichen 10","link":"https:\/\/www.bernd-leitenberger.de\/blog\/category\/allgemein\/die-glorreichen-10\/"},"img":{"alt_text":"","src":"https:\/\/vg09.met.vgwort.de\/na\/7f5d9cf5265047179df05b778bf455b5","width":350,"height":200},"classes":[]},{"id":18524,"url":"https:\/\/www.bernd-leitenberger.de\/blog\/2026\/02\/06\/elon-musks-ki-rechenzentren-im-orbit-nochmals-nachgerechnet\/","url_meta":{"origin":11150,"position":5},"title":"Elon Musks KI-Rechenzentren im Orbit &#8211; nochmals nachgerechnet","author":"Bernd Leitenberger","date":"6. Februar 2026","format":false,"excerpt":"Ich habe mich ja schon mal mit diesem Thema besch\u00e4ftigt, in dem es vor allem um die Kosten und den wirtschaftlichen Unsinn ging - warum sollte ich ein Rechenzentrum in den Orbit bringen, wenn ich es billiger auf der Erde bauen kann und es auch gen\u00fcgend Gegenden gibt in denen\u2026","rel":"","context":"In &quot;Raumfahrt&quot;","block_context":{"text":"Raumfahrt","link":"https:\/\/www.bernd-leitenberger.de\/blog\/category\/raumfahrt\/"},"img":{"alt_text":"","src":"https:\/\/vg06.met.vgwort.de\/na\/78014052fde04012a2be60bd108cd4bb","width":350,"height":200},"classes":[]}],"jetpack_sharing_enabled":true,"amp_enabled":true,"_links":{"self":[{"href":"https:\/\/www.bernd-leitenberger.de\/blog\/wp-json\/wp\/v2\/posts\/11150","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.bernd-leitenberger.de\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.bernd-leitenberger.de\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.bernd-leitenberger.de\/blog\/wp-json\/wp\/v2\/users\/169"}],"replies":[{"embeddable":true,"href":"https:\/\/www.bernd-leitenberger.de\/blog\/wp-json\/wp\/v2\/comments?post=11150"}],"version-history":[{"count":0,"href":"https:\/\/www.bernd-leitenberger.de\/blog\/wp-json\/wp\/v2\/posts\/11150\/revisions"}],"wp:attachment":[{"href":"https:\/\/www.bernd-leitenberger.de\/blog\/wp-json\/wp\/v2\/media?parent=11150"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.bernd-leitenberger.de\/blog\/wp-json\/wp\/v2\/categories?post=11150"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.bernd-leitenberger.de\/blog\/wp-json\/wp\/v2\/tags?post=11150"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}