2 Compitinosol

Cognome ESATTO
Nome GIUSTO
Matricola A
ARCHITETTURA DEGLI ELABORATORI 1 - Seconda prova intermedia - 23 giugno 2003
1) Un dispositivo DM, gestito ad interrupt, genera periodicamente richieste di interruzioni con periodo Tm; la sua RSI ha durata (complessiva)
Rm=100 s. Un secondo dispositivo DP, pi prioritario di DM, ha una RSI di durata (complessiva) Rp=20 s e pu interrompere DM al massimo
una volta durante ciascun periodo Tm. Per non perdere dati di DM, il minimo valore di Tm :
TmMIN=120 s
Poich noto che DP pu interrompere la RSI di DM al pi una sola volta tra due successive richieste
di interruzione di questultimo, questa RSI pu terminare al pi tardi dopo:
Tdm = DurataRsiDm+DurataRsiDp
dalla prima delle due richieste di DM (DP introduce, con la sua RSI, un ritardo che si aggiunge al
tempo necessario allesecuzione della RSI di DM). Pertanto Tdm anche il periodo minimo di DM:
TmMIN = Tdm = 100+20 = 120 s
2) Un dispositivo D1 trasferisce, via DMA, blocchi da 1000 dati ciascuno. Per comandare il trasferimento di un blocco vengono eseguite dalla CPU
3 istruzioni la cui durata complessiva corrisponde a 10 cicli di bus, la RSI attivata dopo il trasferimento dellultimo dato del blocco ha una durata
corrispondente a 200 cicli di bus (ciascun ciclo di bus dura 70 ns). Il tempo di CPU complessivamente impegnato per il trasferimento di uno dei
blocchi (includendo il ritardo dovuto ad accessi DMA di D1) al massimo pari a TDMA s.
TDMA = 84.7 s
Limpegno della CPU nei confronti di D1 include le istruzioni iniziali, il ritardo complessivo dovuto al
fenomeno di cycle stealing durante il trasferimento in DMA, che al massimo pari al numero di cicli
occupati da quel trasferimento (1 ciclo per ogni dato), e lesecuzione della RSI.
TDMA = (CicliIstrIniz + NumDati + CicliRSI) * PeriodoCiclo = (10+1000+200)*70 = 84700 ns = 84.7 s
3) Un ADC pu funzionare sia ad interrupt che in DMA: nel primo caso (una richiesta dinterruzione per dato), la RSI ha una durata complessiva di
10 s, nel secondo caso (una richiesta dinterruzione per blocco di dati), essendo il numero di dati di ogni blocco molto elevato, la durata della
RSI trascurabile. Sapendo che il ciclo di bus ha una durata di 200ns e supponendo di tollerare in entrambi i casi una occupazione massima del
tempo di CPU dedicato al dispositivo del 2% (trascurando la RSI del DMA), allora il periodo minimo con cui possono essere trasferiti i dati gestiti ad interrupt TI; quello con cui possono essere trasferiti i dati via DMA TD.
TI = 500s
TD = 10s
In caso di gestione ad interrupt, loccupazione di tempo di CPU dovuta allesecuzione di una attivazione della routine di servizio ogni periodo del dispositivo. Pertanto risulta:
(DurataRsi / TI ) * 100 = PercentualeOccupazione
TI = (DurataRSI / PercentualeOccupazione) * 100 = 1000 / 2 = 500 s
In caso di gestione in DMA, loccupazione equivalente dovuta al cycle stealing. Pertanto risulta:
(DurataCiclo / TD ) * 100 = PercentualeOccupazione
TD = (DurataCiclo / PercentualeOccupazione) * 100 = 20000 / 2 = 10000 ns = 10 s
4) Un sistema PD32 dotato di una instruction cache e di una data cache completamente associative; ciascuna delle due cache contiene 16 blocchi
da 32 byte. A data cache vuota, viene eseguito il segmento di codice che segue, caricato in memoria a partire dallindirizzo $400. Immaginando
che la data cache adotti un criterio di rimpiazzo di tipo LRU (Least Recently Used), quando viene eseguita listruzione NOP la percentuale di hit
sul totale degli accessi alla data cache pari a ph.
MOVL
#$A, R0
MOVL
#$1000, R1
LOOP:
MOVL
(R1), R2
ANDL
#$FFE, R2
MOVL
R2, (R1)+
SUBL
#1, R0
JNZ
LOOP
NOP
ph= 90 %
Nella domanda la cache coinvolta solo quella dei dati. Il codice effettua una lettura dalla memoria
nella terza istruzione (la prima del ciclo) e una scrittura nella quinta (la terza del ciclo); le altre istruzioni contengono dati immediati, letti quindi dallaltra cache durante la fase di fetch, o operandi su registro e quindi non coinvolgono la cache di dati. La coppia di istruzioni evidenziate coinvolge un long
word al medesimo indirizzo e viene eseguita, con indirizzi successivi a distanza di 4, una volta per ciclo. Vengono pertanto letti/scritti i 10 ($A) longword agli indirizzi:
$1000 $1004 $1008 . . . $1024
Essendo completamente associativa, la cache prevede un TAG di blocco con:
NumBitTag = NumBitIndirizzo Log2 NumByteBlocco = NumBitIndirizzo Log2 32 = NumBitIndirizzo 5
essendo quindi il TAG costituito dallindirizzo privato dei 5 bit meno significativi.
Essendo la cache inizialmente vuota, si verificano i seguenti hit e miss:
N
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
Indirizzo
$1000
$1000
$1004
$1004
$1008
$1008
$100C
$100C
$1010
$1010
$1014
$1014
$1018
$1018
$101C
$101C
$1020
$1020
$1024
$1024
Operazione
Lettura
Scrittura
Lettura
Scrittura
Lettura
Scrittura
Lettura
Scrittura
Lettura
Scrittura
Lettura
Scrittura
Lettura
Scrittura
Lettura
Scrittura
Lettura
Scrittura
Lettura
Scrittura
Tag blocco
$80
$80
$80
$80
$80
$80
$80
$80
$80
$80
$80
$80
$80
$80
$80
$80
$81
$81
$81
$81
Hit/miss
Miss
Hit
Hit
Hit
Hit
Hit
Hit
Hit
Hit
Hit
Hit
Hit
Hit
Hit
Hit
Hit
Miss
Hit
Hit
Hit
Commento
Blocco nuovo (occ. 1)
Si noti che essendo il ciclo eseguito un numero di volte non elevato, non si raggiunto il riempimento
della cache e non sono stati necessari rimpiazzi. La percentuale di hit pari a:
ph = (18 / 20) * 100 = 90%
5) Una memoria cache da 16 Kbyte, di tipo set-associativo a 4 vie costituita da blocchi da 32 byte. Allora la cache ha in tutto Ns set e il byte di
indirizzo $123456 ha un TAG pari a TAGS e, se presente in cache, si trova nel set di indice Is (0IsNs-1); TAGS e Is vanno indicati in notazione esadecimale.
Ns =128
|
TAGS = $123 |
|
Is = $22
NumByteCache = NumByteBlocco * NumVie * Ns

Ns = NumByteCache / (NumByteBlocco * NumVie) = 16 K / (32 * 4) = 214 / 27 = 27 = 128
NumBitTag = NumBitIndirizzo NumBitSet NumBitByteBlocco = NumBitIndirizzo 7 5
TAGS = Indirizzo >> (7+5) = $123456 >> 12 = $123
NumSet = Indirizzo[11..5] = (Indirizzo >> 5) & %1111111 = $91A2 & %1111111 = $22
6) In un sistema PD32 una subroutine riceve 2 parametri duscita p1 e p2, passati per riferimento, e alloca una variabile locale L costituita da un
vettore di 40 longword. Supponendo che la subroutine utilizzi la tecnica dello stack frame, si completino le tre istruzioni qui sotto ove la prima alloca la variabile L sul frame e le altre due assegnano al primo parametro duscita p1 il valore contenuto in L[5].
ADDL
MOVL
#-160, SP
+12(FP), R0
MOVL 140(FP), (R0)
Facendo riferimento alle fig. 4.29 e 4.30 del testo base, nelle locazioni rispettivamente in posizione relativa al FP +8 e +12 sono collocati i puntatori alle variabili che rappresentano il secondo (p2) e primo
parametro (p1) di chiamata, mentre la variabile L di 40 long word (160 byte) occupa le posizioni relative da 160 a 4 estremi compresi. L[i] collocato ad una distanza i*sizeof(longword)=4*i dallinizio
del vettore e pertanto in posizione relativa 160+4*i rispetto al FP.
7) Un sistema con memoria virtuale a byte singolarmente indirizzabili, utilizza indirizzi logici a 32 bit e ha una lunghezza di pagina pari a 4 Kbyte.
Supponendo che la MMU disponga di un TLB (cache completamente associativa) con 32 elementi, ciascuno includente i bit dei campi TAG e
DATO, se lindirizzo fisico costituito da 18 bit, allora la dimensione del TLB di NTLB bit.
NTLB = 832 bit
NTLB = (NumBitTAG + NumBitDato) * NumElemTLB =

= (NumBitTAG + NumBitNumPagFisica) * NumElemTLB
NumBitTag = NumBitIndirizzoLogico Log2 DimPagina = 32 12 = 20 bit
NumBitNumPagFisica = NumBitIndirizzoFisico - Log2 DimPagina = 18 12 = 6 bit
NTLB = (20+6) * 32 = 832 bit
8) In un sistema con MMU in cui lindirizzo logico da 32 bit e quello fisico da 26 bit, la memoria fisica sia suddivisa in pagine da 4 Kbyte. Allora
la dimensione della page table di NPT bit.
NPT = 14 Mbit
Dai dati a disposizione si deve desumere che ciascuno degli elementi della page table contiene il solo
numero di pagina fisica. Gli elementi sono pari al numero delle pagine logiche.
NPT = NumBitNumPagFisica * NumPagLogiche =
= (NumBitIndFisico Log2 DimPagina) * 2^(NumBitIndLogico Log2 DimPagina) =
= (26-12)*2(32-12) = 14 * 220 bit
9) Un processore dotato di un pipeline a k=6 stadi e di una memoria cache. Mediamente il numero di accessi in memoria per ogni istruzione
pari a 1,4 e lhit rate della cache pari al 90%. Si rilevato che ogni miss nella cache provoca nel pipeline un inceppamento (ritardo) di 2 stadi.
In queste ipotesi il fattore di speedup (T1/Tk), trascurando il transitorio iniziale, mediamente pari a Sk1
Sk1 = 4.9062
Si supponga inoltre che, a causa dei vari hazard il pipeline subisca mediamente un ulteriore inceppamento di 3 stadi ogni 30 istruzioni. In queste
ipotesi il fattore di speedup (T1/Tk), sempre trascurando il transitorio iniziale, mediamente pari a Sk2
Sk2 = 4.5507
Facendo il calcolo su una successione di N istruzioni a regime, esse producono N*AccessiPerIstruzione

accessi in memoria; quelli che si esauriscono in cache sono N*AccessiPerIstruzione*HitRate e non
producono inceppamento, mentre la porzione N*AccessiPerIstruzione*(1-HitRate) produce per ciascun accesso un ritardo di StadiRitardo stadi. Risulta per le N istruzioni:
T1 = N * NumStadi * Tstadio + N*AccessiPerIstruzione*(1-HitRate)*StadiRitardo*TStadio
Tk1 = N*TStadio + N*AccessiPerIstruzione*(1-HitRate)*StadiRitardo*TStadio
Sk1 = T1/Tk1 =
= (NumStadi + AccessiPerIstruzione*(1-HitRate)*StadiRitardo) /
(1 + AccessiPerIstruzione*(1-HitRate)*StadiRitardo) =
= (6 + 1.4*0.1*2) / (1 + 1.4*0.1*2) = 4.90625
Se si aggiunge il contributo di hazard, pari a N*RateInceppamento stadi, risulta:
Tk2 = N*TStadio + N*AccessiPerIstruzione*(1-HitRate)*StadiRitardo*TStadio +
+ N*RateInceppamento*TStadio
Sk2 = T1/Tk2 =
(1 + AccessiPerIstruzione*(1-HitRate)*StadiRitardo + RateInceppamento) =
= (6 + 1.4*0.1*2) / (1 + 1.4*0.1*2+3/30) = 4.550725
Cognome ESATTO
Nome GIUSTO
Matricola B
TmMIN=130 s
TmMIN = Tdm = 70+60 = 130 s
5 istruzioni la cui durata complessiva corrisponde a 20 cicli di bus, la RSI attivata dopo il trasferimento dellultimo dato del blocco ha una durata
corrispondente a 100 cicli di bus (ciascun ciclo di bus dura 100 ns). Il tempo di CPU complessivamente impegnato per il trasferimento di uno dei
blocchi (includendo il ritardo dovuto ad accessi DMA di D1) al massimo pari a TDMA s.
TDMA = 82 s
3) Un ADC pu funzionare sia ad interrupt che in DMA: nel primo caso (una richiesta dinterruzione per dato), la RSI ha una durata complessiva
di 15 s, nel secondo caso (una richiesta dinterruzione per blocco di dati), essendo il numero di dati di ogni blocco molto elevato, la durata della
TI =300 s
TD =2 s
4) Un sistema PD32 dotato di una instruction cache e di una data cache completamente associative; ciascuna delle due cache contiene 8 blocchi
da 16 byte. A data cache vuota, viene eseguito il segmento di codice che segue, caricato in memoria a partire dallindirizzo $400. Immaginando
che la data cache adotti un criterio di rimpiazzo di tipo LRU (Least Recently Used), quando viene eseguita listruzione NOP la percentuale di hit
sul totale degli accessi alla data cache pari a ph.
MOVL
#$C, R0
MOVL
#$1000, R1
LOOP:
MOVL
(R1), R2
ANDL
#$FFE, R2
MOVL
R2, (R1)+
SUBL
#1, R0
JNZ
LOOP
NOP
ph=87.5 %
word al medesimo indirizzo e viene eseguita, con indirizzi successivi a distanza di 4, una volta per ciclo. Vengono pertanto letti/scritti i 12 ($C) longword agli indirizzi:
$1000 $1004 $1008 . . . $102C
N
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
Indirizzo
$1000
$1000
$1004
$1004
$1008
$1008
$100C
$100C
$1010
$1010
$1014
$1014
$1018
$1018
$101C
$101C
$1020
$1020
$1024
$1024
$1028
$1028
$102C
$102C
Operazione
Lettura
Scrittura
Lettura
Scrittura
Lettura
Scrittura
Lettura
Scrittura
Lettura
Scrittura
Lettura
Scrittura
Lettura
Scrittura
Lettura
Scrittura
Lettura
Scrittura
Lettura
Scrittura
Lettura
Scrittura
Lettura
Scrittura
Tag blocco
$100
$100
$100
$100
$100
$100
$100
$100
$101
$101
$101
$101
$101
$101
$101
$101
$102
$102
$102
$102
$102
$102
$102
$102
Hit/miss
Miss
Hit
Hit
Hit
Hit
Hit
Hit
Hit
Miss
Hit
Hit
Hit
Hit
Hit
Hit
Hit
Miss
Hit
Hit
Hit
Hit
Hit
Hit
Hit
Commento
ph = (21 / 24) * 100 = 87.5 %
indirizzo $ABC01F ha un TAG pari a TAGS e, se presente in cache, si trova nel set di indice Is (0IsNs-1); TAGS e Is vanno indicati in notazione esadecimale.
Ns =128
|
TAGS =$ABC |
|
Is =$0

TAGS = Indirizzo >> (7+5) = $ABC01F >> 12 = $ABC
NumSet = Indirizzo[11..5] = (Indirizzo >> 5) & %1111111 = $55E00 & %1111111 = $0
vettore di 30 longword. Supponendo che la subroutine utilizzi la tecnica dello stack frame, si completino le tre istruzioni qui sotto ove la prima alloca la variabile L sul frame e le altre due assegnano al secondo parametro duscita p2 il valore contenuto in L[25].
ADDL
#-120, SP
MOVL
+8(FP), R1
MOVL 20(FP), (R1)
parametro (p1) di chiamata, mentre la variabile L di 30 long word (120 byte) occupa le posizioni relative da 120 a 4 estremi compresi. L[i] collocato ad una distanza i*sizeof(longword)=4*i dallinizio
del vettore e pertanto in posizione relativa 120+4*i rispetto al FP.
7) Un sistema con memoria virtuale a byte singolarmente indirizzabili, utilizza indirizzi logici a 48 bit e ha una lunghezza di pagina pari a 64
Kbyte. Supponendo che la MMU disponga di un TLB (cache completamente associativa) con 64 elementi, ciascuno includente i bit dei campi
TAG e DATO, se lindirizzo fisico costituito da 28 bit, allora la dimensione del TLB di NTLB bit.
NTLB =2816 bit


NTLB = (32+12) * 64 = 2816 bit
8) In un sistema con MMU in cui lindirizzo logico da 40 bit e quello fisico da 32 bit, la memoria fisica sia suddivisa in pagine da 1 Mbyte. Allora la dimensione della page table di NPT bit.
NPT =12M bit
= (32-20)*2(40-20) = 12 * 220 bit
9) Un processore dotato di un pipeline a 8 stadi e di una memoria cache. Mediamente il numero di accessi in memoria per ogni istruzione pari a
1,9 e lhit rate della cache pari al 95%. Si rilevato che ogni miss nella cache provoca nel pipeline un inceppamento (ritardo) di 3 stadi. In
queste ipotesi il fattore di speedup (T1/Tk), trascurando il transitorio iniziale, mediamente pari a Sk1
Sk1 =6.4475
Sk2 =5.5791

Sk1 = T1/Tk1 =
= (8 + 1.9*0.05*3) / (1 + 1.9*0.05*3) = 6.447471
Sk2 = T1/Tk2 =
= (8 + 1.9*0.05*3) / (1 + 1.9*0.05*3+4/20) = 5.579125
Cognome ESATTO
Nome GIUSTO
Matricola C
Rm=120 s. Un secondo dispositivo DP, pi prioritario di DM, ha una RSI di durata (complessiva) Rp=40 s e pu interrompere DM al massimo una volta durante ciascun periodo Tm. Per non perdere dati di DM, il minimo valore di Tm :
TmMIN=160 s
TmMIN = Tdm = 120+40 = 160 s
7 istruzioni la cui durata complessiva corrisponde a 30 cicli di bus, la RSI attivata dopo il trasferimento dellultimo dato del blocco ha una durata corrispondente a 70 cicli di bus (ciascun ciclo di bus dura 90 ns). Il tempo di CPU complessivamente impegnato per il trasferimento di uno
dei blocchi (includendo il ritardo dovuto ad accessi DMA di D1) al massimo pari a TDMA s.
TDMA = 54 s
di 13 s, nel secondo caso (una richiesta dinterruzione per blocco di dati), essendo il numero di dati di ogni blocco molto elevato, la durata della RSI trascurabile. Sapendo che il ciclo di bus ha una durata di 140ns e supponendo di tollerare in entrambi i casi una occupazione massima
del tempo di CPU dedicato al dispositivo del 4% (trascurando la RSI del DMA), allora il periodo minimo con cui possono essere trasferiti i dati
gestiti ad interrupt TI; quello con cui possono essere trasferiti i dati via DMA TD.
TI =325 s
TD =3.5 s
TD = (DurataCiclo / PercentualeOccupazione) * 100 = 14000 / 4 = 3500 ns = 3.5 s
4) Un sistema PD32 dotato di una instruction cache e di una data cache completamente associative; ciascuna delle due cache contiene 16 blocchi da 8 byte. A data cache vuota, viene eseguito il segmento di codice che segue, caricato in memoria a partire dallindirizzo $400. Immaginando che la data cache adotti un criterio di rimpiazzo di tipo LRU (Least Recently Used), quando viene eseguita listruzione NOP la percentuale di hit sul totale degli accessi alla data cache pari a ph.
MOVL
#$8, R0
MOVL
#$1000, R1
LOOP:
MOVL
(R1), R2
ANDL
#$FFE, R2
MOVL
R2, (R1)+
SUBL
#1, R0
JNZ
LOOP
NOP
ph=75 %
word al medesimo indirizzo e viene eseguita, con indirizzi successivi a distanza di 4, una volta per ciclo. Vengono pertanto letti/scritti gli 8 ($8) longword agli indirizzi:
$1000 $1004 $1008 . . . $101C
N
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
Indirizzo
$1000
$1000
$1004
$1004
$1008
$1008
$100C
$100C
$1010
$1010
$1014
$1014
$1018
$1018
$101C
$101C
Operazione
Lettura
Scrittura
Lettura
Scrittura
Lettura
Scrittura
Lettura
Scrittura
Lettura
Scrittura
Lettura
Scrittura
Lettura
Scrittura
Lettura
Scrittura
Tag blocco
$200
$200
$200
$200
$201
$201
$201
$201
$202
$202
$202
$202
$203
$203
$203
$203
Hit/miss
Miss
Hit
Hit
Hit
Miss
Hit
Hit
Hit
Miss
Hit
Hit
Hit
Miss
Hit
Hit
Hit
Commento
ph = (12 / 16) * 100 = 75%
indirizzo $23507A ha un TAG pari a TAGS e, se presente in cache, si trova nel set di indice Is (0IsNs-1); TAGS e Is vanno indicati in notazione esadecimale.
Ns =512
|
TAGS =$235 |
|
Is =$F

TAGS = Indirizzo >> (9+3) = $23507A >> 12 = $235
NumSet = Indirizzo[11..3] = (Indirizzo >> 3) & %111111111 = $46A0F & %111111111 = $F
vettore di 15 longword. Supponendo che la subroutine utilizzi la tecnica dello stack frame, si completino le tre istruzioni qui sotto ove la prima
alloca la variabile L sul frame e le altre due assegnano al primo parametro duscita p1 il valore contenuto in L[1].
ADDL
MOVL
#-60, SP
+12(FP), R2
MOVL 56(FP), (R2)

parametro (p1) di chiamata, mentre la variabile L di 15 long word (60 byte) occupa le posizioni relative da 60 a 4 estremi compresi. L[i] collocato ad una distanza i*sizeof(longword)=4*i dallinizio del
vettore e pertanto in posizione relativa 60+4*i rispetto al FP.
NTLB =896 bit

