Politecnico di Milano

Dip. di Elettronica, Informazione e Bioingegneria

prof. Luca Breveglieri prof.ssa Donatella Sciuto
prof. Gerardo Pelosi prof.ssa Cristina Silvano

AXO – Architettura dei Calcolatori e Sistemi Operativi

Prova di lunedì 9 novembre 2020

Cognome ________________________ Nome ________________________

Matricola _____________________ Firma ____________________________

Istruzioni

Si scriva solo negli spazi previsti nel testo della prova e non si separino i fogli.

Per la minuta si utilizzino le pagine bianche inserite in fondo al fascicolo distribuito con il testo della prova. I
fogli di minuta, se staccati, vanno consegnati intestandoli con nome e cognome.

È vietato portare con sé libri, eserciziari e appunti, nonché cellulari e altri dispositivi mobili di calcolo o
comunicazione. Chiunque fosse trovato in possesso di documentazione relativa al corso – anche se non
strettamente attinente alle domande proposte – vedrà annullata la propria prova.

Non è possibile lasciare l’aula conservando il tema della prova in corso.

Tempo a disposizione 2 h : 00 m

Valore indicativo di domande ed esercizi, voti parziali e voto finale:

esercizio 1 (6 punti) _________________________

esercizio 2 (2 punti) _________________________

esercizio 3 (6 punti) _________________________

esercizio 4 (2 punti) _________________________

voto finale: (16 punti) ______________________

CON SOLUZIONI (in corsivo)

esercizio n. 1 – linguaggio macchina
Si deve tradurre in linguaggio macchina simbolico (assemblatore) MIPS il frammento di programma C
riportato sotto. Il modello di memoria è quello standard MIPS e le variabili intere sono da 32 bit. Non si
tenti di accorpare od ottimizzare insieme istruzioni C indipendenti. Si facciano le ipotesi seguenti:
 il registro “frame pointer” fp non è in uso
 le variabili locali sono allocate nei registri, se possibile
 vanno salvati (a cura del chiamante o del chiamato, secondo il caso) solo i registri necessari
Si chiede di svolgere i quattro punti seguenti (usando le varie tabelle predisposte nel seguito):
1. Si descriva il segmento dei dati statici dando gli spiazzamenti delle variabili globali rispetto al registro
global pointer gp, e si traducano in linguaggio macchina le dichiarazioni delle variabili globali.
2. Si descriva l’area di attivazione della funzione ping, secondo il modello MIPS, e l’allocazione dei
parametri e delle variabili locali della funzione ping usando le tabelle predisposte
3. Si traduca in linguaggio macchina il codice dello statement riquadrato nella funzione main.
4. Si traduca in linguaggio macchina il codice dell’intera funzione ping (vedi tab. 4 strutturata).

/ variabili globali /
/ stringa inizializzata, termina con il carattere NULL /
char animal [ ] = “RAT”
int n = 1
int off [ ] =  13, -14, 14 

int strlen (char ) / funzione che modifica arg /

/ funzione ricorsiva /
int ping (int  ptr, char  string) 
int tmp = 0
if (strlen (string) > 0) 
string [0] = string [0] – ptr
tmp = ping (ptr - 1, &string [1]) + tmp - 65
 / if /
return tmp
 / ping /

int main ( )  / programma principale /

n = ping (&off [2], animal)
printf ("\n num = %d, new animal: %s", n, animal)
return 0
 / main /

AXO – prova di lunedì 9 novembre 2020 – CON SOLUZIONI pagina 2 di 18

punto 1 – segmento dati statici (numero di righe non significativo)

spiazzamento
contenuto indirizzo assoluto
rispetto a
simbolico iniziale (in hex)
gp  0x 1000 8000

OFF [2] 0x 1000 0010 0x 8010 indirizzi alti

... ... ...

OFF [0] 0x 1000 0008 0x 8008

N 0x 1000 0004 0x 8004

