Note Ingegneria Informatica · UniTN
Programmazione 1
Esercizi
Lezione
11 set
in corso

Architettura hardware e software di un calcolatore

Lezione 02 di Programmazione 1, 11 settembre 2026. Slide: 1.2 Architettura del calcolatore, slide 1-51. 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

1Definizioni

Macchina di Von Neumann (slide 10-11). È il nome dell’architettura hardware dei calcolatori: CPU, memoria centrale, memoria di massa e periferiche, collegate dal bus di sistema. Dati e istruzioni stanno nella stessa memoria.

Registro. Una piccola memoria dentro la CPU, grande una parola, velocissima. La CPU lavora solo su dati che stanno nei registri: quello che è in memoria va prima portato lì.

Parola (word) e cella (slide 17). La memoria centrale è una sequenza di celle, ognuna contiene una parola. La lunghezza della parola in bit dipende dalla macchina: 16 bit per l’80286, 32 per Pentium e PowerPC, 64 per UltraSPARC.

Indirizzo e spazio di indirizzamento (slide 18). L’indirizzo è il numero che identifica una cella. Il numero di bit di un indirizzo è caratteristico del processore (Pentium: 32 bit) e ne fissa lo spazio di indirizzamento: con kk bit si distinguono 2k2^k celle.

RAM (slide 19-20). Random Access Memory, memoria ad accesso casuale: il tempo di accesso non dipende dall’indirizzo della cella. È volatile: il contenuto si perde quando manca l’alimentazione.

ROM. Read Only Memory, memoria a sola lettura. Sulla slide della memoria centrale c’è solo l’etichetta “RAM e ROM” (slide 22), ma all’esame è uscita come domanda. Il contenuto è scritto in fabbrica (o con procedure speciali) e non si perde allo spegnimento. Contiene il programma che parte all’accensione (firmware, il BIOS o UEFI dei PC): quando si accende il calcolatore la RAM è vuota, e qualcuno deve dire alla CPU da dove cominciare.

Memoria di massa (slide 35). Dispositivo di memorizzazione permanente (non volatile) con grande capacità: dischi, SSD, nastri, CD, DVD.

Cache (slide 33). Memoria veloce (SRAM) fra CPU e memoria centrale, che contiene pochi dati acceduti frequentemente.

Bus di sistema (slide 41). Interconnette i componenti del calcolatore. In ogni istante collega due unità, una che trasmette e una che riceve. È diviso in bus dati, bus indirizzi e linee di controllo.

Clock (slide 13). L’orologio interno che genera gli impulsi che scandiscono il lavoro della CPU. La frequenza si misura in hertz, 1 Hz=11\ \text{Hz} = 1 ciclo al secondo.

Polling e interrupt (slide 46). I due modi di sincronizzare CPU e periferiche. Con il polling (a controllo di programma) il processore continua a verificare se il dato è arrivato. Con l’interrupt il processore viene notificato dell’arrivo del dato, e la notifica interrompe quello che stava facendo.

2Concetti

2.1Tipologie di calcolatori

(slide 3-7)

TipoCaratteristiche
Mainframegrandi dimensioni, elevata potenza, tanta memoria. Negli anni ‘70 occupavano stanze fino a 1000 m², oggi lo spazio di un grande frigorifero in un data center. Gestiscono enormi quantità di transazioni in tempo reale: banche, borsa
Personal computer (desktop)monitor e tastiera separati dall’unità centrale, memorie di massa interne o esterne
Laptopversione portatile del PC
Handheld (smartphone)dimensioni limitate
Smartwatchancora più piccoli

Sui mainframe la slide cita il CEO di IBM (luglio 2026, WSJ): il 70% in valore di tutte le transazioni finanziarie passa ogni giorno da un mainframe. Restano competitivi rispetto ai sistemi distribuiti e al cloud.

La legge di Moore descrive la miniaturizzazione: il numero di transistor su un chip raddoppia circa ogni due anni. Il grafico della slide 5 mostra il volume dei calcolatori che cala dal mainframe allo smartphone, quello della slide 6 i transistor per chip che salgono da circa 10310^3 a circa 10910^9 fra il 1970 e il 2016. Accanto ai dispositivi sempre più piccoli crescono anche le grandi infrastrutture di calcolo, per esempio quelle per l’intelligenza artificiale.

