Professional Documents
Culture Documents
che avviene ai dati una volta presi dalla memoria e conservati dentro il
processore. Ieri abbiamo visto il modello ad accumulatore e stack. Lo stack ha
un vantaggio che consiste in un area di conservazione maggiore rispetto
allaria monocratica del processore ad accumulatore. Ha, insieme a quello
precedente, il vantaggio di avere un indirizzamento implicito del dato. Difatti
mentre nel 1 non potevo dare nessun tipo di specifica al dato perch
sottinteso ( mettilo direttamente nell accumulatore) anche nel 2 caso non
devo specificare nulla: Pop x, push x ( chiaro che il dato va messo nello
stack). Questo significa avere delle istruzioni pi compatte perch le istruzioni
di tipo aritmetico-logiche sono implementate nello stesso modo con cui sono
implementate nella macchina ad accumulatore, anzi ancora meglio se
vogliamo perch nellaccumulatore dicevo una somma e avevo un indirizzo nel
senso che facevo Accumulatore + y e il risultato andava in accumulatore. Nella
macchina a stack dico solamente ADD nel senso che il codice intende: prendi il
dato sullo stack, dopo di che ,sullo stack, dopo che ho preso quel dato c ne
un altro. Prendilo, fai la somma e il risultato lo rimetti nello stack. Lultimo dato
del mio stack sar quindi il risultato trovato precedentemente. In pratica ho
una struttura efficiente usabile per il calcolo delle espressioni matematiche. Per
esempio se abbiamo una espressione del tipo : (z*(y+3x-5)/q) ( risolviamo i
calcoli con maggiore precedenza).
Per cui questa espressione se la vado a scrivere correttamente in uno stack
funziona bene. Il sistema per funzionare bene tira fuori la x poi il * ( posso
implicitamente caricare anche le operazioni nella pila) e poi tiro fuori il 3 valore
che scrivo successivamente per continuare le operazioni. Sostanzialmente le
calcolatrici scientifiche ,quelle che gestiscono parantesi e altro, funziona
proprio con questo meccanismo, il loro processore gestisce i dati con modalit
stack. In pi gestendo le parentesi va a scrivere correttamente nello stack.
Andiamo ora avanti, capiamo che il limite di questa architettura che i dati,
anche se ne ho pi di uno, non vi posso accedere maniera casuale ( Che
significa? E diverso dal significato nel linguaggio casuale cio non prendere un
dato qualsiasi, ma nellinformatica significa che io posso accedere con una
certa volont in maniera del tutto indipendente dagli accessi che ho fatto in
precedenza. Ho cio la libert di prendere quel determinato dato senza nessun
collegamento con quello che ho fatto prima. Non come avveniva nello stack
dove sono vincolato a prendere il precedente o il successivo-> dipende dal
SP).
Avere pi dati allinterno del processore sicuramente una cosa positiva ma
sarebbe ancora meglio se tutti fossero accessibili in maniera casuale. Per fare
questo devo pensare ad un meccanismo pi complesso, avere una serie di
celle ciascuna che pu contenere un dato e avere la libert di accedere ad una
determinata di queste senza seguire un qualche ordine. Per fare ci devo poter
gestire un accesso a questa struttura ma devo anche (effetto collaterale)
pensare a specificare questi dati. Mentre prima dicevo POP e non avevo
bisogno di specificare nientaltro, qui non posso dire leggi e basta ma devo dire
leggi e cosa andare a leggere. Quindi una struttura di questo genere devo
specificare necessariamente gli operandi, e se una istruzione prevede 3
operandi, 2 sorgenti e uno di arrivo(destinazione) dovr necessariamente
specificarli tutti e 3.(nello stack non specificavo niente- nellaccumulatore solo
uno).facendo si, di conseguenza, che le istruzioni diventino pi lunghe
( immagina una macchina stack che fa 4 operazioni, basta 1 solo codice
operativo di 2 bit, in realt sar pi lunga perch prevede anche gli indirizzi,
per posso anche pensare che gli indirizzi sono nello stack). La macchina che
abbiamo appena descritto detta a registri ( le locazioni di prima sono i
registri) e quindi avremo un sistema che sar dimensionato dal numero di
registri e dalla lunghezza di parola ( processore a 32 registri per esempio).
In questa prima parte del corso penseremo a processori che lavorano solo su
dati interi ( dopo vedremo cosa aggiungere al processore per poter lavorare
anche con dati floating point).
Una macchina a registri deve prevedere una serie di strutture che complicano
anche lhardware per: gestire laccesso ai registri per esempio o un controllo
che dica quale dei registri deve andare in ingresso allALU quando deve fare
una operazione. Quindi ritornando al discorso fatto laltro giorno una macchina
a registri diventa LOAD/STORE nel momento in cui quella macchina fa si che le
operazioni interessano soltanto i dati che sono dentro i registri o al pi dati che
sono dentro i registri con leccezione che un operando sorgente possa anche
essere un operando scritto nellistruzione stessa.
Ho tre possibili locazioni di dove possono stare gli operandi: o in memoria o nei
registri o nellistruzione stessa (ovviamente non il risultato perch non ha
senso farglielo ricalcolare). Dal momento in cui il compilatore si accorge che nel
codice stesso vi il valore delloperando pu evitare di prendere quel valore e
scriverlo nel registro. ( Esempio del for) Quando scriver una istruzione al posto
di scrivere una somma di un certo registro r1 e un certo registro r2 e metto il
risultato in r1 posso dirgli direttamente di fare r1+1 senza sprecare memoria in
r2 e questo 1 lo metto direttamente nellistruzione. Non pi una istruzione
ADD ma ADDI(altro codice operativo). Qual la differenza? LALU deve fare
sempre un + per quando ho una istruzione non bisogna vederla ridotta ad una
sola operazione, ma va vista nel suo complesso poich prima di arrivare a fare
quel + il processore esegue altre operazioni. NellADDI uno dei dati in ingresso
allALU viene dato direttamente nellIR ed il numero 1, nella ADD per
prendere 2 dati in ingresso li devo entrambi prendere dai registri. Queste due
operazioni sono diverse anche se lALU fa sempre una somma. In pi non devo
pensare che per eseguire una istruzione non devo sempre pensare di usare
lALU dato che alle volte non viene neanche tirata in ballo.
Per fare unistruzione devo eseguire dei passi che chiameremo microistruzioni. Una istruzione composta da una sequenza di microistruzioni.
Quindi io posso immaginare una istruzione in cui ho un immediato scritto
nellistruzione stessa ( come nel LOAD/STORE dove limmediato era un pezzo
dellindirizzo).
Un altro modo di classificare i processori quello che sancisce il fatto che quel
processore abbia un set di istruzioni a lunghezza fissa o variabile. Cosa
significa? Per eseguire un programma lunit di calcolo esegue una sequenza di
istruzioni che va a pescare dalla memoria ( dove stanno scritte le istruzioni
caricate dal loader che quella parte di codice operativo che carica il
programma in memoria altrimenti il processore non pu leggerlo dato che non
pu leggere direttamente dallhard disk). Inoltre per leggere le istruzioni il
processore deve sapere quanti byte deve leggere ( posso avere unistruzione
da tot byte). In realt oggi esiste un solo approccio anche se di base sono 2
dato che in passato si discusso a lungo su questo determinato argomento.
1. Tutte le istruzioni hanno lunghezza costante ( le istruzioni sono tutte di 32
bit per esempio)