ANIMAL [3] 0x 1000 0003 0x 8003

... ... ...

ANIMAL [0] 0x 1000 0000 0x 8000 indirizzi bassi

punto 1 – codice MIPS della sezione dichiarativa globale (numero di righe non significativo)

.data 0x 1000 0000 # segmento dati statici standard

ANIMAL: .asciiz “RAT” // varglob array stringa ANIMAL (4 char)

N: .word 1 // varglob N inizializzata

OFF: .word 13, -14, 14 // varglob array di interi OFF

AXO – prova di lunedì 9 novembre 2020 – CON SOLUZIONI pagina 3 di 18

 punto 2 – area di attivazione della funzione PING

spiazz. rispetto
contenuto simbolico
a stack pointer
indirizzi alti
$ra salvato +4

$s0 salvato 0  sp (fine area)

$a0 (a causa chiamata STRLEN)  max estens. pila

indirizzi bassi
Il registro a0 andrà salvato in pila da parte della funzione PING, prima di chiamare la funzione STRLEN, e poi
andrà ripristinato subito dopo; pertanto la pila verrà estesa di una parola.

punto 2 – allocazione dei parametri

e delle variabili locali di PING nei registri

parametro o variabile locale registro

ptr $a0

string $a1
tmp $s0

punto 3 – codice MIPS dello statement riquadrato in MAIN (num. righe non significativo)

// n = ping (&off [2], animal)

MAIN: la $t0, OFF // carica ind elem OFF[0]

li $t1, 2 // carica indice elem OFF[2]

sll $t1, $t1, 2 // allinea indice

addu $a0, $t0, $t1 // prepara param &OFF[2] funz PING

la $a1, ANIMAL // prepara param ANIMAL funz PING

jal PING // chiama funz PING

sw $vo, N // prepara valusc funz PING

// nota: li, sll e addu possono essere compattate in addiu $a0, $t0, 8

AXO – prova di lunedì 9 novembre 2020 – CON SOLUZIONI pagina 4 di 18

 punto 4 – codice MIPS della funzione PING (numero di righe non significativo)
PING: addiu $sp, $sp, -8 // COMPLETARE - crea area attivazione
// direttive EQU e salvataggio/ripristino registri - NON VANNO RIPORTATI
// tmp = 0
move $s0, $zero // inizializza varloc TMP

IF: // if (strlen (string) > 0)

addiu $sp, $sp, -4 // salva reg a0 – push a0
sw $a0, ($sp)
move $a0, $a1 // prepara param funz STRLEN
jal STRLEN // chiama funz STRLEN
lw $a0, ($sp) // ripristina reg a0 – pop a0
addiu $sp, $sp, +4
ble $v0, $zero, ENDIF // se STRLEN <= 0 vai a ENDIF

THEN: // string [0] = string [0] - ptr

lb $t0, ($a1) // carica elem (byte) STRING [0]
lw $t1, ($a0) // carica elem (int) puntato da PTR
sub $t2, $t0, $t1 // calcola espr STRING [0] - PTR
sb $t2, ($a1) // aggiorna elem (byte) STRING [0]
// nota: lb e sb per (s)caricare byte, lw per caricare interi (32 bit)

// tmp = ping (ptr - 1, &string [1]) + tmp - 65

addiu $a0, $a0, -4 // prepara param PING, arit. punt.
addiu $a1, $a1, +1 // prepara param PING, arit. punt.
jal PING // chiama funz PING
add $t0, $v0, $s0 // calcola subespr PING(…)+ tmp
addi $s0, $t0, -65 // calcola subespr ... – 65
// nota: per le due addiu, vedi nota ottimizzazione in calce al main
// nota: invece di addi ..., -65, si potrebbe usare subi ..., 65
ENDIF: // return tmp
move $v0, $s0 // prepara valusc TMP