2.2Organizzazione software

(slide 8, ripresa a slide 36)

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.

Esempio 1: aprire un file PDF. Il lettore PDF (applicativo) chiede al sistema operativo di leggere il file; il SO comanda il disco (hardware) e consegna i byte al lettore. Il lettore non sa niente di tracce e settori.

Esempio 2: compilare con gcc. gcc è software di sistema: prende il sorgente C e produce un eseguibile, che poi il SO carica in memoria centrale e fa eseguire alla CPU.

2.3La macchina di Von Neumann

Architettura di Von neumann
ComponenteRuolo
CPUsvolge l’elaborazione, cioè esegue i programmi
Memoria centralecontiene dati e istruzioni dei programmi in esecuzione
Memoria di massaconserva grandi quantità di dati e programmi in modo persistente (non volatile, a differenza della RAM)
Periferichetastiere, monitor, schede di rete, stampanti, …
Bus di sistemacollega tutti gli altri componenti e permette lo scambio di dati

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):

2.4La CPU

La CPU (Central Processing Unit) è l’unità di elaborazione. Esegue tre passi di un algoritmo (slide 12): carica dalla memoria centrale l’istruzione da eseguire, la interpreta, la esegue (un calcolo numerico, o un trasferimento di informazione, per esempio da memoria a periferica). Dentro ci sono (slide 23-24):

CPU Architettura Von Neumann
ParteSiglaA cosa serve
Registro contatore di programmaPCindirizzo della prossima istruzione da eseguire
Registro istruzione correnteCIRl’istruzione in elaborazione in questo momento
Registro di statoSRi flag sull’esito dell’ultima operazione: riporto (C), zero (Z), segno (S), overflow (V)
Registri A e Bgli operandi su cui lavora l’ALU
Registri generalidati temporanei (il riquadro senza nome della slide)
Registro interruzioniINTRsegnala le richieste di interrupt dalle periferiche
Registro indirizziARl’indirizzo della cella di memoria da leggere o scrivere
Registro datiDRla parola appena letta dalla memoria, o da scrivere
Unità aritmetico-logicaALUfa i calcoli: somme, confronti, operazioni logiche
Unità di controlloCUcoordina tutto: prelievo, decodifica, esecuzione
Clockdà il ritmo (sincronizzazione)

Un modo per ricordarli: AR e DR sono la “porta” della CPU verso il bus (uno dice dove, l’altro porta cosa); PC e CIR servono a sapere quale istruzione si sta facendo (la prossima e quella di adesso); A, B e ALU fanno il conto; SR dice com’è andato.

Esempio di SR: dopo 5−55 - 5 l’ALU dà 0 e accende il flag Z (zero). Dopo 3−73 - 7 il risultato è negativo e si accende S (segno). Le istruzioni di salto condizionato guardano questi flag: un “se x=yx = y” diventa “sottrai e salta se Z è acceso”.

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 Hz=11\ \text{Hz} = 1 ciclo al secondo: nel 1981 si era a 44 MHz, nel 2004 a 33 GHz. La frequenza non è tutto: contano anche la memoria disponibile e altri fattori.

Esempio: a 33 GHz un ciclo dura 13⋅109\frac{1}{3 \cdot 10^9} s ≈0,33\approx 0{,}33 ns. A 44 MHz durava 14⋅106\frac{1}{4 \cdot 10^6} s =250= 250 ns, 750 volte di più.

2.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. Nella slide l’incremento è l’ultimo passo; molte CPU reali lo fanno già durante il fetch, e il risultato è lo stesso.

Il fetch è una lettura dalla memoria come le altre: l’unica differenza è che la parola letta finisce nel CIR (è un’istruzione) invece che in A o B (sarebbe un dato). La memoria non sa se sta consegnando un dato o un’istruzione.

Tipi di istruzioni (slide 27):

TipoEsempi
aritmetichesomma, sottrazione, moltiplicazione, divisione, shift
di controllosalto incondizionato o condizionato, chiamata a sottoprogramma
di trasferimento datida registro a registro, da registro a memoria e viceversa

