Architettura hardware e software di un calcolatore

Lezione 02 di Programmazione 1, 11 settembre 2026. Slide: 1.2 Architettura del calcolatore. Prima: Introduzione al corso e algoritmi. Dopo: Il Linguaggio C.

Il filo della lezione:

tipi di calcolatore      mainframe, PC, laptop, smartphone
        |
        v
livelli software         hardware -> SO -> software di sistema -> applicativo
        |
        v
Von Neumann              CPU, memoria centrale, memoria di massa, periferiche, tutti sul bus
        |
        v
dentro la CPU            registri, ALU, unità di controllo, clock
        |
        v
ciclo di esecuzione      fetch -> decode -> execute, un'istruzione alla volta
        |
        v
esempio  c <- a + b      leggere e scrivere una cella passando dal bus
        |
        v
memorie e periferiche    gerarchia, HDD/SSD, polling e interrupt

1Concetti

1.1Tipologie di calcolatori

(slide 3-4)

La legge di Moore descrive la miniaturizzazione: il numero di transistor su un chip raddoppia circa ogni due anni. Accanto ai dispositivi sempre più piccoli crescono anche le grandi infrastrutture di calcolo, per esempio quelle per l’intelligenza artificiale.

1.2Organizzazione software

Un calcolatore si guarda a strati. Ogni strato usa quello sotto e offre qualcosa di più comodo a quello sopra: salendo, aumenta il livello di astrazione.

+-----------------------------+
|  software applicativo       |   fogli elettronici, client di posta, browser
+-----------------------------+
|  software di sistema        |   ambienti di programmazione: compilatore, debugger
+-----------------------------+
|  sistema operativo          |   Windows, Linux, macOS: gestisce memoria, CPU, periferiche
+-----------------------------+
|  hardware                   |   CPU, memorie, periferiche: la parte fisica che calcola
+-----------------------------+

Chi scrive un programma in C lavora col software di sistema (il compilatore), che produce codice eseguito grazie al sistema operativo sull’hardware. Il passaggio dal sorgente all’eseguibile è in Il Linguaggio C.

1.3La macchina di Von Neumann

L’architettura hardware dei calcolatori si chiama macchina di Von Neumann (slide 11).

L’idea chiave è che dati e istruzioni stanno nella stessa memoria. Un programma è anch’esso una sequenza di parole in memoria, che la CPU va a leggere una alla volta.

Come funziona (slide 14):

• i dati passano da un componente all’altro sempre attraverso il bus di sistema;
• le fasi di elaborazione avanzano in modo sincrono con un orologio di sistema, il clock;
• in ogni intervallo di tempo l’unità di controllo (parte della CPU) stabilisce quale operazione svolgere;
• la macchina lavora in modo sequenziale, un’istruzione dopo l’altra. Le architetture più evolute eseguono anche istruzioni in parallelo.

1.4La CPU

La CPU (Central Processing Unit) è l’unità di elaborazione. Dentro ci sono (slide 23-24):

Un registro è una piccola memoria dentro la CPU, grande una parola, velocissima.

Clock (slide 13). Il lavoro della CPU è scandito dagli impulsi del clock. Più alta la frequenza, più istruzioni per unità di tempo. Si misura in hertz, $1\ \text{Hz} = 1$ ciclo al secondo: nel 1981 si era a $4$ MHz, nel 2004 a $3$ GHz. La frequenza non è tutto: contano anche la memoria disponibile e altri fattori.

1.5Il ciclo di esecuzione

Per ogni istruzione la CPU ripete tre fasi (slide 26):

All’avvio del programma il PC contiene l’indirizzo della prima istruzione. Poi:

1. Fetch (prelievo).

1. La CU copia il contenuto del PC nel registro indirizzi AR.
2. La CU manda alla memoria il segnale di controllo READ per leggere la cella all’indirizzo in AR.
3. La parola letta arriva nel registro dati DR. La CU aspetta il segnale MFC (memory function completed) che conferma la fine della lettura.
4. La CU copia DR nel registro istruzione corrente CIR.

2. Decode (interpretazione). La CU decodifica l’istruzione in CIR: capisce che operazione è e su quali operandi.

3. Execute (esecuzione). La CU genera la sequenza di segnali di controllo che realizza l’istruzione, usando i registri A e B, l’ALU e gli altri registri.

Infine il PC viene incrementato per puntare alla prossima istruzione, e si ricomincia.

Tipi di istruzioni (slide 27):

1.6La memoria centrale

La memoria centrale accoglie dati e programmi su cui opera il calcolatore: mentre usi il computer ci sono il sistema operativo, i programmi aperti e i dati che stai inserendo (slide 16-18).

Struttura. Concettualmente è una sequenza di celle, ognuna delle quali contiene una parola (word).