// rientro
addiu $sp, $sp, 8 // elimina area attivazione
jr $ra // rientra a chiamante
Prima di chiamare STRLEN, il reg a0 va salvato (STRLEN lo modifica), e dopo va ripristinato. Prima di
chiamare PING ricorsivamente, non occorre salvarne gli argomenti (non sono usati dopo la chiamata).

AXO – prova di lunedì 9 novembre 2020 – CON SOLUZIONI pagina 5 di 18

seconda parte – assemblaggio e collegamento
Dati i due moduli assemblatore seguenti, si compilino le tabelle relative a:
1. il modulo oggetto di ROUTINE (il modulo oggetto di MAIN prodotto dall’assemblatore e le relative tabelle
sono già dati)
2. le basi di rilocazione del codice e dei dati di entrambi i moduli
3. la tabella globale dei simboli e la tabella del codice eseguibile

modulo MAIN modulo ROUTINE

.data
.data
SUMFL: .word 0
STR: .asciiz "WALLABY"
.eqv LEN, 5
// N.B.: la direttiva asciiz aggiunge
il char NULL al termine della stringa, .text
per terminarla .globl ROUTINE
.text ROUTINE: lw $s0, ($a0)
.globl MAIN addi $s1, $zero, LEN
MAIN: la $a0, STR beq $s0, $zero, SKIP
jal ROUTINE addu $s1, $a0, $s1
lw $a0, STR SKIP: lw $s2, ($s1)
li $v0, 1 bne $s0, $s1, MAIN
syscall sw $s0, SUMFL
li $v0, 10 jr $ra
syscall

Regola generale per la compilazione di tutte le tabelle contenenti codice:

 i codici operativi e i nomi dei registri vanno indicati in formato simbolico
 tutte le costanti numeriche all’interno del codice vanno indicate in esadecimale, con o senza prefisso 0x,
e di lunghezza giusta per il codice che rappresentano
esempio: un’istruzione come addi $t0, $t0, 15 è rappresentata: addi $t0, $t0, 0x000F
 nei moduli oggetto i valori numerici che non possono essere indicati poiché dipendono dalla rilocazione
successiva, vanno posti a zero e avranno un valore definitivo nel codice eseguibile

AXO – prova di lunedì 9 novembre 2020 – CON SOLUZIONI pagina 6 di 18

 (1) – moduli oggetto

modulo MAIN modulo ROUTINE

dimensione testo: 28 hex (40 dec) dimensione testo: 20 hex (32 dec)

dimensione dati: 08 hex (8 dec) dimensione dati: 04 hex (4 dec)

testo testo
indirizzo indirizzo
istruzione istruzione
di parola di parola
0 lui $a0, 0x 0000 0 lw $s0, ($a0)
4 ori $a0, $a0, 0x 0000 4 addi $s1, $zero, 0x 0005
8 jal 0x 0000000 8 beq $s0, $zero, 0x 0001 (= +1)
C lw $a0, 0x 0000($gp) C addu $s1, $a0, $s1
10 lui $v0, 0x 0000 10 lw $s2, ($s1)
14 ori $v0, $v0, 0x 0001 14 bne $s0, $s1, 0x 0000
18 syscall 18 sw $s0, 0x 0000($gp)
1C lui $v0, 0x 0000 1C jr $ra
20 ori $v0, $v0, 0x 000A 20
24 syscall 24
28
2C

dati dati
indirizzo indirizzo
contenuto contenuto
di parola di parola
0 ꞌWꞌ ꞌAꞌ ꞌLꞌ ꞌLꞌ 0 0x 0000 0000
4 ꞌAꞌ ꞌBꞌ ꞌYꞌ 0x00

tabella dei simboli tabella dei simboli

tipo può essere T (testo) oppure D (dato) tipo può essere T (testo) oppure D (dato)
simbolo tipo valore simbolo tipo valore
MAIN T 0x 0000 0000 ROUTINE T 0x 0000 0000
STR D 0x 0000 0000 SKIP T 0x 0000 0010
SUMFL D 0x 0000 0000