Un’istruzione di salto è quella che cambia il PC con un valore diverso da “il successivo”: è così che la CPU realizza i “se” e i “mentre” degli algoritmi.

2.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).

Spazio di indirizzamento. Anche gli indirizzi sono numeri binari di lunghezza fissa. Con indirizzi di kk bit si possono distinguere 2k2^k celle diverse. Il perché: ognuno dei kk bit vale 0 o 1, quindi le combinazioni sono 2⋅2⋯2=2k2 \cdot 2 \cdots 2 = 2^k, e ogni combinazione è un indirizzo. Con k=3k = 3: 000, 001, …, 111, cioè 8 indirizzi, da 0 a 7.

Lo schema della slide 22, con k=10k = 10 e h=16h = 16:

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 18 dice “2k2^k bit”: sono 2k2^k celle (parole), ognuna di hh bit. La memoria totale è quindi 2k⋅h2^k \cdot h bit: con k=10k = 10, h=16h = 16 sono 1024⋅16=16 3841024 \cdot 16 = 16\,384 bit, cioè 20482048 byte.

Nello schema compaiono anche AR (largo k=10k = 10 bit, perché contiene un indirizzo) e DR (largo h=16h = 16 bit, perché contiene una parola), con le frecce load (dalla memoria al DR) e store (dal DR alla memoria).

RAM. La memoria centrale di solito è una RAM:

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. Per questo la memoria principale è DRAM (serve tanta) e la cache è SRAM (serve veloce).

ROM. Accanto alla RAM c’è una piccola ROM, non volatile, con il programma di avvio (vedi Definizioni). RAM e ROM sono tutte e due ad accesso casuale: la differenza è che la ROM non si scrive durante il normale funzionamento e non si cancella allo spegnimento.

2.7Unità di misura della memoria

Le slide usano bit, byte, KB e MB senza definirli; all’esame è uscita “unità di memorizzazione”.

UnitàQuanto vale
bituna cifra binaria, 0 o 1: l’informazione minima
byte8 bit
KB (kilobyte)210=10242^{10} = 1024 byte
MB (megabyte)220=1 048 5762^{20} = 1\,048\,576 byte
GB (gigabyte)2302^{30} byte

Le slide usano la convenzione binaria (1 KB = 1024 byte), come si vede dai conti della slide 33. Per non confondersi con i multipli decimali (1 kB = 1000 byte, usati per esempio da chi vende dischi) i multipli binari si scrivono anche KiB, MiB, GiB.

Esempio 1, i conti della slide 33:

Esempio 2, la memoria della slide 42: 64 MB =26⋅220=226= 2^6 \cdot 2^{20} = 2^{26} byte, e 226⋅8=229=536 870 9122^{26} \cdot 8 = 2^{29} = 536\,870\,912 bit, come scritto nel disegno. Se ogni byte ha il suo indirizzo, servono indirizzi di 26 bit.

2.8Esempio: eseguire c←a+bc \leftarrow a + b

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

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

I passi dettagliati della lettura e della scrittura, con i valori delle slide, sono sotto in Esempi svolti a lezione. Il nome aa non esiste per la CPU: esiste solo l’indirizzo 123123. Associare nomi a indirizzi è il lavoro del compilatore, ed è da qui che nasce il concetto di variabile in Il Linguaggio C.

2.9Il bus di sistema

Il bus collega i componenti del calcolatore (slide 41-42). 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:

LineeTrasportano
bus indirizzil’indirizzo della cella o del dispositivo coinvolto
bus datiil dato da leggere o scrivere
bus di controlloche operazione fare (READ, WRITE) e la temporizzazione (OK, MFC)

Il disegno della slide 42 mostra processore, memoria, hard disk, scheda video (framebuffer), scheda audio e un controller per mouse, tastiera e porta seriale, tutti attaccati alle stesse tre linee: address, data, control. Per questo serve il bus mastering: se due unità trasmettessero insieme sulle stesse linee i segnali si mescolerebbero.

Come ricordarlo: per ogni trasferimento servono tre informazioni, dove (indirizzi), cosa (dati), che cosa fare e quando (controllo).