• A ogni cella si accede direttamente specificandone l’indirizzo, per leggerla o scriverla in un solo passo.
• La lunghezza di una parola, in bit, dipende dalla macchina: 16 bit per l’80286, 32 per Pentium e PowerPC, 64 per UltraSPARC.

Spazio di indirizzamento. Anche gli indirizzi sono numeri binari di lunghezza fissa. Con indirizzi di $k$ bit si possono distinguere $2^k$ celle diverse.

indirizzo (k = 10 bit)         parola (h = 16 bit)
        0   ->  | 0 1 1 0 1 0 0 1 0 0 0 1 1 0 1 0 |
        1   ->  | . . . . . . . . . . . . . . . . |
        2   ->  | . . . . . . . . . . . . . . . . |
      ...
     1023   ->  | . . . . . . . . . . . . . . . . |

spazio di indirizzamento: 2^10 = 1024 celle

La slide dice ”$2^k$ bit”: sono $2^k$ celle (parole), ognuna di $h$ bit.

RAM (slide 19-20). La memoria centrale di solito è una RAM (Random Access Memory):

• ad accesso casuale: il tempo per raggiungere una cella non dipende dal suo indirizzo. Il contrario è un nastro magnetico, dove per arrivare in fondo devi scorrere tutto;
• volatile: spegnendo, il contenuto si perde.

Nelle DRAM (dynamic) il contenuto va rinfrescato periodicamente. Complica la gestione ma rende la singola cella più semplice, quindi si impacchettano più celle nello stesso spazio. Le SRAM (static) non hanno bisogno di refresh ma sono meno dense.

1.7Esempio: eseguire $c \leftarrow a + b$

Un’istruzione di alto livello diventa un piccolo algoritmo per la CPU (slide 28-32):

1. leggi i valori di $a$ e $b$ dalla memoria;
2. sommali con l’ALU (gli operandi passano dai registri A e B);
3. scrivi il risultato nella cella di $c$.

Leggere il valore di $a$. Nell’esempio delle slide $a$ sta nella cella di indirizzo $123$ e vale $42$.

1. La CU carica l’indirizzo $123$ nel registro AR, che lo mette sul bus indirizzi.
2. La CU manda READ sul bus di controllo.
3. La memoria mette il contenuto della cella $123$, cioè $42$, sul bus dati, e il valore arriva nel registro DR.
4. La memoria risponde OK sul bus di controllo: la lettura è completata.

Scrivere il risultato in $c$. Simmetrico: la CU mette l’indirizzo di $c$ ($321$ nelle slide) in AR e sul bus indirizzi, mette il risultato ($70$) in DR e sul bus dati, manda WRITE sul bus di controllo, la memoria salva il valore nella cella $321$ e risponde OK.

Il nome $a$ non esiste per la CPU: esiste solo l’indirizzo $123$. Associare nomi a indirizzi è il lavoro del compilatore, ed è da qui che nasce il concetto di variabile in Il Linguaggio C.

1.8Il bus di sistema

Il bus collega i componenti del calcolatore (slide 41). In ogni istante collega due unità, una che trasmette e una che riceve. È la CPU a scegliere quale collegamento attivare e quale operazione fare (bus mastering, schema master/slave).

Il bus è diviso in tre gruppi di linee:

1.9Gerarchia di memoria

Memorie veloci costano di più e sono piccole, memorie capienti sono lente. Si usano tutte insieme, ognuna al suo livello (slide 33):

       velocità ↑              capacità ↓
  +---------------------+
  |  registri           |   dentro la CPU, pochi byte (es. 64 bit)
  +---------------------+
  |  cache (SRAM)       |   pochi dati usati spessissimo (es. 250 KB)
  +---------------------+
  |  memoria principale |   DRAM, molti più dati, meno veloce
  +---------------------+
  |  memoria di massa   |   HDD, SSD, CD, DVD: tantissimi dati, molto più lenta
  +---------------------+
       velocità ↓              capacità ↑

Le slide fanno anche il parallelo con la memoria umana: a lungo termine (si scrive, si legge, si cancella) e a breve termine (volatile, capacità limitata, decade in centinaia di millisecondi, il chunking ne aumenta la capacità).

1.10Memorie di massa

Una memoria di massa è un dispositivo di memorizzazione permanente con grande capacità (slide 35). Si classificano in:

• fisse o rimovibili;
• ad accesso sequenziale (nastro) o casuale (disco);
• in sola lettura (RO), lettura e scrittura (RW), o WORM (write once, read many);
• magnetiche, ottiche, magneto-ottiche.

Hard disk (HDD) (slide 37-39). Dal 1956. Usa materiali ferromagnetici: ogni micro-cella si magnetizza in una direzione o nell’altra, e ogni direzione vale un bit. La magnetizzazione resta senza alimentazione ma si può cambiare.