tabella di rilocazione tabella di rilocazione

indirizzo indirizzo
cod. operativo simbolo cod. operativo simbolo
di parola di parola
0 lui STR (parte %hi) 8 beq SKIP
4 ori STR (parte %lo) 14 bne MAIN
8 jal ROUTINE 18 sw SUMFL
C lw STR

Il simbolo LEN dichiarato tramite .eqv è una pura costante e si può non mettere in tabella simboli (la
direttiva .eqv ha lo stesso significato di #define in C, e non ha rilevanza ai fini della rilocazione).

AXO – prova di lunedì 9 novembre 2020 – CON SOLUZIONI pagina 7 di 18

 (2) – posizione in memoria dei moduli

modulo MAIN modulo ROUTINE

base del testo: 0x 0040 0000 base del testo: 0x 0040 0028

base dei dati: 0x 1000 0000 base dei dati: 0x 1000 0008

(3) – tabella globale dei simboli

simbolo valore finale simbolo valore finale

MAIN 0x 0040 0000 ROUTINE 0x 0040 0028

STR 0x 1000 0000 SKIP 0x 0040 0038

SUMFL 0x 1000 0008

NELLA TABELLA DEL CODICE ESEGUIBILE SI CHIEDONO SOLO LE ISTRUZIONI DEI MODULI
MAIN E ROUTINE CHE ANDRANNO COLLOCATE AGLI INDIRIZZI SPECIFICATI

(3) – codice eseguibile

testo

indirizzo codice (con codici operativi e registri in forma simbolica)

... ...

0x 0040 0008 jal 0x 010000A // MAIN: jal ROUTINE

0x 0040 000C lw $a0, 0x 8000($gp) // MAIN: lw $a0, STR

... ...

0x 0040 0030 beq $s0, $zero, 0x 0001 (= +1) // ROUTINE: beq $s0, $zero, SKIP

... ...

0x 0040 003C bne $s0, $s1, 0x FFF0 (= -16) // ROUTINE: bne $s0, $1, MAIN

0x 0040 0040 sw $s0, 0x 8008($gp) // ROUTINE: sw $s0, SUMFL

... ...

AXO – prova di lunedì 9 novembre 2020 – CON SOLUZIONI pagina 8 di 18

spazio libero per continuazione o brutta copia

AXO – prova di lunedì 9 novembre 2020 – CON SOLUZIONI pagina 9 di 18

 esercizio n. 2 – logica digitale
Sia dato il circuito sequenziale composto da due bistabili master-slave di tipo D (D1, Q1 e D2, Q2, dove
D è l’ingresso del bistabile e Q è lo stato / uscita del bistabile), due ingressi IN e SEL, e un’uscita U,
descritto dal circuito seguente:

Si chiede di completare il diagramma temporale riportato qui sotto. Si noti che:

 si devono trascurare completamente i ritardi di propagazione delle porte logiche e i ritardi di
commutazione dei bistabili
 i bistabili sono il tipo master-slave la cui struttura è stata trattata a lezione, con uscita che commuta
sul fronte di discesa del clock (come indicato anche in figura)

tabella dei segnali (diagramma temporale) da completare

 per i segnali D1, Q1, D2, Q2 e U, ricavare, per ogni ciclo di clock, l’andamento della forma d’onda
corrispondente riportando i relativi valori 0 o 1
 a solo scopo di chiarezza, per i segnali di ingresso IN e SEL è riportata anche la forma d’onda per
evidenziare la corrispondenza tra questa e i valori 0 e 1 presenti nella tabella dei segnali complessiva
 notare che nel primo intervallo i segnali Q1 e Q2 sono già dati (rappresentano lo stato iniziale)

0 0 1 1 1 1 1 1 1 1 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 1 1
IN

1 1 1 1 1 1 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 0 0
SEL

D1

0 0 0 0
Q1

D2

0 0 0 0
Q2

CLK 0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1

AXO – prova di lunedì 9 novembre 2020 – CON SOLUZIONI pagina 10 di 18

 SOLUZIONE:

0 0 1 1 1 1 1 1 1 1 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 1 1
IN

1 1 1 1 1 1 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 0 0
SEL

0 0 1 1 1 1 0 0 1 1 1 1 0 0 1 1 1 1 0 0 0 0 1 1 0 0 0 0
D1

0 0 0 0 1 1 1 1 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 1 1 1 1
Q1

0 0 0 0 1 1 1 1 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 1 1 1 1
D2

0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0
Q2

1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0
U

CLK 0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1

AXO – prova di lunedì 9 novembre 2020 – CON SOLUZIONI pagina 11 di 18

esercizio n. 3 – microarchitettura del processore pipeline
prima parte – pipeline e segnali di controllo

Sono dati il seguente frammento di codice macchina MIPS (simbolico), che inizia l’esecuzione all’indirizzo
indicato, e i valori iniziali per alcuni registri e parole di memoria.

indirizzo codice MIPS registro contenuto iniziale

0x 008F FFF8 lw $t1, 0x FFFC($s7) $t1 0x 1002 0001
0x 008F FFFC add $t2, $t2, $t2 $t2 0x 1234 ABCD
0x 0090 0000 sw $t1, 0x 0008($s7) $t7 0x AAAA BBBB
0x 0090 0004 addi $t2, $t1, 0x 7FFC $s7 0x 1000 FFFF
0x 0090 0008 bne $t1, $t7, 0x 0005 memoria contenuto iniziale
0x 0090 000C 0x 1000 FFFB 0x 0055 CCCC

1) Si completi in binario la rappresentazione macchina dell’istruzione lw $t1, 0x FFFC($s7)