NTLB = (18+10) * 32 = 896 bit
8) In un sistema con MMU in cui lindirizzo logico da 32 bit e quello fisico da 22 bit, la memoria fisica sia suddivisa in pagine da 16 Kbyte. Allora la dimensione della page table di NPT bit.
NPT =2M bit

= (22-14)*2(32-14) = 8 * 218 = 2 * 220 bit
pari a 1,2 e lhit rate della cache pari all88%. Si rilevato che ogni miss nella cache provoca nel pipeline un inceppamento (ritardo) di 2 stadi. In queste ipotesi il fattore di speedup (T1/Tk), trascurando il transitorio iniziale, mediamente pari a Sk1
Sk1 =4.1056
Si supponga inoltre che, a causa dei vari hazard il pipeline subisca mediamente un ulteriore inceppamento di 1 stadio ogni 8 istruzioni. In queste
Sk2 =3.7424

Sk1 = T1/Tk1 =
= (5 + 1.2*0.12*2) / (1 + 1.2*0.12*2) = 4.10559
Sk2 = T1/Tk2 =
= (5 + 1.2*0.12*2) / (1 + 1.2*0.12*2+1/8) = 3.742392
Cognome ESATTO
Nome GIUSTO
Matricola D
TmMIN=190 s
TmMIN = Tdm = 90+100 = 190 s
5 istruzioni la cui durata complessiva corrisponde a 15 cicli di bus, la RSI attivata dopo il trasferimento dellultimo dato del blocco ha una durata corrispondente a 85 cicli di bus (ciascun ciclo di bus dura 120 ns). Il tempo di CPU complessivamente impegnato per il trasferimento di uno
dei blocchi (includendo il ritardo dovuto ad accessi DMA di D1) al massimo pari a TDMA s.
TDMA = 108 s
di 12 s, nel secondo caso (una richiesta dinterruzione per blocco di dati), essendo il numero di dati di ogni blocco molto elevato, la durata della RSI trascurabile. Sapendo che il ciclo di bus ha una durata di 150ns e supponendo di tollerare in entrambi i casi una occupazione massima
del tempo di CPU dedicato al dispositivo del 3% (trascurando la RSI del DMA), allora il periodo minimo con cui possono essere trasferiti i dati
TI =400 s
TD =5 s
4) Un sistema PD32 dotato di una instruction cache e di una data cache completamente associative; ciascuna delle due cache contiene 32 blocchi da 16 byte. A data cache vuota, viene eseguito il segmento di codice che segue, caricato in memoria a partire dallindirizzo $400. Immaginando che la data cache adotti un criterio di rimpiazzo di tipo LRU (Least Recently Used), quando viene eseguita listruzione NOP la percentuale di hit sul totale degli accessi alla data cache pari a ph.
MOVL
#$F, R0
MOVL
#$1000, R1
LOOP:
MOVL
(R1), R2
ANDL
#$FFE, R2
MOVL
R2, (R1)+
SUBL
#1, R0
JNZ
LOOP
NOP
ph=86.667 %
word al medesimo indirizzo e viene eseguita, con indirizzi successivi a distanza di 4, una volta per ciclo. Vengono pertanto letti/scritti i 15 ($F) longword agli indirizzi:
$1000 $1004 $1008 . . . $1038
N
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
Indirizzo
$1000
$1000
$1004
$1004
$1008
$1008
$100C
$100C
$1010
$1010
$1014
$1014
$1018
$1018
$101C
$101C
$1020
$1020
$1024
$1024
$1028
$1028
$102C
$102C
$1030
$1030
$1034
$1034
$1038
$1034
Operazione
Lettura
Scrittura
Lettura
Scrittura
Lettura
Scrittura
Lettura
Scrittura
Lettura
Scrittura
Lettura
Scrittura
Lettura
Scrittura
Lettura
Scrittura
Lettura
Scrittura
Lettura
Scrittura
Lettura
Scrittura
Lettura
Scrittura
Lettura
Scrittura
Lettura
Scrittura
Lettura
Scrittura
Tag blocco
$100
$100
$100
$100
$100
$100
$100
$100
$101
$101
$101
$101
$101
$101
$101
$101
$102
$102
$102
$102
$102
$102
$102
$102
$103
$103
$103
$103
$103
$103
Hit/miss
Miss
Hit
Hit
Hit
Hit
Hit
Hit
Hit
Miss
Hit
Hit
Hit
Hit
Hit
Hit
Hit
Miss
Hit
Hit
Hit
Hit
Hit
Hit
Hit
Miss
Hit
Hit
Hit
Hit
Hit
Commento
ph = (26 / 30) * 100 = 86.667%
indirizzo $110963 ha un TAG pari a TAGS e, se presente in cache, si trova nel set di indice Is (0IsNs-1); TAGS e Is vanno indicati in notazione esadecimale.
Ns =32
|
TAGS =$110 |
|
Is =$12

TAGS = Indirizzo >> (5+7) = $110963 >> 12 = $110
NumSet = Indirizzo[11..7] = (Indirizzo >> 7) & %11111 = $2212 & %1111111 = $12
vettore di 20 longword. Supponendo che la subroutine utilizzi la tecnica dello stack frame, si completino le tre istruzioni qui sotto ove la prima
alloca la variabile L sul frame e le altre due assegnano al secondo parametro duscita p2 il valore contenuto in L[19].
ADDL
MOVL
#-80, SP
+8(FP), R3
MOVL 4(FP), (R3)

parametro (p1) di chiamata, mentre la variabile L di 20 long word (80 byte) occupa le posizioni relative da 80 a 4 estremi compresi. L[i] collocato ad una distanza i*sizeof(longword)=4*i dallinizio del
vettore e pertanto in posizione relativa 80+4*i rispetto al FP.
NTLB =672 bit

NTLB = (25+17) * 16 = 672 bit
NPT =16M bit
= (32-16)*2(36-16) = 16 * 220 bit
Sk1 =6.8651
Sk2 =6.2888

Sk1 = T1/Tk1 =
= (9 + 1.3*0.07*4) / (1 + 1.3*0.07*4) = 6.865103
Sk2 = T1/Tk2 =
= (9 + 1.3*0.07*4) / (1 + 1.3*0.07*4+3/24) = 6.288784
Cognome....................................................................Nome..............................................................................Matricola......................
1) Un sistema PD32 dotato di una instruction cache (destinata a memorizzare OL e EL delle istruzioni da eseguire) e di una data cache a mappatura diretta con 256 blocchi di 32 byte. Si determini lhit rate HR raggiunto in data cache dal seguente frammento di codice, nellipotesi che la data cache sia inizialmente vuota:
SUM:
MOVL
#$400, R0
MOVL
#$1AB00, R1
MOVL
#$0, R2
LOOP:
ADDL
(R1)+, R2
SUBL
#$1, R0
JNZ
LOOP
HR = 87.5 %
TAG = $D
Si determini inoltre il TAG del primo blocco spostato in data cache
L'unico accesso in memoria durante la fase di execute delle istruzioni del programma quello dovuto all'istruzione
ADDL. Poich con i dati dell'esercizio il primo long word letto quello di indirizzo pi basso di un blocco in cache, e
ogni blocco contiene 8 longword, essendo la cache inizialmente vuota, si ha un miss all'inizio di ogni sequenza di 8
word da caricare, cio in totale $400/8 = $80 = 128 miss.
HitRate = NumHit / NumTotale = (($400-$80) / $400) * 100 = ((1024-128) / 1024) * 100 = 87.5 %
NumBitTag = NumBitIndirizzo (NumBitIndiceBlocco + NumBitIndiceByte) = 32 8 5 = 19
TAGPrimoBlocco = IndirizzoPrimoWord >> (NumBitIndiceBlocco + NumBitIndiceByte) = $1AB00 >> 13 = $D
2) Si consideri un sistema di memoria con una cache con tempo di accesso di 20 ns e una memoria centrale con tempo di accesso di 100 ns. Si determini lhit rate minimo HRMIN che deve esibire un programma affinch il tempo di accesso medio sia al pi di 36 ns
HRMIN= 80%
TempoAccessoMedioMax = HitRateMin * TempAccCache + (1-HitRateMin) * TempoAccessoMem

HitRateMin = (TempoAccessoMem -TempoAccessoMedioMax) / (TempoAccessoMem - TempAccCache) =
= (100-36) / (100-20) = 0.8 = 80 %
3) In un sistema PD132 che utilizza la tecnica dello stack frame,una subroutine SUB1 riceve come unico parametro un vettore V di 10 longword,
passato per indirizzo, e alloca una sola variabile locale x, anchessa rappresentata da una longword. Si completino le due istruzioni qui sotto che
in SUB1 realizzano lassegnamento V [5]=x
MOVL
+8(FP), R0
MOVL -4(FP) , 20(R0)
Facendo riferimento alle fig. 4.29 e 4.30 del testo base, nelle locazioni rispettivamente in posizione relativa al FP +8 e
4 sono collocati il puntatore al vettore e la variabile x. Per ottenere l'offset di V[5] si calcola 5*size(longword) = 20.
4) Due convertitori ADC1 e ADC2 acquisiscono, per un intervallo di 2 secondi rispettivamente 1000 e 40000 campioni alla rispettiva frequenza di
500 Hz e 20 KHz. Il trasferimento dei campioni in memoria viene gestito ad interrupt per ADC1 e in DMA per ADC2. Trascurando la predisposizione iniziale del DMA ma includendo sia la gestione dellinterruzione del DMA che quella dovuta allultimo campione di ADC1, sapendo che
la RSI di ADC1 ha una durata complessiva R1 = 400 s, quella del DMA R2 = 300s, che la durata del ciclo di bus Tb = 100 ns, e che non vi
sono altri dispositivi nel sistema, il tempo minimo lasciato nei 2 secondi alla CPU per svolgere attivit non inerenti i due dispositivi pari a
TrMIN:
TrMIN = 1595.9501 ms
Il caso peggiore si realizza quando tutti i trasferimenti in DMA corrispondono ad altrettanti "furti di ciclo" a danno
della CPU. Nel periodo di durata TempoTotale, RSI1 viene eseguita NumCampioniADC1 volte e la CPU subisce
NumCampioniADC2 cicli di rallentamento. Dopo l'ultimo trasferimento del DMA, inizia la routine RSI2: da quel
momento la porzione di tempo sottratta ad altre attivit fino all'istante TempoTotale pari a R2 solo se RSI2 riesce a
completarsi entro quell'istante, altrimenti pari al tempo rimanente fino all'istante TempoTotale.
RestoDopoDMA = PeriodoDMA-Tb = 50-0.1 = 49.9 s < R2 = 300 s
TempoCPUADCTotaleMax
= TempoCPUADC1 + TempoCPUADC2 =
= NumCampioniADC1 * R1 + NumCampioniADC2 * Tb + RestoDopoDMA =
= 1000 * 400 + 40000 * 0.1 + 49.9 = 404049.9 s
TempoCPUAltroMin
= TempoTotale TempoCPUADCTotaleMax = 2000 404.0499 = 1595.9501 ms
Con minore precisione rispetto alle specifiche, considerando l'intero contributo di R2 si ottiene:
= NumCampioniADC1 * R1 + NumCampioniADC2 * Tb + R2 =
= 1000 * 400 + 40000 * 0.1 + 300 = 404300 s
TempoCPUAltroMin
5) Un dispositivo D1 trasferisce, ad interrupt, dati con una frequenza di 1 Kdati/s. La sua RSI ha una durata complessiva R1 = 200 s. Se un dispo-
sitivo D2 di priorit superiore a D1 gestito da una RSI di durata complessiva R2 = 20 s, e non vi sono altri dispositivi nel sistema, il minimo
periodo di D2 perch lacquisizione da D1 non perda dati pari a T2MIN (suggerimento: la RSI di D1 e tutte le RSI di D2 attivate in un periodo di
D1 devono essere concluse allo scadere del periodo):
T2MIN = 25 s
Affinch D1 non perda dati il ritardo introdotto dalla gestione di N interruzioni prodotte da D2 in un periodo di D1
deve comunque consentire l'esecuzione completa della RSI di D1 entro quel periodo. Il caso peggiore si realizza quando pendente una richiesta di D2 assieme a quella di D1 all'inizio del periodo e, detto 0 l'istante iniziale del periodo di
D1, l'ultima delle N richieste di interruzione si verifica all'istante T1-R2 (cio la sua RSI termina allo scadere del periodo D1). In questa condizione N pari all'intero immediatamente superiore o uguale al rapporto T1/T2.
TempoResiduoPerD1 = T1 N*R2 >= R1
N = ceiling(T1/T2) <= (T1 R1) / R2 = (1000 200) / 20 = 40 s
T2 >= 1000/40 = 25 s
6) Il progettista di un sistema, dotato di un dispositivo D gestito ad interrupt, stabilisce che la percentuale massima tollerabile di occupazione del
tempo di CPU dedicata a D sul totale sia pari al 70%. Sapendo che D genera richieste di interruzione con periodo fisso Td e che la durata della
RSI di D pari a Rd = 50s, il valore minimo di Td che garantisce di non superare quella percentuale massima di occupazione pari a TdMIN:
TdMIN = 71.428 s
L'occupazione data dal rapporto Rd/Td che rappresenta la quota parte del periodo del dispositivo D esclusivamente
dedicata dalla CPU al dispositivo stesso.
PercOccMax = (Rd/Tdmin) * 100 = 5000/Tdmin = 70 %
Tdmin = 5000/70 = 71.428 s
7) Per un processore con indirizzi logici da 20 bit, si voglia definire un modulo MMU che gestisca una memoria fisica da 16 Mbyte (singolarmente
indirizzabili) suddividendola in 32 pagine e organizzando le cose in modo che nella memoria fisica possano essere contemporaneamente presenti
16 programmi, ciascuno dei quali pu occupare 1 Mbyte. Allora la page table costituita da NPT elementi e ciascun elemento contiene un indice
di pagina fisica costituito BIPF bit.
NPT = 2 elementi
BIPF = 5 .bit
DimPagina = DimMemFisica / NumPagine = 16 Mbyte/32 = 0.5 Mbyte

NumBitOffset = log2 DimPagina = log2 (0.5 Mbyte) = 19 bit
NumBitPagLogica = NumBitIndLogico NumBitOffset = 20-19 = 1
NumElemPT = 2NumBitPagLogica = 21 = 2
NumBitPagFisica = log2 (NumPagFisiche) = log2 (32) = 5
8) Per un processore con indirizzi da 32 bit, si voglia definire un sistema di memoria virtuale che consenta di utilizzare una memoria fisica da 16
Mbyte (singolarmente indirizzabili), suddividendola in pagine da 512 KByte. Si voglia inoltre dotare il sistema descritto di un TLB con un numero di elementi uguale al numero delle pagine fisiche. Allora il TLB costituito da NTLB elementi e la sua dimensione complessiva, tenendo conto
della presenza di un bit di validit per ciascun elemento, di DTLB bit.
NTLB = 32 elementi
DTLB = 608 bit
NumElemTLB = NumPagFisiche = DimMemFisica / DimPagina = 16 Mbyte /0.5 Mbyte = 32

NumBitPagFisica = log2 NumPagFisiche = log2 (32) = 5 bit
NumBitPagVirtuale = NumBitIndVirtuale NumBitOffset = 32-19 = 13
DimTLB = NumElemTLB * (NumBitPagVirtuale + NumBitPagFisica + NumBitValidit) = 32 * (13+5+1) = 608
9) Un processore RISC dotato di pipeline a K=6 stadi. In media una istruzione su Nm=20 di tipo LDR/STR e comporta un accesso alla memoria
(ulteriore a quello per il fetch). Gli accessi alla memoria sono velocizzati da una cache con uno hit rate medio del 90%; ogni miss nella cache
provoca nel pipeline un inceppamento (stall) di 1 stadio. In assenza di altri tipi di stall (dovuti a data hazard o branch hazard) il fattore di speedup Sk (calcolato trascurando il transitorio iniziale, cio assumendo che il numero di istruzioni eseguite tenda allinfinito) :
Sk = 5.524887
Facendo il calcolo su una successione di N istruzioni, esse producono N*AccessiPerIstruzione accessi in memoria;
quelli che si esauriscono in cache sono N*AccessiPerIstruzione*HitRate e non producono rallentamenti, mentre la
porzione N*AccessiPerIstruzione*(1-HitRate) produce, per ciascun accesso, un ritardo corrispondente a StadiRitardo
stadi. Questi rallentamenti sono presenti sia nel caso con che senza pipeline. Risulta per le N istruzioni (a regime, cio
per N che tende allinfinito):
Tk = N*TStadio + N*AccessiPerIstruzione*(1-HitRate)*StadiRitardo*Tstadio
AccessiPerIstruzione = 1 + FrazLDRSTR = 1 + 1/20
Sk = T1/Tk = (NumStadi + AccessiPerIstruzione*(1-HitRate)*StadiRitardo) /
(1 + AccessiPerIstruzione*(1-HitRate)*StadiRitardo =
= (6+(1+1/20)(1-0.9)*1) / (1+(1+1/20)(1-0.9)*1) = 6.105 / 1.105 = 5.524887
1) Un sistema PD32 dotato di una instruction cache (destinata a memorizzare OL e EL delle istruzioni da eseguire) e di una data cache a mappatura diretta con 128 blocchi di 64 byte. Si determini lhit rate HR raggiunto in data cache dal seguente frammento di codice, nellipotesi che la
data cache sia inizialmente vuota:
SUM:
MOVL
#$500, R1
MOVL
#$CFA00, R2
MOVL
#$0, R3
LOOP:
ADDL
(R2)+, R3
SUBL
#$1, R1
JNZ
LOOP
HR = 93,75%
TAG = $67
ogni blocco contiene 16 longword, essendo la cache inizialmente vuota, si ha un miss all'inizio di ogni sequenza di 16
word da caricare, cio in totale $500/16 = $50 = 80 miss.
TAGPrimoBlocco = IndirizzoPrimoWord >> (NumBitIndiceBlocco + NumBitIndiceByte) = $CFA00 >> 13 = $67
HRMIN= 90%

= (60-15) / (60-10) = 0.9 = 90 %
passato per indirizzo, e alloca una sola variabile locale y, anchessa rappresentata da una longword. Si completino le due istruzioni qui sotto che
in SUB1 realizzano lassegnamento V [10]=y
MOVL
+8(FP), R0
MOVL -4(FP) , 40(R0)
4 sono collocati il puntatore al vettore e la variabile y. Per ottenere l'offset di V[10] si calcola 10*size(longword) = 40.
4) Due convertitori ADC1 e ADC2 acquisiscono, per un intervallo di 1 secondo rispettivamente 2000 e 50000 campioni alla rispettiva frequenza di
2 KHz e 50 KHz. Il trasferimento dei campioni in memoria viene gestito ad interrupt per ADC1 e in DMA per ADC2. Trascurando la predisposizione iniziale del DMA ma includendo sia la gestione dellinterruzione del DMA che quella dovuta allultimo campione di ADC1, sapendo
che la RSI di ADC1 ha una durata complessiva R1 = 300 s, quella del DMA R2 = 500s, che la durata del ciclo di bus Tb = 200 ns, e che
non vi sono altri dispositivi nel sistema, il tempo minimo lasciato nel secondo di trasferimento alla CPU per svolgere attivit non inerenti i due
dispositivi pari a TrMIN::
TrMIN = 389.9802 ms
= 2000 * 300 + 50000 * 0.2 + 19.8 = 610019.8 s
TempoCPUAltroMin
= 2000 * 300 + 50000 * 0.2 + 500 = 610500 s
TempoCPUAltroMin
5) Un dispositivo D1 trasferisce, ad interrupt, dati con una frequenza di 2 Kdati/s. La sua RSI ha una durata complessiva R1 = 100 s. Se un di-
spositivo D2 di priorit superiore a D1 gestito da una RSI di durata complessiva R2 = 40 s, e non vi sono altri dispositivi nel sistema, il minimo periodo di D2 perch lacquisizione da D1 non perda dati pari a T2MIN (suggerimento: la RSI di D1 e tutte le RSI di D2 attivate in un periodo di D1 devono essere concluse allo scadere del periodo):
T2MIN = 50 s
N = ceiling(T1/T2) <= (T1 R1) / R2 = (500 100) / 40 = 10 s
T2 >= 500/10 = 50 s
TdMIN = 200 s
Tdmin = 8000/40 = 200 s
7) Per un processore con indirizzi logici da 23 bit, si voglia definire un modulo MMU che gestisca una memoria fisica da 128 Mbyte (singolarmente indirizzabili) suddividendola in 64 pagine e organizzando le cose in modo che nella memoria fisica possano essere contemporaneamente
presenti 16 programmi, ciascuno dei quali pu occupare 8 Mbyte. Allora la page table costituita da NPT elementi e ciascun elemento contiene
un indice di pagina fisica costituito BIPF bit.
NPT = 4 elementi
BIPF = 6 bit
DimPagina = DimMemFisica / NumPagine = 128 Mbyte/64 = 2 Mbyte

NumBitOffset = log2 DimPagina = log2 (2 Mbyte) = 21 bit
Mbyte (singolarmente indirizzabili), suddividendola in pagine da 2 MByte. Si voglia inoltre dotare il sistema descritto di un TLB con un numero di elementi uguale al numero delle pagine fisiche. Allora il TLB costituito da NTLB elementi e la sua dimensione complessiva, tenendo conto della presenza di un bit di validit per ciascun elemento, di DTLB bit.
NTLB = 64 elementi
DTLB = 1152 bit
NumElemTLB = NumPagFisiche = DimMemFisica / DimPagina = 128 Mbyte /2 Mbyte = 64

9) Un processore RISC dotato di pipeline a K=7 stadi. In media una istruzione su Nm=25 di tipo LDR/STR e comporta un accesso alla memoria (ulteriore a quello per il fetch). Gli accessi alla memoria sono velocizzati da una cache con uno hit rate medio del 95%; ogni miss nella cache
Sk = 6.703422
= (7+(1+1/25)(1-0.95)*1) / (1+(1+1/25)(1-0.95)*1) = 7.052 / 1.052 = 6.703422
SUM:
MOVL
#$200, R2
MOVL
#$5E100, R3
MOVL
#$0, R4
LOOP:
ADDL
(R3)+, R4
SUBL
#$1, R2
JNZ
LOOP
HR=75%
TAG=$BC
ogni blocco contiene 16 byte, essendo la cache inizialmente vuota, si ha un miss all'inizio di ogni sequenza di 4 word da
caricare, cio in totale $200/4 = $80 = 128 miss.
TAGPrimoBlocco = IndirizzoPrimoWord >> (NumBitIndiceBlocco + NumBitIndiceByte) = $5E100 >> 11 = $BC
HRMIN= 75%