2.10Gerarchia 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 (es. 32 MB)
  +---------------------+
  |  memoria di massa   |   HDD, SSD, CD, DVD: tantissimi dati, molto più lenta
  +---------------------+
       velocità ↓              capacità ↑

Gli SSD, dice la slide, sono 4-10 volte più veloci degli HDD in scrittura.

Perché la cache funziona, anche se è piccola: i programmi riusano spesso gli stessi dati e le stesse istruzioni (un ciclo ripete le stesse righe e legge la stessa variabile a ogni giro), e usano spesso celle vicine fra loro. Tenendo vicino alla CPU quei pochi dati, la maggior parte delle letture si risolve in cache senza andare in DRAM. Questo pezzo non è sulle slide.

Le slide fanno anche il parallelo con la memoria umana (slide 34): a lungo termine (si scrive, si legge, si cancella) e a breve termine (volatile, capacità limitata, decade in centinaia di millisecondi; capire una parola stampata richiede circa 150 ms). Il chunking, cioè raggruppare gli elementi in blocchi, ne aumenta la capacità: 3471298056 sono dieci cifre difficili da tenere a mente, 347 129 8056 sono tre blocchi. La slide indica un esercizio in aula, senza testo.

2.11Memorie di massa

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

Dimensioni tipiche secondo la slide: floppy 1,44 MB, CD 650 MB, DVD 4,7-18 GB, nastri da 350 MB a oltre 20 GB, hard disk molto più di 150 GB.

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 è semipermanente: resta senza alimentazione ma si può cambiare.

TempoCos’èOrdine di grandezza
ST posizionamento (seek)spostare la testina sulla traccia giusta4-8 ms
LT latenza (rotazione)aspettare che il settore passi sotto la testinain media mezzo giro: circa 4,2 ms a 7200 giri/min
TT trasferimentoportare i dati in memoriatrascurabile (80-110 MB/s)

Da dove viene il 4,2: a 7200 giri al minuto il disco fa 7200/60=1207200 / 60 = 120 giri al secondo, quindi un giro dura 1/1201/120 s ≈8,3\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≈4,28{,}3 / 2 \approx 4{,}2 ms. Gli 8 ms sono il caso peggiore, non la latenza tipica. La slide scrive “~8 ms a 7200 rpm”: è il tempo di un giro intero.

Perché TT è trascurabile: un blocco di 4 KB =4096= 4096 byte a 100 MB/s richiede 4096100⋅220\frac{4096}{100 \cdot 2^{20}} s ≈0,04\approx 0{,}04 ms, cento volte meno di ST e LT.

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

2.12Periferiche

Interfaccia (slide 43-45). Ogni periferica si collega al bus attraverso un’interfaccia di I/O che gestisce lo scambio di dati con la CPU. Lo schema della slide 43: dal bus arrivano le tre linee; nell’interfaccia un decodificatore degli indirizzi (riconosce quando il bus parla con questa periferica), i circuiti di controllo, i registri dei dati e di stato; sotto, la periferica. In generale l’interfaccia contiene un registro dati, un registro di comando e un registro di stato (a volte collegato al registro interruzioni della CPU). I registri della periferica possono:

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
PollingInterrupt
comela CPU chiede in continuazione se il dato è prontola periferica avvisa la CPU quando è pronto
prosemplicela CPU non spreca tempo ad aspettare
controla CPU resta bloccata in un ciclo di attesaserve salvare e ripristinare lo stato

Un’analogia: aspettare un pacco. Polling è scendere ad aprire il portone ogni cinque minuti per vedere se il corriere è arrivato. Interrupt è fare altro finché suona il campanello.

Terminali e stampanti (slide 49-50). Un terminale è tastiera, video e spesso mouse; nei PC sono integrati nel calcolatore. 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 (solo testo), ad aghi, a getto d’inchiostro, laser.

3Metodo

Domanda a parole (“descrivi il bus di sistema”, “differenza fra memoria centrale e di massa”). Definizione in una frase, poi le parti o le proprietà in elenco, poi un esempio o un numero. Per il bus: cosa collega, due unità per volta con la CPU master, le tre linee con cosa porta ciascuna, un trasferimento d’esempio.