000010 10111 01001 1111111111111100

6 bit 5 bit 5 bit 16 bit
op_code rs rt offset

La pipeline NON è ottimizzata per la gestione dei conflitti di controllo. Si consideri il ciclo di clock 5 in cui
l’esecuzione delle istruzioni nei vari stadi è la seguente:

    ciclo di clock
    1  2  3  4  5  6  7  8  9  10 

1 – lw  IF  ID  EX  MEM  WB           

istruzione 

2 – add    IF  ID  EX  MEM  WB         

3 – sw      IF  IDstallo  ID  EX  MEM  WB     

4 ‐ addi        IFstallo  IF  ID  EX  MEM  WB   

  5 ‐ bne            IF  ID  EX  MEM  WB 

2) Calcolare il valore dell’indirizzo di memoria dati nell’istruzione lw (load):

0x 1000 FFFF + 0x FFFF FFFC = 0x 1000 FFFB (con overflow) ________________

3) Calcolare il valore di $t2 + $t2 dell’istruzione add (addizione):

0x 1234 ABCD + 0x 1234 ABCD (raddoppio) = 0x 2469 579A ______________________

4) Dire se il salto condizionato bne viene preso (taken) e calcolarne l’ind. di destinazione:

t1  t7 salto preso;
ind. dest.(BTA) = 0x 0090 000C + (0x 0000 0005 * 4) = 0x 0090 0020 ______

AXO – prova di lunedì 9 novembre 2020 – CON SOLUZIONI pagina 12 di 18

 Completare le tabelle.
I campi Istruzione e di tipo NumeroRegistro possono essere indicati in forma simbolica, tutti gli altri in
esadecimale (prefisso 0x implicito). Utilizzare n.d. se il valore non può essere determinato. N.B.: tutti i
campi vanno completati con valori simbolici o numerici tranne quelli precompilati con *******.