= (70-22) / (70-6) = 0.75 = 75 %
passato per indirizzo, e alloca una sola variabile locale z, anchessa rappresentata da una longword. Si completino le due istruzioni qui sotto che
in SUB1 realizzano lassegnamento V [8]=z
MOVL
+8(FP), R0
MOVL -4(FP) , 32(R0)
4 sono collocati il puntatore al vettore e la variabile z. Per ottenere l'offset di V[8] si calcola 8*size(longword) = 32.
non vi sono altri dispositivi nel sistema, il tempo minimo lasciato nei 2 secondi alla CPU per svolgere attivit non inerenti i due dispositivi pari
a TrMIN:
TrMIN = 1592.76679 ms
RestoDopoDMA = PeriodoDMA-Tb = 33.33-0.12 = 33.21 s < R2 = 400 s
= 2000 * 200 + 60000 * 0.12 + 33.21 = 407233.21 s
TempoCPUAltroMin
= 2000 * 200 + 60000 * 0.12 + 400 = 407600 s
TempoCPUAltroMin
5) Un dispositivo D1 trasferisce, ad interrupt, dati con una frequenza di 2.5 Kdati/s. La sua RSI ha una durata complessiva R1 = 100 s. Se un di-
T2MIN = 40 s
N = ceiling(T1/T2) <= (T1 R1) / R2 = (400 100) / 30 = 10 s
T2 >= 400/10 = 40 s
TdMIN = 80 s
Tdmin = 4000/50 = 80 s
indirizzabili) suddividendola in 128 pagine e organizzando le cose in modo che nella memoria fisica possano essere contemporaneamente presenti 16 programmi, ciascuno dei quali pu occupare 4 Mbyte. Allora la page table costituita da NPT elementi e ciascun elemento contiene un
indice di pagina fisica costituito BIPF bit.
NPT = 8 elementi
BIPF = 7 bit
DimPagina = DimMemFisica / NumPagine = 64 Mbyte/128 = 0.5 Mbyte

Mbyte (singolarmente indirizzabili), suddividendola in pagine da 512 KByte. Si voglia inoltre dotare il sistema descritto di un TLB con un numero di elementi uguale al numero delle pagine fisiche. Allora il TLB costituito da NTLB elementi e la sua dimensione complessiva, tenendo
conto della presenza di un bit di validit per ciascun elemento, di DTLB bit.
NTLB = 128 elementi
DTLB = 2688 bit
NumElemTLB = NumPagFisiche = DimMemFisica / DimPagina = 64 Mbyte /0.5 Mbyte = 128
Sk = 4.466956
= (5+(1+1/40)(1-0.85)*1) / (1+(1+1/40)(1-0.85)*1) = 5.15375 / 1.15375 = 4.466956
SUM:
MOVL
#$600, R4
MOVL
#$2CE00, R5
MOVL
#$0, R6
LOOP:
ADDL
(R5)+, R6
SUBL
#$1, R4
JNZ
LOOP
HR=.96,875.%
TAG=$B
ogni blocco contiene 128 byte, essendo la cache inizialmente vuota, si ha un miss all'inizio di ogni sequenza di 32 word
da caricare, cio in totale $600/32 = $30 = 48 miss.
TAGPrimoBlocco = IndirizzoPrimoWord >> (NumBitIndiceBlocco + NumBitIndiceByte) = $2CE00 >> 14 = $B
HRMIN= 85%

= (110-42) / (110-30) = 0.85 = 85 %
passato per indirizzo, e alloca una sola variabile locale w, anchessa rappresentata da una longword. Si completino le due istruzioni qui sotto che
in SUB1 realizzano lassegnamento V [30]=w
MOVL
+8(FP), R0
MOVL -4(FP) , 120(R0)
4 sono collocati il puntatore al vettore e la variabile w. Per ottenere l'offset di V[30] si calcola 30*size(longword) =
120.
non vi sono altri dispositivi nel sistema, il tempo minimo lasciato nel secondo di traferimento alla CPU per svolgere attivit non inerenti i due
dispositivi pari a TrMIN:
TrMIN = 695.17512 ms
= 1000 * 300 + 40000 * 0.12 + 24.88 = 304824.88 s
TempoCPUAltroMin
= 1000 * 300 + 40000 * 0.12 + 150 = 304950 s
TempoCPUAltroMin
5) Un dispositivo D1 trasferisce, ad interrupt, dati con una frequenza di 250 dati/s. La sua RSI ha una durata complessiva R1 = 400 s. Se un di-
T2MIN = 100 s
N = ceiling(T1/T2) <= (T1 R1) / R2 = (4000 400) / 90 = 40
T2 >= 4000/40 = 100 s
TdMIN = 66.666 s
Tdmin = 4000/60 = 66.666 s
presenti 16 programmi, ciascuno dei quali pu occupare 16 Mbyte. Allora la page table costituita da NPT elementi e ciascun elemento contiene un indice di pagina fisica costituito BIPF bit.
NPT = 16 elementi
BIPF = 8 bit
DimPagina = DimMemFisica / NumPagine = 256 Mbyte/256 = 1 Mbyte

NTLB = 256 elementi
DTLB = 5376 bit
NumElemTLB = NumPagFisiche = DimMemFisica / DimPagina = 256 Mbyte /1 Mbyte = 256
Sk =7.860055
= (8+(1+1/50)(1-0.98)*1) / (1+(1+1/50)(1-0.98)*1) = 8.0204 / 1.0204 = 7.860055
COGNOME.................................................................................... NOME..................................................................... MATR. ........................
1.
ARCHITETTURA DEGLI ELABORATORI 1 - Seconda prova intermedia 20 giugno 2005

