Politecnico di Milano

Dip. di Elettronica, Informazione e Bioingegneria

prof.ssa Anna Antola prof.ssa Donatella Sciuto
prof. Luca Breveglieri prof.ssa Cristina Silvano

AXO – Architettura dei Calcolatori e Sistemi Operativi

Prova di mercoledì 6 novembre 2019

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
prima parte – traduzione da C ad assembler

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 descrivano l’area di attivazione della funzione const e l’allocazione delle variabili locali e dei
parametri di const nei registri.
3. Si traduca in linguaggio macchina il codice dello statement riquadrato nel prog. principale main.
4. Si traduca in linguaggio macchina il codice dell’intera funzione const (vedi tab. 4 strutturata).

/ sezione dichiarativa costanti e variabili globali /

#define SUP ...
int funct [8200] / 8192 = 2^13 e 32768 = 2^15 /
int inf = 0
int num
int print (int  val) / testata funz foglia print /
int const (int max, int idx)  / funzione const /
int err, curr, prev
prev = max
do 
idx--
curr = funct [idx]
if (curr == prev) 
err = print (&prev) / indirizzo di prev /
 / if /
prev = curr
 while (idx != 0) / do /
return curr
 / const /
void main ( )  / programma principale /
num = 8200
inf = const (SUP, num)
 / main /

AXO – prova di mercoledì 6 novembre 2019 – CON SOLUZIONI pagina 2 di 16

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

spiazzamento

negativo ?
spiazzamento

positivo o
contenuto
rispetto a
simbolico
gp  0x 1000 8000

indirizzi
alti

NUM 0x 0024 pos

INF 0x 0020 pos

FUNCT [8199] 0x 001C pos

FUNCT [...]

indirizzi
FUNCT [0] 0x 8000 neg
bassi

Per definizione l’elemento intero (una parola da 32 bit ossia da 4 byte) FUNCT [0] della variabile
globale vettore FUNCT ha spiazzamento   215  0x 8000 rispetto al registro puntatore globale
$gp. Inoltre si ha che 8192  213 e 8192  4  215. Pertanto l’elemento intero FUNCT [8192] del
vettore ha spiazzamento  0 rispetto a $gp. Ora, si ha che 8199  8192  7 e 7  4  28, pertanto
l’elemento intero FUNCT [8199] del vettore ha spiazzamento  28  0x 001C rispetto a $gp. Per
finire, la variabile globale intera INF ha spiazzamento  28  4  32  0x 0020 e la variabile globale
intera NUM ha spiazzamento  32  4  36  0x 0024, rispetto a $gp.

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

.data 0x 1000 0000 // segmento dati statici standard

.equ SUP, ... // costante SUP

FUNCT: .space 32800 // ingombro di array FUNCT: 32800  8200  4

INF: .word 0 // varglob INF (inizializzata a 0)

NUM: .space 4 // ingombro di varglob NUM (non iniz)

AXO – prova di mercoledì 6 novembre 2019 – CON SOLUZIONI pagina 3 di 16

 punto 2 – area e registri di CONST (numero di righe non significativo)

area di attivazione di CONST

spiazz. rispetto
contenuto simbolico
a stack pointer
indirizzi alti
ra (salvato da CONST) 12
s0 (salvato da CONST) 8
s1 (salvato da CONST) 4
PREV (varloc allocata in pila) 0  sp (fine area)

indirizzi bassi

allocazione dei parametri e delle

variabili locali di CONST nei registri

parametro / variabile locale registro

MAX (primo argomento) a0

IDX (secondo argomento) a1
ERR (varloc allocata in registro) s0
CURR (varloc allocata in registro) s1

La varloc PREV è riferita per indirizzo, dunque va allocata in pila (non in un registro). La funzione const non
è foglia, dunque deve salvare il registro ra. La funzione print usa il registro a0, ma dopo il rientro di print la
funzione const non lo usa più, pertanto non occorre che const lo salvi in pila. La funzione print è foglia e non
usa il registro a1, pertanto non occorre che const lo salvi in pila sebbene lo usi dopo il rientro di print.