Lettura o scrittura di una cella. Si scrive sempre nello stesso ordine: indirizzo in AR e sul bus indirizzi; per la scrittura dato in DR e sul bus dati; segnale READ o WRITE sul bus di controllo; per la lettura dato dalla memoria al bus dati e in DR; OK dalla memoria. Per ogni passo si nomina il registro e la linea del bus.

Tracing del ciclo di esecuzione. Tabella con colonne PC, AR, DR, CIR, A, B (e le celle di memoria che cambiano). Per ogni istruzione: le quattro righe del fetch, una riga di decode, le righe dell’execute, l’incremento del PC.

Conti sulla memoria.

  1. Celle indirizzabili con kk bit: 2k2^k.
  2. Bit di indirizzo per NN celle: il più piccolo kk con 2k≥N2^k \geq N.
  3. Dimensione totale: celle per bit di una parola, poi diviso 8 per i byte.
  4. Controllo: le potenze di 2 da sapere a memoria, 210=10242^{10} = 1024, 216=65 5362^{16} = 65\,536, 220≈1062^{20} \approx 10^6, 230≈1092^{30} \approx 10^9, 232≈4,3⋅1092^{32} \approx 4{,}3 \cdot 10^9.

Tempo di accesso di un disco.

  1. Giri al secondo == giri al minuto /60/ 60.
  2. Durata di un giro =1/= 1 / giri al secondo, in ms.
  3. Latenza media == mezzo giro.
  4. Tempo di accesso =ST+LT+TT= ST + LT + TT, con TT di solito trascurabile.

4Esempi svolti a lezione

Leggere il valore di aa (slide 30). Nell’esempio delle slide aa sta nella cella di indirizzo 123123 e vale 4242.

  1. La CU carica l’indirizzo 123123 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 123123, cioè 4242, sul bus dati, e il valore arriva nel registro DR.
  4. La memoria risponde OK sul bus di controllo: la lettura è completata.
passoARDRbus indirizzibus datibus controllo
1123123
2123123READ
31234212342
412342OK

Poi 42 passa da DR al registro A, pronto per la somma. Lo stesso per bb, che finisce in B.

Scrivere il risultato in cc (slide 32). Simmetrico: la CU mette l’indirizzo di cc (321321 nelle slide) in AR e sul bus indirizzi, mette il risultato (7070) in DR e sul bus dati, manda WRITE sul bus di controllo, la memoria salva il valore nella cella 321321 e risponde OK. La slide numera cinque passi:

passoARDRbus indirizzibus datibus controllocella 321
1321321?
23217032170?
33217032170WRITE?
4321703217070
532170OK70

La differenza con la lettura: qui il dato va da DR alla memoria, e DR si riempie prima del segnale; nella lettura DR si riempie dopo. Con a=42a = 42 e c=70c = 70, nelle slide bb vale 70−42=2870 - 42 = 28.

Il ciclo completo su un programmino (esempio in più, non sulle slide: la slide 26 descrive le fasi ma non le segue su un programma). Una macchina giocattolo con quattro istruzioni in memoria, che fa proprio c←a+bc \leftarrow a + b con i valori delle slide:

