1 bites CPU

Ismét megtetszett. És nem a sebessége miatt, hiszen egyszerre csak 1 bittel foglalkozik.
Ellenben faék egyszerű, szemléletes.

Alább látható egy ilyen egybites egyszerű utasításfeldolgozó.
 

MC14500B

Utasításkészlete:

0x0  Flag 0 // Emit pulse on FLAG_0 Pin
0x1  LD     // RR :=  (D_IN & I_EN)
0x2  LDC    // RR := !(D_IN & I_EN)
0x3  OR     // RR := RR |  (D_IN & I_EN)

0x4  ORC    // RR := RR | !(D_IN & I_EN)
0x5  AND    // RR := RR &  (D_IN & I_EN)
0x6  ANDC   // RR := RR & !(D_IN & I_EN)
0x7  XNOR   // RR := RR ^ !(D_IN & I_EN)

0x8  STO    // Write  RR to data memory, if O_EN = 1
0x9  STOC   // Write !RR to data memory, if O_EN = 1
0xa  IEN    // I_EN = RR
0xb  OEN    // O_EN = RR

0xc  JMP    // Emit pulse on JMP Pin (= jump to subroutine)
0xd  RTN    // Emit pulse on RTN Pin (= return from subroutine, skip next)
0xe  SKZ    // skip next opcode, if RR is Zero
0xf  Flag F // Emit Pulse on Flag_F Pin

Lefordítottam a VHDL kódját, FPGA helyett az egyik legkisebb XC9536 CPLD-t vettem alapul. Maradt ebben is bőven hely, olyan pici a hardver. Persze a teljes rendszerhez még kellenek további áramkörök (Mux, Demux+bitLatch, counter).

cpldfit:  version P.20131013                        Xilinx Inc.
                                  Fitter Report
Design Name: mc14500b                            Date:  6-14-2021, 10:32PM
Device Used: XC9536XL-5-VQ44
Fitting Status: Successful

*************************  Mapped Resource Summary  **************************

Macrocells     Product Terms    Function Block   Registers      Pins           
Used/Tot       Used/Tot         Inps Used/Tot    Used/Tot       Used/Tot       
14 /36  ( 39%) 37  /180  ( 21%) 18 /108 ( 17%)   8  /36  ( 22%) 13 /34  ( 38%)

** Function Block Resources **

Function    Mcells      FB Inps     Pterms      IO          
Block       Used/Tot    Used/Tot    Used/Tot    Used/Tot    
FB1           4/18        5/54        4/90       4/17
FB2          10/18       13/54       33/90       9/17
             -----       -----       -----      -----    
             14/36       18/108      37/180     13/34

Még nem tudom, mi lesz a folytatás, de ennek az utasításvégrehajtónak a faék egyszerűsége megtetszett.
Ha netán valaki ismer ennél is kevesebb félvezető egységet igénylőt, ami univerzális célra használhatónak tűnik, bátran írja meg hozzászólásban.

Hozzászólások

Szerkesztve: 2021. 06. 14., h – 22:59

Érdemes lenne csinálni hozzá toolingot C fordítóval mindennel úgy, hogy fusson rajta a Linux. Ha lesz egy új technológia, amivel sokkal gyorsabb, de kevésbé komplex CPU-t lehet gyártani, akkor hirtelen az 1 bites CPU-é lesz a világ! Fel kell készülni erre az esetre! :-)

... hat, elobb irjunk egy 8 bites osszeadot, es akkor utana lehet folytatni a forditok fejleszteset ;) De viccen kivul, ket 8 bites szam osszeadasat ez hany orajel alatt tudja megcsinalni? Tegyuk fel hogy a memoria 8x8 bites (256 byte) leosztasu, azt kell interface-elni ezzel a CPU-szeruseggel. 

1 félösszeadó + 7 teljes összeadó.
Félösszeadó: xor az érték and a carry.

LD    IN_A0
XNOR  IN_B0
STOC  OUT_0

LD   IN_A0
AND  IN_B0
STO  CARRYREG

És készen van az alsó bit. De ebből lehet hogy egyik load megspórolható. Még nem vagyok benne biztos.
A teljes összeadó legrosszabb esetben 13 órajel, többet nem tudtam optimalizálni.

Összesen egy 8 bites szám összeadása 97 órajel. Ha 1 MHz-en jár, akkor 10.000 darabot megcsinál másodpercenként.
A CPLD-s vagy TTL IC-kből összerakott verziót ha 7 MHz-es órajelen járatjuk, akkor 70.000 darab ... ahogy a C64 esetén.
clc; lda $RAM1; adc $RAM2; sta $RAM3 ... 70.000 összeadás/másodperc @ 980 kHz.

Igen, sajnos ez az irany amit ez az integralt aramkor kepviselt az talan mar edukativ celbol is inkabb torteneti erdekesseg. Ha a beagyazott lelkivilagot kellene oktatnom, akkor biztos nem ebbe az iranyba mennek el ;)

Kicsit massszavakkal: azert egy 4-8-16 bites teljes osszeadonak nem olyan rosszak meg a signal propagation delay ertekei ahhoz hogy egy CPU-szerusegbe ez adja a szuk keresztmetszetet az orajel felvitelehez. Azt is meg mernem kockaztatni hogy ennek az aramkornek is kb ugyanannyi lehet a kesleltetese (lasd meg: https://en.wikipedia.org/wiki/Carry-lookahead_adder es tarsai vs. ez a cucc). Azaz valojaban nem nyersz sokat, se komplexitasban, es talan tranzisztorszamban sem hogy 1-2-3 orajel helyett ~100 orajelig tartson ugyanaz. Arrol nem is beszelve hogy akkor ez ezekszerint ~100 instruction-t is megeszik az idealis ~1-3 helyett. 

Igen, 1 bites műveletből összerakni a 8 bitet időigényes. A gyakorlat nem véletlenül hozta képbe a 8, 16, 32, 64 bites összeadót. Sőt a 64 bites hardverszorzót _int128 bites eredménnyel is ma már általános lett. Illetve ma már f64-ig floating pointra is mindez megvan. Drágább hardver, de időben aranyat ér.
Sőt adatpárhuzamosítással további időnyereség érhető el. Az 512 bites SIMD szintén a hardverpazarlás és időnyereség tengelyén való egyensúlyozás.

Nekem még az a carry fast forward technika tetszett, amikor a 32 bites összeadó esetén csinálsz 3 darab 16 bitest és a felső részt kiszámolod carry=0 -ra és carry=1 -re, majd a végén kiválasztod az eredményt aszerint, hogy az alsónak lett-e túlcsordulása. De ez kapásból 1,5-szer annyi összeadó, ellenben a carry felterjesztést mint lassító tényezőt részben kiküszöbölted, így jelentősen gyorsabb.

Viszont ha elméleti matematikusi vénával akarsz bazi nagy számokkal számolni, ott ugyanilyen fájdalmas módon kell összerakni az aritmetikát. Szerencsére viszonylag ritka az ilyen eset.

Igen, ezt szerettem volna én is hangsúlyozni.

Még annyit pótlólag hozzáfűznék, hogy ma már sokat veszített a jelentőségéből ez a kis egy bites csoda, hiszen ha 8 bites, legalább 4 Mhz-es kontroller kapható 100 Ft körüli összegért, akkor nyilván nem áll le senki ezzel az egy Mhz-es jószággal vacakolni, de az oktatás terén nagyon komoly jelentőséggel bír, hiszen egyszerű, A-tól Z-ig megismerhető, az utasításkészlete 15 perc alatt bemagolható. Ugródeszkának kivánni sem lehet jobbat.