punto 3 – codice MIPS degli statement riquadrati di MAIN – (numero di righe non significativo)
// num = 8200
li $t0, 8200 // carica costante 8200
sw $t0, NUM // aggiorna varglob NUM

// inf = const (SUP, num)

li $a0, SUP // prepara param MAX di funz CONST
lw $a1, NUM // prepara param IDX di funz CONST
jal CONST // chiama funz CONST
sw $v0, INF // aggiorna varglob INF

AXO – prova di mercoledì 6 novembre 2019 – CON SOLUZIONI pagina 4 di 16

 punto 4 – codice MIPS dell’intera funzione CONST – (numero di righe non significativo)
CONST: addiu $sp, $sp, -16 // COMPLETARE - crea area attiv.
// scrivere qui le direttive .equ per gli spiazzamenti in pila
.equ RA, 12 // spi reg ra salvato
.equ S0, 8 // spi reg s0 salvato
.equ S1, 4 // spi reg s1 salvato
.equ PREV, 0 // spi varloc PREV

// salvataggi di registri - NON VANNO RIPORTATI

// prev = max
sw $a0, PREV($sp) // inizializza varloc PREV

DO: // idx--
subi $a1, $a1, 1 // aggiorna param IDX

// curr = funct [idx]

la $t0, FUNCT // carica indir di elem FUNCT [0]
sll $t1, $a1, 2 // allinea indice IDX
addu $t0, $t0, $t1 // calcola indir di elem FUNCT [IDX}
lw $s1, ($t0) // aggiorna varloc CURR

IF: // if (curr == prev)

lw $t2, PREV($sp) // carica varloc PREV
bne $s1, $t2, ENDIF // se curr != prev vai a ENDIF

THEN: // err = print (&prev) (indirizzo di prev)

addiu $a0, $sp, PREV // prepara param VAL di funz PRINT
jal PRINT // chiama funz PRINT
move $s0, $v0 // aggiorna varloc ERR

ENDIF: // prev = curr

sw $s1, PREV($sp) // aggiorna varloc PREV

// while (idx != 0)
bne $a1, $zero, DO // se idx != 0 vai a DO

ENDDO: // return curr – SCRIVERE solo preparazione del valore uscita

move $v0, $s1

AXO – prova di mercoledì 6 novembre 2019 – CON SOLUZIONI pagina 5 di 16

seconda parte – assemblaggio e collegamento
Dati i due moduli assemblatore seguenti, si compilino le tre tabelle seguenti relative a:
 i due moduli oggetto prodotti dall’assemblatore
 le basi di rilocazione del codice e dei dati dei moduli
 la tabella globale dei simboli e la tabella del codice eseguibile
Le tabelle 1, 2 e 3 di entrambi i moduli MAIN e FUNCTION vanno compilate. Le tabelle 1 e 3 di entrambi i
moduli contengono già i codici operativi delle istruzioni (con le pseudo-istruzioni espanse).

modulo MAIN modulo FUNCTION

.data .data
MIN .word 32 FILL: .space 8
VECT .space 40 ELEM .word 80
MAX .space 4 .text
.text .globl FUNCTION
.globl MAIN FUNCTION: lw $t1, ELEM
MAIN: addi $t0, $zero, 28 beq $t1, $zero, FUNCTEND
sw $t0, MIN lw $t1, MIN
la $a0, VECT beq $t1, $zero, MAIN
jal FUNCTION FUNCTEND: jr $ra
MAINEND: sw $v0, MAX

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, senza prefisso 0x, e di
lunghezza giusta per il codice che rappresentano
esempio: un’istruzione come addi $t0, $t0, 15 è rappresentata come addi $t0, $t0, 000F
 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
