Appunti di Calcolatori Elettronici

Ap p u n t i d i Ca l co l a t o ri El et t ro n i ci
Co n cet t i i n t ro d u t t i v i g en era l i
M ODELLO DI MACCHINA MULTILIVELLO .............................................................................. 1
Introduzione .................................................................................................................. 1
Linguaggi, livelli e macchine virtuali .............................................................................. 3
La struttura a livelli delle macchine odierne .................................................................... 4
Evoluzione delle macchine a più livelli............................................................................ 5
Hardware, software e firmware....................................................................................... 6
Equivalenza tra hardware e software ............................................................................ 6
L'ORGANIZZAZIONE DEI SISTEMI DI ELABORAZIONE................................................ 7
Introduzione .................................................................................................................. 7
La CPU......................................................................................................................... 8
Ciclo di esecuzione delle istruzioni ............................................................................. 9
Insieme delle istruzioni ............................................................................................ 10
Organizzazione della CPU ........................................................................................ 10
Esecuzione di istruzioni in parallelo .......................................................................... 11
La memoria ................................................................................................................. 15
I bit......................................................................................................................... 16
Gli indirizzi di memoria ........................................................................................... 16
Proprietà generali della memoria: RAM e ROM.......................................................... 17
Input e Output ............................................................................................................. 18
M
o
ullttiilliivveellllo
mu
naa m
hiin
maacccch
dii m
od
deellllo
od
Mo
Introduzione
Un calcolatore digitale è sostanzialmente una macchina in grado di risolvere dei
problemi eseguendo le istruzioni che gli vengono fornite. Una sequenza di istruzioni
che descrive come eseguire un certo compito è detta programma.
Un calcolatore digitale è dotato di un numero elevatissimo di circuiti
elettronici: questi sono in grado di riconoscere ed eseguire "direttamente" solo un
insieme limitato di istruzioni semplici; perciò, tutti i programmi, per poter essere
eseguiti, devono essere convertiti (ed è sempre possibile farlo) in sequenze di tali
istruzioni semplici ( 1). L'insieme delle istruzioni semplici di un calcolatore forma un
linguaggio che permette all’utente di comunicare con il calcolatore: questo
linguaggio prende il nome di linguaggio macchina.
Nel progettare un calcolatore, in base all'uso che se ne intende fare, si tende a
semplificare il più possibile le istruzioni del linguaggio macchina, anche e
1
Generalmente, le istruzioni di base sono di 3 tipi fondamentali: somma di 2 numeri, controllo di un numero per vedere se
è uguale a 0, spostamento di dati da una parte della memoria del calcolatore ad un’altra.
Appunti di “Calcolatori Elettronici”
soprattutto per ridurre la complessità ed il costo dell’elettronica da utilizzare.
Tuttavia, lo svantaggio di questa elevata semplicità sta nella difficoltà, per l'utente,
di utilizzarlo. Il problema viene allora risolto progettando un nuovo insieme di
istruzioni, che risulti più conveniente da usare: mentre il linguaggio macchina
verrà indicato nel seguito con L1 (e viene spesso detto linguaggio built-in), questo
secondo insieme di istruzioni verrà indicato come linguaggio L2.
Il linguaggio L2 può essere a sua volta utilizzato in due modi differenti. Infatti,
dato che un calcolatore può eseguire sempre e soltanto istruzioni in L1, si tratta di
vedere in quali modi viene effettuato il passaggio da L2 ad L1:
•
il primo metodo consiste nel sostituire ad ogni istruzione in L2 l'equivalente
sequenza di istruzioni in L1: con questo metodo, detto di traduzione, il
calcolatore esegue il nuovo programma in L1 anziché il programma originale
in L2;
Istruzioni in L1
Istruzioni in L1
Istruzione 0
Istruzione 1
Istruzioni in L1
Istruzione 2
Esecuzione
....
Sequenza di istruzioni
in linguaggio L1
Programma in L2
Metodo di traduzione
•
il secondo metodo è invece un po’ più complesso: bisogna infatti scrivere un
programma, in linguaggio L1, che riceva in input i programmi in L2 e li
esegua esaminando una istruzione dopo l'altra ed eseguendo per ognuna la
sequenza equivalente di istruzioni in L1. Questo secondo metodo è detto di
interpretazione ed il programma in L1 che lo realizza prende il nome di
interprete.
Esecuzione
Interprete
Programma in L2
Programma in L1
Metodo di interpretazione
In generale, quindi, con la traduzione si passa prima al programma equivalente in
L1 e poi lo si esegue; al contrario, con l'interpretazione, non viene generato alcun
programma intermedio: ogni istruzione in L2 viene esaminata, decodificata e
immediatamente eseguita. La caratteristica comune è, ovviamente, il fatto per cui il
calcolatore esegue solo istruzioni in L1.
Ovviamente, per rendere pratici i processi di traduzione o di interpretazione, è
necessario che i linguaggi L1 ed L2 non differiscano troppo tra loro: tuttavia,
questo fa’ sì che anche L2 risulti non particolarmente comodo da usare per l'utente.
Di qui l'idea (e spesso la necessità) di inventare anche un terzo insieme di
Autore: Sandro Petrizzelli
2
aggiornamento: 30 giugno 2001
Concetti introduttivi generali sui calcolatori
istruzioni, questa volta più orientato all'utente che non alla macchina di quanto
non avvenisse per L2. Indicheremo questo linguaggio con L3.
In generale, questa invenzione di una intera serie di linguaggi, ognuno più
conveniente del suo predecessore, può proseguire teoricamente all’infinito; nella
realtà, il processo si arresta quando si ottiene un linguaggio adatto alle proprie
esigenze. Ogni linguaggio usa il suo predecessore come base, per cui è possibile
considerare un calcolatore che usa questa tecnica come una serie di strati (o
livelli), posti uno sopra l’altro e corrispondenti ciascuno ad un dato linguaggio.
Evidentemente, il linguaggio di livello più basso è il più semplice ma anche il più
scomodo (si tratta del linguaggio macchina), mentre invece quello di livello più alto
è il più complicato ma anche più “familiare” per l’utente.
Linguaggi, livelli e macchine virtuali
Ogni macchina è dotata di un proprio linguaggio macchina (L1), cioè l'insieme
di tutte le istruzioni che essa può eseguire "direttamente". In questo senso
possiamo dire che una macchina definisce un linguaggio. Vale però anche il
viceversa, nel senso che ogni linguaggio definisce una macchina, intesa come quella
macchina che può eseguire direttamente tutti i programmi scritti in quel
linguaggio. Chiaramente, a linguaggi complessi (quelli ad alto livello, per esempio)
corrisponderanno macchine complesse e costose, ma questo non impedisce di
pensare che tali macchine possano comunque esistere.
Possiamo allora visualizzare un calcolatore dotato di N livelli (cioè di N
linguaggi) come N differenti macchine VIRTUALI, ognuna relativa ad un livello. Nel
seguito, useremo i termini "livello" e "macchina virtuale" in modo intercambiabile.
Macchina virtuale Mn,
con linguaggio macchina Ln
Macchina virtuale Mn-1,
con linguaggio macchina Ln-1
Livello n
Livello n-1
..................
Macchina virtuale M3,
con linguaggio macchina L3
Livello 3
Macchina virtuale M2,
con linguaggio macchina L2
Livello 2
Macchina virtuale M1,
con linguaggio macchina L1
Livello 1
Schematizzazione di una macchina a più livelli
aggiornamento: 30 giugno 2001
3
Autore: Sandro Petrizzelli
Appunti di “Calcolatori Elettronici”
Solo quei programmi scritti in linguaggio L1 potranno essere eseguiti
direttamente dai circuiti elettronici di una macchina. Ogni programma che sia
scritto in un linguaggio diverso da L1 dovrà subire o una serie di traduzioni fino ad
arrivare ad un programma in L1 oppure dovrà essere interpretato da un interprete
di livello inferiore, fino ad un interprete di livello L1. Chiaramente, però, una
persona che scrive programmi per la macchina virtuale di livello N non si deve
preoccupare degli interpreti e dei traduttori sottostanti: la struttura della macchina
garantisce che questi programmi saranno in qualche modo eseguiti.
La struttura a livelli delle macchine odierne
Nei calcolatori moderni si possono generalmente individuare i seguenti livelli:
•
il livello più basso (livello 0, detto anche livello della logica digitale) è quello
dell' hardware, ossia dei circuiti elettrici ed elettronici di cui il calcolatore si
compone. Tali dispositivi eseguono direttamente i programmi scritti nel
linguaggio macchina del livello superiore, cioè il livello 1 ( 2);
•
il livello successivo (livello 1) è propriamente il livello del linguaggio macchina:
a partire da questo livello si introduce il concetto di programma come sequenza
di istruzioni da eseguire; in particolare, nel livello 1 c'è un programma, detto
microprogramma, che si occupa di interpretare le istruzioni del livello 2. Per
questo motivo, il livello 1 viene detto livello della microprogrammazione. Da
notare che, per definizione stessa di tale livello, non possono esistere due
calcolatori aventi lo stesso livello 1: ci possono essere, e ci sono, similitudini,
ma mai l'uguaglianza;
•
il livello 2 è noto come livello della macchina standard. Non tutti i
calcolatori dispongono del livello 1: in questi casi, i programmi di livello 2
vengono eseguiti dai circuiti di livello 0 senza traduzioni o interpretazioni
intermedie;
•
al di sopra del livello 2 c'è il livello 3, che presenta alcune particolari
caratteristiche: intanto, esso si differenzia dal livello 2 in quanto fornisce un
insieme di nuove istruzioni, una organizzazione della memoria differente, la
capacità di eseguire più programmi in parallelo ed altro; tuttavia, gran parte
delle istruzioni del livello 3 compaiono anche nel livello 2. Ecco perchè
potremmo dire che si tratta di un livello ibrido. Le nuove capacità aggiunte a
livello 3 vengono eseguite da un particolare interprete, il quale fa operare il
livello 2: si tratta del sistema operativo. In altre parole, le istruzioni del livello
3 identiche a quelle del livello 2 vengono eseguite dal livello 2, ossia vengono
interpretate direttamente dal microprogramma (livello 1) corrispondente; le
altre istruzioni vengono invece interpretate dal sistema operativo. Il livello 3 è
noto perciò come livello del sistema operativo;
•
mentre tra i livelli finora esaminati ci sono fondamentalmente notevoli affinità,
il passaggio dal livello 3 al livello 4 è molto più brusco e netto. Lo scopo dei
primi livelli (da 0 a 3) non è certo un utilizzo diretto da parte del
programmatore medio, bensì il funzionamento dei traduttori e degli interpreti
che supportano i livelli superiori. Al contrario, tali livelli superiori sono
2
Ci sarebbe in verità anche un livello più basso del livello 0, il cosiddetto livello di dispositivo che però riguarda il campo
della ingegneria elettronica e non ci interessa.
Autore: Sandro Petrizzelli
4
aggiornamento: 30 giugno 2001
Concetti introduttivi generali sui calcolatori
concepiti per un uso diretto da parte del programmatore, il quale li utilizza per
la risoluzione dei propri problemi. La differenza forse più evidente è la
seguente: mentre i linguaggi dei livelli 1, 2 e 3 sono costituiti solo da numeri
(ottimi per le macchine ma pessimi per le persone), i linguaggi dal livello 4 in
su cominciano a contenere stringhe ed abbreviazioni sicuramente più
congeniali per l'uomo. Il livello 4 è noto come livello del linguaggio
Assembler: si tratta fondamentalmente di una forma simbolica di uno dei
linguaggi sottostanti. In pratica, questo livello consente di scrivere programmi
formalmente analoghi a quelli dei livelli inferiori, ma comunque meno ostici
per l’utente. I programmi del livello 4 vengono prima tradotti nei linguaggi di
livello 1, 2 e 3 e poi interpretati per l'esecuzione. I programmi dediti alla
traduzione sono gli assemblatori;
•
al di sopra del livello 4 c'è il livello dei linguaggi simbolici ad alto livello,
ossia di linguaggi molto vicini al linguaggio naturale dell'uomo. Programmi
scritti in questi linguaggi vengono solitamente tradotti in programmi di livello
4 o 3 dai cosiddetti compilatori.
Evoluzione delle macchine a più livelli
Esaminiamo velocemente lo sviluppo storico delle macchine a più livelli.
I primi calcolatori digitali (1940) possedevano soltanto 2 livelli: il livello di
macchina standard, in cui era fatta tutta la programmazione, e quello della logica
digitale, che eseguiva i programmi.
Nel 1951 si passò a calcolatori a 3 livelli, al fine soprattutto di semplificare
l'hardware: ogni macchina aveva adesso un interprete la cui funzione era quella di
eseguire i programmi del linguaggio della macchina standard tramite la loro
interpretazione.
Nel giro di pochi anni si passò al livello degli assemblatori e dei compilatori, allo
scopo di facilitare il compito dei programmatori.
Agli inizi, i calcolatori erano un qualcosa su cui i programmatori potevano e
dovevano operare personalmente per far funzionare i propri programmi. Questo
implicava che essi dovessero conoscere a fondo la macchina e la soluzione di
eventuali problemi. Di conseguenza, era più il tempo in cui si cercava di
individuare i guasti che non il tempo dedicato alle esecuzioni vere e proprie dei
programmi.
Dopo 10 anni (1960), si tentò di ridurre questa perdita di tempo automatizzando
il lavoro degli operatori: venne introdotto un programma, detto sistema operativo,
il quale, una volta ricevuti i programmi in input dal programmatore, si occupava di
leggerli ed eseguirli. La sofisticazione dei sistemi operativi fu molto rapida: nuove
istruzioni, opzioni e caratteristiche furono aggiunte al livello della macchina
standard, finché non costituirono un nuovo livello, quello appunto del sistema
operativo.
I primi sistemi operativi non facevano altro che leggere i pacchi di schede forniti
dai programmatori e stampavano gli output su una stampante: questo tipo di
organizzazione era conosciuta come sistema bacth (o a lotti) ed era generalmente
piuttosto lenta. Più tardi, invece, furono sviluppate delle versioni dei sistemi
operativi che permettevano a diversi programmatori di comunicare direttamente
con il calcolatore. In questo tipo di sistemi, venivano usati dei cavi (generalmente di
tipo “telefonico”) per collegare i terminali al calcolatore centrale. In questo modo, il
programmatore poteva inviare i propri programmi ed osservare i risultati (in tempi
aggiornamento: 30 giugno 2001
5
Autore: Sandro Petrizzelli
Appunti di “Calcolatori Elettronici”
molto rapidi) da qualunque luogo. Questi sistemi furono e sono tuttora chiamati
sistemi time-sharing.
Hardware, software e firmware
Come più volte sottolineato, i programmi scritti nel linguaggio macchina (livello
1) di un calcolatore possono essere direttamente eseguiti dai circuiti elettronici
(livello 0) del calcolatore stesso, senza l’intervento di alcun interprete o
intermediario. Questi circuiti elettronici, insieme a quelli che costituiscono la
memoria ed i dispositivi di I/O, costituiscono il cosiddetto hardware del
calcolatore.
Il cosiddetto software è invece l’insieme degli algoritmi e delle loro
rappresentazioni per il calcolatore, ossia i programmi. Tali programmi possono
essere rappresentati su vari supporti (schede perforate, cassette magnetiche, film
fotografici o tanti altri mezzi), ma la vera essenza del software è l’insieme di
istruzioni che costituiscono i programmi e non certo i mezzi fisici su cui sono
registrati.
Una specie di “forma intermedia” tra hardware e software è costituita dal
cosiddetto firmware: si tratta del software che viene “incorporato” nei dispositivi
elettronici digitali durante la loro costruzione. Si ricorre al firmware quando si
prevede di cambiare i programmi molto raramente o addirittura mai, oppure anche
quando è importante che un dato programma non venga perso, ad esempio per
cadute di corrente. Nella maggior parte dei calcolatori, i microprogrammi sono
firmware.
E
waarree
waarree ee ssooffttw
dw
haarrd
nzzaa ttrraa h
uiivvaalleen
Eqqu
Il concetto di equivalenza tra hardware e software esprime semplicemente il
fatto che ogni operazione eseguita dal software può essere costruita
direttamente nell’hardware, così come ogni istruzione eseguita dall’hardware
può essere simulata nel software .
La decisione se mettere certe funzioni nel software o nell’hardware è basilare nel
progetto dei calcolatori ed è influenzata da alcuni importanti fattori, come il costo,
la velocità, l’affidabilità, la frequenza prevista negli eventuali cambiamenti ed altro.
Sui primi calcolatori, la distinzione tra hardware e software era chiara e netta:
l’hardware eseguiva alcune istruzioni semplici, come la somma (ADD) ed il salto
(JUMP), mentre tutto il resto era programmato esplicitamente via software. Così
facendo, quando un programma doveva moltiplicare due numeri, il programmatore
doveva scrivere la propria procedura di moltiplicazione oppure usarne una
predefinita di libreria. Quando, però, fu evidente che alcune operazioni venivano
eseguite molto frequentemente, si passò a realizzare circuiti specializzati per
l’effettuazione di tali operazioni direttamente a livello hardware, il che le rendeva
molto più veloci. Ci fu così una ovvia tendenza a “spostare le operazioni verso il
basso”, ossia appunto verso l’hardware.
Quando invece arrivò l’era della microprogrammazione e dei calcolatori a più
livelli, nacque la tendenza esattamente opposta. Mentre, nei primi calcolatori,
l’istruzione ADD veniva eseguita direttamente dall’hardware, sui calcolatori
microprogrammati essa veniva interpretata da un microprogramma eseguito al
livello più basso, il quale seguiva una serie di passi, del tipo seguente: preleva
l’istruzione, determinane il tipo, localizza i dati da sommare, prendi i dati dalla
Autore: Sandro Petrizzelli
6
aggiornamento: 30 giugno 2001
Concetti introduttivi generali sui calcolatori
memoria, esegui l’addizione e memorizza il risultato. Questo è un classico esempio
di una funzione che viene “spostata verso l’alto”, dal livello dell’hardware (livello 0)
al livello della microprogrammazione (livello 1).
A questo punto, è evidente che, con lo sviluppo delle macchine a più livelli, ogni
progettista deve decidere cosa porre ad ogni livello delle proprie macchine; si tratta
perciò di una ulteriore generalizzazione del problema di scegliere se implementare
una funzione in hardware o in software.
A quest’ultimo proposito, si ritiene interessante elencare alcune funzioni
caratteristiche dei moderni calcolatori che vengono eseguite dall’hardware oppure
da microprogrammi ma che inizialmente erano programmate esplicitamente a livello
di macchina standard (livello 2):
•
istruzioni per la moltiplicazione e la divisione di interi;
•
istruzioni per l’aritmetica in virgola mobile;
•
istruzioni per l’aritmetica in doppia precisione (che cioè coinvolge numeri
con il doppio delle cifre significative);
•
istruzioni per la chiamata ed il ritorno delle procedure;
•
istruzioni per il conteggio;
•
modalità per velocizzare calcoli che coinvolgono vettori;
•
modalità per permettere che i programmi vengano collocati in memoria
dopo che hanno già iniziato la loro esecuzione (concetto di rilocazione dei
programmi);
•
clock per scandire il tempo di esecuzione dei programmi;
•
sistemi di interruzione, che segnalano ad esempio al calcolatore quando
una operazione di input o di output è terminata;
•
capacità di sospendere un programma e cominciarne un altro (concetto di
commutazione di processi).
L
E
ON
NE
ZIIO
OR
RA
AZ
BO
EL
LA
AB
DII E
TE
EM
MII D
ST
SIIS
DE
EII S
ED
ON
NE
ZIIO
ZZ
ZA
AZ
GA
AN
NIIZ
RG
L''O
OR
Introduzione
Un calcolatore digitale è costituito da un sistema interconnesso dei seguenti
dispositivi:
•
processori;
•
memorie;
•
dispositivi di I/O.
La figura seguente riporta una schematizzazione assolutamente generale di un
calcolatore automatico:
aggiornamento: 30 giugno 2001
7
Autore: Sandro Petrizzelli
Appunti di “Calcolatori Elettronici”
dati
algoritmo
risultati
Unità di
ingresso
(input)
Unità di
uscita
(output)
Memoria
Unità
di
controllo
Unità
aritmetica
e logica
L’insieme dell’unità aritmetica e logica e dell’unità di controllo è quello che oggi si
definisce processore.
La CPU
L'organizzazione di un semplice calcolatore dotato di BUS per il collegamento tra
i dispositivi è mostrata nella seguente:
Unità Centrale di Elaborazione
(CPU)
Unità di
controllo
Unità aritmetica
e logica
Registri
...
...
Memoria
centrale
Stampante
Disco
BUS
Organizzazione di un semplice calcolatore con una CPU e due dispositivi di I/O
•
il cuore del sistema è costituito dalla CPU (Unità centrale di elaborazione), la
quale consta a sua volta delle seguenti componenti:
Autore: Sandro Petrizzelli
8
aggiornamento: 30 giugno 2001
Concetti introduttivi generali sui calcolatori
o
unità di controllo
o
unità aritmetica e logica (ALU)
o
registri interni;
•
in posizione fisicamente adiacente alla CPU c'è la memoria centrale (di tipo
RAM, Random Access Memory, cioè ad accesso casuale uniforme);
•
seguono i vari dispositivi di Input (disco, tastiera, mouse, scanner, ...) e di
Output (video, stampante, ...).
Occupiamoci in particolare della CPU e delle sue componenti:
•
l' unità di controllo ha il compito di prelevare le istruzioni dalla memoria
principale e di determinarne il tipo, oltre che di sovrintendere al
funzionamento generale del calcolatore;
•
l' unità aritmetico-logica esegue le operazioni elementari (OR, AND, XOR,
somma, moltiplicazione,...) richieste dalle istruzioni;
•
i registri interni sono una specie di piccola memoria ad altissima velocità,
usata dalla CPU per memorizzare i risultati temporanei delle proprie operazioni
e certe informazioni di controllo; ognuno di questi registri ha una particolare
funzione; ad esempio:
o
il registro più importante è il Program Counter (PC), il quale punta
alla prossima istruzione da eseguire ( 3);
o
il registro delle istruzioni Instruction Register (IR) contiene di volta
in volta l'istruzione da eseguire.
C
nii
uzziioon
deellllee iissttrru
nee d
uzziioon
dii eesseeccu
Ciicclloo d
La CPU esegue un programma (ossia una sequenza di istruzioni) attraverso la
successione dei seguenti passi:
1. legge la nuova istruzione dalla memoria (usando l’indirizzo contenuto nel
registro PC) e la pone nel registro delle istruzioni (IR); questa fase è detta
di fetch dell’istruzione;
2. cambia il valore del registro PC, in modo che punti all’istruzione seguente;
3. determina il tipo di istruzione appena prelevata, leggendo i primi bit del
registro IR (i quali recano il codice operativo dell’istruzione);
4. se l’istruzione usa dei dati (operandi) nella memoria, determina la loro
posizione;
5. preleva i suddetti dati e li pone nei registri interni della CPU;
6. esegue l’istruzione, tramite l’uso dell’unità aritmetica e logica;
7. memorizza il risultato nel “posto” previsto dalla istruzione (sia esso un
registro o una locazione di memoria);
8. ritorna al passo 1 e comincia ad eseguire l’istruzione seguente.
3
Si noti che il nome “contatore di programma” è decisamente fuorviante, in quanto non ha niente a che fare con il
conteggio di qualcosa.
aggiornamento: 30 giugno 2001
9
Autore: Sandro Petrizzelli
Appunti di “Calcolatori Elettronici”
Spesso, questa sequenza di passi viene detta ciclo preleva-decodifica-esegui,
per evidenti motivi. Essa è alla base del funzionamento di tutti i calcolatori.
IIn
nssiieem
mee d
deellllee iissttrru
uzziioon
nii
Il gruppo di tutte le istruzioni disponibili per un programmatore, ad un
determinato livello, si chiama insieme di istruzioni di quel livello. Il numero di
istruzioni contenute in tale insieme varia sia da livello a livello sia da macchina a
macchina. Un grosso insieme di istruzioni non necessariamente è migliore di uno
piccolo; al contrario, spesso vale il concetto opposto, dato che un grosso insieme di
istruzioni significa che tali istruzioni sono piuttosto specifiche, mentre invece i
compilatori dei linguaggi ad alto livello (come il Pascal o il C) lavorano meglio su
macchine con insiemi di istruzioni piccoli e ben scelti.
Le macchine con insiemi di istruzioni molto piccoli sono dette macchine RISC
(Reduced Instruction Set Computers) e si contrappongono alle macchine CISC
(Complex Instruction Set Computers): esempi di macchine CISC sono i processori
Intel a partire dal 80386, oppure i più vecchi IBM 360, Motorola 780030 o il DEC
VAX. Le macchina RISC non usano la microprogrammazione e sono molto veloci.
O
U
PU
CP
deellllaa C
nee d
niizzzzaazziioon
Orrggaan
L’organizzazione interna di una parte della classica CPU di Von Neumann è
mostrata dettagliatamente nella figura seguente, facendo riferimento ad un esempio
semplice di somma tra due numeri:
A+B
Registro
della CPU
A
B
A
B
Registri di input
della ALU
ALU
Registro di output
della ALU
A+B
Cammino dei dati di una tipica macchina di Von Neumann
Quando l'unità aritmetica e logica deve eseguire una operazione tra due dati, il
cammino di tali dati, secondo lo schema di Von Neumann, è il seguente:
Autore: Sandro Petrizzelli
10
aggiornamento: 30 giugno 2001
Concetti introduttivi generali sui calcolatori
•
i due dati vengono prelevati dai registri interni della CPU (oppure dalla
memoria);
•
vengono quindi inviati a due registri di input per l'ALU;
•
l'ALU esegue l'operazione richiesta sui dati contenuti in tali registri e
deposita il risultato in un registro di output (sempre specifico della ALU),
dal quale i dati verranno successivamente trasportati nella destinazione
finale (che potrà essere un registro della CPU, come in figura, oppure una
locazione della memoria centrale).
A proposito della posizione degli operandi di una istruzione e del risultato di una
operazione su di essi, si distinguono tre categorie di istruzioni:
o
istruzioni da memoria a registro, che permettono il passaggio delle
parole dalla memoria ai registri della CPU, dove possono essere usate come
input dell’ALU, quali operandi di istruzioni;
o
istruzioni da registro a registro, che prendono i due operandi dai registri
della CPU, li portano nei registri di input della ALU, eseguono l’operazione
su di essi e memorizzano il risultato di nuovo in un registro della CPU;
o
istruzioni da memoria a memoria, che portano gli operandi dalla
memoria direttamente ai registri di input dell’ALU, eseguono l’operazione e
riscrivono il risultato direttamente in memoria.
Il cammino dei dati è il cuore della maggior parte delle CPU, in quanto, in un
certo senso, definisce ciò che la macchina può fare.
E
paarraalllleelloo
np
nii iin
uzziioon
dii iissttrru
nee d
uzziioon
Esseeccu
L’obbiettivo primario dei progettisti dei calcolatori è stato sempre, fin dagli albori
dell’informatica, quello di rendere i calcolatori quanto più veloci possibile: a tal
proposito, ci si rese conto subito che le accelerazioni ottenibili tramite un
miglioramento dell’hardware sono comunque limitate; ad esempio, le leggi della
fisica dicono che niente può andare più veloce della luce (cioè circa 30 cm per ns
nel vuoto e 20 cm in un filo di rame), il che comporta che, per realizzare un
calcolatore con un tempo di esecuzione di 1 ns per istruzione, la distanza totale su
cui il segnale elettrico può viaggiare, all’interno della CPU, verso la memoria e di
ritorno dalla memoria, non può essere maggiore di 20 cm; in poche parole,
calcolatori molto veloci devono anche essere molto piccoli.
Non basta però dire che minori dimensioni equivalgono a maggiori velocità:
infatti, i calcolatori veloci producono più calore di quelli lenti, per cui la riduzione
delle dimensioni complica i meccanismi di dissipazione del calore. Proprio per
questo, alcuni supercalcolatori sono immersi nel freon liquido, usato come liquido
di raffreddamento, per riuscire a trasferire all’esterno il calore il più velocemente
possibile.
Sulla scorta di queste ed altre considerazioni relative ai vincoli fisici di
realizzazione dei calcolatori, si è pensato che, al posto di costruire un’unica CPU ad
alta velocità, si potrebbe costruire una macchina con molte ALU più lente (e quindi
più economiche e facili da realizzare) o perfino con diverse CPU complete, da
collegare e far funzionare in modo da ottenere la stessa potenza di calcolo ma ad un
costo minore. Si parla in questo caso genericamente di macchine parallele;
aggiornamento: 30 giugno 2001
11
Autore: Sandro Petrizzelli
Appunti di “Calcolatori Elettronici”
vogliamo dare dei cenni ad alcune tecniche di realizzazione di questo tipo di
macchine.
In primo luogo, le macchine parallele possono essere divise in tre categorie, a
seconda di quanti flussi di istruzioni e di dati sono presenti in esse
(classificazione di Flynn):
•
macchine SISD (Single Instruction Single Data): flusso di istruzioni unico e
flusso di dati unico;
•
macchine SIMD (Single Instruction Multiple Data): flusso di istruzioni
unico e flusso di dati multiplo;
•
macchine MIMD (Multiple Instruction Multiple Data): flusso di istruzioni
multiplo e flusso di dati multiplo.
La macchina tradizionale di Von Neumann è ovviamente di tipo SISD: essa ha un
unico flusso di istruzioni (cioè un unico programma) eseguito da una CPU ed ha poi
un’unica memoria che contiene i dati usati dal programma; la prima istruzione
viene presa dalla memoria e poi eseguita, dopodiché si passa al prelievo ed alla
esecuzione dell’istruzione successiva e così via fino al termine del programma.
Si tratta perciò di un modello prettamente sequenziale. Nonostante questo, anche
in un simile modello è possibile avere un limitato grado di parallelismo: infatti, si
può tentare di prelevare una nuova istruzione e cominciare ad eseguirla prima che
quella attualmente in esecuzione sia completata. Ad esempio, il calcolatore CDC
6600 ed alcuni dei suoi successori erano dotati di unità funzionali multiple (ALU
specializzate), ognuna delle quali poteva eseguire una sola operazione ad alta
velocità. Un esempio di una simile macchina è riportato nella figura seguente:
Registri
+
+
-
*
+
Una CPU con 5 unità funzionali che possono operare in parallelo
Come si vede, abbiamo 5 unità funzionali, tre per le operazioni di somma (molto
frequenti) ed una ciascuno per le operazioni di sottrazione e moltiplicazione.
L’idea di fondo di una simile architettura è che l’unità di controllo vada a
prendere una istruzione dalla memoria e poi la passi ad una delle unità funzionali
Autore: Sandro Petrizzelli
12
aggiornamento: 30 giugno 2001
Concetti introduttivi generali sui calcolatori
per l’esecuzione; nel frattempo, l’unità di controllo prende l’istruzione successiva e
la passa ad un’altra unità funzionale. Questo procedimento continua fin quando
tutte le unità funzionali del tipo richiesto sono occupate oppure quando l’operando
necessario ad una istruzione è ancora in fase di elaborazione.
Questa strategia richiede che il tempo per eseguire una istruzione sia abbastanza
maggiore di quello richiesto per prelevarla: per questo motivo, essa viene
generalmente usata solo per operazioni in virgola mobile, che sono complesse e
lunghe, e non per operazioni su interi, che sono invece semplici e veloci.
Una variante della strategia appena descritta consiste nel dividere l’esecuzione di
ogni istruzione in più parti; ad esempio, nella prossima figura è illustrato quello
che accade per una CPU suddivisa in 5 unità di elaborazione, denominate P1, P2,
P3, P4 e P5:
P1
P2
P3
P4
P5
Unità di
prelevamento
istruzioni
Analizzatore
di
istruzioni
Unità di
calcolo
indirizzi
Unità di
prelevamento
dati
Unità di
esecuzione
istruzioni
P1:
P2:
P3:
P4:
P5:
1
2
3
4
5
6
7
8
9
1
2
3
4
5
6
7
8
1
2
3
4
5
6
7
1
2
3
4
5
6
1
2
3
4
5
tempo ->
Macchina a 5 unità con pipeline (figura in alto). Lo stato di ogni unità di elaborazione (figura
in basso) viene illustrato in funzione del tempo
Durante il primo intervallo di tempo, l’istruzione viene prelevata dalla memoria
dall’unità P1; nel secondo intervallo di tempo, l’istruzione viene passata a P2 per
essere analizzata, mentre, in contemporanea, P1 prende una nuova istruzione. In
ognuno degli intervalli successivi, una nuova istruzione è prelevata da P1, mentre
le altre istruzioni sono passate ad una unità successiva lungo il percorso.
Una simile organizzazione è detta macchina a pipeline: se ciascun intervallo di
tempo dura x ns, sono necessari 5x ns per eseguire una istruzione; tuttavia,
all’unità P5 arriva una istruzione completa ogni x ns, ottenendo così un incremento
di prestazioni di ben 5 volte (una volta raggiunta la condizione di regime, a partire
dal quinto intervallo di tempo).
Una cosa importante da notare è che una macchina a pipeline, nonostante
impieghi una sorta di parallelismo interno, è ancora una macchina SISD: c’è infatti
un solo programma ed un solo insieme di dati.
A differenze delle macchine SISD, le macchine SIMD operano invece in parallelo
su insiemi multipli di dati. Una tipica architettura adatta a questo compito è la
cosiddetta macchina vettoriale, schematizzata nella figura seguente:
aggiornamento: 30 giugno 2001
13
Autore: Sandro Petrizzelli
Appunti di “Calcolatori Elettronici”
A
Vettore
in input
B
ALU vettoriale
Vettore
in output
A+B
Esempio di ALU vettoriale composta da 8 unità
In questo caso, il percorso dei dati a simile a quello delle macchine SISD
tradizionali, ad eccezione del fatto che, invece di avere una sola variabile per ogni
ingresso della ALU, abbiamo ora un vettore con N input. Ovviamente, la ALU è ora
una ALU vettoriale, capace cioè di eseguire delle operazioni ricevendo in ingresso
non più due scalari, bensì due vettori, e restituendo a sua volta un vettore.
Un approccio alternativo è costituito dal cosiddetto Array Processor, illustrato
nella figura seguente:
Unità di controllo
Trasmette istruzioni
Processore
Memoria
Griglia di processori/memoria di dimensione 8×8
Autore: Sandro Petrizzelli
14
aggiornamento: 30 giugno 2001
Concetti introduttivi generali sui calcolatori
Si tratta di una vera e propria griglia quadrata di elementi, ognuno dei quali è
costituito da un processore e da una memoria. Esiste una singola unità di
controllo, che trasmette le istruzioni, le quali sono eseguite da tutti i processori
usando la propria memoria (caricata durante la fase di inizializzazione). Una simile
architettura è particolarmente adatta per calcoli su matrici.
La terza categoria di Flynn è costituita dalle macchine MIMD, in cui diverse CPU
eseguono diversi programmi, a volte condividendo una parte di memoria comune.
La figura seguente mostra ad esempio una macchina MIMD in cui più processori
usano una memoria unica, cui accedono tramite un bus:
CPU
CPU
CPU
Memoria
condivisa
CPU
BUS
Multiprocessore di base
Il problema di una simile architettura è che, se le CPU sono molte veloci, i
conflitti sull’uso del bus sono troppi. Una alternativa per aggirare questo problema
sarebbe quella di dotata ciascun processore di una quantità di memoria locale
propria, non accessibile agli altri, da affiancare alla memoria condivisa:
Memoria
locale
Memoria
locale
Memoria
locale
Memoria
locale
CPU
CPU
CPU
CPU
Memoria
condivisa
BUS
Multiprocessore con memorie locali
La memoria locale può essere usata per il codice del programma e, in generale,
per tutti gli elementi che non devono essere condivisi.
Altri processori non usano addirittura un unico bus, ma diversi bus per ridurre
ulteriormente il carico. Altri ancora usano la tecnica della memoria cache, in cui
tenere le parole della memoria usate più frequentemente.
La memoria
La memoria è quella parte del calcolatore in cui sono immagazzinati i programmi
ed i dati. Senza una memoria in cui i processori possano leggere e scrivere
informazioni, non esisterebbero calcolatori digitali con programmi memorizzati.
aggiornamento: 30 giugno 2001
15
Autore: Sandro Petrizzelli
Appunti di “Calcolatori Elettronici”
II bbiitt
L’unità fondamentale della memoria è la cifra binaria, detta bit. Ogni bit può
contenere uno 0 oppure un 1. E’ dunque l’unità più semplice possibile da
memorizzare ed elaborare.
Spesso si dice che i calcolatori usano l’aritmetica binaria perché è più efficiente;
in realtà, l’aritmetica binaria gode di due pregi: l’efficienza e l’affidabilità.
Cominciamo
proprio
dall’affidabilità: l’informazione digitale può essere
memorizzata distinguendo tra i diversi valori di qualche grandezza fisica continua
(o, meglio, analogica), come la tensione o la corrente; quanti più valori devono
essere distinti, tanto meno separazione esisterà tra valori adiacenti e quindi tanto
meno la memoria sarà affidabile; allora, nel caso del sistema di numerazione
binaria, i valori da distinguere sono solo due, il che lo rende il sistema più
affidabile possibile per la codifica delle informazioni.
Talvolta, si pubblicizzano alcuni calcolatori, come i grandi mainframe IBM,
dicendo che sono dotati dell’aritmetica decimale oltre che di quella binaria. Il
“trucco”, in questa affermazione, è semplice: si usano 4 bit per memorizzare una
singola cifra decimale, secondo una tecnica chiamata BCD (Binary-Coded Decimal).
Evidentemente, dato che 4 bit forniscono 2 4 =16 combinazioni, 10 di queste sono
usate per le 10 cifre decimali (da 0 a 9), mentre le rimanenti 6 rimangono
inutilizzate. Così facendo, ad esempio, il numero 1944 sarà codificato nel modo
seguente:
sistema decimale:
sistema binario:
0001 1001 0100 0100
0000011110011000
In entrambi i casi, sono stati usati 16 bit, ma con una differenza fondamentale: i
16 bit del formato decimale possono memorizzare solo i numeri da 0 a 9999,
permettendo cioè solo 10000 combinazioni, mentre invece i 16 bit binari
consentono di rappresentare 65536 diverse combinazioni, ossia più di 6 volte tanto.
Per questa ragione si dice che l’aritmetica binaria è più efficiente.
G
moorriiaa
meem
dii m
nd
diirriizzzzii d
Gllii iin
La memoria principale di un calcolatore è costituita da un numero di celle (o
locazioni), ognuna delle quali può immagazzinare un elemento di informazione.
Ogni cella è individuata da un proprio numero (detto indirizzo) con il quale i
programmi possono riferirsi ad essa. Se una memoria ha N celle, allora tali celle
avranno indirizzi compresi tra 0 e N-1.
cella #0
cella #1
cella #2
cella ....
cella #N-2
cella #N-1
Schematizzazione della divisione in celle di una memoria, numerate in modo progressivo da 0 ad
N-1, dove N è il numero di celle
Autore: Sandro Petrizzelli
16
aggiornamento: 30 giugno 2001
Concetti introduttivi generali sui calcolatori
Ogni cella di memoria contiene lo stesso numero di bit. Se una cella contiene K
bit, allora essa può contenere una qualsiasi delle 2 K combinazioni diverse di tali
bit. Le celle adiacenti hanno ovviamente indirizzi consecutivi.
I calcolatori che usano l' aritmetica binaria esprimono anche gli indirizzi di
memoria tramite numeri binari. Ad esempio, se un indirizzo di memoria binario è
costituito da M bit, significa che il numero massimo di celle direttamente
indirizzabili è 2 M . Il numero di bit nell'indirizzo è dunque collegato al numero
massimo di celle direttamente indirizzabili, ma invece non dipende affatto dal
numero di bit per ogni cella. Ad esempio, una memoria con 2 12 celle ciascuna da 8
bit avrebbe bisogno di indirizzi a 12 bit così come una memoria con 2 12 celle da 60
bit: ciò che conta è il numero di celle e non la loro dimensione.
La cella è l’unità indirizzabile più piccola. Negli ultimi anni, molti costruttori
hanno standardizzato celle a 8 bit, dette byte. A loro volta, i byte sono raggruppati
in parole. Il numero di byte costituenti una parola varia da calcolatore e
calcolatore: ad esempio, un calcolatore con una parola a 16 bit ha evidentemente 2
byte/parola, mentre invece un calcolatore con una parola a 32 bit ha
evidentemente 4 byte/parola (questo è il caso oggi più comune).
La ragione per l’uso delle parole è che molte istruzioni operano su parole intere:
un esempio classico è la somma tra due parole. Di conseguenza, una macchina a
16 bit (ossia con parole a 16 bit) avrà registri a 16 bit e istruzioni per manipolare
parole a 16 bit, mentre invece una macchina a 32 bit (ossia con parole a 32 bit)
avrà registri a 32 bit e istruzioni per spostare, sommare, sottrarre e manipolare
parole a 32 bit.
P
M
OM
RO
M ee R
AM
RA
moorriiaa:: R
meem
deellllaa m
neerraallii d
prriieettàà ggeen
Prroop
Le memorie che possono essere sia scritte sia lette sono chiamate RAM (Random
Access Memory, ossia memoria ad accesso casuale), che in realtà è un termine
improprio (per quanto ormai diffusamente utilizzato), dato che tutti i chip di
memoria sono accessibili in maniera casuale.
Le RAM si dividono in due varietà:
•
le RAM statiche (SRAM) sono costruite internamente in modo che il loro
contenuto venga mantenuto fin quando sono alimentate;
•
le RAM dinamiche (DRAM) sono sostanzialmente delle matrici di piccoli
condensatori, ognuno dei quali può essere caricato o scaricato, in modo da
memorizzare uno 0 oppure un 1. Dato che la carica elettrica tende a
disperdersi, ogni bit di una DRAM deve essere rinfrescato ogni pochi
millisecondi se si vuole che i dati non svaniscano. Dato che deve essere la
logica esterna a curare il “rinfrescamento”, le memorie DRAM richiedono
una interfaccia più complessa rispetto alle SRAM; a fronte di questo
svantaggio, le DRAM hanno il pregio di capacità generalmente maggiori
rispetto alle SRAM. Alcune DRAM hanno inoltre la logica di rinfrescamento
direttamente sul chip, il che permette sia una grande capacità sia una
interfaccia semplice: si parla in questo caso di chip quasi-statici.
Le RAM non sono comunque l’unico tipo di chip di memoria; in molte
applicazioni, infatti, il programma da eseguire e parti dei dati necessari devono
rimanere memorizzati anche quando la corrente viene disinserita; oltre a questo,
molti programmi devono necessariamente rimanere inalterati una volta installati.
Questi requisiti hanno portato allo sviluppo delle memorie ROM (Read-Only
Memory, ossia memorie a sola lettura): il contenuto di queste memorie non può
aggiornamento: 30 giugno 2001
17
Autore: Sandro Petrizzelli
Appunti di “Calcolatori Elettronici”
essere cambiato o cancellato in alcun modo. Il contenuto di una ROM viene inserito
durante la costruzione del chip, esponendo un materiale fotosensibile attraverso
una maschera che contiene la configurazione desiderata di bit e poi incidendo la
superficie esposta (oppure quella non esposta).
Le ROM sono molto più economiche delle RAM, specialmente se ordinate in
grandi quantità per sostenere le spese della creazione della maschera. Tuttavia,
queste memorie sono evidentemente poco flessibili proprio perché non modificabili.
Le cosiddette memorie PROM (Programmable ROM, ossia ROM programmabili) sono
state allora introdotte per facilitare lo sviluppo di nuovi prodotti basati su ROM: il
chip è come una ROM, ma può essere programmato (anche se una sola volta) sul
campo.
Lo sviluppo successivo di questi chip è stato quelle delle memorie EPROM
(Erasable PROM, ossia PROM cancellabili): questi chip non solo sono programmabili
come le PROM, ma sono anche cancellabili. In poche parole, quando la cosiddetta
“finestra al quarzo” di una EPROM viene esposta ad una forte luce ultravioletta per
15 minuti, tutti i bit vengono posti ad 1. Nei casi in cui sono necessari molti
cambiamenti durante il ciclo di progettazione, la EPROM è senz’altro più economia
della PROM, proprio perché può essere riutilizzata.
Ancora meglio delle EPROM sono le memorie EEPROM (Electrically Erasable
PROM, ossia PROM cancellabili elettricamente), dette anche EAROM (Electrically
Alterable ROM, ossia ROM alterabili elettricamente): queste memorie possono
essere cancellate semplicemente applicando degli impulsi elettrici anziché
inserendole in una camera speciale per l’esposizione alla luce ultravioletta.
Segnaliamo che una EEPROM differisce da una RAM poiché sia la scrittura di un
byte sia la cancellazione di un byte richiedono un tempo migliaia di volte più lungo;
al contrario, i tempi di accesso per la lettura delle memorie ROM in generale sono
comparabili con quelli delle RAM.
Input e Output
Nei moderni calcolatori si usano solitamente due diverse organizzazioni del
sistema di I/O. Consideriamo ad esempio i main frame:
BUS di memoria
Memoria
centrale
BUS di I/O
CPU
Processore
di I/O
(canale)
Processore
di I/O
(canale)
Controllore
dei terminali
Disco
Disco
Disco
Stampante
Struttura di I/O di un grande mainframe
Autore: Sandro Petrizzelli
18
aggiornamento: 30 giugno 2001
Concetti introduttivi generali sui calcolatori
•
intanto, il sistema di calcolo della macchina è costituito dalla CPU (che può
essere affiancata anche da altre CPU), dalla memoria centrale e da un o più
altri “processori specializzati” per l'input/output, chiamati canali dei dati;
tutti i dispositivi di I/O sono collegati a questi canali;
•
quando la CPU necessita di una operazione di I/O, il meccanismo che viene
utilizzato è il seguente:
o
una volta individuato il dispositivo di I/O del quale si vuol fare uso, la
CPU carica nel relativo canale un “programma speciale” e dice al canale
stesso di eseguirlo;
o
il canale, quindi, si occupa di manipolare tutti gli I/O che sono diretti
alla memoria centrale (input) o che provengono dalla memoria centrale
(output), in modo da lasciare libera la CPU di compiere altre
operazioni;
o
appena terminato il proprio compito, il canale spedisce alla CPU un
segnale detto interruzione (interrupt), avvisando di aver terminato i
propri compiti e richiedendo la sua attenzione.
Il vantaggio di un meccanismo del genere è evidente: tutto il lavoro di I/O viene
demandato al canale, mentre la CPU può occuparsi d'altro; in questo modo, i calcoli
e l'I/O possono avvenire contemporaneamente.
Dato che manipolano generalmente grandi quantità di dati per l'I/O, i mainframe
vengono generalmente dotati di 3 distinti bus:
•
un primo bus collega direttamente ogni canale alla memoria centrale, in
modo che il canale stesso possa leggere e scrivere autonomamente parole
di memoria;
•
un secondo bus collega la CPU a ciascun canale, in modo che essa possa
inviare i comandi ai canali e che ogni canale possa inviare alla CPU i
segnali di interruzione;
•
infine, c'è il bus che collega direttamente la CPU alla memoria centrale.
Nel caso invece dei personal computer, l'organizzazione è evidentemente più
semplice: per queste macchine è prevista una grande piastra a circuito stampato,
detta scheda madre, che contiene i chip della CPU, un po’ di memoria, alcuni chip
di supporto ed un unico bus inciso lungo la sua lunghezza, detto bus di sistema;
tale bus presenta dei connettori ai quali possono essere inseriti i connettori terminali
sia della memoria addizionale sia delle schede dei dispositivi di I/O.
Lo schema di un PC è perciò del tipo seguente:
Disco
CPU
Memoria
centrale
Controllore
della
stampante
Controllore
del video
Controllore
del floppy
disk drive
Controllore
dell'hard
disk rive
BUS
aggiornamento: 30 giugno 2001
19
Autore: Sandro Petrizzelli
Appunti di “Calcolatori Elettronici”
C'è dunque un unico bus che collega la CPU con la memoria e con i dispositivi di
I/O; in particolare, ogni dispositivo di I/O è costituito da due parti:
•
la prima parte, quella direttamente collegata al bus, contiene la maggior
parte della elettronica ed è chiamata controllore;
•
la seconda contiene il dispositivo fisico vero e proprio.
Il controllore è contenuto in una scheda che, come detto prima, viene inserita
sulla piastra madre (tramite opportuni slot) e viene collegata al bus. Solo alcuni
controllori (ad esempio quello della tastiera) vengono direttamente collocati sulla
scheda madre, senza l'uso di piastre aggiuntive.
Il compito del controllore è quello appunto di “controllare” il suo dispositivo di
I/O e di gestire l'accesso di tale dispositivo al bus. Supponiamo, ad esempio, che il
programma in esecuzione in un certo momento richieda dei dati dal disco fisso; il
meccanismo che parte è il seguente:
•
il programma stesso dà un comando al controllore del disco;
•
il controllore dà a sua volta dei comandi all’ hard disk drive e comincia la
ricerca dei dati richiesti;
•
una volta localizzati la pista ed il settore appropriati, il drive comincia a far
pervenire i dati al controllore, tramite un flusso di bit;
•
il controllore suddivide tale flusso di bit in parole e, tramite il bus, scrive
ogni parola in memoria.
In particolare, ci sono dei controllori che sono in grado di leggere o scrivere
parole in memoria senza che alcun intervento "vigile" della CPU: in questo caso si
dice che il controllore in questione ha un accesso diretto alla memoria (DMA).
Il bus non è ovviamene utilizzato solo dai controllori di I/O; anche la CPU usa il
bus per prelevare dati e istruzioni. Può accadere allora che, nello stesso istante, la
CPU ed un controllore richiedano l'accesso al bus. A stabilire chi dei due deve avere
per primo l'accesso al bus è uno specifico chip, detto arbitro del bus: in generale,
esso dà la precedenza ai dispositivi di I/O per motivi di sicurezza dei dati, dato che
alcuni dispositivi di I/O non tollerano ritardi. Ovviamente, quando nessun
dispositivo di I/O richiede l'accesso al bus, allora la CPU ha l'accesso completo. Il
processo per cui i dispositivi di I/O vengono sempre privilegiati, rispetto alla CPU,
per l'accesso al bus prende il nome di furto di cicli ed è un fattore di
rallentamento del calcolatore.
Autore: Sandro Petrizzelli
e-mail: [email protected]
sito personale: http://users.iol.it/sandry
Autore: Sandro Petrizzelli
20
aggiornamento: 30 giugno 2001