• Ogni superficie è divisa in tracce concentriche, ogni traccia in settori. Le tracce alla stessa distanza dal centro sulle diverse facce formano un cilindro.
• Tempo di accesso $= ST + LT + TT$:

Da dove viene il 4,2: a 7200 giri al minuto il disco fa $7200 / 60 = 120$ giri al secondo, quindi un giro dura $1/120$ s $\approx 8{,}3$ ms. Quando la testina arriva sulla traccia, il settore cercato può essere appena passato (bisogna aspettare quasi un giro intero) o essere proprio lì (zero attesa): in media si aspetta mezzo giro, $8{,}3 / 2 \approx 4{,}2$ ms. Gli 8 ms sono il caso peggiore, non la latenza tipica.

SSD (slide 40). Memorie a stato solido: accesso tutto elettronico, niente parti in movimento. Avvio immediato, posizionamento circa $0{,}1$ ms, latenza bassissima, $100$-$600$ MB/s. Costano di più per GB.

1.11Periferiche

Interfaccia (slide 43-45). Ogni periferica si collega al bus attraverso un’interfaccia che gestisce lo scambio di dati con la CPU. Contiene un registro dati, un registro di comando e un registro di stato. I registri della periferica possono:

• stare nello stesso spazio di indirizzi della memoria (memory mapped I/O);
• avere uno spazio di indirizzi e istruzioni separato (port mapped I/O).

Invece di un’interfaccia diversa per ogni dispositivo si usano interfacce standard: seriale RS-232-C, SCSI, USB.

Polling e interrupt (slide 46-48). La CPU è molto più veloce di qualsiasi periferica, quindi bisogna sincronizzarle. Esempio: leggere da un disco.

POLLING                                    INTERRUPT
CPU: comando di lettura                    CPU: comando di lettura
CPU: controlla stato -> non pronto         CPU: continua a fare altro
CPU: controlla stato -> non pronto         ...
CPU: controlla stato -> non pronto         periferica: "pronto!" (interrupt)
CPU: controlla stato -> pronto             CPU: salva il suo stato
CPU: copia il dato in memoria              CPU: routine di gestione (parte del SO)
                                                copia il dato in memoria
                                           CPU: riprende da dove era

Terminali e stampanti (slide 49-50). Un video si descrive con dimensione (diagonale in pollici), risoluzione (pixel × pixel), dot pitch (mm) e frequenza di refresh (Hz). Una stampante con velocità (pagine al minuto, PPM) e risoluzione (punti per pollice, DPI); tipi: a margherita, ad aghi, a getto d’inchiostro, laser.

2Esercizi tipo esame

Esercizio 1. Una macchina ha indirizzi di 16 bit e parole di 32 bit. Quante celle può indirizzare? Quanti byte di memoria sono al massimo?

Esercizio 2. Quanti bit di indirizzo servono per 1000 celle? E per una memoria di 4 GiB in cui ogni byte ha il suo indirizzo?

Esercizio 3. Un disco gira a 5400 giri/min e ha tempo di posizionamento medio 9 ms. Stima il tempo medio di accesso a un settore, trascurando il trasferimento.

Esercizio 4. Descrivi i passi con cui la CPU scrive il valore 70 nella variabile $c$, che sta all’indirizzo 321. Quali registri e quali linee del bus usa?

Esercizio 5. SI o NO?

1. La RAM conserva i dati anche a computer spento.
2. La cache è più veloce della memoria centrale.
3. Il PC contiene l’istruzione in esecuzione.
4. Il bus dati trasporta gli indirizzi delle celle.
5. Con la gestione a interrupt la CPU aspetta in un ciclo che la periferica sia pronta.
6. Un hard disk è una memoria ad accesso sequenziale.

3Errori tipici

• Confondere PC (un indirizzo) e CIR (un’istruzione).
• Dire che con $k$ bit si indirizzano $2^k$ bit: sono $2^k$ celle, ognuna di una parola (la slide lo scrive male).
• Prendere la frequenza di clock per il numero di istruzioni al secondo.
• Usare un giro intero come latenza media di un disco: è mezzo giro.
• Confondere “accesso casuale” con “accesso a caso”: vuol dire che ogni cella si raggiunge direttamente, nello stesso tempo.
• Scambiare polling e interrupt.

4Domande

• Quali sono le tre linee del bus di sistema e cosa trasporta ciascuna?

• Descrivi i passi per leggere il valore della variabile $a$ che sta all’indirizzo $123$.

• Da quali tre tempi è composto il tempo di accesso di un hard disk?

• Che differenza c’è fra gestione delle periferiche a polling e a interrupt?