esempio: lw $t0, RIL diventa lw $t0, 0000($gp) nell’oggetto e diventa lw $t0,
nnnn($gp) nell’eseguibile, dove RIL è un simbolo rilocabile che si riferisce a un dato globale e nnnn
è il valore opportunamente calcolato durante la generazione dell’eseguibile

AXO – prova di mercoledì 6 novembre 2019 – CON SOLUZIONI pagina 6 di 16

 (1) – moduli oggetto
modulo MAIN modulo FUNCTION

dimensione testo: 18 hex (24 dec) dimensione testo: 14 hex (20 dec)

dimensione dati: 30 hex (48 dec) dimensione dati: 0C hex (12 dec)

testo testo

indirizzo istruzione indirizzo istruzione

0 addi $t0, $zero, 001C 0 lw $t1, 0000($gp)
4 sw $t0, 0000($gp) 4 beq $t1, $zero, 0002
8 lui $a0, 0000 8 lw $t1, 0000($gp)
C ori $a0, 0000 C beq $t1, $zero, 0000
10 jal 0000000 10 jr $ra
14 sw $v0, 0000($gp) 14

dati dati

indirizzo contenuto (in esadecimale) indirizzo contenuto (in esadecimale)

0 0000 0020 0 non specificato
4 non specificato 8 0000 0050
2C non specificato

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 0000 0000 FUNCTION T 0000 0000
MAINEND T 0000 0014 FUNCTEND T 0000 0010
MIN D 0000 0000 FILL D 0000 0000
VECT D 0000 0004 ELEM D 0000 0008
MAX D 0000 002C

tabella di rilocazione tabella di rilocazione

indirizzo cod. operativo simbolo indirizzo cod. operativo simbolo

4 sw MIN 0 lw ELEM
8 lui VECT 8 lw MIN
C ori VECT C beq MAIN
10 jal FUNCTION
14 sw MAX

AXO – prova di mercoledì 6 novembre 2019 – CON SOLUZIONI pagina 7 di 16

 (2) – posizione in memoria dei moduli
MAIN FUNCTION

base del testo: 0040 0000 base del testo: 0040 0018

base dei dati: 1000 0000 base dei dati: 1000 0030

(3) – tabella globale dei simboli

simbolo valore finale simbolo valore finale
MAIN 0040 0000 FUNCTION 0040 0018

MAINEND 0040 0014 FUNCTEND 0040 0028

MIN 1000 0000 FILL 1000 0030

VECT 1000 0004 ELEM 1000 0038

MAX 1000 002C

(3) – codice eseguibile

testo

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

0040 0000 addi $t0, $zero, 001C

0040 0004 sw $t0, 8000($gp)

0040 0008 lui $a0, 1000

0040 000C ori $a0, 0004

0040 0010 jal 00100006

0040 0014 sw $v0, 802C($gp)

0040 0018 lw $t1, 8038($gp)

0040 001C beq $t1, $zero, 0002

0040 0020 lw $t1, 8000($gp)

0040 0024 beq $t1, $zero, FFF6 (= -10)

0040 0028 jr $ra

Non si richiede la tabella globale dei dati.

AXO – prova di mercoledì 6 novembre 2019 – CON SOLUZIONI pagina 8 di 16

 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), con un ingresso I 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 della porta logica XOR e del negatore, 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

diagramma temporale da completare

    1        1        1        1      1    1        1        1   

I  0    0        0        0        0      0       0    0         

                                                         

D1                                                         

                                                         

Q1  0                                                       

                                                         

D2                                                         

                                                         

Q2  0                                                       

                                                         

U                                                         

                                                         

CLK                                                         

AXO – prova di mercoledì 6 novembre 2019 – CON SOLUZIONI pagina 9 di 16

 Soluzione Un segnale Q è costante per tutto un intervallo di tempo e ha il valore che il corrispondente