segnali all’ingresso dei registri di interstadio (subito prima del fronte di SALITA del clock – ciclo 5)
IF (addi) ID (sw) EX (sw-stallo) MEM (add)
registro IF/ID registro ID/EX registro EX/MEM registro MEM/WB
.WB.MemtoReg .WB.MemtoReg .WB.MemtoReg
X 0 0
.WB.RegWrite .WB.RegWrite .WB.RegWrite
0 0 1
.M.MemWrite .M.MemWrite
1 0
.M.MemRead .M.MemRead
0 0
.M.Branch .M.Branch
0 0
.PC .PC .PC
0090 0008 0090 0004 0090 0004+ (0000 0008)*4
= 0090 0024
.istruzione .(Rs) ($s7) iniziale
addi 1000 FFFF
.(Rt) ($t1) finale .(Rt) ($t1) iniziale
0055 CCCC 1002 0001
.Rt .R .R
$t1 n.d. $t2
.Rd
****************
.imm/offset esteso .ALU_out .ALU_out
0000 0008 **************** 2469 579A
.EX.ALUSrc .Zero .DatoLetto
1 0 ****************
.EX.RegDest
X

segnali di altre unità funzionali (subito prima del fronte di SALITA del clock – ciclo 5)
Mem.indirizzo RegWrite
2469 579A add 1 lw
MemWrite RegDest
0 add 0 sw-stall
MemRead MemtoReg
0 add 1 lw

ATTENZIONE: LA TABELLA SOTTO È RELATIVA AL CICLO 6 (non 5)

segnali relativi al RF (subito prima del fronte di DISCESA interno al ciclo di clock – ciclo 6)
RF.RegLettura1 RF.DatoLetto1 RF.RegScrittura
$t1 addi 0055 CCCC ($t1) dopo lw $t2 add
RF.RegLettura2 RF.DatoLetto2 RF.DatoScritto
$t2 addi 1234 ABCD ($t2) iniz 2469 579A ($t2) finale

AXO – prova di lunedì 9 novembre 2020 – CON SOLUZIONI pagina 13 di 18

 seconda parte – gestione di conflitti e stalli
Si consideri la sequenza di istruzioni sotto riportata
1. add $3, $1, $2
2. lw $4, 32($3)
3. sub $4, $3, $4
4. beq $3, $4, -8 // il salto NON VIENE PRESO
5. sw $4, 16($3)
    ciclo di clock 

    1  2  3  4  5  6  7  8  9  10  11  12  13 

1  IF  ID  EX  MEM  WB                 

1, 2  3 
istruzione 

2    IF  ID  EX  MEM  WB               

3  4 

3      IF  ID  EX  MEM  WB             

3, 4  4 

4        IF  ID  EX  MEM  WB           

3, 4 
      ID  EX   MEM  WB IF         
  5 
3, 4 
Si risponda alle domande seguenti, facendo l’ipotesi che la pipeline:
 sia ottimizzata per la gestione dei conflitti di controllo (valutazione cond. di salto in stadio ID)
 sia dotata di tutti i percorsi di propagazione (EX/EX, MEM/EX, MEM/MEM, EX/ID e MEM/ID)

a) si riportino nel diagramma temporale Tabella 1 (numero di righe non significativo) 

sopra predisposto tutte le dipendenze di istruzione percorso di  ciclo di clock dove 
dato (verde dip; rosso conflitti) * istruzione  da cui 
registro
propagazione  è attivo il percorso 
b) si riportino in Tabella 1 – prime tre dipende 
coinvolto 
e stalli  di propagazione 
colonne – le dipendenze di dato che
risultano essere conflitti 2  1  $3  EX/EX  4 
c) si disegni in Tabella 2 il diagramma
temporale della pipeline, mettendo in 3  1  $3  risolto  na 
evidenza gli eventuali percorsi di MEM/EX 
propagazione che possono essere attivati
3  2  $4  6 
+1 stallo 
per risolvere i conflitti, e gli stalli EX/ID 
eventualmente da inserire affinché la 4  3  $4  7 
+ 1 stallo 
propagazione sia efficace
d) si indichino in Tabella 1 – ultima 5  3  $4  risolto  na 
colonna – i percorsi di propagaz.
effettivamente attivati e gli stalli Tabella 2 
associati, e il ciclo di clock dove sono attivi
  1  2  3  4  5  6  7  8  9  10  11  12  13  14 