In un sistema PD32 una subroutine riceve un parametro dingresso longword (32 bit) P, passato per valore, e alloca una variabile
locale L costituita da una struttura con due campi f1 ed f2, ciascuno occupante un longword. La subroutine utilizzi la tecnica dello
stack frame descritta nel paragrafo 4.7.3 del testo. Si completino le due istruzioni qui sotto ove la prima alloca la variabile L sul
frame e laltra assegna al campo f2 della variabile L il valore del parametro dingresso P.
ADDL #-8, SP
L:
f1
f2
MOVL 8 (FP), -4 (FP)
Nel prologo della subroutine lo SP deve essere decrementato di una quantit pari allo spazio in byte complessivamente occupato dalle variabili locali. Le strutture di dati (struct) hanno i campi che occupano locazioni successive di memoria nellordine espresso dalla loro dichiarazione. La variabili locali vengono riferite attraverso il registro FP con
offset negativo, i parametri di chiamata con offset positivo (esclusi gli offset 0 e +4 che rappresentano rispettivamente
i valori old FP e RetADR).
2.
Supponendo che in un sistema ARM una chiamata a subroutine sia realizzata con il seguente codice (a sinistra):
BL
.WORD
.WORD
.WORD
SUBR
VAL1
VAL2
VAL3
LDR R0, [LR, LSL #2]

LDR R0, [LR], #4
LDR R0, [LR, #4]
LDR R0, [LR, #2]!
indicare quale delle 4 istruzioni sulla destra, eseguita allinizio della subroutine SUBR, carica nel registro R0 il parametro VAL2.
Allingresso della subroutine, LR contiene lindirizzo del longword che segue immediatamente quello contenente
listruzione BL SUBR. Pertanto, per un passaggio di parametri con la tecnica in-line calling sequence, rispetto a
quellindirizzo gli offset dei parametri sono rispettivamente 0 per il primo, 4 per il secondo, 8 per il terzo.
3.
Due dispositivi D1, D2 trasferiscono, ad interrupt, dati con una frequenza di 1 Kdati/s. Le richieste di interruzione prodotte da D2
hanno luogo con un ritardo (fisso) D21=500s rispetto a quelle di D1. La routine di servizio RSI di D1 ha una durata complessiva
R1 = 200 s. Sapendo che non vi sono altri dispositivi nel sistema, la max durata ammessa per la routine di servizio RS2 di D2
affinch lacquisizione da entrambi i dispositivi non perda dati pari a R2MAX:
R2MAX = 800s
Nel periodo che separa una richiesta di interruzione da parte di D1 e quella immediatamente successiva, D2 fa pervenire una e una sola richiesta di interruzione. Allinterno del comune periodo (i due dispositivi lavorano alla stessa frequenza) si devono pertanto completare entrambe le RSI (vedi figure nei due casi di diversa priorit relativa tra i due
dispositivi), da cui risulta R2MAX = PeriodoDispositivi-R1 = 1000-200=800s.
D1
D1
D2
D2
D1>D2
R1
R2
D21
D1
R1
R2
T+D21
D1
D2
2T
D2
D1<D2
R1
0
4.
R2
D21
R1
T
T+D21
2T
Un convertitore ADC, associato ad un clock di periodo Td, gestito ad interrupt con una RSI di durata complessiva pari a
Radc=40s. Si stabilisce che la percentuale massima tollerabile di occupazione del tempo di CPU dedicata ad ADC sul totale sia
pari al 40%. Allora il valore minimo di Td che garantisce di non superare quella percentuale di occupazione pari a TdMIN:
TdMIN= 100 s
La percentuale di occupazione della CPU da parte dello ADC corrisponde allesecuzione di una istanza della RSI
allinterno di un singolo periodo, per cui pari a:
PercOccupazioneADC = (Radc/Td)*100
da cui risulta
TdMIN = (Radc/PercOccupazioneADCMAX) *100 = (40/40)*100 = 100s.
5.
Un processore RISC, dotato di cache, di tipo superscalare con un fattore 3 ed ha un pipeline di 6 stadi; ciascuno stadio ha una
durata di 20 ns. Sapendo che, in un determinato intervallo di tempo, in ciascun pipeline la percentuale di istruzioni che subiscono,
per hazard e altri fattori, un ritardo di uno stadio pari al 20% e quella delle istruzioni che subiscono un ritardo di due stadi pari
al 15%, la durata media T dellesecuzione delle istruzioni in quellintervallo pari a:

T= 10 ns
Facendo il calcolo su una successione di N istruzioni, di esse, a regime, N*(1-PercRitardo1/100-PercRitardo2/100) impegnano ciascuna (1/P)*DurataStadio (se i pipeline sono P in parallelo, senza inceppamenti, ogni DurataStadio vengono completate, a regime, P istruzioni), N*PercRitar1/100 impegnano (2/P)*DurataStadio, e N*PercRitar2/100 impegnano (3/P)*DurataStadio, da cui risulta un tempo medio per eseguire le N istruzioni:
T=
N*((1-PercRitar1/100-PercRitar2/100)*(1/P) + (PercRitar1/100)*(2/P) + (PercRitar2/100(*(3/P))*DurataStadio / N =
((1-PercRitar1/100-PercRitar2/100)*(1/P) + (PercRitar1/100)*(2/P) + (PercRitar2/100)*(3/P)) * DurataStadio =
((1-20/100-15/100)*(1/3) + (20/100)*(2/3) + 15/100) * 20 = 10 ns
6.
Un processore RISC con un pipeline di 7 stadi adotta un sistema di branch prediction per ridurre i branch hazard basato su una
Branch History Table (BHT). Supponendo che una scelta errata in un salto condizionato provochi un inceppamento di 2 stadi del
pipeline, che la probabilit di insuccesso della BHT, cui corrisponde linceppamento, sia pari al 30% e che ogni stadio del
pipeline abbia una durata di 30ns, allora nellipotesi che non vi siano inceppamenti del pipeline durante lesecuzione delle altre istruzioni, il fattore di speedup Sk (calcolato quindi trascurando il transitorio iniziale e immaginando che il programma sia costituito da sole istruzioni di salto condizionato) :
Sk = 4.375
Facendo il calcolo su una successione di N istruzioni, di esse, a regime, N*(1-PercMissBHT/100) impegnano 1 DurataStadio mentre N*PercMissBHT/100 impegnano (1+StadiIncep) * DurataStadio. Senza pipeline la durata complessiva
sarebbe N*NumStadi*DurataStadio. Da questo risulta:
SK = (N*NumStadi*DurataStadio) / ((N*(1-PercMissBHT/100) + N*(PercMissBHT/100)* (1+StadiIncep)) * DurataStadio) =
NumStadi / ((1-PercMissBHT/100) + (PercMissBHT/100)* (1+StadiIncep)) =
NumStadi / (1+(PercMissBHT/100)*StadiIncep) =
7 / (1+(30/100)*2) = 4.375
7.
In un sistema PD32 con memoria virtuale, pagine da 8kByte e clock da 1GHz, i trasferimenti da o verso il disco avvengono in
DMA. A regime il numero di pagine rimpiazzate in un secondo 20; di queste il 25% risultano modificate. I singoli dati trasferiti
via DMA sono longword da 4 byte. La RSI del DMA, attivata al termine del trasferimento di ciascuna pagina, impiega 200 istruzioni di durata media pari a 5 cicli di clock. Calcolare la percentuale di tempo massimo richiesto alla CPU per effettuare i trasferimenti, diviso nelle due componenti TD (conflitti DMA) e TS (tempo impiegato dalla RSI):
TD = 5.12E-03 %
TS = 2.5E-03 %
Per il DMA si considerer il caso peggiore di un furto di ciclo ad ogni trasferimento da/al dispositivo. Ad ogni secondo NumPagineRimpiazzate producono ciascuna una lettura da disco e di queste in percentuale PercModificate
producono ciascuna anche una scrittura su disco. Il trasferimento di una pagina in uno dei due versi produce DimPagina/4 longword trasferiti, cui corrispondono altrettante richieste di DMA, e una singola esecuzione della RSI del
DMA. Da questo risulta (eseguendo il calcolo nellintervallo di un secondo):
NumPagineTrasfAlSecondo = NumPagineRimpiazzate*(1+PercModificate/100)
NumLongwordTrasfAlSecondo = NumPagineTrasfAlSecondo*DimPagina/4
TD =. NumLongwordTrasfAlSecondo * TCiclo * 100 =
20 * (1+25/100) * (2^13 / 4) * 10^-9 * 100 = 5.12E-03 %
TS =. NumPagineTrasfAlSecondo * DurataRSI * 100 =
NumPagineTrasfAlSecondo * NumIstrRSI * CicliMediaIstr * TCiclo * 100 =
20 * (1+25/100) * 200 * 5 * 10^-9 * 100 = 2.5E-03 %
8.
In un sistema PD32 con pagine (insieme di blocchi, si veda fig. 4.24 pag. 183 del testo) da 8kByte, la memoria cache di tipo setassociativo a 16 vie costituita da blocchi da 64 byte. Il processore genera indirizzi da 32 bit e, per ciascun blocco, la cache contiene anche 2 bit di controllo (oltre ai bit del TAG). Si indichino: il numero NS di set della cache e il numero B di bit di cui ciascun set costituito.
NS = 128
B = 8528 bit
Ogni pagina include blocchi che sarebbero distribuiti in tutti i diversi set della cache. Pertanto:
NS = DimPagina/DimBlocco =
2^13 / 2^6 = 128
Ogni via di un set include un blocco, un TAG e un bit di validit, da cui:
BitPerVia = BitPerBlocco+BitTAG+ 2 = BitPerBlocco+(BitIndirizzo-BitIndiceByte-BitIndiceSet)+ 2=
BitPerBlocco+(BitIndirizzo log2 BytePerBlocco log2 NS)+ 2 =
2^9+(32-6-7)+2 = 533
BitPerSet = BitPerVia*NumViePerSet =
533*16 = 8528
9.
In un sistema PD32 dotato di memoria cache di tipo set-associativo a 16 vie, con 128 set contenenti blocchi da 64 byte, durante
lesecuzione di un programma che trasferisce i dati di un vettore A (10 longword, indirizzo iniziale $12000) ad un vettore D (indirizzo iniziale $A4000) delle stesse dimensioni, sono coinvolti i set della cache di indice S1, S2 i cui TAG valgono T1, T2 (Si e
Ti in esadecimale).

T1 =$9 S1 =$0T2 =$52 S2 =$0
Dopo aver verificato che per tutti i byte coinvolti nel trasferimento viene riferita sempre la stessa coppia di set (uno
per lettura, uno per scrittura), si ottiene (N-1 la maschera usata per catturare i (log2 N) bit meno significativi)
T1 = (Adr1 >> (log2 BytePerBlocco + log 2 NumSet)) = $12000>>(6+7) = 9
S1 = (Adr1 >> log2 BytePerBlocco) & (NumSet-1) = ($12000>>6) & $7f = $480 & $7f = 0
T2 = (Adr1 >> (log2 BytePerBlocco + log 2 NumSet)) = $A4000>>(6+7) = $52
S2 = (Adr1 >> log2 BytePerBlocco) & (NumSet-1) = ($A4000>>6) & $7f = $2900 & $7f = 0
10. Un sistema di memoria virtuale per il PD32 (con indirizzi virtuali da 32 bit) consente di utilizzare una memoria fisica da 16
Mbyte, con pagine da 64 Kbyte, utilizzando un TLB avente un numero di elementi pari alla met del numero delle pagine fisiche.
In ciascun elemento presente un bit di validit. Indicare il numero NTLB degli elementi del TLB e la sua dimensione DTLB in bit:
NTLB = 128 elementi
DTLB = 3200 bit
NTLB = NumPagFisiche / 2 = DimMemFisica / (DimPagina * 2) = 2^24 / 2^17 = 128
NumBitElementoTLB = NumBitIndPagLogica + NumBitIndPagFisica + 1=
log2 NumPagineLogiche + log2 NumPagineFisiche + 1=
log2 (DimMemLogica/DimPagina) + log2 (DimMemFisica/DimPagina) + 1 =
log2 DimMemLogica + log2 DimMemFisica 2*log2 DimPagina + 1
DTLB = NumBitElementoTLB * NTLB =
= (32 + 24 32 +1) * 128 = 25 * 128 = 3200
1.

In un sistema PD32 una subroutine riceve un parametro dingresso longword (32 bit) P, passato per valore, e alloca una variabile
locale L costituita da una struttura con tre campi f1, f2 e f3, ciascuno occupante un longword. La subroutine utilizzi la tecnica dello stack frame descritta nel paragrafo 4.7.3 del testo. Si completino le due istruzioni qui sotto ove la prima alloca la variabile L
sul frame e laltra assegna al campo f1 della variabile L il valore del parametro dingresso P.
L:
f1
ADDL #-12, SP
f2
MOVL 8 (FP), -12 (FP)

f3
2.
BL
.WORD
.WORD
.WORD
SUBR
VAL1
VAL2
VAL3

LDR R1, [LR, #8]
LDR R1, [LR], #8
LDR R1, [LR, #4]!
3.
R2MAX = 200 s
D1
D1
D2
D2
D1>D2
R1
R2
D21
D1
R1
R2
T+D21
D1
D2
2T
D2
D1<D2
R1
0
4.
R2
D21
R1
T
T+D21
2T
TdMIN= 300 s
da cui risulta
5.

T= 7.5 ns
T=
((1-30/100-10/100)*(1/4) + (30/100)*(2/4) + (10/100)*(3/4)) * 20 = 7.5 ns
6.
Sk = 4.667
7 / (1+(25/100)*2) = 4.667
7.
TD = 2.048E-03 %
TS = 2E-03 %
16 * (1+25/100) * (2^12 / 4) * 10^-9 * 100 = 2.048E-03 %
16 * (1+25/100) * 200 * 5 * 10^-9 * 100 = 2E-03 %
8.
NS = 32
B = 8368 bit
2^12 / 2^7 = 32
2^10+(32-7-5)+2 = 1046
1046*8 = 8368
9.
Ti in esadecimale).

T1 =$9 S1 =$0 T2 =$52 S2 =$0
S1 = (Adr1 >> log2 BytePerBlocco) & (NumSet-1) = ($12000>>7) & $3f = $240 & $3f = $0
NTLB = 256 elementi
DTLB = 6656 bit
= (32 + 25 32 +1) * 256 = 26 * 256 = 6656

1.
In un sistema PD32 una subroutine riceve un parametro dingresso L, passato per valore, costituito da una struttura con due campi
f1 ed f2, ciascuno occupante un longword (32 bit), e alloca una variabile locale LL longword. La subroutine utilizzi la tecnica dello
stack frame descritta nel paragrafo 4.7.3 del testo. Si completino le due istruzioni qui sotto ove la prima alloca la variabile LL sul
frame e laltra assegna alla variabile LL il valore del campo f2 del parametro dingresso L.
L:
f1
ADDL #-4, SP
f2
MOVL 12 (FP), -4 (FP)

2.
BL
.WORD
.WORD
.WORD
SUBR
VAL1
VAL2
VAL3
LDR R2, [LR, #2]!

LDR R2, [LR], #4
LDR R2, [LR, #4]
3.
R2MAX = 150 s
D1
D1
D2
D2
D1>D2
R1
R2
D21
D1
R1
R2
T+D21
D1
D2
2T
D2
D1<D2
R1
0
4.
R2
D21
R1
T
T+D21
2T
TdMIN= 120 s
da cui risulta
5.

T= 7.75 ns
T=
((1-15/100-20/100)*(1/3) + (15/100)*(2/3) + 20/100) * 15 = 7.75 ns
6.
Sk = 4
7 / (1+(25/100)*3) = 4
7.
TD = 1.80224E-03 %
TS = 3.52E-03 %
32 * (1+10/100) * (2^11 / 4) * 10^-9 * 100 = 1.80224E-03 %
32 * (1+10/100) * 200 * 5 * 10^-9 * 100 = 3.52E-03 %
8.
NS = 16
B = 16560 bit
2^12 / 2^8 = 16
2^11+(32-8-4)+2 = 2070
2070*8 = 16560
9.
Ti in esadecimale).

T1 =$5 S1 =$0 T2 =$29 S2 =$0
S1 = (Adr1 >> log2 BytePerBlocco) & (NumSet-1) = ($14000>>8) & $3f = $1400 & $3f = 0
S2 = (Adr1 >> log2 BytePerBlocco) & (NumSet-1) = ($A4000>>8) & $3f = $A400 & $3f = $0
NTLB = 1024 elementi
DTLB = 29696 bit
= (32 + 26 30 +1) * 1024 = 29 * 1024 = 29696

1.
In un sistema PD32 una subroutine riceve un parametro dingresso P passato per valore, costituito da una struttura con tre campi f1,
f2 ed f3, ciascuno occupante un longword (32 bit), e alloca una variabile locale L longword. La subroutine utilizzi la tecnica dello
stack frame descritta nel paragrafo 4.7.3 del testo. Si completino le due istruzioni qui sotto ove la prima alloca la variabile L sul
frame e laltra assegna alla variabile L il valore del campo f3 del parametro dingresso P.
P:
f1
ADDL #-4, SP
f2
MOVL 16 (FP), -4 (FP)

f3
2.
BL
.WORD
.WORD
.WORD
SUBR
VAL1
VAL2
VAL3
LDR R3, [LR, #8]

LDR R3, [LR], #8
LDR R3, [LR, #4]!
3.
R1 = 90 s. Sapendo che non vi sono altri dispositivi nel sistema, la max durata ammessa per la routine di servizio RS2 di D2 affinch lacquisizione da entrambi i dispositivi non perda dati pari a R2MAX:
R2MAX = 110 s
D1
D1
D2
D2
D1>D2
R1
R2
D21
D1
R1
R2
T+D21
D1
D2
2T
D2
D1<D2
R1
0
4.
R2
D21
R1
T
T+D21
2T
TdMIN= 175 s
da cui risulta
5.

T= 15.5 ns
T=
((1-25/100-15/100)*(1/2) + (25/100)*(2/2) + (15/100)*(3/2)) * 20 = 15.5 ns
6.
Sk = 3.684
7 / (1+(30/100)*3) = 3.684
7.
TD = 2.6624E-03 %
TS = 1.3E-03 %
20 * (1+30/100) * (2^13 / 4) * 0.5 * 10^-9 * 100 = 2.6624E-03 %
20 * (1+30/100) * 200 * 5 * 0.5 * 10^-9 * 100 = 1.3E-03 %
8.
In un sistema PD32 con pagine (insieme di blocchi, si veda fig. 4.24 pag. 183 del testo) da 8kByte, la memoria cache di tipo setassociativo a 32 vie costituita da blocchi da 128 byte. Il processore genera indirizzi da 32 bit e, per ciascun blocco, la cache
contiene anche 2 bit di controllo (oltre ai bit del TAG). Si indichino: il numero NS di set della cache e il numero B di bit di cui
ciascun set costituito.
NS = 64
B = 33440 bit
2^13 / 2^7 = 64
2^10+(32-7-6)+2 = 1045
1045*32 = 33440
9.
Ti in esadecimale).

T1 =$8 S1 =$0 T2 =$52 S2 =$0
S1 = (Adr1 >> log2 BytePerBlocco) & (NumSet-1) = ($10000>>7) & $3f = $2000 & $3f = $0
NTLB = 512 elementi
DTLB = 14336 bit
= (32 + 25 30 +1) * 512 = 28 * 512 = 14336
COGNOME ESATTO
NOME GIUSTO
MATR A

1.
In un sistema PD32 una subroutine con la tecnica dello stack frame descritta nel paragrafo 4.7.3 del testo, riceve, nellordine, un
parametro dingresso longword (32 bit) A, passato per valore, e un parametro di uscita F, passato per indirizzo, costituito da una
struttura con due campi f1 ed f2, ciascuno occupante un longword. Si completino le seguenti due istruzioni PD32, con cui la subroutine assegna al campo f2 della struttura F il valore del parametro dingresso A.
........................... MOVL 8(FP), R0
....................MOVL 12 (FP), 4(R0)
Le strutture di dati (struct) hanno i campi che occupano locazioni successive di memoria nellordine espresso dalla loro dichiarazione. La variabili locali vengono riferite attraverso il registro FP con offset negativo, i parametri di chiamata con offset positivo (esclusi gli offset 0 e +4 che rappresentano rispettivamente i valori old FP e RetADR).
2.
Si supponga ora che la subroutine dellesercizio precedente sia realizzata, con le medesime modalit di passaggio degli stessi parametri, in un sistema ARM usando R11 come frame pointer (la prima istruzione della subroutine sia: STMFD SP!, {R11, LR});
si completino le due istruzioni qui sotto, con cui la subroutine assegna al campo f2 della struttura L il valore del parametro
dingresso P:
........................ LDR R0, [R11, #8]
....................... LDR R1, [R11, #12]
.......................... STR R1 , [R0, #4]
La situazione del frame dellattivazione corrente analoga a quella dellesercizio precedente. Il registro aggiuntivo va
utilizzato per il movimento da memoria a memoria.
3.
Due dispositivi D1, D2 operano un trasferimento periodico di dati, gestito ad interrupt, il medesimo periodo T. Le richieste di interruzione prodotte da D2 hanno luogo con un ritardo (fisso) D21=T/2 rispetto a quelle di D1. La routine di servizio RSI di D1 ha
una durata complessiva R1 = 200 s; quella di D2 ha durata complessiva R2 = 100 s. Sapendo che non vi sono altri dispositivi
nel sistema, il minimo periodo TMIN ammesso affinch lacquisizione da entrambi i dispositivi non perda dati :
.....................................TMIN = 300 s
dispositivi), da cui risulta TMIN = R1+R2.
D1
D1
D2
D2
D1>D2
R1
R2
R1
D21
D1
R2
T+D21
D1
D2
2T
D2
D1<D2
R1
0
4.
R2
D21
R1
R1
T
R2
T+D21
R1
2T
Un convertitore ADC, associato ad un clock di periodo Td = 200s, gestito ad interrupt con una RSI di durata complessiva pari
a Radc=40s. Un programma P, se eseguito in assenza di interruzioni, verrebbe completato in Tp=30s, Se eseguito mentre hanno
luogo le interruzioni di ADC, il medesimo programma subisce un rallentamento e il suo completamento avviene in TC secondi:
........................................... TC= 37.5 s
Il rallentamento dovuto alle interruzioni e, pertanto, allesecuzione delle corrispondenti attivazioni RSI.
Ogni Td il processore impegnato per Radc nellesecuzione della RSI; nei rimanente intervallo Td - Radc esegue le istruzioni del programma P.
In sostanza allesecuzione di P il processore dedica una frazione del suo tempo pari a: F = (Td Radc)/Td.
Per eseguire i Tp richiesti da P, il processore impiega un tempo Tc tale che F*Tc = Tp.
Risulta: Tc = Tp/F
ADC
5.
ADC
ADC
durata di 20 ns. Si supponga che, a regime (con i pipeline pieni), durante lesecuzione di 3000 istruzioni, in ciascun pipeline la
percentuale di istruzioni che subiscono, per hazard e altri fattori, un ritardo di uno stadio sia pari al 20%. In queste condizioni,
lesecuzione delle 3000 istruzioni viene completata in un tempo pari a TH; mentre, nel caso non si verifichi nessun hazard, la loro
esecuzione verrebbe completata in un tempo pari a T:
............................................ TH =24 s
..............................................T= 20 s
Facendo il calcolo sulla successione delle N istruzioni, di esse N*(1-PercRitardo1/100) impegnano ciascuna
(1/P)*DurataStadio (se i pipeline sono P in parallelo, senza inceppamenti, ogni DurataStadio vengono completate, a
regime, P istruzioni), N*PercRitar1/100 impegnano invece (2/P)*DurataStadio, da cui risulta un tempo totale TH per
eseguire le N istruzioni:
TH = N*((1-PercRitar1/100)*(1/P) + (PercRitar1/100)*(2/P)) * DurataStadio
Senza hazard, ogni istruzione richiede a regime (1/P)*DurataStadio, per cui la durata totale risulta:
T= N*(1/P) * DurataStadio
6.
In un sistema PD32 la durata dei cicli di accesso alla memoria sia di TC=20ns. Durante lesecuzione di unapplicazione, vengano
continuamente trasferiti in memoria, via DMA, 20 blocchi da 8000 byte ogni secondo (i singoli dati trasferiti via DMA siano longword da 4 byte ). La RSI del DMA, attivata al termine del trasferimento di ciascun blocco, comporti lesecuzione di 20 istruzioni, ciascuna di durata media pari 100ns. Calcolare la percentuale di tempo massimo richiesto alla CPU per effettuare i trasferimenti, diviso nelle due componenti TD (conflitti DMA) e TS (tempo impiegato dalla RSI):
........................................TD = 0.08 %
...................................... TS = 0.004 %
Dai dati si sa che nellunit di tempo (1 s) vengono trasferiti NumBlocchiPerSecondo e quindi quellintervallo di tempo comprende sia limpegno equivalente di CPU dovuto al cycle stealing che quello dovuto alle NumBlocchiPerSecondo attivazioni della RSI. Per il DMA si considerer come al solito il caso peggiore di un furto di ciclo ad ogni trasferimento da/al dispositivo, corrispondente ad un tempo CPU (equivalente) dedicato ad ogni trasferimento pari ad 1 ciclo, cio TC. Eseguendo i calcoli nellintervallo di un secondo, risulta in percentuale:
TD = NumTrasferPerSecondo * TC * 100 = (NumBlocchiPerSecondo * NumByteBlocco / BytePerTrasf)) * TC * 100
TS = NumBlocchiPerSecondo * TRSI * 100 = NumBlocchiPerSecondo * NumIstruzPerRSI * DurataMediaIstr* 100

7.
Un sistema PD32 dotato di una memoria cache di tipo set-associativo costituita da NS set da 32 vie e ciascuna via costituita da
un blocco da 32 byte. Associati a ciascun blocco, la cache comprende anche 2 bit di controllo e 20 bit, destinati a contenere il
TAG del blocco. Ciascun set pertanto dotato di una memoria associativa contenente i TAG dei blocchi presenti nel set. Tenendo
presente che il processore genera indirizzi da 32 bit, si indichino: il numero NS di set della cache e il numero B di bit di cui costituita ciascuna delle NS memorie associative della cache.
.............................................. NS = 128
.......................................... B = 640 bit
NumBitIndirizzo = NumBitTAG + log2 NS + log2 BytePerBlocco
NS = 2 NumBitIndirizzo - NumBitTAG - log2 BytePerBlocco
Essendo la cache set-associativa, i confronti in parallelo sono eseguiti in una CAM che ha tanti elementi quanti le vie e
ciascuno di questi contiene un TAG, per cui risulta:
B = NumVie * NumBitTAG
8.
lesecuzione della sequenza di cinque istruzioni, collocate in memoria a partire dellindirizzo $12340, le quali accedono ai primi
cinque elementi (da 32 bit) di un vettore D (situato in memoria a partire dellindirizzo $A48C0), sono coinvolti i set della cache
di indice S1, S2 i cui TAG valgono T1, T2 (Si e Ti in esadecimale).
T1 =$ 00009
S1 =$ 0D ]
T2 =$ 00052
S2 =$ 23 ]
per il fetch, uno per i dati), si ottiene (N-1 la maschera usata per catturare i (log2 N) bit meno significativi)
T1 = (Adr1 >> (log2 BytePerBlocco + log2 NumSet))
S1 = (Adr1 >> log2 BytePerBlocco) & (NumSet-1)
T2 = (Adr2 >> (log2 BytePerBlocco + log2 NumSet))
S2 = (Adr2 >> log2 BytePerBlocco) & (NumSet-1)
9.
Un sistema di memoria virtuale per il PD32 (con indirizzi virtuali da 32 bit) consente di utilizzare una memoria fisica da 16
Mbyte, con pagine da 64 Kbyte. La page table costituita da N elementi. Gli indici di pagina fisica sono costituiti da NB bit. Il sistema utilizza un TLB avente un numero di elementi pari ad un quarto del numero delle pagine fisiche; ciascun elemento del TLB
comprende anche un bit di validit. Indicare la dimensione DTLB (in bit) del TLB:
.............................. N = 64 K elementi
............................................ NB = 8 bit
N = NumPagLog = 2 NumBitIndicePagLog = 2 NumBitIndirizzoVirtuale log2 NumBytePagina
NB = NumBitIndicePagFis = log2 NumByteMemFis log2 NumBytePagina
P = NumElementiTLB / NumPagineFisiche
DTLB = NumElementiTLB * (NumBitIndicePagLog + NumBitIndicePagFis + 1) =
= 2 NumBitIndicePagFis * P * (NumBitIndicePagLog + NumBitIndicePagFis + 1)
...................................DTLB = 1600 bit
COGNOME ESATTO
NOME GIUSTO
MATR B

In un sistema PD32 una subroutine, con la tecnica dello stack frame descritta nel paragrafo 4.7.3 del testo, riceve, nellordine, un parametro dingresso longword (32 bit) B, passato per valore, e due parametri di uscita Q1 e Q2, passati entrambi per indirizzo, ciascuno
dei quali costituito da una struttura con due campi c1 e c2, ciascuno occupante un longword. Si completino le seguenti due istruzioni
PD32, con cui la subroutine assegna al campo c2 della struttura Q1 il valore del parametro dingresso B.
MOVL 12 (FP), R0
MOVL 16 (FP), 4 (R0)
10. Si supponga ora che la subroutine dellesercizio precedente sia realizzata, con le medesime modalit di passaggio degli stessi parametri, in un sistema ARM usando R11 come frame pointer (la prima istruzione della subroutine sia: STMFD SP!, {R11, LR});
si completino le due istruzioni qui sotto, con cui la subroutine assegna al campo c2 della struttura Q1 il valore del parametro
dingresso B:
LDR R0 , [R11, #12]
LDR R1, [R11, #16]
STR R1 , [R0, #4]
11. Due dispositivi D1, D2 operano un trasferimento periodico di dati, gestito ad interrupt, con il medesimo periodo T. Le richieste di
interruzione prodotte da D2 hanno luogo con un ritardo (fisso) D21=T/2 rispetto a quelle di D1. La routine di servizio RSI di D1
ha una durata complessiva R1 = 400 s; quella di D2 ha durata complessiva R2 = 200 s. Sapendo che non vi sono altri dispositivi nel sistema, il minimo periodo TMIN ammesso affinch lacquisizione da entrambi i dispositivi non perda dati :
TMIN = 600 s
12. Un convertitore ADC, associato ad un clock di periodo Td = 300s, gestito ad interrupt con una RSI di durata complessiva pari
a Radc=60s. Un programma P, se eseguito in assenza di interruzioni, verrebbe completato in 40s, Se eseguito mentre hanno luogo le interruzioni di ADC, il medesimo programma subisce un rallentamento e il suo completamento avviene in TC secondi:
TC= 50 s
13. Un processore RISC, dotato di cache, di tipo superscalare con un fattore 4 ed ha un pipeline di 6 stadi; ciascuno stadio ha una
TH = 36 s
T= 30 s
14. In un sistema PD32 la durata dei cicli di accesso alla memoria sia di Tc = 30ns. Durante lesecuzione di unapplicazione, vengano
continuamente trasferiti in memoria, via DMA, 30 blocchi da 4000 byte ogni secondo (i singoli dati trasferiti via DMA siano longword da 4 byte ).. La RSI del DMA, attivata al termine del trasferimento di ciascun blocco, comporti lesecuzione di 10 istruzioni, ciascuna di durata media pari 110ns. Calcolare la percentuale di tempo massimo richiesto alla CPU per effettuare i trasferimenti, diviso nelle due componenti TD (conflitti DMA) e TS (tempo impiegato dalla RSI):
TD = 0.09 %
TS = 0.0033 %
15. Un sistema PD32 dotato di una memoria cache di tipo set-associativo costituita da NS set da 16 vie e ciascuna via costituita da
NS = 16
B = 352 bit
16. In un sistema PD32 dotato di memoria cache di tipo set-associativo a 32 vie, con 64 set contenenti blocchi da 64 byte, durante
cinque elementi (da 32 bit) di un vettore D (situato in memoria a partire dellindirizzo $87BC0), sono coinvolti i set della cache
T1 =$00043
S1 =$0A ]
T2 =$00087 S2 =$2F ]
Mbyte, con pagine da 16 Kbyte. La page table costituita da N elementi. Gli indici di pagina fisica sono costituiti da NB bit. Il sistema utilizza un TLB avente un numero di elementi pari alla met del numero delle pagine fisiche; ciascun elemento del TLB
N = 256 K elementi
NB = 11 bit
DTLB = 30720 bit
COGNOME ESATTO
NOME GIUSTO
MATR C

In un sistema PD32 una subroutine, con la tecnica dello stack frame descritta nel paragrafo 4.7.3 del testo, riceve, nellordine, un parametro di uscita D, passato per indirizzo, e un parametro dingresso longword (32 bit) H, passato per valore; il parametro di uscita D
costituito da una struttura con due campi d1 e d2, ciascuno occupante un longword. Si completino le seguenti due istruzioni PD32,
con cui la subroutine assegna al campo d2 della struttura D il valore del parametro dingresso H.
MOVL 12 (FP), R0
MOVL 8 (FP), 4 (R0)
si completino le due istruzioni qui sotto, con cui la subroutine assegna al campo d2 della struttura D il valore del parametro
dingresso H:
LDR R0 , [R11, #12]
LDR R1, [R11, #8]
STR R1 , [R0, #4]
TMIN = 450 s
TC= 60 s
TH = 48 s
T= 40 s
TD = 0.32 %
TS = 0.0144 %
NS = 64
B = 160 bit
cinque elementi (da 32 bit) di un vettore D (situato in memoria a partire dellindirizzo $B5A80), sono coinvolti i set della cache
T1 =$00011
S1 =$51 ]
T2 =$0005A S2 =$6A ]
Mbyte, con pagine da 32 Kbyte. La page table costituita da N elementi. Gli indici di pagina fisica sono costituiti da NB bit. Il sistema utilizza un TLB avente un numero di elementi pari ad un quarto del numero delle pagine fisiche; ciascun elemento del
TLB comprende anche un bit di validit. Indicare la dimensione DTLB (in bit) del TLB:
N = 128 K elementi
NB = 9 bit
DTLB = 3456 bit
COGNOME ESATTO
NOME GIUSTO
MATR D

In un sistema PD32 una subroutine, con la tecnica dello stack frame descritta nel paragrafo 4.7.3 del testo, riceve, nellordine, un parametro dingresso longword (32 bit) F, passato per valore, e un parametro di uscita S, passato per indirizzo, costituito da una struttura
con tre campi s1, s2 ed s3, ciascuno occupante un longword. Si completino le seguenti due istruzioni PD32, con cui la subroutine assegna al campo s3 della struttura S il valore del parametro dingresso F.
MOVL 8 (FP), R0
MOVL 12 (FP), 8 (R0)
si completino le due istruzioni qui sotto, con cui la subroutine assegna al campo s3 della struttura S il valore del parametro
dingresso F:
LDR R0 , [R11, #8]
LDR R1, [R11, #12]
STR R1 , [R0, #8]
TMIN = 750 s
TC= 90 s
TH = 54 s
T= 45 s
TD = 0.15 %
TS = 0.01625%
NS = 32
B = 704 bit
lesecuzione della sequenza di cinque istruzioni, collocate in memoria a partire dellindirizzo $29CC0, le quali accedono ai primi
cinque elementi (da 32 bit) di un vettore D (situato in memoria a partire dellindirizzo $B7780), sono coinvolti i set della cache di
indice S1, S2 i cui TAG valgono T1, T2 (Si e Ti in esadecimale).
T1 =$00029
S1 =$33 ]
T2 =$000B7 S2 =$1E ]
Mbyte, con pagine da 8 Kbyte. La page table costituita da N elementi. Gli indici di pagina fisica sono costituiti da NB bit. Il sistema utilizza un TLB avente un numero di elementi pari alla met del numero delle pagine fisiche; ciascun elemento del TLB
N = 512K elementi
NB = 12 bit
DTLB = 65536 bit
COGNOME ESATTO
NOME GIUSTO
MATR A

1.
In un sistema PD32 una subroutine, con la tecnica dello stack frame descritta nel paragrafo 5.3 del testo, riceve, nellordine, un
parametro dingresso byte (8 bit) A, passato per valore, e un parametro di uscita F, passato per indirizzo, costituito da una struttura con due campi f1 ed f2, ciascuno occupante un word (16 bit). Supponendo che, in memoria, i dati di lunghezza inferiore a 4
byte, debbano comunque essere collocati ad indirizzi multipli di 4 (debbano cio sempre occupare un longword, utilizzando
lusuale ordinamento little endian e lasciando eventualmente inutilizzati i byte in eccesso), si completino le seguenti tre istruzioni PD32, con cui la subroutine assegna al campo f2 della struttura F lestensione con segno del valore del parametro dingresso A.
MOVB 12(FP), R0
MOVL
8(FP), R1
MOVW R0, 4(R1)

Lallineamento imposto comporta che anche gli offset rispetto a FP nel frame e quelli dei campi delle strutture siano
tutti multipli di 4.
2.
* Un sistema con processore ARM dotato di una data cache di tipo completamente associativo con 64 blocchi da 32 byte ciascuno. Supponendo che sia inizialmente R0=0x1400, R1=0x1000 e la cache sia vuota, lesecuzione per intero del seguente ciclo:
LOOP: LDRH R2, [R1], #2
SUBS R0, R0, #1
BNE
LOOP
produce in totale un numero Nm di miss in data cache pari a:
Nm = 320
Nm = NumBlocchiDiversiLetti = NumHalfWordLetti / NumHalfWordPerBlocco
3.
* Un dispositivo D1 che genera interruzioni periodiche con periodo Td1, gestito ad interrupt con una RSI di durata complessiva
pari a R1=40s. In un ampio intervallo di tempo un programma P ripete il medesimo ciclo: in assenza di interruzioni la durata di
un ciclo pari a Tc=3ms, di cui una porzione iniziale pari al 10% eseguita ad interrupt disabilitati. Allora, in presenza delle interruzioni di D1 e in assenza di altre interruzioni, il minimo periodo ammissibile Td1MIN per non perdere dati da D1 pari a:
Td1MIN = 340 s
Nel caso peggiore il ritardo introdotto dal programma principale per effetto della sezione ad interrupt disabilitati,
presente nella prima parte del ciclo, si verifica quando linterruzione perviene durante lesecuzione dellistruzione di
disabilitazione. In questa situazione la RSI del dispositivo viene eseguita al termine dellintervallo ad interrupt disabilitati, cio dopo Tdis = Tc*PorzioneDisabilitata (unit di tempo), quindi il periodo di interruzione minimo deve includere questo intervallo e la RSI, cio risulta Td1MIN = Tdis+R1.
** Se il dispositivo dellesercizio precedente opera con periodo Td1MIN,
la durata TpINT di un singolo ciclo del programma principale pari a:
TpINT = 3.4 ms
Va dapprima osservato che vi sono apparentemente due diverse situazioni da analizzare, quella in cui linterruzione
di D1 perviene allinterno nella prima porzione ad interrupt disabilitati del ciclo del programma principale, e quella
in cui non hanno luogo richieste di interruzione durante quella porzione (le due situazioni dipendono dalla fase reciproca tra listante di inizio di ciascun ciclo del programma principale e la prima richiesta di interruzione che il dispositivo produce dopo tale istante). Nel primo caso, quando il dispositivo opera con Td1 = Td1MIN, durante il primo periodo del dispositivo allinterno del ciclo viene eseguita la porzione ad interrupt disabilitati e subito dopo la RSI, durante i periodi successivi la RSI occuper una prima parte del periodo Td1 (fig. a); perch si verifichi il secondo caso,
necessario che una richiesta di interruzione da D1 sia pendente al termine dellistruzione che precede immediatamente quella di disabilitazione (presumibilmente quella di salto allindietro del ciclo): cos infatti la successiva richiesta di interruzione sar prodotta esattamente al termine dellesecuzione della porzione ad interrupt disabilitati, essendo questultima di durata Tdis = Td1MIN R1 (fig. b). In entrambi i casi quindi, in ogni periodo una porzione di
durata R1 dedicata al dispositivo e una di durata Td1MIN R1=Tdis dedicata al programma principale. Quindi per
completare il ciclo necessario un numero totale di periodi del dispositivo pari a (numero con eventuale parte frazionaria) Nd1 = Tc/Tdis = 1/Porzione Disabilitata, e quindi una durata complessiva pari a TpINT = Nd1* Td1MIN =
Td1MIN /Porzione Disabilitata.
4.
D1
Tdis
D1
D1
D1
D1
Fig. a
D1
Tdis
Fig. b
5.
In un sistema PD32 paginato, con pagine da 64 KB, la page table del modulo MMU contenga i seguenti 4 valori (da 8 bit):
$10, $1A, $07, $FE
Allora quando il processore esegue listruzione MOVL #0, $0002007A, il longword di memoria
il cui contenuto viene azzerato situato allindirizzo fisico:
indirizzo fisico = $ 07007A
NumBitOffset = log2 DimPagina
Offset = IndirLog & (DimPag-1)
NumPagLog = IndirLog >> NumBitOffset
IndirFis = (Map(NumPagLog)<<NumBitOffset) | Offset
6.
In un sistema PD32, che dotato di un sistema di interrupt vettorizzati, il dispositivo DX risponde al segnale IACK inviando il
codice $1A. La routine di servizio delle interruzioni generate da DX sia situata in memoria a partire dallindirizzo ISRDX. Si
scriva listruzione che inizializza correttamente lelemento della interrupt vector table associato al dispositivo DX.
istruzione = MOVL #ISRDX, $1A*4
La tabella dei vettori contiene nellelemento di indice idx lindirizzo della RSI associata al dispositivo che ha IVN=idx.
Trattandosi di una tabella di puntatori ha elementi di size=4 byte. Listruzione di inizializzazione pertanto MOVL
#LabelRSI, IVN*4.
7.
* Una immagine di tipo raster sia rappresentata da una matrice di pixel (320240) situata in memoria in un area detta frame
buffer; per ciascun pixel dellimmagine il frame buffer contiene 16 bit che ne definiscono il colore e lintensit. Il trasferimento
dellimmagine al dispositivo di visualizzazione venga effettuato con modalit DMA prelevando dalla memoria, ad uno ad uno, i
dati da 16 bit che definiscono ciascun pixel, in modo tale da visualizzare 25 immagini al secondo.
Si calcoli il periodo di tempo TDMA che intercorre tra il trasferimento di un dato e il successivo.
TDMA = 520,833 ns
* Se il frame buffer contenuto nella stessa memoria, caratterizzata da un tempo di ciclo pari a 60 ns, cui accede anche la CPU
per il prelievo e lesecuzione delle istruzioni, allora, in conseguenza del trasferimento DMA, la CPU pu subire un rallentamento
massimo RMAX che, in percentuale, pari a:
RMAX = 11.52 %
Il frame buffer contiene NumColonne*NumRighe elementi; in un secondo devono essere trasferiti NumColonne*NumRighe*NumImmPerSecondo, quindi il periodo di trasferimento di ciascun elemento TDMA = 1 / NumColonne*NumRighe*NumImmPerSecondo. Considerando il caso peggiore in cui ogni trasferimento produca un cycle stealing, risulta RMAX = 100*TempoCicloBus/ TDMA.
8.
Un processore della famiglia PXA 2xx sia dotato di sistema di predizione dei salti che fa uso di un branch target buffer, contenente 128 elementi, consistente in una cache veloce a mappatura diretta. Ciascun elemento di questa cache costituito da: un campo
da n bit contenente il TAG, 2 bit che codificano la predizione, 30 bit che forniscono lindirizzo da inserire, eventualmente, nel
PC. Tenendo presente che gli indirizzi generati dal processore durante la fase di fetch sono da 30 bit, si indichi il numero n di bit
del campo TAG usato nei confronti per stabilire se per listruzione di salto in esame vi un hit o un miss in questa cache.
n = 23
Poich la cache-BHT a mappatura diretta, dei NumBitIndIstrDiSalto forniti dalla CPU, i log2 NumElementiBHT
bit meno significativi sono usati come indice del blocco, i rimanenti n = NumBitIndIstrDiSalto - log2 NumElementiBHT rappresentano il TAG.
9.
* Un sistema con memoria virtuale a byte singolarmente indirizzabili, utilizza indirizzi logici a 32 bit e ha una lunghezza di pagina pari a 4 Kbyte. Supponendo che la MMU disponga di un TLB (cache completamente associativa) con 128 elementi, ciascuno
costituito da un campo TAG (contenente lindice di pagina virtuale) e da un campo DATO (che individua la corrispondente pagina fisica). La dimensione del TLB sia di 3584 bit; allora lindirizzo fisico costituito da NIF bit.
NIF = 20 bit

NumBitIndicePagLog = NumBitIndirLog - NumBitOffset
NumBitIndicePagFis = NumBitIndirFis NumBitOffset
NumBitTLB = NumElemTLB*(NumBitIndicePagLog + NumBitIndicePagFis)
NumBitIndirFis = NumBitIndicePagFis+NumBitOffset =
= (NumBitTLB/NumElemTLB)-NumBitIndicePagLog+NumBitOffset
10. ** Un processore dotato di un pipeline a k=6 stadi e di una memoria cache. Mediamente ogni 20 istruzioni eseguite, una un
salto condizionato e il numero di accessi in memoria per ogni istruzione pari a 1,2. Ogni miss nella cache provoca nel pipeline
un inceppamento (ritardo) di 2 stadi; mentre ogni predizione di salto sbagliata comporta un ritardo di 3 stadi. I progettisti del microprocessore hanno a disposizione unarea di silicio e devono scegliere se pi conveniente utilizzarla per un aumento delle dimensioni della cache (con il quale lo hit rate medio passerebbe da 90% a 95%), oppure della branch history table (che ridurrebbe
dal 10 all8% la percentuale media di previsioni di salto sbagliate). Per operare questa scelta necessario confrontare i valori del
fattore di speed-up (S+cache, S+BHT) (a regime) che si ottengono con le due soluzioni. Si calcolino questi 2 valori:
S+cache = 5.39
S+BHT = 4.98
Nel valutare il fattore di speed-up S occorre tener presente che il cache miss introduce un ritardo nellesecuzione
dellistruzione che provoca il miss stesso di NumStadiRitardoMiss*DurataStadio sia con pipeline che senza, mentre il
ritardo dovuto alla predizione di salto sbagliata presente solo con pipeline. Quindi risulta a regime:
S = limN(N*NumStadi*DurataStadio + N*NumAccessiPerIstr*(1-HitRate)*NumStadiRitardoMiss*DurataStadio) /
(k*DurataStadio + (N-1)*DurataStadio + N*NumAccessiPerIstr*(1-HitRate)*NumStadiRitardoMiss*DurataStadio +
N*PercentualeIstrSalto*RatePrevSaltoSbaglBHT*NumStadiRitardoBHT) =
= (NumStadi+NumAccessiPerIstr*(1-HitRate)*NumStadiRitardoMiss) /
(1+NumAccessiPerIstr*(1-HitRate)*NumStadiRitardoMiss+ PercentualeIstrSalto *
RatePrevSaltoSbaglBHT*NumStadiRitardoBHT)
COGNOME ESATTO
NOME GIUSTO
1.
MATR B
parametro dingresso word (16 bit) B, passato per valore, e un parametro di uscita S, passato per indirizzo, costituito da una struttura con due campi s1 ed s2, ciascuno occupante un byte (8 bit). Supponendo che, in memoria, i dati di lunghezza inferiore a 4
byte, debbano comunque essere collocati ad indirizzi multipli di 4 (debbano cio sempre occupare un longword, utilizzando
lusuale ordinamento little endian e lasciando eventualmente inutilizzati i byte in eccesso), si completino le seguenti tre istruzioni PD32, con cui la subroutine assegna al campo s2 della struttura S il byte pi significativo del valore del parametro dingresso B
MOVB 13(FP), R0
MOVL
8(FP), R1
MOVB R0, 4(R1)

2.
LOOP: LDRB R2, [R1], #1
SUBS R0, R0, #1
BNE
LOOP
Nm = 72
Nm = NumBlocchiDiversiLetti = NumByteLetti / NumBytePerBlocco
3.
Td1MIN = 150 s
TpINT =
3 ms
4.
D1
Tdis
D1
D1
D1
D1
Fig. a
D1
Tdis
Fig. b
5.
$200, $21A, $207, $2FE
Allora quando il processore esegue listruzione MOVL #0, $0000307B, il longword di memoria
indirizzo fisico = $ 2FE07B
6.
In un sistema PD32, che dotato di un sistema di interrupt vettorizzati, il dispositivo DY risponde al segnale IACK inviando il
codice $2B. La routine di servizio delle interruzioni generate da DY sia situata in memoria a partire dallindirizzo ISRDY. Si
scriva listruzione che inizializza correttamente lelemento della interrupt vector table associato al dispositivo DY.
istruzione = MOVL #ISRDY, $2B*4
#LabelRSI, IVN*4.
7.
* Una immagine di tipo raster sia rappresentata da una matrice di pixel (640x480) situata in memoria in un area detta frame
TDMA = 130,208 ns
RMAX = 23.04 %
8.
n = 22
9.
NIF = 26 bit

S+cache = 7.23
S+BHT = 6.49
COGNOME ESATTO
NOME GIUSTO
1.
MATR C
parametro di uscita R, passato per indirizzo, costituito da una struttura con due campi r1 ed r2, ciascuno occupante un byte (8 bit),
e un parametro dingresso longword (32 bit) C, passato per valore. Sapendo che richiesto in memoria un allineamento su multiplo di 4 dei dati inferiori ai 32 bit, utilizzando lusuale ordinamento little endian, si completino le seguenti tre istruzioni PD32,
con cui la subroutine assegna al campo r2 della struttura R il byte pi significativo del valore del parametro dingresso C
MOVB 11(FP), R0
MOVL 12(FP), R1
MOVB R0, 4(R1)
2.
LOOP: LDR
R2, [R1], #4
SUBS R0, R0, #1
BNE
LOOP
Nm = 384
Nm = NumBlocchiDiversiLetti = NumWordLetti / NumWordPerBlocco
3.
Td1MIN = 880 s
4.

TpINT = 4.4 ms
D1
Tdis
D1
D1
D1
D1
Fig. a
D1
Tdis
Fig. b
5.
$30, $3A, $37, $3E, $33, $3F, $31, $3C
Allora quando il processore esegue listruzione MOVL #0, $0006407C, il longword di memoria
indirizzo fisico = $ 31407C
6.
In un sistema PD32, che dotato di un sistema di interrupt vettorizzati, il dispositivo DZ risponde al segnale IACK inviando il
codice $3C. La routine di servizio delle interruzioni generate da DZ sia situata in memoria a partire dallindirizzo ISRDZ. Si scriva listruzione che inizializza correttamente lelemento della interrupt vector table associato al dispositivo DZ.
istruzione = MOVL #ISRDZ, $3C*4
#LabelRSI, IVN*4.
7.
TDMA = 127,157 ns
RMAX = 15.73 %
8.
n = 24
9.
NIF = 24 bit

S+cache = 4.55
S+BHT = 4.13
COGNOME ESATTO
NOME GIUSTO
1.
MATR D
parametro di uscita M, passato per indirizzo, costituito da una struttura con due campi m1 ed m2, ciascuno occupante un word (16
bit), e un parametro dingresso byte (8 bit) D, passato per valore. Sapendo che richiesto in memoria un allineamento su multiplo di 4 dei dati inferiori ai 32 bit, utilizzando lusuale ordinamento little endian, si completino le seguenti tre istruzioni PD32,
con cui la subroutine assegna al campo m2 della struttura M lestensione con segno del valore del parametro dingresso D
MOVB
8(FP), R0
MOVL 12(FP), R1
MOVW R0, 4(R1)
2.
LOOP: LDRSH R2, [R1], #2
SUBS R0, R0, #1
BNE
LOOP
Nm = 336
Nm = NumBlocchiDiversiLetti = NumHalfWordLetti / NumHalfWordPerBlocco
3.
Td1MIN = 240 s
4.

TpINT = 4.8 ms
D1
Tdis
D1
D1
D1
D1
Fig. a
D1
Tdis
Fig. b
5.
$4000, $403A, $4037, $403E, $4033, $403F
Allora quando il processore esegue listruzione MOVL #0, $0000507D, il longword di memoria
indirizzo fisico = $ 403F07D
6.
In un sistema PD32, che dotato di un sistema di interrupt vettorizzati, il dispositivo DW risponde al segnale IACK inviando il
codice $4D. La routine di servizio delle interruzioni generate da DW sia situata in memoria a partire dallindirizzo ISRDW. Si
scriva listruzione che inizializza correttamente lelemento della interrupt vector table associato al dispositivo DW.
istruzione = MOVL #ISRDW, $4D*4
#LabelRSI, IVN*4.
7.
TDMA = 254,313 ns
RMAX = 7.864 %
8.
n = 21
9.
NIF = 32 bit

S+cache = 6.69
S+BHT = 6.11
COGNOME SOLUZIONE commentata
NOME
MATR A

1.
In un sistema PD132 (PD32 esteso con indirizzamento assoluto indiretto) la subroutine SA riceve 3 parametri (P1, P2, P3) da 16 bit, i primi due passati per
riferimento, il terzo per valore, attraverso la seguente calling sequence:
JSR SA
...... ;indirizzo di P1
...... ;valore di P3
CONT1: ......
Si completino le ultime due delle seguenti 3 istruzioni, con cui si copia il valore del terzo parametro nel secondo e si ritorna al programma chiamante (alla
posizione del label CONT1).
SA: POP R0
;PC salvato R0
MOVW 8(R0), @4(R0) ;P3 P2
JMP
10(R0)
;ritorno al progr. chiamante
Allingresso della subroutine sul top dello stack c lindirizzo della calling sequence.
2. In un sistema ARM la subroutine S1, con la tecnica dello stack frame, riceve, nellordine, 3 parametri (P1, P2, P3) da 32 bit, i primi due passati per riferimento, il terzo per valore. Come frame pointer sia usato R11 e le prime due istruzioni della subroutine siano: STMFD SP!, {R11, LR};
MOV R11, SP
si completino le quattro istruzioni, con cui la subroutine copia il valore del terzo parametro nel secondo e ritorna al programma chiamante:.
LDR R0, [R11, #8]
LDR R1, [R11, #12]
STR R0, [R1]
LDMFD SP!, {R11, PC}
Durante lesecuzione della subroutine rispetto al frame pointer R11 nello stack si trovano, LR ad un offset +4, P3 ad un
offset +8, lindirizzo di P2 ad un offset +12, lindirizzo di P1 ad un offset +16. Lultima istruzione inserisce direttamente
nel PC lindirizzo di ritorno che era stato salvato in LR.
3. * Supponendo che in un sistema ARM sia dotato di una cache set-associativa a 8 vie, inizialmente vuota, con un TAG da 20 bit e un indice di set da 7 bit.
Quando viene eseguita listruzione: LDR R2, [R0, R1, LSL #2], il contenuto dei registri sia R0=0x1100 e R1=0x4455. Allora nella cache viene caricato un blocco da B byte nel set di indice S, memorizzando come TAG associato al blocco il valore T:
B = 32
S = $12
T = $12
Loffset del byte nel blocco occupa NumBitOffset=32-BitTAG-BitSet bit dellindirizzo emesso dal processore; un
blocco in cache quindi costituito da B=2NumBitOffset byte. Calcolato lindirizzo in base alla modalit di indirizzamento
delloperando
in
memoria
dellistruzione,
risulta
S=(Indirizzo>>NumBitOffset)&(2NumBitSet-1)
e
T=Indirizzo>>(NumBitOffset+NumBitSet).
4.
Un processore dotato di una cache completamente associativa con blocchi da 32 byte; a ciascun blocco siano associati 2 bit di controllo. La dimensione
complessiva della cache sia di 8864 bit.
Se lindirizzo emesso dal processore da 24 bit, il numero di linee (blocchi) di cui costituita la cache pari a Nc:
Nc = 32
Nc = NumBitCache/NumBitPerElemento = NumBitCache/(NumBitTAG+NumBitControllo+NumBitBlocco) =
NumBitCache/(NumBitIndirizzo-log2 DimBlocco+NumBitControllo+NumBitBlocco)
5.
Un sistema PD32 dotato di memoria paginata con pagine da 4Kbyte usa un TLB completamente associativo costituito da 4 elementi. Allindirizzo logico
$1A80 del programma in esecuzione si trova listruzione MOVL #0, (R1)+;
Quando viene eseguita questa istruzione, R1 contiene $2200 e il TLB contiene i valori indicati nella seguente tabella:
CAM
DATO
$5
$17
$1
$11
Allora lindirizzo fisico del longword che viene azzerato :
IFDato: $16200
$6
$19
$2
$16
mentre lindirizzo fisico in cui si trova listruzione :
IFIstr: $ 11A80
Gli IPL (contenuti nella porzione CAM del TLB) occupano i 32-NumBitOffset=32-log2 DimPagina bit pi significativi
dellindirizzo logico. I corrispondenti IPF (parte pi significativa dellindirizzo fisico) sono contenuti nella porzione
DATO; la parte meno significativa dellindirizzo fisico costituita dai log2 DimPagina bit delloffset.
6.
Nel sistema PD32 dotato di memoria paginata dellesercizio precedente (pagine da 4Kbyte) la memoria fisica presente di 1 MByte. I primi 4 elementi della
page table contengono i valori indicati nella seguente tabella:
IPF
Un dispositivo di input trasferisce in memoria, via DMA, a partire dallindirizzo logico $2000, un blocco di 2K dati da 32 bit.
0
$12
1
$11
Allora il primo dato del blocco viene collocato in memoria allindirizzo fisico:
IFP: $ 14000
2
$14
3
$13
mentre lultimo dato del blocco viene collocato in memoria allindirizzo fisico:
IFU: $ 13FFC
LIPL costituito dai 32-NumBitOffset=32-log2 DimPagina bit pi significativi dellindirizzo logico. Gli indirizzi fisici
richiesti si ottengono sostituendo gli IPL con gli IPF contenuti negli elementi della page table di indice IPL.
7.
Un dispositivo di conversione A/D, gestito in DMA, trasferisce blocchi di 256 dati da 16 bit. I dati vengono trasferiti in un buffer circolare sufficientemente
grande e regolarmente svuotato in modo tale da consentire il funzionamento continuativo del dispositivo. Mediamente il 50% degli accessi DMA alla memoria confligge con gli accessi del processore e ne provoca un rallentamento. Il periodo del ciclo di accesso alla memoria Tc=80ns. La durata della routine
di servizio dellinterrupt generato dal DMA Rd=50s. Allora il tempo di CPU impegnato per il trasferimento DMA di ciascun blocco di dati Td:
Td = 60.24 s
Td = Rd+NumDatiBlocco*PercCicliRubati*Tc/100.
8.
Un processore esegue ripetutamente un ciclo di istruzioni che, in assenza di interruzioni, ha una durata di Tc = 2ms; la porzione iniziale del ciclo, di durata
Ti, viene eseguita ad interrupt disabilitati. Nel sistema sia presente un dispositivo D che genera interruzioni periodiche con periodo Td=500s, cui associa-
ta una RSI di durata complessiva pari a R=100s. In questa situazione, per garantire che non vi sia perdita di dati nella gestione di D, la porzione eseguita ad
interrupt disabilitati pu avere una durata massima pari a Timax:
Timax = 400 s
disabilitazione. In questa situazione la RSI del dispositivo viene eseguita al termine dellintervallo ad interrupt disabilitati, cio dopo Ti unit di tempo; nella porzione Td-Ti deve essere eseguita lintera RSI se non si vogliono perdere
dati. Pertanto deve risultare Td-TiR ovvero Ti= Td-R, da cui Timax = Td-R.
9.
Con riferimento al processore PD32, dotato di un sistema di interrupt vettorizzati, si pu pensare di affidare ad una subroutine (SETIV) limpostazione degli
elementi del vettore di interrupt (Interrupt Vector Table) nel PD32. La subroutine riceve in R0 il codice identificativo (IVN) del dispositivo e in R1
lindirizzo della routine di servizio associata al dispositivo stesso; compito della subroutine di impostare correttamente, nel vettore di interrupt, lelemento
relativo al dispositivo. La subroutine pu essere realizzata con le seguenti tre istruzioni, le prime due delle quali richiesto di completare:
SETIV: ASLL #2, R0
MOVL R1, (R0)

RTS
Nel PD32 lInterrupt Vector Table situata in memoria a partire dallindirizzo 0. In essa lelemento associato al dispositivo identificato dal codice IVN si trova ad un offset pari a IVN*4 e contiene lindirizzo della routine di servizio
associata al dispositivo.
10.
In un processore RISC, la predizione dei salti viene effettuata tramite una Branch History Table (BHT) costituita da una cache di 128 elementi a mappatura
diretta. Ciascun elemento, oltre che il TAG, comprende 2 bit nei quali codificato uno dei 4 stati con cui viene descritta la storia precedente dellistruzione e
che determinano la predizione del salto. Essendo gli indirizzi delle istruzioni sempre multipli di 4, il PC da 30 bit. Durante la fase di fetch di ciascuna istruzione di salto condizionato, i 7 bit meno significativi dei 30 del suo indirizzo individuano lelemento della BHT in cui, in caso di HIT, presente
linformazione che ne predice il salto. Allora la BHT costituita da N bit:
N = 3200 bit
N = NumElementi*(30 - log2 NumElementi + 2).

NOME
MATR B
1. In un sistema PD132 (PD32 esteso con indirizzamento assoluto indiretto) la subroutine SB riceve 3 parametri (P1, P2, P3) da 32 bit, il primo passato per riferimento, il secondo e il terzo per valore, attraverso la seguente calling sequence:
JSR SB
CONT1: ......
Si completino le ultime due delle seguenti 3 istruzioni, con cui si copia il valore del secondo parametro nel primo e si ritorna al programma chiamante (alla
SB: POP R1
;PC salvato R1
MOVL 4(R1), @(R1) ;P2 P1
JMP
12(R1)
2. In un sistema ARM la subroutine S2, con la tecnica dello stack frame, riceve, nellordine, 3 parametri (P1, P2, P3) da 32 bit, il primo passato per riferimento, il secondo e il terzo per valore. Come frame pointer sia usato R11 e le prime due istruzioni della subroutine siano:
STMFD SP!, {R11, LR};

MOV R11, SP
si completino le quattro istruzioni, con cui la subroutine copia il valore del secondo parametro nel primo e ritorna al programma chiamante:.
LDR R1, [R11, #12]
LDR R0, [R11, #16]
STR R1, [R0]
Durante lesecuzione della subroutine rispetto al frame pointer R11 nello stack si trovano, LR ad un offset +4, P3 ad un
offset +8, P2 ad un offset +12, lindirizzo di P1 ad un offset +16. Lultima istruzione inserisce direttamente nel PC
lindirizzo di ritorno che era stato salvato in LR.
B = 64
S = $BC
T = $3
delloperando
in
memoria
dellistruzione,
risulta
e
4.
Nc = 64
5.
$5C80 del programma in esecuzione si trova listruzione MOVL #0, (R1)+;
CAM
DATO
$2
$17
$1
$13
IFDato: $ 26200
$6
$19
$4
$16
IFIstr: $ 2FC80
6.
IPF
0
$12
1
$13
IFP: $ 26000
2
$A4
3
$A5
IFU: $ 149FFC
7.
Un dispositivo di conversione A/D, gestito in DMA, trasferisce blocchi di 1024 dati da 16 bit. I dati vengono trasferiti in un buffer circolare sufficientemente grande e regolarmente svuotato in modo tale da consentire il funzionamento continuativo del dispositivo. Mediamente il 25% degli accessi DMA alla
memoria confligge con gli accessi del processore e ne provoca un rallentamento. Il periodo del ciclo di accesso alla memoria Tc=50ns. La durata della routine di servizio dellinterrupt generato dal DMA Rd=60s. Allora il tempo di CPU impegnato per il trasferimento DMA di ciascun blocco di dati Td:
Td = 72.8 s
8.
Timax = 540 s
9.
SETIV: ASLL #2, R1
MOVL R2, (R1)

RTS
10.
N = 1664 bit

NOME
MATR C
1. In un sistema PD132 (PD32 esteso con indirizzamento assoluto indiretto) la subroutine SC riceve 3 parametri (P1, P2, P3) da 16 bit, i primi due passati per
valore, il terzo per riferimento, attraverso la seguente calling sequence:
JSR SC
CONT1: ......
Si completino le ultime due delle seguenti 3 istruzioni, con cui si copia il valore del primo parametro nel terzo e si ritorna al programma chiamante (alla posizione del label CONT1).
SC: POP R3
;PC salvato R3
MOVW (R3), @4(R3) ;P1 P3
JMP
8(R3)
2. In un sistema ARM la subroutine S3, con la tecnica dello stack frame, riceve, nellordine, 3 parametri (P1, P2, P3) da 32 bit, i primi due passati per valore, il
terzo per riferimento. Come frame pointer sia usato R11 e le prime due istruzioni della subroutine siano:

MOV R11, SP
si completino le quattro istruzioni, con cui la subroutine copia il valore del primo parametro nel terzo e ritorna al programma chiamante:.
LDR R0, [R11, #16]
LDR R1, [R11, #8]
STR R0, [R1]
Durante lesecuzione della subroutine rispetto al frame pointer R11 nello stack si trovano, LR ad un offset +4, lindirizzo
di P3 ad un offset +8, P2 ad un offset +12, P1 ad un offset +16. Lultima istruzione inserisce direttamente nel PC
lindirizzo di ritorno che era stato salvato in LR.
B = 128
S = $179
T = $0
delloperando
in
memoria
dellistruzione,
risulta
e
4.
Nc = 16
5.
$6B04 del programma in esecuzione si trova listruzione MOVL #0, (R1)+;
CAM
DATO
$5
$17
$1
$13
IFDato: $ 17220
$6
$19
$4
$16
IFIstr: $ 19B04
6.
IPF
0
$A2
1
$A1
IFP: $ A4000
2
$A4
3
$A3
IFU: $ A3FFC
7.
Un dispositivo di conversione A/D, gestito in DMA, trasferisce blocchi di 1024 dati da 16 bit. I dati vengono trasferiti in un buffer circolare sufficientemente grande e regolarmente svuotato in modo tale da consentire il funzionamento continuativo del dispositivo. Mediamente il 50% degli accessi DMA alla
memoria confligge con gli accessi del processore e ne provoca un rallentamento. Il periodo del ciclo di accesso alla memoria Tc=60ns. La durata della routine di servizio dellinterrupt generato dal DMA Rd=40s. Allora il tempo di CPU impegnato per il trasferimento DMA di ciascun blocco di dati Td:
Td = 70.72 s
8.
Timax = 550 s
9.
SETIV: ASLL #2, R2
MOVL R3, (R2)

RTS
10.
N = 864 bit

NOME
MATR D
1. In un sistema PD132 (PD32 esteso con indirizzamento assoluto indiretto) la subroutine SD riceve 3 parametri (P1, P2, P3) da 32 bit, il primo passato per valore, il secondo e il terzo per riferimento, attraverso la seguente calling sequence:
JSR SD
CONT1: ......
Si completino le ultime due delle seguenti 3 istruzioni, con cui si copia il valore del primo parametro nel secondo e si ritorna al programma chiamante (alla
SD: POP R4
;PC salvato R4
MOVL (R4), @4(R4) ;P1 P2
JMP
12(R4)
2. In un sistema ARM la subroutine S4, con la tecnica dello stack frame, riceve, nellordine, 3 parametri (P1, P2, P3) da 32 bit, il primo passato per valore, il
secondo e il terzo per riferimento. Come frame pointer sia usato R11 e le prime due istruzioni della subroutine siano:

MOV R11, SP
si completino le quattro istruzioni, con cui la subroutine copia il valore del primo parametro nel secondo e ritorna al programma chiamante:.
LDR R1, [R11, #16]
LDR R0, [R11, #12]
STR R1, [R0]
Durante lesecuzione della subroutine rispetto al frame pointer R11 nello stack si trovano, LR ad un offset +4, lindirizzo
di P3 ad un offset +8, lindirizzo di P2 ad un offset +12, P1 ad un offset +16. Lultima istruzione inserisce direttamente nel
PC lindirizzo di ritorno che era stato salvato in LR.
B = 256
S = $1A
T = $C
delloperando
in
memoria
dellistruzione,
risulta
e
4.
Nc = 128
5.
$AA80 del programma in esecuzione si trova listruzione MOVL #0, (R1)+;
CAM
DATO
$5
$B7
$1
$B3
IFDato: $ 166200
$6
$A9
$4
$A6
IFIstr: $ 16EA80
6.
IPF
0
$B1
1
$B3
IFP: $ 16A000
2
$B5
3
$B4
IFU: $ 169FFC
7.
Un dispositivo di conversione A/D, gestito in DMA, trasferisce blocchi di 256 dati da 16 bit. I dati vengono trasferiti in un buffer circolare sufficientemente
grande e regolarmente svuotato in modo tale da consentire il funzionamento continuativo del dispositivo. Mediamente il 25% degli accessi DMA alla memoria confligge con gli accessi del processore e ne provoca un rallentamento. Il periodo del ciclo di accesso alla memoria Tc=70ns. La durata della routine
di servizio dellinterrupt generato dal DMA Rd=30s. Allora il tempo di CPU impegnato per il trasferimento DMA di ciascun blocco di dati Td:
Td = 34.48 s
8.
Un processore esegue ripetutamente un ciclo di istruzioni che, in assenza di interruzioni, ha una durata di Tc = 4.8ms; la porzione iniziale del ciclo, di durata
Timax = 720 s
9.
SETIV: ASLL #2, R1
MOVL R0, (R1)

RTS
10.
che determinano la predizione del salto. Essendo gli indirizzi delle istruzioni sempre multipli di 4, il PC da 30 bit. Durante la fase di fetch di ciascuna istruzione di salto condizionato, gli 8 bit meno significativi dei 30 del suo indirizzo individuano lelemento della BHT in cui, in caso di HIT, presente
N = 6144 bit
7cr
SOLUZIONE
ARCHITETTURA DEGLI ELABORATORI - seconda prova intermedia 5 giugno 2010

1.
2.
In un sistema PD32 la subroutine S1, utilizzante la tecnica dello stack frame, riceve nel registro R1 un parametro dingresso X, da
32 bit, passato per riferimento, e nello stack un parametro di uscita Y, da 16 bit, passato per riferimento. Si completino le
istruzioni sul retro, con cui la subroutine inserisce in Y il complemento a 1 del word pi significativo di X.
Un sistema PD32 sia dotato di una data cache set-associativa a 2 vie, con 64 byte per blocco, 32 set complessivi e metodo di
rimpiazzo LRU. Con la cache inizialmente vuota e R1=$18C0, R2=$30C0, R3=$210 (=528), venga eseguito il seguente
segmento di codice; indicare il valore hr dello hit rate (in percentuale) quando viene eseguita listruzione NOP.
LOOP: MOVL (R1), (R2)+
SUBL #1, R3
JNZ LOOP
NOP
3.
Un sistema PD32 sia dotato di una data cache completamente associativa, con 32 byte per blocco e 32 blocchi. Con la cache
inizialmente vuota e R1=$2, venga eseguito il seguente segmento di codice; indicare i valori di R1 e del TAG quando si verifica
il secondo miss nella cache.
L1:
4.
5.
6.
7.
MOVB (R1), R0
LSLL 3, R1
JMP L1
In un elaboratore ARM dotato di MMU, il sistema operativo deve avviare un programma che stato progettato (decisione presa
in fase di linking) per essere eseguito a partire dallindirizzo 0x0. Tuttavia, la prima pagina di memoria fisicamente disponibile si
trova allindirizzo 0x12346000: il sistema operativo deve quindi rilocare il programma. Sapendo che nellelaboratore gli indirizzi
fisici sono da 29 bit, quelli logici da 32 bit e che la dimensione di una pagina pari a 8 Kbyte, si indichi in esadecimale
lindice di pagina fisica IPF1 che il sistema operativo deve inserire nella prima riga della page table del programma. Si indichi
inoltre sempre in esadecimale loffset O allinterno di una pagina che corrisponde ad un accesso allindirizzo logico 0x5432.
In un elaboratore ARM dotato di un sistema di memoria virtuale, ciascun elemento della page table contiene, oltre allindice di
pagina fisica (IPF), 4 bit di controllo e 16 bit per leventuale indirizzo della pagina in memoria secondaria. Sapendo che loffset
allinterno di una pagina rappresentato con 14 bit, e che la memoria fisicamente indirizzabile di 1 Gbyte, si calcolino il
numero BPV di bit necessari per individuare una pagina virtuale, e la dimensione complessiva D (espressa in bit) della page table.
Il progettista di un sistema, dotato di un dispositivo D gestito ad interrupt, stabilisce che la percentuale massima tollerabile di
occupazione del tempo di CPU dedicata a D sul totale sia pari al 70%. Sapendo che D genera richieste di interruzione con periodo
fisso Td = 500s. Calcolare il valore massimo RdMAX della durata della RSI di D che garantisce di non superare quella
percentuale massima di occupazione.
Una immagine di tipo raster sia rappresentata da una matrice di pixel (800600) situata in memoria in unarea detta frame
dati da 16 bit che definiscono ciascun pixel. Sapendo che il periodo di tempo che intercorre tra il trasferimento di un dato ed il
successivo TDMA = 100 ns, si indichi il numero N di immagini che possono essere visualizzate in un secondo. Se il frame buffer
contenuto nella stessa memoria, caratterizzata da un tempo di ciclo pari a 20 ns, cui accede anche la CPU per il prelievo e
lesecuzione delle istruzioni, allora, in conseguenza del trasferimento DMA, la CPU pu subire un rallentamento; si indichi il
valore massimo RMAX, in percentuale, di questo rallentamento.
8. Un dispositivo D1 trasferisce, ad interrupt, dati con una frequenza di 103 dati/s. La sua RSI ha una durata complessiva R1 = 150
s. Se un dispositivo D2, di priorit superiore a D1, gestito da una RSI di durata complessiva R2 = 50 s, e non vi sono altri
dispositivi nel sistema, il minimo periodo di D2 perch lacquisizione da D1 non perda dati pari a T2MIN (suggerimento: la RSI
di D1 e tutte le RSI di D2 attivate in un periodo di D1 devono essere concluse allo scadere del periodo). Calcolare T2MIN.
9. Un processore, con clock a 200 MHz, dotato di un pipeline a k=5 stadi e di una memoria cache. La durata di ciascuno stadio
di un periodo del clock. Mediamente ogni 20 istruzioni eseguite, una un salto condizionato; ogni predizione di salto sbagliata
comporta nel pipeline un inceppamento (ritardo) di 2 stadi. Il numero di accessi in memoria per ogni istruzione pari a 1,3; ogni
miss nella cache provoca nel pipeline uno stallo di 3 stadi. Sapendo che lo hit rate medio della cache pari al 90% e che la
percentuale media di previsioni di salto sbagliate del 10%, si determini il tempo medio T necessario a eseguire 1000 istruzioni.
Nelleseguire il calcolo si supponga che, allinizio del segmento di 1000 istruzioni, il pipeline sia gi pieno.
10. Un processore CISC, con clock di 100 MHz, sia caratterizzato da una control store (CS) cui si accede in un ciclo di clock e da
una RAM, priva di cache, per accedere alla quale sono richiesti 3 cicli di clock; in media ciascuna istruzione di macchina
richiede, oltre ad un accesso alla RAM per la fase di fetch, lesecuzione di 5 microistruzioni (ciascuna delle quali comporta un
accesso alla CS). Un processore RISC, avente la stessa frequenza di clock (100 MHz), impiega, in media, 1.2 cicli di clock per
eseguire una istruzione. Un programma P richiede lesecuzione complessiva di 1000 istruzioni sul processore CISC; lo stesso
programma P richiede lesecuzione complessiva di 5000 istruzioni sul processore RISC. Calcolare il tempo TC necessario per
lesecuzione di P sul processore CISC e quello TR necessario per lesecuzione di P sul processore RISC.
11. Nellassemblare il modulo sorgente color1.s, lassemblatore arm-elf-as assegna al simbolo stack, definito da una direttiva label
nella sezione .bss, il valore 0x000BC800. Il loader arm-elf-ld costruisce il modulo eseguibile collocando il segmento .text a
partire dallindirizzo 0x30000000, il segmento .data a partire dallindirizzo 0x300002c0 e il segmento .bss a partire dallindirizzo
0x30000300. Si indichi lindirizzo di memoria corrispondente al simbolo stack quando il modulo eseguibile sar stato caricato in
memoria.
7cr
SOLUZIONE
1.
NOTW 2(R1), R2
MOVL 8(FP), R3
MOVW R2, (R3)
2.
hr = 100*1022/1056 % = 96.78 %
3.
R1= $80
TAG = $4
4.
IPF1 = 0x91A3
O = 0x1432
5.
BPV = 18 bit
D = 9437184 bit
6.
RdMAX = 350 s
7.
N = 20.83
RMAX = 20 %
8.
T2MIN = 58.82 s
9.
T = 7 s
10. TC = 80 s
TR = 60 s
11. stack = 0x300BCB00
7cr
SOLUZIONE

1.
2.
32 bit, passato per valore, e nello stack, nellordine, un parametro di uscita Y, da 16 bit, passato per riferimento e un parametro
dingresso Z, da 32 bit, passato per valore. Si completino le istruzioni sul retro, con cui la subroutine inserisce in Y il
complemento a 1 del word meno significativo di X.
rimpiazzo LRU. Con la cache inizialmente vuota e R1=$A200, R2=$6200, R3=$820 (=2080), venga eseguito il seguente
SUBL #1, R3
JNZ LOOP
NOP
3.
inizialmente vuota e R2=$824, venga eseguito il seguente segmento di codice; indicare i valori di R2 e del TAG quando si
verifica il secondo miss nella cache.
L2:
4.
5.
6.
7.
MOVB (R2), R0
ADDL $10, R2
JMP L2
lindirizzo di pagina fisica IPF1 che il sistema operativo deve inserire nella prima riga della page table del programma. Si indichi
inoltre sempre in esadecimale loffset O allinterno di una pagina che corrisponde ad un accesso allindirizzo fisico 0x1421.
contenuto nella stessa memoria, caratterizzata da un tempo di ciclo pari a 20 ns, cui accede anche la CPU per il prelievo e
Un dispositivo D1 trasferisce, ad interrupt, dati con una frequenza di 103 dati/s. La sua RSI ha una durata complessiva R1 = 100
s. Se un dispositivo D2 di priorit superiore a D1 gestito da una RSI di durata complessiva R2 = 30 s, e non vi sono altri
dispositivi nel sistema, il minimo periodo di D2 perch lacquisizione da D1 non perda dati pari a T2 MIN (suggerimento: la RSI
11. Nellassemblare il modulo sorgente lcd.s, lassemblatore arm-elf-as assegna al simbolo lcd_enable, definito da una direttiva label
nella sezione .text, il valore 0x000000A0. Il loader arm-elf-ld costruisce il modulo eseguibile color1 collocando il segmento .text
a partire dallindirizzo 0x30000000; la porzione .text del modulo lcd.o viene collocata subito dopo quella del modulo color1.o, a
partire dallindirizzo 0x300000A8; il segmento .data viene collocato a partire dallindirizzo 0x300002C0 e il segmento .bss a
partire dallindirizzo 0x30000300. Si indichi lindirizzo di memoria corrispondente al simbolo lcd_enable quando il modulo
eseguibile sar stato caricato in memoria.
8.
7cr
SOLUZIONE
1.
NOTW R2, R3
MOVL 12(FP), R4
MOVW R3, (R4)
2.
hr = 100*4094/4160 % = 98.413 %
3.
R2= $844
TAG = $42
4.
IPF1 = 0xAACF
O = 0x421
5.
BPV = 20 bit
D = 41943040 bit
6.
RdMAX = 240 s
7.
N = 10.41
RMAX = 10 %
8.
T2MIN = 33.33 s
9.
T = 9.48 s
10. TC = 90 s
TR = 70 s
11. lcd_enable = 0x30000148
7cr
SOLUZIONE

1.
2.
16 bit, passato per riferimento, e nello stack un parametro di uscita Y, da 16 bit, passato per riferimento. Si completino le
istruzioni sul retro, con cui la subroutine inserisce in Y il complemento a 1 di X.
rimpiazzo LRU. Con la cache inizialmente vuota e R1=$2080, R2=$4080, R3=$410 (=1040), venga eseguito il seguente
SUBL #1, R3
JNZ LOOP
NOP
3.
inizialmente vuota e R3=$632, venga eseguito il seguente segmento di codice; indicare i valori di R3 e del TAG quando si
verifica il secondo miss nella cache
L3:
4.
5.
6.
7.
MOVB (R3), R0
LSRL 2, R3
JMP L3
inoltre sempre in esadecimale loffset O allinterno di una pagina che corrisponde ad un accesso allindirizzo fisico 0x2345.
contenuto nella stessa memoria, caratterizzata da un tempo di ciclo pari a 37.5 ns, cui accede anche la CPU per il prelievo e
11. Nellassemblare il modulo sorgente color2.s, lassemblatore arm-elf-as assegna al simbolo stack, definito da una direttiva label
nella sezione .bss, il valore 0x 000BC800. Il loader arm-elf-ld costruisce il modulo eseguibile collocando il segmento .text a
partire dallindirizzo 0x30000000, il segmento .data a partire dallindirizzo 0x300002C0 e il segmento .bss a partire dallindirizzo
0x30000500. Si indichi lindirizzo di memoria corrispondente al simbolo stack quando il modulo eseguibile sar stato caricato in
memoria.
7cr
SOLUZIONE
1.
NOTW (R3), R0
MOVL 8(FP), R1
MOVW R0, (R1)
2.
hr = 100*2014/2080 % = 96.826 %
3.
R3= $18C
TAG = $6
4.
IPF1 = 0x9ABC
O = 0x345
5.
BPV = 19 bit
D = 19922944 bit
6.
RdMAX = 450 s
7.
N = 8.33
RMAX = 15 %
8.
T2MIN = 62.5 s
9.
T = 9.6 s
10. TC = 100 s
TR = 55 s
11. stack = 0x300BCD00
7cr
SOLUZIONE

1.
2.
16 bit, passato per riferimento, e nello stack, nellordine, un parametro di uscita Y, da 16 bit, passato per riferimento e un
parametro dingresso Z, da 16 bit, passato per riferimento. Si completino le istruzioni sul retro, con cui la subroutine inserisce in
Y il complemento a 1 di X.
rimpiazzo LRU. Con la cache inizialmente vuota e R1=$0C280, R2=$10280, R3=$1020 (=4128), venga eseguito il seguente
SUBL #1, R3
JNZ LOOP
NOP
3.
inizialmente vuota e R4=$A65, venga eseguito il seguente segmento di codice indicare i valori di R4 e del TAG quando si
verifica il secondo miss nella cache.
L4:
4.
5.
6.
7.
MOVB (R4), R0
SUBL $10, R4
JMP L4
inoltre sempre in esadecimale loffset O allinterno di una pagina che corrisponde ad un accesso allindirizzo logico 0x842.
allinterno di una pagina rappresentato con 14 bit, e che la memoria fisicamente indirizzabile di 512 Mbyte, si calcolino il
contenuto nella stessa memoria, caratterizzata da un tempo di ciclo pari a 37.5 ns, cui accede anche la CPU per il prelievo e
11. Nellassemblare il modulo sorgente lcd.s, lassemblatore arm-elf-as assegna al simbolo lcd_disable, definito da una direttiva label
nella sezione .text, il valore 0x000000BC. Il loader arm-elf-ld costruisce il modulo eseguibile color2 collocando il segmento .text
a partire dallindirizzo 0x30000000; la porzione .text del modulo lcd.o viene collocata subito dopo quella del modulo color2.o, a
partire dallindirizzo 0x300000A8; il segmento .data viene collocato a partire dallindirizzo 0x300002C0 e il segmento .bss a
partire dallindirizzo 0x30000300. Si indichi lindirizzo di memoria corrispondente al simbolo lcd_disable quando il modulo
eseguibile sar stato caricato in memoria.
7cr
SOLUZIONE
1.
NOTW (R4), R1
MOVL 12(FP), R2
MOVW R1, (R2)
2.
hr = 100*8126/8256 % = 98.425 %
3.
R4= $A35
TAG = $28
4.
IPF1 = 0xECA9
O = 0x42
5.
BPV = 18 bit
D = 9961472 bit
6.
RdMAX = 270 s
7.
N = 13.88
RMAX = 25 %
8.
T2MIN = 20 s
9.
T = 3.96 s
10. TC = 50 s
TR = 30 s
11. lcd_disable = 0x30000164
SOLUZIONE
ARCHITETTURA DEGLI ELABORATORI - Seconda prova intermedia - 18 giugno 2012

TmMIN = 170 s
2) Un dispositivo D1 trasferisce, via DMA, blocchi da 1024 dati. Per comandare il trasferimento di un blocco vengono eseguite dalla CPU 4 istruzioni la cui durata complessiva corrisponde a 12 cicli di bus; i dati vengono trasferiti ad uno ad uno via DMA; la RSI attivata dopo il trasferimento dellultimo dato del blocco ha una durata corrispondente a 60 cicli di bus (ciascun ciclo di bus dura 40 ns). Il tempo di CPU complessivamente
impegnato per il trasferimento di uno dei blocchi (includendo il ritardo dovuto ad accessi DMA di D1) al massimo pari a TDMA s.
TDMA = 43.84 s
3) Un ADC pu funzionare sia ad interrupt che in DMA: nel primo caso (una richiesta dinterruzione per dato), la RSI ha una durata complessiva di
8 s, nel secondo caso (una richiesta dinterruzione per blocco di dati), essendo il numero di dati di ogni blocco molto elevato, la durata della RSI
trascurabile. Sapendo che il ciclo di bus ha una durata di 60ns e supponendo di tollerare in entrambi i casi una occupazione massima del tempo
di CPU dedicato al dispositivo del 70% (trascurando la RSI del DMA), allora il periodo minimo con cui possono essere trasferiti i dati gestiti ad
interrupt TI; quello con cui possono essere trasferiti i dati via DMA TD.
TI = 11.42857 s
TD = 85.71429 ns
4) Un sistema ARM dotato di una instruction cache e di una data cache completamente associative; ciascuna delle due cache contiene 16 blocchi
da 32 byte. A data cache vuota, viene eseguito il segmento di codice che segue, caricato in memoria a partire dallindirizzo 0x400. Immaginando
che la data cache adotti un criterio di rimpiazzo di tipo LRU (Least Recently Used), quando viene eseguita listruzione
mov pc, lr
la percentuale di hit sul totale degli accessi alla data cache pari a ph.
mov
r0, #0xB
mov
r1, #0x2000
LOOP:
ldr
r2, [R1]
bic
r2, r2, #0xFF
str
r2, [R1], +#4
subs
r0, r0, #1
bne
LOOP
mov pc, lr
ph = 90.9091%
indirizzo 0x123456 ha un TAG pari a TAGS e, se presente in cache, si trova nel set di indice Is (0IsNs-1); TAGS e Is vanno indicati in notazione esadecimale.
Ns =1024
TAGS = 0x024 |
Is = 0x1A2
6) In un sistema ARM una subroutine che fa uso di una stack frame (le prime istruzioni che essa esegue sono stmfd sp! {fp, lr}; mov fp, sp) riceve,
nello stack, 2 parametri duscita p1 e p2, passati per riferimento, e alloca una variabile locale L costituita da un vettore di 10 word. Supponendo
che la subroutine utilizzi la tecnica dello stack frame, si completino le istruzioni qui sotto ove la prima alloca la variabile L sul frame e le altre tre
assegnano al primo parametro duscita p1 il valore contenuto in L[2].
SUB SP, SP, #40

LDR R0, [FP, -#32]
LDR R1, [FP, #12]
STR R0, [R1]
NTLB = 3584 bit
8) In un sistema con MMU in cui lindirizzo logico da 32 bit e quello fisico da 20 bit, la memoria fisica sia suddivisa in pagine da 4 Kbyte. Allora
la dimensione della page table di NPT bit.
NPT = 8 M bit
Sk1 = 3.431118
Si supponga inoltre che, a causa dei vari hazard il pipeline subisca mediamente un ulteriore inceppamento di 1 stadio ogni 20 istruzioni. In queste ipotesi il fattore di speedup (T1/Tk), sempre trascurando il transitorio iniziale, mediamente pari a Sk2
Sk2 = 3.297508
10) Con riferimento al codice di pg 290 e 291 del libro di testo, se il codice della routine di servizio fosse collocato a partire dallindirizzo $2250
(anzich $2200), il contenuto del terzo longword della sequenza di avvio (nel testo collocato allindirizzo $4278) sarebbe:
nuovo contenuto = $ 22A8
SOLUZIONE

1) Un dispositivo, gestito ad interrupt, genera periodicamente richieste di interruzioni con periodo Tm; la sua RSI ha durata (complessiva) Rm=80
s. Un secondo dispositivo DP, pi prioritario di DM, ha una RSI di durata (complessiva) Rp=55 s e pu interrompere DM al massimo una
volta durante ciascun periodo Tm. Per non perdere dati di DM, il minimo valore di Tm :
TmMIN =135 s
2) Un dispositivo D1 trasferisce, via DMA, blocchi da 2048 dati ciascno. Per comandare il trasferimento di un blocco vengono eseguite dalla CPU
5 istruzioni la cui durata complessiva corrisponde a 15 cicli di bus; i dati vengono trasferiti ad uno ad uno via DMA; la RSI attivata dopo il trasferimento dellultimo dato del blocco ha una durata corrispondente a 90 cicli di bus (ciascun ciclo di bus dura 50 ns). Il tempo di CPU complessivamente impegnato per il trasferimento di uno dei blocchi (includendo il ritardo dovuto ad accessi DMA di D1) al massimo pari a TDMA s.
TDMA = 107.65 s
di 10 s, nel secondo caso (una richiesta dinterruzione per blocco di dati), essendo il numero di dati di ogni blocco molto elevato, la durata della
TI =12.5 s
TD = 87.5 ns
4) Un sistema ARM dotato di una instruction cache e di una data cache completamente associative; ciascuna delle due cache contiene 8 blocchi
da 16 byte. A data cache vuota, viene eseguito il segmento di codice che segue, caricato in memoria a partire dallindirizzo 0x4000. Immaginando che la data cache adotti un criterio di rimpiazzo di tipo LRU (Least Recently Used), quando viene eseguita listruzione mov pc, lr
mov
r0, #0xD
mov
r1, #0x3000
LOOP: ldr
r2, [R1]
and
r2, r2, #0xFF00
str
r2, [R1], +#4
subs
r0, r0, #1
bne
LOOP
mov pc, lr
ph = 84.6154 %
indirizzo 0xABC01F ha un TAG pari a TAGS e, se presente in cache, si trova nel set di indice Is (0IsNs-1); TAGS e Is vanno indicati in notazione esadecimale.
Ns = 512
|
TAGS = 0x157 |
|
Is = 0x100
che la subroutine utilizzi la tecnica dello stack frame, si completino le istruzioni qui sotto ove la prima alloca la variabile L sul frame e le altre tre
assegnano al secondo parametro duscita p2 il valore contenuto in L[19].
SUB SP, SP, #80

LDR R1, [FP, -#4]
LDR R2, [FP, #8]
STR R1, [R2]
NTLB = 1664 bit
NPT = 2M bit
9) Un processore dotato di un pipeline a 5 stadi e di una memoria cache. Mediamente il numero di accessi in memoria per ogni istruzione pari a
1,4 e lhit rate della cache pari al 92%. Si rilevato che ogni miss nella cache provoca nel pipeline un inceppamento (ritardo) di 3 stadi. In
queste ipotesi il fattore di speedup (T1/Tk), trascurando il transitorio iniziale, mediamente pari a Sk1
Sk1 = 3.994012
Sk2 = 3.896787
(anzich $2200), il contenuto dellundicesimo longword della routine di servizio (nel testo collocato allindirizzo $2228) sarebbe:
nuovo contenuto = 0x42B8
SOLUZIONE

TmMIN = 90 s
2) Un dispositivo D1 trasferisce, via DMA, blocchi da 512 dati. Per comandare il trasferimento di un blocco vengono eseguite dalla CPU 3 istruzioni la cui durata complessiva corrisponde a 9 cicli di bus; i dati vengono trasferiti ad uno ad uno via DMA; la RSI attivata dopo il trasferimento dellultimo dato del blocco ha una durata corrispondente a 80 cicli di bus (ciascun ciclo di bus dura 60 ns). Il tempo di CPU complessivamente impegnato per il trasferimento di uno dei blocchi (includendo il ritardo dovuto ad accessi DMA di D1) al massimo pari a TDMA s.
TDMA = 36.06 s
di 14 s, nel secondo caso (una richiesta dinterruzione per blocco di dati), essendo il numero di dati di ogni blocco molto elevato, la durata della RSI trascurabile. Sapendo che il ciclo di bus ha una durata di 40ns e supponendo di tollerare in entrambi i casi una occupazione massima del
tempo di CPU dedicato al dispositivo del 60% (trascurando la RSI del DMA), allora il periodo minimo con cui possono essere trasferiti i dati
TI = 23.3333 s
TD = 66.6667 ns
4) Un sistema ARM dotato di una instruction cache e di una data cache completamente associative; ciascuna delle due cache contiene 16 blocchi da 8 byte. A data cache vuota, viene eseguito il segmento di codice che segue, caricato in memoria a partire dallindirizzo 0x5000. Immaginando che la data cache adotti un criterio di rimpiazzo di tipo LRU (Least Recently Used), quando viene eseguita listruzione mov pc, lr
mov
r0, #0x9
mov
r1, #0x4000
LOOP: ldr
r2, [R1]
bic
r2, r2, #0xF000
str
r2, [R1], +#4
subs
r0, r0, #1
bne
LOOP
mov pc, lr
ph = 72,2222 %
5) Una memoria cache da 512 Kbyte, di tipo set-associativo a 16 vie costituita da blocchi da 128 byte. Allora la cache ha in tutto Ns set e il byte
di indirizzo 0x23507A ha un TAG pari a TAGS e, se presente in cache, si trova nel set di indice Is (0IsNs-1); TAGS e Is vanno indicati in notazione esadecimale.
Ns = 256
|
TAGS = 0x 046|
|
Is = 0x A0
che la subroutine utilizzi la tecnica dello stack frame, si completino le istruzioni qui sotto ove la prima alloca la variabile L sul frame e le altre
tre assegnano al primo parametro duscita p1 il valore contenuto in L[1].
SUB SP, SP, #120

LDR R2, [FP, -#116]
LDR R3, [FP, #12]
STR R2, [R3]
NTLB = 4096 bit
NPT = 7M bit
Sk1 = 5.132231
Sk2 = 5.02834
(anzich $2200), il contenuto del sesto longword della sequenza di avvio (nel testo collocato allindirizzo $4284) sarebbe:
nuovo contenuto = $ 32BC
SOLUZIONE

TmMIN = 200 s
2) Un dispositivo D1 trasferisce, via DMA, blocchi da 800 dati. Per comandare il trasferimento di un blocco vengono eseguite dalla CPU 6 istruzioni la cui durata complessiva corrisponde a 18 cicli di bus; i dati vengono trasferiti ad uno ad uno via DMA; la RSI attivata dopo il trasferimento dellultimo dato del blocco ha una durata corrispondente a 75 cicli di bus (ciascun ciclo di bus dura 80 ns). Il tempo di CPU complessivamente impegnato per il trasferimento di uno dei blocchi (includendo il ritardo dovuto ad accessi DMA di D1) al massimo pari a TDMA s.
TDMA = 71.44 s
4)
di 12 s, nel secondo caso (una richiesta dinterruzione per blocco di dati), essendo il numero di dati di ogni blocco molto elevato, la durata della RSI trascurabile. Sapendo che il ciclo di bus ha una durata di 50ns e supponendo di tollerare in entrambi i casi una occupazione massima del
tempo di CPU dedicato al dispositivo del 50% (trascurando la RSI del DMA), allora il periodo minimo con cui possono essere trasferiti i dati
TI = 24 s
TD = 100 ns
Un sistema ARM dotato di una instruction cache e di una data cache completamente associative; ciascuna delle due cache contiene 32 blocchi da 16 byte. A data cache vuota, viene eseguito il segmento di codice che segue, caricato in memoria a partire dallindirizzo 0xA00. Immaginando che la data cache adotti un criterio di rimpiazzo di tipo LRU (Least Recently Used), quando viene eseguita listruzione mov pc, lr
mov
r0, #0x10
mov
r1, #0x5000
LOOP: ldr
r2, [R1]
orr
r2, r2, #0x0F
str
r2, [R1], +#4
subs
r0, r0, #1
bne
LOOP
mov pc, lr
ph = 87.5 %
5) Una memoria cache da 1 Mbyte, di tipo set-associativo a 32 vie costituita da blocchi da 256 byte. Allora la cache ha in tutto Ns set e il byte di
indirizzo 0x110963 ha un TAG pari a TAGS e, se presente in cache, si trova nel set di indice Is (0IsNs-1); TAGS e Is vanno indicati in notazione esadecimale.
Ns = 128
|
TAGS = 0x 022|
|
Is = 0x 09
che la subroutine utilizzi la tecnica dello stack frame, si completino le istruzioni qui sotto ove la prima alloca la variabile L sul frame e le altre
tre assegnano al secondo parametro duscita p2 il valore contenuto in L[38].
SUB SP, SP, #160

LDR R3, [FP, -#8]
LDR R1, [FP, #8]
STR R3, [R1]
NTLB = 1920 bit
NPT = 13*128K bit
Sk1 = 5.658385
Sk2 = 5.571865
(anzich $2200), il contenuto del quattordicesimo longword della routine di servizio (nel testo collocato allindirizzo $2234) sarebbe:
nuovo contenuto = $ 52CC
Cognome....................................................................
Nome...................................................................
Matricola.........................
Canale.........
1) Un sistema ARM dotato di una instruction cache e di una data cache a mappatura diretta con 256 blocchi di 32 byte. Si determini lhit rate HR
raggiunto in data cache dal seguente frammento di codice, nellipotesi che la data cache sia inizialmente vuota:
SUM:
MOV
R0, #0x400
MOV
R1, #0x1A800
MOV
R2, #0x0
LOOP:
LDR
R3, [R1], #4
ADD
R2, R2, R3
SUBS
R0, R0, #1
BNE LOOP
HR = 87.5%
TAG = 0xD
HRMIN = 80%
3) In un sistema ARM la subroutine SUB1, che fa uso di uno stack frame (le prime istruzioni che essa esegue sono stmfd sp! {fp, lr}; mov fp, sp)
riceve, nello stack, come unico parametro un vettore V di 10 word, passato per indirizzo, e alloca una sola variabile locale x, anchessa da un
word. Si completino le tre istruzioni qui sotto che in SUB1 realizzano lassegnamento V [5] = x
LDR R0, [FP, #-4]
LDR
STR
R1,
R0,
[FP, #+8] |
[R1, #+20]
500 Hz e 20 KHz. Il trasferimento dei campioni in memoria viene gestito ad interrupt per ADC1 e in DMA per ADC2. Trascurando la predisposizione iniziale del DMA ma includendo sia la gestione dellinterruzione del DMA che quella dovuta allultimo campione di ADC1, sapendo che
la RSI di ADC1 ha una durata complessiva R1 = 400 s, quella del DMA R2 = 40s, che la durata del ciclo di bus Tb = 100 ns, e che non vi
sono altri dispositivi nel sistema, il tempo minimo lasciato nei 2 secondi alla CPU per svolgere attivit non inerenti ai due dispositivi pari a
TrMIN:
TrMIN = 1595.96 ms
5) Un dispositivo D1 trasferisce, ad interrupt, dati con una frequenza di 1000 dati/s; la sua RSI ha una durata complessiva R1 = 300 s. Un secondo
dispositivo D2, avente la stessa priorit di D1, trasferisce, ad interrupt, dati con una frequenza di 500 dati/s; la sua RSI ha una durata complessiva
R2 = 200 s. Se un dispositivo D3 di priorit superiore a D1 e a D2 gestito da una RSI di durata complessiva R3 = 20 s, e non vi sono altri dispositivi nel sistema, il minimo periodo di D3 perch lacquisizione da D1 e da D2 non perda dati pari a T3MIN:
T3MIN = 40 s
TdMIN = 71.428 s
indirizzabili) suddividendola in 32 pagine e organizzando le cose in modo che nella memoria fisica possano essere contemporaneamente presenti
16 programmi, ciascuno dei quali pu occupare 1 Mbyte. Allora la page table costituita da NPT elementi e ciascun elemento contiene un indice
di pagina fisica costituito BIPF bit.
NPT = 2 elementi
BIPF = 5 bit
Mbyte (singolarmente indirizzabili), suddividendola in pagine da 512 KByte. Si voglia inoltre dotare il sistema descritto di un TLB con un numero di elementi uguale al numero delle pagine fisiche. Allora il TLB costituito da NTLB elementi e la sua dimensione complessiva, tenendo conto
della presenza di un bit di validit per ciascun elemento, di DTLB bit.
NTLB = 32 elementi
DTLB = 608 bit
9) Un processore RISC dotato di pipeline a K = 6 stadi. In media una istruzione su Nm = 20 di tipo LDR/STR e comporta un accesso alla memoria ulteriore a quello per il fetch. Gli accessi alla memoria sono velocizzati da una cache con uno hit rate medio del 90%; ogni miss nella cache
Sk = 5.524887
Cognome....................................................................
Nome...................................................................
Matricola.........................
Canale.........
1) Un sistema ARM dotato di una instruction cache e di una data cache a mappatura diretta con 128 blocchi di 64 byte. Si determini lhit rate
HR raggiunto in data cache dal seguente frammento di codice, nellipotesi che la data cache sia inizialmente vuota:
SUM:
MOV
R0, #0x500
MOV
R1, #0xCF000
MOV
R2, #0x0
LOOP:
LDR
R3, [R1], #4
ADD
R2, R2, R3
SUBS
R0, R0, #1
BNE LOOP
HR = 93.75%
TAG = 0x67
HRMIN = 90%
riceve, nello stack, come unico parametro un vettore V di 20 word, passato per indirizzo, e alloca una sola variabile locale y, anchessa da un
word. Si completino le tre istruzioni qui sotto che in SUB1 realizzano lassegnamento V [10]=y
LDR R0, [FP, #-4]
LDR
STR
R1,
R0,
[FP, #+8] |
[R1, #+40]
che la RSI di ADC1 ha una durata complessiva R1 = 300 s, quella del DMA R2 = 20s, che la durata del ciclo di bus Tb = 200 ns, e che non
vi sono altri dispositivi nel sistema, nellintervallo di 1 secondo in cui avvengono i trasferimenti, il tempo minimo lasciato alla CPU per svolgere
attivit non inerenti ai due dispositivi pari a TrMIN:
TrMIN = 389.98 ms
5) Un dispositivo D1 trasferisce, ad interrupt, dati con una frequenza di 2000 dati/s; la sua RSI ha una durata complessiva R1 = 100 s. Un secondo dispositivo D2, avente la stessa priorit di D1, trasferisce, ad interrupt, dati con una frequenza di 1000 dati/s; la sua RSI ha una durata complessiva R2 = 200 s. Se un dispositivo D3 di priorit superiore a D1 e a D2 gestito da una RSI di durata complessiva R3 = 40 s, e non vi
sono altri dispositivi nel sistema, il minimo periodo di D3 perch lacquisizione da D1 e da D2 non perda dati pari a T3MIN:
T3MIN = 100 s
TdMIN = 200 s
presenti 16 programmi, ciascuno dei quali pu occupare 8 Mbyte. Allora la page table costituita da NPT elementi e ciascun elemento contiene
un indice di pagina fisica costituito BIPF bit.
NPT = 4 elementi
BIPF = 6 bit
NTLB = 64 elementi
DTLB = 1152 bit
9) Un processore RISC dotato di pipeline a K=7 stadi. In media una istruzione su Nm=25 di tipo LDR/STR e comporta un accesso alla memoria ulteriore a quello per il fetch. Gli accessi alla memoria sono velocizzati da una cache con uno hit rate medio del 95%; ogni miss nella cache
provoca nel pipeline un inceppamento (stall) di 1 stadio. In assenza di altri tipi di stall (dovuti a data hazard o branch hazard) il fattore di
speedup Sk (calcolato trascurando il transitorio iniziale, cio assumendo che il numero di istruzioni eseguite tenda allinfinito) :
Sk = 6.703422
Cognome....................................................................
Nome...................................................................
Matricola.........................
Canale.........
SUM:
MOV
R0, #0x200
MOV
R1, #0x5E000
MOV
R2, #0x0
LOOP: LDR
R3, [R1], #4
ADD
R2, R2, R3
SUBS
R0, R0, #1
BNE LOOP
HR = 75%
TAG = 0xBC
HRMIN = 75%
riceve, nello stack, come unico parametro un vettore V di 30 word, passato per indirizzo, e alloca una sola variabile locale z, anchessa da un
word. Si completino le tre istruzioni qui sotto che in SUB1 realizzano lassegnamento V [8]=z
LDR R0, [FP, #-4]
LDR
STR
R1,
R0,
[FP, #+8] |
[R1, #+32]
vi sono altri dispositivi nel sistema, il tempo minimo lasciato nei 2 secondi alla CPU per svolgere attivit non inerenti ai due dispositivi pari a
TrMIN:
TrMIN = 1592.77 ms
5) Un dispositivo D1 trasferisce, ad interrupt, dati con una frequenza di 2500 dati/s; la sua RSI ha una durata complessiva R1 = 200 s. Un secondo dispositivo D2, avente la stessa priorit di D1, trasferisce, ad interrupt, dati con una frequenza di 500 dati/s; la sua RSI ha una durata complessiva R2 = 100 s. Se un dispositivo D3 di priorit superiore a D1 e a D2 gestito da una RSI di durata complessiva R3 = 20 s, e non vi
sono altri dispositivi nel sistema, il minimo periodo di D3 perch lacquisizione da D1 e da D2 non perda dati pari a T3MIN:
T3MIN = 80 s
TdMIN = 80 s
indirizzabili) suddividendola in 128 pagine e organizzando le cose in modo che nella memoria fisica possano essere contemporaneamente presenti 16 programmi, ciascuno dei quali pu occupare 4 Mbyte. Allora la page table costituita da NPT elementi e ciascun elemento contiene un
indice di pagina fisica costituito BIPF bit.
NPT = 8 elementi
BIPF = 7 bit
Mbyte (singolarmente indirizzabili), suddividendola in pagine da 512 KByte. Si voglia inoltre dotare il sistema descritto di un TLB con un numero di elementi uguale al numero delle pagine fisiche. Allora il TLB costituito da NTLB elementi e la sua dimensione complessiva, tenendo
conto della presenza di un bit di validit per ciascun elemento, di DTLB bit.
NTLB = 128 elementi
DTLB = 2688 bit
Sk = 4.466956
Cognome....................................................................
Nome...................................................................
Matricola.........................
Canale.........
SUM:
MOV
R0, #0x600
MOV
R1, #0x2CC00
MOV
R2, #0x0
LOOP: LDR
R3, [R1], #4
ADD
R2, R2, R3
SUBS
R0, R0, #1
BNE LOOP
HR = 96.875%
TAG = 0xB
HRMIN = 85%
riceve, nello stack, come unico parametro un vettore V di 40 word, passato per indirizzo, e alloca una sola variabile locale w, anchessa da un
word. Si completino le tre istruzioni qui sotto che in SUB1 realizzano lassegnamento V [30]=w
LDR R0, [FP, #-4]
LDR
STR
R1,
R0,
[FP, #+8] |
[R1, #+120]
vi sono altri dispositivi nel sistema, nellintervallo di 1 secondo in cui avvengono i trasferimenti, il tempo minimo lasciato alla CPU per svolgere
attivit non inerenti ai due dispositivi pari a TrMIN:
TrMIN = 695.18 ms
5) Un dispositivo D1 trasferisce, ad interrupt, dati con una frequenza di 250 dati/s; la sua RSI ha una durata complessiva R1 = 400 s. Un secondo
dispositivo D2, avente la stessa priorit di D1, trasferisce, ad interrupt, dati con una frequenza di 1000 dati/s; la sua RSI ha una durata complessiva R2 = 200 s. Se un dispositivo D3 di priorit superiore a D1 e a D2 gestito da una RSI di durata complessiva R3 = 80 s, e non vi sono
altri dispositivi nel sistema, il minimo periodo di D3 perch lacquisizione da D1 e da D2 non perda dati pari a T3MIN:
T3MIN = 200 s
TdMIN = 66.667 s
presenti 16 programmi, ciascuno dei quali pu occupare 16 Mbyte. Allora la page table costituita da NPT elementi e ciascun elemento contiene un indice di pagina fisica costituito BIPF bit.
NPT = 16 elementi
BIPF = 8 bit
NTLB = 256 elementi
DTLB = 5376 bit
Sk = 7.860055
COGNOME .. NOME ..MATR. . CANALE

1.
In un sistema ARM la subroutine S1, utilizzante la tecnica dello stack frame, riceve nello stack, nellordine, 3 parametri (P1, P2,
P3) da 32 bit, i primi due passati per riferimento, il terzo per valore. Si completino le tre istruzioni, con cui la subroutine copia il
valore del terzo parametro nel secondo.
LDR R0, [FP, +8]
LDR R1, [FP, +12] |
[R1]
STR R0,
2.
Un sistema ARM sia dotato di una cache set-associativa a 4 vie, inizialmente vuota, con un TAG da 20 bit e un indice di set da 8
bit. Quando viene eseguita listruzione: LDR R1, [R0, 0x44], sia R0=0x3344. Allora nella cache viene caricato un blocco nel set
di indice S1, associando ad esso il TAG T1; inoltre il dato letto si trova allinterno del blocco di indice S1 alloffset O1. Indicare,
in esadecimale, i valori di S1, T1, O1.
S1 = 0x 38, T1 = 0x 3, O1 = 0x 8
]
3.
Un sistema con processore ARM con frequenza di clock pari a 400 MHz dotato di una data cache di tipo completamente
associativo con 64 blocchi da 32 byte ciascuno. Lhit rate della cache sia pari al 95%; in caso di hit unistruzione load/store venga
completata in un ciclo, mentre in caso di miss essa richieda 2 cicli. In queste ipotesi, a regime, 100.000 accessi in memoria
impegnano la CPU per un tempo complessivo, espresso in microsecondi, pari a Tt. Indicare il valore di Tt.
Tt = 262.5 s
4.
Un sistema dotato di MMU utilizza indirizzi logici da 24 bit ed indirizzi fisici da 20 bit. La dimensione delle pagine di memoria
4KByte. Ciascun elemento della Page Table contiene anche un bit di controllo che impedisce operazioni di scrittura sulla
corrispondente pagina fisica. Si indichi la dimensione D (numero di bit) della Page Table.
D = 9*212 = 36864
5.
In un sistema ARM con pagine di memoria di 8KByte i primi 4 elementi della Page Table contengono i seguenti valori
0 0x060
1 0x070
Considerando le seguenti istruzioni ARM:
LDR R0, =0x005FFC
2 0x020
STMIA R0, {R2,R3}
3 0x030
Si indichino, in esadecimale, gli indirizzi fisici IND2 e IND3 nei quali vengono copiati i valori di R2 e R3.
IND2 = 0x 41FFC;
6.
IND3 = 0x 60000
Un telefono cellulare dotato di un ricevitore Bluetooth 1.2 che, tramite interfaccia seriale, comunica con un processore ARM
alla velocit V = 800*210 bit/s (819'200 bit al secondo). La porta seriale collegata al processore dotata di un buffer interno di B
= 16 bit, e richiede lintervento del processore solo quando il buffer pieno. Lingegnere responsabile dello stack Bluetooth sta
valutando se la ricezione debba essere gestita tramite interrupt o tramite DMA. Nel primo caso, sapendo che la durata della
routine di servizio delle interruzioni (inclusi il salvataggio del contesto e il riconoscimento dellinterruzione) pari a TRSI = 17 s,
la percentuale del tempo di processore che, nel caso peggiore, risulta impegnata durante la ricezione pari a TIRQ.
Nel secondo caso (DMA), sapendo che il bus dati verso la memoria ha una larghezza di 16 bit e che un accesso in memoria
richiede TM = 50 ns, la percentuale del tempo di processore che risulta impegnata nel caso peggiore (trascurando il tempo
necessario a riprogrammare il DMA al termine della ricezione di ciascun blocco) pari a TDMA. Indicare i valori di TIRQ e TDMA.
TIRQ = 87,04 % ;
TDMA = 0.256 %
7.
Due dispositivi D1, D2, gestiti ad interrupt, trasferiscono un dato ogni T = 100 s. Le richieste di interruzione di D2 sono pi
prioritarie di quelle di D1 e hanno luogo con un ritardo (fisso) di 20 s dopo quelle di D1. La routine di servizio di D1 ha una
durata complessiva R1 = 60 s. Sapendo che non vi sono altri dispositivi nel sistema, indicare il massimo tempo di esecuzione
R2MAX della routine di servizio di D2 ammesso affinch non vi sia perdita di dati.
8.
In un processore RISC, la predizione dei salti viene effettuata tramite un BTB (Branch Target Buffer), costituito da una cache di
128 elementi completamente associativa. Ciascun elemento, oltre che lindirizzo dellistruzione di salto condizionato (TAG),
comprende lindirizzo di destinazione del salto e un campo da 2 bit usato per la predizione. Essendo gli indirizzi delle istruzioni
sempre multipli di 4, essi sono da 30 bit. Indicare il numero N di bit di cui costituito il BTB.
N = 7936
9.
Un processore dotato di un pipeline a k = 5 stadi e di una memoria cache. Mediamente ciascuna istruzione comporta 1.3 accessi
in memoria e lhit rate della cache pari al 90%. Ogni miss nella cache provoca un ritardo di 2 stadi (e un conseguente pari
inceppamento nel pipeline). A causa dei vari hazard il pipeline subisce mediamente un ulteriore inceppamento di 1 stadio ogni 10
istruzioni. In queste ipotesi il fattore di speedup (T1/Tk), trascurando il transitorio iniziale, pari a Sk. Indicare il valore di Sk.
R2MAX = 40 s
Sk = 3.867647
10. Con riferimento al codice di pg 290-291 del libro di testo, se il codice della routine di servizio fosse collocato a partire
dallindirizzo $30000000 (anzich $2200), indicare quale sarebbe il contenuto C del terzo longword della sequenza di avvio (nel
testo collocato allindirizzo $4278).
C = $ 30000058

1.
P3) da 32 bit, il primo passato per riferimento, il secondo e il terzo per valore. Si completino le tre istruzioni, con cui la
subroutine copia il valore del secondo parametro nel primo.
LDR R1, [FP, +12]
LDR R2,
STR R1,
[FP, +16] |
[R2]
2.
Un sistema ARM sia dotato di una cache set-associativa a 8 vie, inizialmente vuota, con un TAG da 21 bit e un indice di set da 7
bit. Quando viene eseguita listruzione: LDR R1, [R2, 0x61],, sia R2=0xAABB. Allora nella cache viene caricato un blocco nel
set di indice S1, associando ad esso il TAG T1; inoltre il dato letto si trova allinterno del blocco di indice S1 alloffset O1.
Indicare, in esadecimale, i valori di S1, T1, O1.
S1 = 0x 31, T1 = 0x 15, O1 = 0x C
]
3.
Tt = 1080 s
4.
D = 10*213 = 81920
5.
0 0x006
1 0x007
LDR R0, =0x003FFC
2 0x003
STMIA R0, {R2,R3}
3 0x004
IND2 = 0x 0FFFC;
IND3 = 0x 6000
6.
Un telefono cellulare dotato di un ricevitore Bluetooth 1.2 che, tramite interfaccia seriale, comunica con un processore ARM
alla velocit V = 720*210 bit/s (737'280 bit al secondo). La porta seriale collegata al processore dotata di un buffer interno di B
= 16 bit, e richiede lintervento del processore solo quando il buffer pieno. Lingegnere responsabile dello stack Bluetooth sta
TIRQ = 92.16 % ;
TDMA = 0.18432 %
7.
8.
256 elementi a mappatura diretta. Ciascun elemento, oltre che il TAG, comprende lindirizzo di destinazione del salto e un campo
da 1 bit usato per la predizione. Essendo gli indirizzi delle istruzioni sempre multipli di 4, essi sono da 30 bit. Durante la fase di
fetch di ciascuna istruzione di salto condizionato, gli 8 bit meno significativi dei 30 del suo indirizzo individuano lelemento della
BTB in cui, in caso di HIT, presente linformazione che ne predice il salto. Indicare il numero N di bit di cui costituito il BTB.
N = 13568
9.
in memoria e lhit rate della cache pari al 90%. Ogni miss nella cache provoca un ritardo di 3 stadi (e un conseguente pari
R2MAX = 120 s
Sk = 4.510638
dallindirizzo $300000B0 (anzich $2200), indicare quale sarebbe il contenuto C del sesto longword della sequenza di avvio (nel
C = $ 3000010C

1.
P3) da 32 bit, i primi due passati per valore, il terzo per riferimento. Si completino le tre istruzioni, con cui la subroutine copia il
valore del primo parametro nel terzo.
LDR R2, [FP, +16]
LDR R3,
STR R2,
[FP, +8] |
[R3]
2.
Un sistema PD32 sia dotato di una cache set-associativa a 2 vie, inizialmente vuota, con un TAG da 18 bit e un indice di set da 10
bit. Quando viene eseguita listruzione: LDR R1, [R3, 0x3C], sia R3=0x17766. Allora nella cache viene caricato un blocco nel
S1 = 0x 37A, T1 = 0x 5, O1 = 0x 2
]
3.
Tt = 1090 s
4.
D = 12*217 = 1572864
5.
0 0x060
1 0x070
LDR R0, =0x001FFC
2 0x020
STMIA R0, {R2,R3}
3 0x030
IND2 = 0x C1FFC;
IND3 = 0x E0000
6.
Un telefono cellulare dotato di un ricevitore Bluetooth 2.0+EDR che, tramite interfaccia seriale, comunica con un processore
ARM alla velocit V = 1 Mbit/s (220 bit al secondo). La porta seriale collegata al processore dotata di un buffer interno di B =
32 bit, e richiede lintervento del processore solo quando il buffer pieno. Lingegnere responsabile dello stack Bluetooth sta
TIRQ = 81.92 % ;
TDMA = 0.16384 %
7.
8.
32 elementi completamente associativa. Ciascun elemento, oltre che lindirizzo dellistruzione di salto condizionato (TAG),
comprende lindirizzo di destinazione del salto e un campo da 2 bit usato per la predizione. Essendo gli indirizzi delle istruzioni
sempre multipli di 4, essi sono da 30 bit. Indicare il numero N di bit di cui costituito il BTB.
N = 1984
9.
in memoria e lhit rate della cache pari al 90%. Ogni miss nella cache provoca un ritardo di 1 stadio (e un conseguente pari
R2MAX = 80 s
Sk = 3.594752
dallindirizzo $300000C0 (anzich $2200), indicare quale sarebbe il contenuto C del terzo longword della sequenza di avvio (nel
C = $ 30000118

1.
P3) da 32 bit, il primo passato per valore, il secondo e il terzo per riferimento. Si completino le tre istruzioni, con cui la
subroutine copia il valore del primo parametro nel secondo.
LDR R3, [FP, +16]
LDR R4, [FP, +12] |
STR R3,
[R4]
2.
Un sistema PD32 sia dotato di una cache set-associativa a 8 vie, inizialmente vuota, con un TAG da 22 bit e un indice di set da 6
bit. Quando viene eseguita listruzione: LDR R1, [R4, 0xB9], sia R4=0xAAAA. Allora nella cache viene caricato un blocco nel
S1 = 0x 36, T1 = 0x 2A, O1 = 0x 3
]
3.
Tt = 416 s
4.
Un sistema dotato di MMU utilizza indirizzi logici da 30 bit ed indirizzi fisici da 26 bit. La dimensione delle pagine di
memoria 8KByte. Ciascun elemento della Page Table contiene anche un bit di controllo che impedisce operazioni di
scrittura sulla corrispondente pagina fisica. Si indichi la la dimensione D (numero di bit) della Page Table.
D = 14*217 = 1835008
5.
0 0x00A
1 0x00B
LDR R0, =0x003FFC
2 0x004
STMIA R0, {R2,R3}
3 0x001
IND2 = 0x 17FFC;
IND3 = 0x 08000
6.
Un telefono cellulare dotato di un ricevitore Bluetooth 2.0+EDR che, tramite interfaccia seriale, comunica con un processore
ARM alla velocit V = 2 Mbit/s (221 bit al secondo). La porta seriale collegata al processore dotata di un buffer interno di B =
32 bit, e richiede lintervento del processore solo quando il buffer pieno. Lingegnere responsabile dello stack Bluetooth sta
TIRQ = 91.7504 % ;
7.
TDMA = 0.262144 %
R2MAX = 70 s
8.
64 elementi a mappatura diretta. Ciascun elemento, oltre che il TAG, comprende lindirizzo di destinazione del salto e un campo
da 1 bit usato per la predizione. Essendo gli indirizzi delle istruzioni sempre multipli di 4, essi sono da 30 bit. Durante la fase di
fetch di ciascuna istruzione di salto condizionato, i 6 bit meno significativi dei 30 del suo indirizzo individuano lelemento della
BTB in cui, in caso di HIT, presente linformazione che ne predice il salto. Indicare il numero N di bit di cui costituito il BTB.
N = 3520
9.
in memoria e lhit rate della cache pari al 90%. Ogni miss nella cache provoca un ritardo di 1 stadio (e un conseguente pari
Sk = 6.245614
dallindirizzo $300000E0 (anzich $2200), indicare quale sarebbe il contenuto C del sesto longword della sequenza di avvio (nel
C = $ 3000013C

2 Compitinosol

Caricato da

Informazioni sul documento

Titolo originale

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

2 Compitinosol

Caricato da

Copyright:

Formati disponibili

Cognome ESATTO

ARCHITETTURA DEGLI ELABORATORI 1 - Seconda prova intermedia - 23 giugno 2003

Essendo la cache inizialmente vuota, si verificano i seguenti hit e miss:

Blocco nuovo (occ. 2)

NumByteCache = NumByteBlocco * NumVie * Ns

MOVL 140(FP), (R0)

NTLB = (NumBitTAG + NumBitDato) * NumElemTLB =

Facendo il calcolo su una successione di N istruzioni a regime, esse producono N*AccessiPerIstruzione

ARCHITETTURA DEGLI ELABORATORI 1 - Seconda prova intermedia - 23 giugno 2003

Essendo la cache inizialmente vuota, si verificano i seguenti hit e miss:

Blocco nuovo (occ. 2)

Blocco nuovo (occ. 3)

NumByteCache = NumByteBlocco * NumVie * Ns

MOVL 20(FP), (R1)

NTLB = (NumBitTAG + NumBitDato) * NumElemTLB =

NumBitTag = NumBitIndirizzoLogico Log2 DimPagina = 48 16 = 32 bit

Facendo il calcolo su una successione di N istruzioni a regime, esse producono N*AccessiPerIstruzione

ARCHITETTURA DEGLI ELABORATORI 1 - Seconda prova intermedia - 23 giugno 2003

Essendo la cache inizialmente vuota, si verificano i seguenti hit e miss:

Blocco nuovo (occ. 2)

Blocco nuovo (occ. 3)

Blocco nuovo (occ. 4)

NumByteCache = NumByteBlocco * NumVie * Ns

MOVL 56(FP), (R2)

NTLB = (NumBitTAG + NumBitDato) * NumElemTLB =

NPT = NumBitNumPagFisica * NumPagLogiche =

T1 = N * NumStadi * Tstadio + N*AccessiPerIstruzione*(1-HitRate)*StadiRitardo*TStadio

ARCHITETTURA DEGLI ELABORATORI 1 - Seconda prova intermedia - 23 giugno 2003

Essendo la cache inizialmente vuota, si verificano i seguenti hit e miss:

Blocco nuovo (occ. 2)

Blocco nuovo (occ. 3)

Blocco nuovo (occ. 4)

NumByteCache = NumByteBlocco * NumVie * Ns

MOVL 4(FP), (R3)

NTLB = (NumBitTAG + NumBitDato) * NumElemTLB =

Facendo il calcolo su una successione di N istruzioni a regime, esse producono N*AccessiPerIstruzione

Si determini inoltre il TAG del primo blocco spostato in data cache

TempoAccessoMedioMax = HitRateMin * TempAccCache + (1-HitRateMin) * TempoAccessoMem

MOVL -4(FP) , 20(R0)

DimPagina = DimMemFisica / NumPagine = 16 Mbyte/32 = 0.5 Mbyte

NumElemTLB = NumPagFisiche = DimMemFisica / DimPagina = 16 Mbyte /0.5 Mbyte = 32

Si determini inoltre il TAG del primo blocco spostato in data cache

TempoAccessoMedioMax = HitRateMin * TempAccCache + (1-HitRateMin) * TempoAccessoMem

MOVL -4(FP) , 40(R0)

DimPagina = DimMemFisica / NumPagine = 128 Mbyte/64 = 2 Mbyte

NumElemTLB = NumPagFisiche = DimMemFisica / DimPagina = 128 Mbyte /2 Mbyte = 64

TempoAccessoMedioMax = HitRateMin * TempAccCache + (1-HitRateMin) * TempoAccessoMem

MOVL -4(FP) , 32(R0)

DimPagina = DimMemFisica / NumPagine = 64 Mbyte/128 = 0.5 Mbyte

= (5+(1+1/40)(1-0.85)*1) / (1+(1+1/40)(1-0.85)*1) = 5.15375 / 1.15375 = 4.466956

TempoAccessoMedioMax = HitRateMin * TempAccCache + (1-HitRateMin) * TempoAccessoMem

MOVL -4(FP) , 120(R0)

DimPagina = DimMemFisica / NumPagine = 256 Mbyte/256 = 1 Mbyte

COGNOME.................................................................................... NOME..................................................................... MATR. ........................

ARCHITETTURA DEGLI ELABORATORI 1 - Seconda prova intermedia 20 giugno 2005

LDR R0, [LR, LSL #2]

COGNOME.................................................................................... NOME..................................................................... MATR. ........................

ARCHITETTURA DEGLI ELABORATORI 1 - Seconda prova intermedia 20 giugno 2005

COGNOME.................................................................................... NOME..................................................................... MATR. ........................

ARCHITETTURA DEGLI ELABORATORI 1 - Seconda prova intermedia 20 giugno 2005

COGNOME.................................................................................... NOME..................................................................... MATR. ........................

ARCHITETTURA DEGLI ELABORATORI 1 - Seconda prova intermedia 20 giugno 2005

MOVL 8 (FP), -12 (FP)

T1 = N * NumStadi * Tstadio + NAccessiPerIstruzione(1-HitRate)StadiRitardoTStadio

= (5+(1+1/40)(1-0.85)1) / (1+(1+1/40)(1-0.85)1) = 5.15375 / 1.15375 = 4.466956