indirizzo   contenuto
    4       LOAD A, 123      A ← cella 123
    5       LOAD B, 124      B ← cella 124
    6       ADD              A ← A + B  (con l'ALU)
    7       STORE A, 321     cella 321 ← A
  ...
  123       42               a
  124       28               b
  321       ?                c

All’inizio il PC vale 4.

fasePCARDRCIRABcella 321
fetch 1: PC → AR44?
fetch 2-3: READ, la parola arriva in DR44LOAD A, 123?
fetch 4: DR → CIR44LOAD A, 123LOAD A, 123?
decode: leggere la cella 123 in A44LOAD A, 123?
execute: 123 → AR, READ, 42 in DR, DR → A412342LOAD A, 12342?
PC + 1512342LOAD A, 12342?
fetch dell’istruzione in 555LOAD B, 124LOAD B, 12442?
execute: 124 → AR, READ, 28 in DR, DR → B512428LOAD B, 1244228?
PC + 1612428LOAD B, 1244228?
fetch dell’istruzione in 666ADDADD4228?
execute: l’ALU somma A e B, risultato in A66ADDADD7028?
PC + 176ADDADD7028?
fetch dell’istruzione in 777STORE A, 321STORE A, 3217028?
execute: 321 → AR, A → DR, WRITE732170STORE A, 321702870
PC + 1832170STORE A, 321702870

Controllo: 42+28=7042 + 28 = 70, ed è il valore che le slide scrivono nella cella 321. Si contano quattro istruzioni e sette accessi alla memoria: quattro fetch, due letture di dati, una scrittura. Ogni accesso passa dal bus, ed è uno dei motivi per cui una frequenza di clock non è un numero di istruzioni al secondo.

La memoria della slide 22. k=10k = 10 bit di indirizzo, h=16h = 16 bit di parola: 210=10242^{10} = 1024 celle, indirizzi da 0 a 1023, in tutto 1024⋅16=16 3841024 \cdot 16 = 16\,384 bit =2048= 2048 byte =2= 2 KB.

Le dimensioni della slide 33 e la memoria della slide 42: svolte sopra in Unità di misura della memoria, compreso l’errore di battitura sui 32 MB.

Latenza a 7200 giri al minuto (slide 39): svolta sopra, 4,2 ms in media, 8,3 ms nel caso peggiore.

Lettura da disco a polling e a interrupt (slide 47-48): lo schema a due colonne sopra. Nei passi della slide, a polling: (1) la CPU manda il comando di lettura e si mette in attesa; (2) durante l’attesa esegue un ciclo che controlla il registro di stato della periferica; (3) appena il dato è pronto lo copia dal registro dati della periferica in un suo registro e da lì in memoria. A interrupt: (1) la CPU manda il comando e prosegue; (2) quando il dato è pronto la periferica solleva un interrupt; (3) la CPU interrompe quello che fa, salva il suo stato ed esegue la routine di gestione delle interruzioni (parte del SO); (4) la routine copia il dato dal registro della periferica in un registro della CPU e poi in memoria; (5) la CPU riprende da dove era.

5Esercizi tipo esame

In una pagina a parte, dal più facile al livello del 30: Architettura hardware e software di un calcolatore (esercizi).

6Errori tipici

7Domande

Quali sono i quattro livelli dell’organizzazione software di un calcolatore, dal basso verso l’alto?

Dal basso: hardware, sistema operativo, software di sistema (compilatore, debugger), software applicativo. Salendo aumenta il livello di astrazione.

Quali componenti ha la macchina di Von Neumann e cosa li collega?

CPU, memoria centrale, memoria di massa, periferiche, collegati dal bus di sistema.

Cosa contiene il registro PC e cosa il registro CIR?

PC: l’indirizzo della prossima istruzione da eseguire. CIR: l’istruzione in esecuzione, già letta dalla memoria. Il PC contiene un indirizzo, il CIR un’istruzione.

A cosa servono i registri AR e DR?

AR: l’indirizzo della cella da leggere o scrivere, anche quando è un’istruzione. DR: la parola appena letta dalla memoria o quella da scrivere.

Descrivi i passi della fase di fetch.

PC → AR; la CU manda READ alla memoria; la parola letta arriva in DR; la CU aspetta MFC (memory function completed); DR → CIR.

In che unità si misura la frequenza del clock e cosa indica?

In hertz: 1 Hz = un impulso di clock al secondo. Non è il numero di istruzioni al secondo, perché ogni istruzione richiede in generale più cicli di clock (fetch, decode ed execute sono sequenze di passi, e l’accesso alla memoria può far aspettare).

Con indirizzi di kk bit, quante celle di memoria si possono indirizzare?

2k2^k celle, ognuna di una parola da hh bit. Con k=10k = 10 sono 1024 celle. Le slide scrivono “2k2^k bit”: è un errore.

Cosa significa che la RAM è ad accesso casuale? E che è volatile?

Accesso casuale: si raggiunge una cella direttamente dal suo indirizzo, e il tempo non dipende da quale sia (il contrario del nastro). Volatile: senza alimentazione il contenuto si perde.