IF  ID  EX  MEM  WB       
1 
1, 2  (3)  3 
  IF  ID  EX  MEM  WB      
2 
3  (3)  (4)  4 
    IF  ID  ID  EX‐EX MEM WB      
3 
stallo  3  (4‐4)  4 
      IF  IF  ID ID EX MEM WB      
4 
stallo  stallo  3, (4) 
        IF IF ID EX MEM WB     
5 
stallo  3, 4 
(*) Nota: per specificare le dipendenze ( conflitti e non) basta indicare sul diagramma iniziale i registri coinvolti nei vari
stadi; le frecce sono state aggiunte per meglio comprendere la soluzione, ma non sono richieste nell prova online;

AXO – prova di lunedì 9 novembre 2020 – CON SOLUZIONI pagina 14 di 18

 Si consideri lo schema di PROCESSORE PIPELINE CON STALLO E PROPAGAZIONE, e i percorsi di
propagazione effettivamente attivati e riportati in Tabella 1 della domanda precedente. Per ciascun
ciclo di clock in cui è attiva almeno una propagazione (solo di tipo EX/EX o MEM/EX), si completi
una colonna della Tabella 3 con le informazioni richieste.
Per i registri di interstadio che sono stati scritti in conseguenza di uno stallo, si indichi V.S. (valore di
stallo). Se il valore non può essere calcolato si usi n.d.

NOTA BENE: per percorsi attivi nello stesso ciclo di clock e riferiti alla stessa istruzione, utilizzare una
sola colonna per rappresentarli.

Tabella 3 

ciclo di clock dove

è attiva almeno 4 6
una propagazione

istruzione che ne
usufruisce
2 (lw) 3 (sub)

tipo (o tipi) di MEM-EX

EX-EX (rs)
propagazione (rt)

ID / EX.Rs $3 (lw) $3 (sub)

segnali di ingresso all’unità di propagazione

ID / EX.Rt $4 (lw) $4 (sub)

v.s.
EX / MEM.R $3 (add)
(sub)

0
EX / MEM.RegWrite 1 (add)
(stallo)

MEM / WB.R n.d. $4 (lw)

MEM / WB.RegWrite n.d. 1 (lw)

MUX di propagazione
interessato
PA PB

ingresso di selezione
segnali di uscita

di propagazione

MUX PA
10 00
dell’unità

ingresso di selezione
MUX PB
00 01

AXO – prova di lunedì 9 novembre 2020 – CON SOLUZIONI pagina 15 di 18

esercizio n. 4 – domande su argomenti vari
domanda 1 – memoria cache
Si consideri una gerarchia di memoria composta dalla memoria centrale di 4 G byte indirizzabile a byte con
parole da 32 bit, e da una memoria cache istruzioni e una memoria cache dati da 512 K byte ciascuna,
entrambe a indirizzamento diretto (direct mapping) con blocchi da 256 byte e strategia di scrittura
write-through (scrittura immediata). Si svolgano i punti seguenti:

1) Si indichi la struttura degli indirizzi di memoria per le memorie cache (istruzioni e dati sono uguali)

indirizzo di memoria: 4 G byte memoria centrale = 2 32

, dunque 32 bit ________________

spiazzamento: 256 byte per blocco = 28 , dunque 8 bit ____________________________

indice: numero blocchi in cache = 512 K byte / 256 byte = 2 19

/ 2 8 = 2 11, dunque 11 bit

etichetta: per differenza, 32 bit  11 bit  8 bit = 13 bit ___________________________

