delucagiovanni forum

ciao,
visto che mi sto imbattendo nella realizzazione di una CPU homemade con TTL logic, sto partendo con la ALU.
secondo voi, quali dovrebbero essere le funzioni aritmetiche e booleane essenziali che dovrebbe eseguire una semplice ALU 8 bit?

ad esempio:
------------------------------
somma
sottrazione
incremento di un valore
decremento di un valore
moltiplicazione
divisione
confronto A>B, A<B, A=B
------------------------------
or
nor
and
nand
not
xor
shift sinistra, destra
------------------------------
cosa mi consigliate di aggiungere?

grazie

di togliere:

moltiplicazione
divisione

le fai in software, o in microcodice
e ti consiglio in software, prima

ciao execute,
le funzioni da te elencate sono quelle di norma implementate su ALU di primo livello in grado di eseguire operazioni booleane e aritmetiche fondamentali.
Tuttavia la moltiplicazione e la divisione risultano abbastanza difficili da realizzare con logica cablata.

Per aiutarti ti propongo un circuito che ho sviluppato una quind. di anni fa, o forse più, che permette di eseguire una moltiplicazione di due valori a 4bit, il risultato chiaramente è presentato su 8bit.
Prima di realizzarlo con chip reali prova a simularlo e prova tu stesso a espanderlo a 8bit.

Bah, le mul si portano dietro problemi
cosa succede se nel tuo circuito (unsigned) mul 4 bit fai b1111 x b1111 ????
va messo anche circuito per dire -> overflow, disastro, pasticcio

@legacy

non ti sei fatto bene i conti......

1111 x 1111 = 11100001 che in decimale è uguale a 225

il moltiplicatore da me descritto sopra va benissimo per eseguire moltiplicazioni a 4 bit senza aver necessità di overflow poichè anche moltiplicando dec 10 x 10 avresti 100 che in esa diventa x64

x0A x x0A = x64 = cento (dec)

sono stato chiaro? eccoti l'esempio reale (simulato)



e qui l'esempio A x A = 64

non ci siamo capiti

una ALU ha operandi dello stesso numero di bit del risultato, quindi se parti da 4 bit ed ottieni in uscita 8 bit non va bene
nel caso abbiamo detto bx1111 x bx1111 = bx11100001, due sorgenti operandi a 4 bit ed un risultato ad 8 bit
come propaghi quegli 8 bit nella CPU che e' a 4 bit ? a rigore non puoi, puoi soltanto propagare 4 bit, perche' tutta la CPU e' a 4bit

e nel caso di prima con soli 4 bit in uscita avresti bx0001 non e' corretto come risultato matematico perche' ti perderesti i primi bx1110
per il motivo che il risultato non ti ci sta in 4 bit: quando succede devi segnalarlo !

che soluzione proponi ? usare registro di appoggio ? con comparatore ?

esemplificando:

hai ALU a 4 bit: source1, source2, target1, appoggio, tutti e 4 registri a 4bit

{target1,appoggio}=source1 x source2
if appoggio notEq to bx0000 -> cpu.alu.flag.overflow=bx1

source1=bx1111
source2=bx1111
target1=bx0001
appoggio=bx1110
cpu.alu.flag.overflow=bx1

una roba cosi' ? dove la CPU sa che la MUL e' in overflow (cpu.alu.flag.overflow=bx1)
e leggendo il registro appoggio si recupera anche di quanto ?

Ok legacy,
nel caso che il bus dati CPU sia limitato a 4bit il registro di "appoggio" è una strada percorribile.
Cmq, il mio moltiplicatore stava solo a dimostrare la fattibilità con hw cablato,
con semplici modifiche potrebbe essere espanso a nbit con result 2nbit.
Poi decidi tu se il risultato lo vuoi caricare su registri Low e High e siringarlo sul bus in 2cicli.

ciao

Per la divisione, divisore+modulo resto, hai implementato qualcosa di simile ?