segnale D aveva immediatamente prima del fronte di discesa del clock all’inizio dell’intervallo.
Ecco il procedimento di calcolo dei valori in un intervallo di tempo:
 per tutto l’intervallo corrente, si pongono i segnali Q1 e Q2 rispettivamente uguali ai valori dei
corrispondenti segnali D1 e D2 verso la fine dell’intervallo precedente
 si calcolano i segnali D1 e D2 nell’intervallo corrente, istante per istante, in funzione di I, Q1 e Q2
Poi si passa all’intervallo di tempo successivo e così via fino al termine. Ovviamente nel primo intervallo i
segnali Q1 e Q2 sono già dati (è lo stato iniziale, non calcolabile perché non è noto l’intervallo precedente).
Pertanto ricavare il diagramma temporale è semplice e rapido. Eccolo:

    1        1        1        1      1    1        1        1   

I  0  1  0        0        0        0      0       0    0         

  1    1        1      1        1        1        1    1         

D1    0        0      0    0        0        0        0        0   

          1                                        1       

Q1  0                        0                               

          1                                        1       

D2                          0                               

                  1                                       

Q2  0                                0                       

                  1                                       

U  0                                0                       

                                                         

CLK                                                         

Si noti che se vale U = 1, la porta XOR si comporta da negatore dell’altro segnale, dunque annulla l’effetto
del negatore di I. Ne risulta che si ha D1 = I; invece, se vale U = 0, la porta XOR riproduce sulla sua uscita
l’altro segnale, dunque si ha D1 = !I.
Il secondo bistabile master-slave riceve sull’ingresso D2 il valore Q1 e nell’intervallo successivo mostra tale
valore su Q2.

AXO – prova di mercoledì 6 novembre 2019 – CON SOLUZIONI pagina 10 di 16

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 0FFF 0004 add $t1, $t2, $t3 $t1 0x 1001 0000
0x 0FFF 0008 lw $t2, 0x AAAF($t3) $t2 0x 0001 0115
0x 0FFF 000C beq $t1, $t3, 0x FFFE $t3 0x 1000 FFF5
0x 0FFF 0010 addi $t3, $t1, 0x 7FFC memoria contenuto iniziale
0x 0FFF 0014 0x 1000 4004 0x 0044 0FFF
0x 1000 AAA4 0x 1001 1112

1) Si completi in binario la rappresentazione macchina dell’istruzione add $t1, $t2, $t3

000000 01010 01011 01001 00000 100000

6 bit 5 bit 5 bit 5 bit 5 bit 6 bit
op_code rs rt rd shamt function

2) Dato il valore su 16 bit espresso in esadecimale 0x AAAF lo si interpreti come uno spiazzamento di
parola. A partire da questo, si determini su 32 bit con estensione di segno il valore corrispondente
allo spiazzamento di byte. Si esprima tale valore in esadecimale.

AAAF = 1010 1010 1010 1111

esteso di segno su 32 bit = 1111 1111 1111 1111 1010 1010 1010 1111
spiazzamento di byte (moltiplicazione per 4) =
11 1111 1111 1111 1010 1010 1010 1111 00 in esadecimale FFFE AABC

La pipeline NON è ottimizzata per la gestione dei conflitti di controllo. Si consideri il ciclo di clock 4 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 ‐ add  IF  ID  EX  MEM  WB           

istruzione 

2 ‐ lw    IF  ID  EX  MEM  WB         

3 ‐ beq      IF  IDstallo  ID  EX  MEM  WB     

4 ‐ addi        IFstallo  IF  ID  EX  MEM  WB   

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

0x 1000 FFF5 + 0x FFFF AAAF = 0x 1000 AAA4 ________________________

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

0x 0001 0115 + 0x 1000 FFF5 = 0x 1002 010A ________________________

AXO – prova di mercoledì 6 novembre 2019 – CON SOLUZIONI pagina 11 di 16

 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 4)