2) Qual’è la dimensione del blocco in parole da 32 bit? 256 byte / 4 byte per parola = 64 parole

3) Quanti blocchi contiene ciascuna cache (sono uguali) ? da prima, 211 = 2048 blocchi

4) Il tempo di accesso alla memoria centrale è pari a 10 cicli di clock per la prima parola del blocco e a 2
cicli di clock per le parole a indirizzi successivi (memoria interallacciata). Il bus dati è da 32 bit. Si
calcoli il tempo necessario per caricare un blocco di memoria in cache in caso di fallimento (miss).

penalità di fallimento: 10 cicli + 2 cicli  (64  1) parole = 136 cicli di clock _______________

5) Si calcoli il tempo medio di accesso alla memoria considerando che il tempo di accesso alla cache è pari
a 1 ciclo di clock, lo hit rate (tasso di successo) della cache istruzioni è pari al 98 %, e lo hit rate
della cache dati è pari al 90 %. Si supponga che il 25 % delle istruzioni eseguite siano lw e sw.

In generale il tempo medio di accesso alla memoria vale 100 / 125 (T medio di accesso alla cache
istruzioni) + 25 / 125 (T medio di accesso alla cache dati).

T medio di accesso alla cache istruzioni: 1 + 0,02  136 =3,72 cicli di clock ________________

T medio di accesso alla cache dati: 1 + 0,1  136 =14,6 cicli di clock ______________________

T medio di accesso alla memoria: 0,8  2,72 + 0,2  14,6 = 2,176 + 2,92 = 5,896 cicli di clock ___

AXO – prova di lunedì 9 novembre 2020 – CON SOLUZIONI pagina 16 di 18

domanda 2 – funzionamento del bus

Si consideri un bus con queste ipotesi: il bus è sincrono e svolge un’operazione (arbitraggio, lettura,
scrittura) entro un ciclo di clock; i segnali di controllo sono attivi alti; tutti i segnali hanno ritardo di
propagazione nullo. Si svolgano i punti seguenti:

1) Il processore è master, quando un controllore di DMA (DMAC) chiede (e ottiene) il controllo del bus
tramite arbitraggio centralizzato con segnali BUS_BUSY, BUS_REQ e BUS_GRANT. L’arbitro del bus
(componente del processore) ha ritardo di 10 ns. Il DMAC ha ritardo di 5 ns.
Si completi il diagramma temporale sotto (scrivendo 0 o 1), fino a quando il DMAC ha acquisito il
controllo del bus e il bus è tornato nella situazione iniziale (numero di colonne non significativo):

operazione (transazione) di arbitraggio

BUS_BUSY 1 1 1 0 1 1 1
BUS_REQ 0 1 1 1 0 0 0
BUS_GRANT 0 0 0 1 1 1 0
tempo (ns) 0 5 10 15 20 25 30 35 40

DMAC richiede controllo del bus (attivando req), arbitro garantisce dopo 10 ns (attivando grant) e
rilascia il controllo del bus (disattivando busy), DMAC toglie richiesta dopo 5 ns (disattivando req) e
assume il controllo del bus (riattivando busy), arbitro toglie grant dopo 10 ns (disattivando grant): Il
bus torna in situazione iniziale in 5 ns: totale 30 ns. (colonna in bold)

2) Quanto tempo occorre affinché il controllo del bus sia pienamente trasferito al DMAC ?

Tempo: dal diagramma temporale sopra, 30 ns _________________________________________

3) A quale frequenza di clock massima può funzionare questo bus ?

Frequenza: 1 / 30 ns  0,0333 GHz  33,3 MHz _________________________________________

AXO – prova di lunedì 9 novembre 2020 – CON SOLUZIONI pagina 17 di 18

spazio libero per continuazione o brutta copia

AXO – prova di lunedì 9 novembre 2020 – CON SOLUZIONI pagina 18 di 18