IF (beq) ID (beq-stallo) EX (lw) MEM (add)
registro IF/ID registro ID/EX registro EX/MEM registro MEM/WB
.WB.MemtoReg .WB.MemtoReg .WB.MemtoReg
0 1 0
.WB.RegWrite .WB.RegWrite .WB.RegWrite
0 1 1
.M.MemWrite .M.MemWrite
0 0
.M.MemRead .M.MemRead
0 1
.M.Branch .M.Branch
0 0
.PC .PC .PC valore numerico
0FFF 0010 0FFF 0010 0FFF 000C + FFFE AABC =
0FFD AAC8
.istruzione .(Rs) (t1) iniziale
beq 1001 0000
.(Rt) (t3) iniziale .(Rt) t2 iniziale
1000 FFF5 0001 0115
.Rt .R .R
t3 t2 t1
.Rd
****************
.imm/offset esteso .ALU_out ind. mem dati .ALU_out
FFFF FFFE 1000 AAA4 (t2) + (t3) 1002 010A
.EX.ALUSrc .Zero .DatoLetto
0 0 ****************
.EX.RegDest
0

segnali di altre unità funzionali (subito prima del fronte di SALITA del clock – CICLO 4)
Mem.indirizzo RegWrite
1002 010A add n.d. istruzione precedente alla add non specif.
MemWrite RegDest
0 add 0 lw
MemRead MemtoReg
0 add n.d. istruzione precedente alla add non specif.

segnali relativi al RF (subito prima del fronte di DISCESA interno al ciclo di clock – CICLO 5)
RF.RegLettura1 RF.DatoLetto1 RF.RegScrittura
t1 beq 1001 0000 (t1) iniz t1 add
RF.RegLettura2 RF.DatoLetto2 RF.DatoScritto
t3 beq 1000 FFF5 (t3) iniz 1002 010A (t1) finale

AXO – prova di mercoledì 6 novembre 2019 – CON SOLUZIONI pagina 12 di 16

 seconda parte – gestione di conflitti e stalli
Si consideri la sequenza di istruzioni sotto riportata
1. lw $3, 32($1)
2. add $1, $3, $2
3. sw $1, 16($3)
4. beq $3, $1, 8

    ciclo di clock 

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

1  IF  ID  EX  MEM  WB                 

1  3 
istruzione 

2    IF  ID  EX  MEM  WB               

3, 2  1 

3      IF  ID  EX  MEM  WB             

3, 1 

4        IF  ID  EX  MEM  WB           

3, 1 

Si risponda alle domande seguenti, facendo l’ipotesi che la pipeline

 sia ottimizzata per la gestione dei conflitti di controllo (valutazione condizione di salto nello
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 sopra

Tabella 1 (numero di righe non significativo) 
predisposto tutte le dipendenze di dato
b) si riportino in tabella 1 – prime tre colonne istruzione percorso di  ciclo di clock dove
– le dipendenze di dato che risultano essere registro
istruzione  da cui  propagazione  è attivo il percorso
conflitti coinvolto 
dipende  e stalli  di propagazione 
c) si disegni in Tabella 2 il diagramma
temporale della pipeline, mettendo in evidenza 1 stallo + 
2  1  3  5 
gli eventuali percorsi di propagazione che MEM‐EX rs 
possono essere attivati per risolvere i na 
conflitti, e gli stalli eventualmente da inserire 3  1  3  na 
affinché la propagazione sia efficace
(assorbito)
d) si indichino in Tabella 1 – ultima colonna – i 3  2  1  MEM‐MEM*   7 
percorsi di propagazione effettivamente
attivati e gli stalli associati, e il ciclo di clock in na 
cui risultano attivi 4  1  3  na 
(assorbito)
(*) va bene anche EX-EX al ciclo 6 4  2  1  EX‐ID rt  6 
 
Tabella 2 
  1  2  3  4  5  6  7  8  9  10  11  12  13  14 

IF  ID  EX  MEM  WB                   

1 
1  (3)  3 

  IF  ID  ID  EX  MEM WB               

2 
stallo  3, 2  (1)  (1)  1 

    IF  IF  ID  EX  MEM  WB             

3 
stallo  3, 1 

        IF  ID  EX  MEM  WB           

4 
3, 1 

AXO – prova di mercoledì 6 novembre 2019 – CON SOLUZIONI pagina 13 di 16

 e) 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 5
una propagazione

istruzione che ne
usufruisce
2 (add)

tipo(i) di
MEM-EX (rs)
propagazione

ID / EX.Rs $3
segnali di ingresso all’unità di propagazione

ID / EX.Rt $2

EX / MEM.R v.s.

EX / MEM.RegWrite 0 (stallo)

MEM / WB.R $3

MEM / WB.RegWrite 1

MUX di propagazione
interessato
PA

ingresso di selezione
segnali di uscita

di propagazione

MUX PA
01
dell’unità

ingresso di selezione
MUX PB
00

AXO – prova di mercoledì 6 novembre 2019 – CON SOLUZIONI pagina 14 di 16

esercizio n. 4 – domande su argomenti vari
logica combinatoria

Si vuole progettare la rete combinatoria che realizza una versione semplificata dell’unità di controllo
del processore pipeline MIPS.
L’unità di controllo in oggetto riceve in ingresso un “CODICE ISTRUZIONE” di 3 bit e genera 7 uscite da 1
bit ciascuna, le quali rappresentano una parte dei segnali di controllo della pipeline.
Nella tabella ingressi-uscite predisposta, a ogni configurazione di CODICE ISTRUZIONE (C2, C1, C0) è
associato il simbolico dell’istruzione stessa.
Si definisca la tabella ingressi-uscite del circuito, tenendo conto della seguente ulteriore specifica:
 se per una certa istruzione e per un certo segnale di controllo risulta indifferente generare il valore 0
oppure il valore 1, si scelga sempre di sintetizzare il segnale con uno 0

C2 C1 C0 RegDest ALUSrc Branch MemRead MemWrite RegWrite MemtoReg

ADD 0 0 0 1 0 0 0 0 1 0

SUB 0 0 1 1 0 0 0 0 1 0

AND 0 1 0 1 0 0 0 0 1 0

OR 0 1 1 1 0 0 0 0 1 0

SLT 1 0 0 1 0 0 0 0 1 0

LW 1 0 1 0 1 0 1 0 1 1

SW 1 1 0 0 1 0 0 1 0 0

BEQ 1 1 1 0 0 1 0 0 0 0

Si fornisca IN PRIMA FORMA CANONICA (Sum_Of_Products – SOP), senza semplificazioni, l’espressione

logica in funzione degli ingressi per le uscite seguenti:

ALUSrc = C2 !C1 C0 + C2 C1 !C0 _____________________________________________________

RegWrite = !C2 !C1 !C0 + !C2 !C1 C0 + !C2 C1 !C0 + !C2 C1 C0 + C2 !C1 !C0 + C2 !C1 C0 ____

Si consideri poi l’espressione ottenuta al punto precedente per il segnale RegWrite e la si semplifichi
usando le regole dell’algebra fino a ottenere un’espressione costituita dalla somma di due soli termini:

RegWrite = !C2 !C1 !C0 + !C2 !C1 C0 + !C2 C1 !C0 + !C2 C1 C0 + C2 !C1 !C0 + C2 !C1 C0 ____

= !C2 !C1 (!C0 + C0) + !C2 C1 (!C0 + C0) + C2 !C1 (!C0 + C0) (raccoglimento) _____

= !C2 !C1 + !C2 C1 + C2 !C1 (elemento 1) ____________________________________

= !C2 (!C1 + C1) + C2 !C1 (raccoglimento) ____________________________________

= !C2 + C2 !C1 (elemento 1 – forma SOP quasi minima – accettabile) _______________

= !C2 + !C1 (assorbimento – forma SOP minima) ________________________________

Nota bene: !C2 + !C1 = ! (C2 C1), dunque si potrebbe ulteriormente risparmiare un negatore usando solo
una porta NAND; tuttavia la forma ! (C2 C1) non è di tipo SOP (e neppure di tipo POS).

AXO – prova di mercoledì 6 novembre 2019 – CON SOLUZIONI pagina 15 di 16

memoria cache
Si consideri una gerarchia di memoria per un processore MIPS composta da una memoria centrale da 4G
byte indirizzabile a byte con parole da 32 bit, e da una memoria cache istruzioni e una dati da 1K byte
ciascuna, entrambe a indirizzamento diretto (direct mapped), con blocchi da 256 byte.
Il tempo di accesso alla memoria cache (sia istruzioni sia dati) è pari a 1 ciclo di clock.
Il tempo di accesso alla memoria centrale è pari a 20 cicli di clock per la prima parola e a 5 cicli di
clock per le parole a indirizzi consecutivi (memoria interallacciata). Il bus dati è da 32 bit.

1. Indicare la struttura dell’indirizzo di memoria per accedere alla memoria cache.

bit di etichetta bit di indice blocco bit di spiazzamento

22 bit 2 bit 8 bit

2. Calcolare il tempo necessario per caricare un blocco dalla memoria centrale in caso di fallimento
(miss), in numero di cicli di clock.

n. parole in un blocco = 256 byte / 4 byte per parola = 64 parole

penalità di fallimento = 20 cicli clock  1 parola + 5 cicli clock  63 parole = 335 cicli clock

3. Va in esecuzione un nuovo programma che accede, caricandolo in memoria cache, a un array di interi di
dimensione pari a 1032 byte. Calcolare il numero di fallimenti (miss) per la cache dati e mostrare
nella tabella i blocchi dell’array presenti in cache dati al termine del caricamento, numerandoli a
partire da 0 (numero di righe non significativo).

# fallimenti caricamento = 5 miss (1032 byte corrispondono a 5 blocchi, dunque ci sono 5 miss)

n. blocco cache dati n. blocco array

0 0, 4
1 1
2 2
3 3

4. Calcolare il tempo totale di accesso alla memoria dati per questo programma, considerando che il
programma, dopo l’accesso di cui alla domanda precedente, accede sequenzialmente ai primi 100
elementi dell’array e agli ultimi 8 elementi dell’array in un ciclo ripetuto 10 volte.

Tempo totale di accesso alla memoria dati = T accesso domanda 3 + T accesso domanda 4
L’array è composto da 1032 byte / 4 byte per elemento = 258 elementi. Ogni blocco contiene 64 elementi.
Pertanto, dei 100 + 8 = 108 elementi acceduti, i primi 100 si trovano nel blocco 0 (64 elementi) e nel blocco
1 (36 elementi), mentre gli ultimi 8 si trovano nel blocco 3 (6 elementi) e nel blocco 4 (ultimi 2 elementi).
Per calcolare il tempo di accesso alla cache dati, è necessario calcolare il numero totale di miss, oltre ai 5
miss per il primo caricamento dell’array che porta ad avere in cache i blocchi 4, 1, 2 e 3 (cfr. domanda 3).
Per ciascuna delle 10 ripetizioni della sequenza di accesso all’array (cfr. domanda 4), ci sono sempre due
miss, per il blocco 0 e per il blocco 4, i quali blocchi finiscono nella stessa posizione (blocco) di cache.
Totale numero di accessi alla cache dati = 258 elementi + 10 ripetizioni  108 elementi = 1338 accessi
Tempo di accesso alla cache dati = 1338 cicli clock + (5 + 10  2) miss  335 cicli clock = 9713 cicli clock

AXO – prova di mercoledì 6 novembre 2019 – CON SOLUZIONI pagina 16 di 16