Descargado en:

patatabrava.com

FUNDAMENTOS DE COMPUTADORES (UCM)

EJERCICIOS DE FUNDAMENTOS DE
COMPUTADORES DEL 2DO CUATRIMESTRE (CON
SOLUCION)

CURSO 15-
PROF.
16
 PROBLEMAS DE FUNDAMENTOS DE COMPUTADORES (HOJA 2.3)
(SISTEMA DE MEMORIA DE UN COMPUTADOR)

1) Sea un computador con una MP de 1 Mbyte y dotado con una MC de 16 bloques de cache de 64
bytes cada uno. Determinar el formato de la direccin de memoria fsica desde el punto de vista
del emplazamiento en memoria cache, especificando el nmero de bits que ocupa cada uno de los
campos que la componen para emplazamiento directo.
Solucin:
En este caso se indica que hay 16 marcos de bloque, por lo que se requieren 4 bits para
representarlos en cache. El resto de bits de la direccin de memoria, tras descontar los que
son utilizados para indicar el desplazamiento dentro de un bloque para acceder a una palabra
(6 bits), son utilizados para la etiqueta. En el caso que nos ocupa son 20-4-6=10 bits, y la
representacin global de memoria principal para la cache que queda entonces es:

E:10 M:4 P:6

2) Rellenar la siguiente tabla (siempre que sea posible), suponiendo que siempre se accede a un byte,
donde se especifica el tamao de la memoria principal, el tamao de la memoria cache
(emplazamiento directo), el tamao del bloque y los bits que se reservan para la etiqueta:
Tamao MP Tamao MC Tamao Bloque Etiqueta
1MB 256B 32B 12
1MB 1KB 512B 10
1MB 512B -(1) 3
1MB 215 B 32B 5
2MB 16KB 1KB 7
2MB 214 B 1KB 7
2MB 1KB 128B 11
2MB 218 B 8KB 3
4MB 1MB 2 ..220 B(2)
0
2
16MB 1MB 256KB 4

1. Como el tamao de la MC es 29 B m + k = 9. Por lo tanto los bits de etiqueta sern n

- m - k = 20 - 9 = 11 3, tal como indica la tabla. En consecuencia, no hay solucin.
2. En este caso el tamao de la MC es 220 B. Por lo tanto el tamao de bloque puede
variar desde 20 (lo que representan 220 marcos de 1 palabra) hasta 220 (lo que
representa 1 marco de 220 palabras.

1
3) Sea el siguiente programa, que se ejecuta en un computador con una MP de 64 Kpalabras, dotado
de una MC con emplazamiento directo de 1 Kpalabras y con bloques de 128 palabras. El tiempo
de ciclo de la memoria principal es 10t, el de la memoria cache es t y el tiempo de penalizacin por
un fallo es de 500t.
Etiqueta Direccin (hex)
Inicio ...................................... 0110
........................... 0170
............... 0A50
2 veces 3 veces
.............. 0EFF
........................... 1B00
Fin ....................................... 1DCF

a) Especificar el n de bits de los campos etiqueta, bloque y palabra

b) Considerando solamente el tiempo de bsqueda en memoria de las instrucciones, calcular el
tiempo necesario para la ejecucin del programa y la ganancia con respecto a un computador
sin cache.

Solucin:
Aparatado a)
E:6 M:3 P:7

Apartado b)
Total accesos = (0x0170-0x0110) + 2*(0x0A50-0x0170) + 6*(0x0EFF-0x0A50+1)
+ 2*(0x1B00-0x0EFF) + (0x1DCF-0x1B00)
= 96 + 4544 + 7200 + 6146 + 719 = 18705
Tiempo sin MC = 18705*10t = 187050t
Traza del programa:
0x01100x016F Bloques 272/128367/128 Bloques 22 1 fallo
Comienza el bucle x2:
0x01700x0A4F Bloques 368/1282639/128
Bloques 220 18 fallos (el bloque 2 ya estaba)
Comienza el bucle x3:
0x0A500x0EFF Bloques 2640/1283839/128 Bloques 2029 9 fallos
0x0A500x0EFF Bloques 2029 4 fallos (el 22-27 ya estn)
0x0A500x0EFF Bloques 2029 4 fallos (el 22-27 ya estn)
Fin del bucle x3.
0x0F000x1B00 Bloques 3840/1286912/128 Bloques 3054 25 fallos

Volvera a repetirse el bucle x2 una vez ms:

2 (18+17+25) +1 (el bloque 2* no est la 2 vez) = 121 fallos
Fin del bucle x2.
0x1B010x1DCF Bloques 6913/1287631/128 Bloques 5459 5 fallos
TOTAL: 1 (Inicio) + 121 (Bucle x2) + 5 (Fin) = 127 fallos
*
2
*
8,16 9,17 2 ,10,18 3,11,19 4,12,20 5,13 6,14 7,15
*
24 25 26 27 20 ,28 21,29 22 23

32,,48 33,,49 34,,50 35,,51 36,,52 37,,53 30*,,54 31,,47

56 57 58 59 54* 55

Tiempo con MC = 18705t + 127*500t = 82205t

MEJORA = 100*(TMP-TMC)/TMP = 56%

2
4) Sea un computador con una memoria principal de 4 Kpalabras y una cache de emplazamiento
directo con 4 bloques y 64 palabras por bloque. Se ejecuta 10 veces una serie de accesos en lectura.
Estas lecturas referencian consecutivamente todas las palabras comprendidas entre las direcciones
0x096 y la 0x247 (expresadas en hexadecimal). Indicad el nmero de fallos que se producen, en
qu bloques de la cache se ubica cada rango de direcciones y la etiqueta de cada bloque.
Solucin:
12 bits
B: 6 P: 6
E: 4 M: 2 P: 6
Clasificamos los accesos por bloques:
Bloque 2: 0x010016..0x01011F=0x096..0x0BF Marco 2, Etiqueta 0x0
Bloque 3: 0x011000..0x01111F=0x0C0..0x0FF Marco 3, Etiqueta 0x0
Bloque 4: 0x100000..0x10011F=0x100..0x13F Marco 0, Etiqueta 0x1
Bloque 5: 0x140..0x17F Marco 1, Etiqueta 0x1
Bloque 6: 0x180..0x1BF Marco 2, Etiqueta 0x1
Bloque 7: 0x1C0..0x1FF Marco 3, Etiqueta 0x1
Bloque 8: 0x200..0x23F Marco 0, Etiqueta 0x2
Bloque 9: 0x240..0x247 Marco 1, Etiqueta 0x2
Tambin lo podemos hacer en decimal: 0x096 a 0x247 son los bloques 150/64583/64=29

Para contar el nmero de fallos pintamos una tabla donde cada celda es un marco de la cache:
4, 8 5, 9 2, 6 (1 vuelta) 3, 7
4, 8 5, 9 2, 6 (2 vuelta y suc.) 3, 7

Total accesos: 0x247-0x096+1=434

Primera iteracin: 8 fallos
Segunda a 9 iteraciones: 8 fallos
Total fallos: 8*10 = 80 fallos

3
5) Sea un computador con memoria cache con las caractersticas siguientes:
Memoria principal: 64 KB
Memoria cache de 256 bytes con bloques de 64 bytes
a) Indicar el formato de la direccin para MP y para la MC
b) Calcular el nmero de bits necesarios para implementar la MC (incluyendo datos y etiquetas).
c) En un momento dado los contenidos del array de etiquetas de la cache (en hexadecimal) son
los indicados en la tabla. Expresar en hexadecimal el rango de direcciones de memoria
principal ubicadas en cada bloque de la memoria cache.
d) Supongamos que un programa realiza la siguiente cadena de referencias en lectura (en
hexadecimal): D380, 6010, D3F0, 6018, 1830. Calcular el nmero de fallos que se producen e
indicar cmo se queda el array de etiquetas de la memoria cache despus de acceder a la
ltima direccin.

Etiqueta Bloque
18 0
25 1
D3 2
51 3
Solucin
Apartado a)
16 bits
B: 10 P: 6
E: 8 M: 2 P: 6

Apartado b)
4 bloques * (8 bits etiqueta/bloque + 8bits/B*64 B/bloque) = 2080 bits = 260 B

Apartado c)
Etiqueta Bloque en MP Rango de direcciones
18 1800 1800-183F
25 2501 2540-257F
D3 D310 D380-D3BF
51 5111 51C0-51FF

Apartado d)
(1) D380 Bloque D310, ACIERTO
(2) 6010 Bloque 6000, FALLO, reemplazamos el marco 0 de MC
(3) D3F0 Bloque D311, FALLO, reemplazamos el marco 3 de MC
(4) 6018 Bloque 6000, ACIERTO (ver (2))
(5) 1830 Bloque 1800, FALLO, el marco 0 ha sido reemplazado
Etiqueta Bloque en MP Rango de direcciones
18 1800 1800-183F
25 2501 2540-257F
D3 D310 D380-D3BF
D3 D311 D3C0-D3FF

4
6) Sea un computador con memoria cache con las caractersticas siguientes:
Memoria principal de 32 KB
Memoria cache de 512 bytes con bloques de 128 bytes.
a) Indicar el formato de la direccin para MP y para la MC
b) En un momento dado los contenidos del array de etiquetas de la cache (en hexadecimal) son
los indicados en la tabla. Expresar en hexadecimal el rango de direcciones de memoria
principal ubicadas en cada bloque de la memoria.
c) Supongamos que un programa realiza la siguiente cadena de referencias (accesos a nivel de
palabra): de 2080 a 209F, de 2880 a 289F y de 03F0 a 0410. Indicad el nmero de aciertos
que se producen.

Etiqueta Bloque
35 0
10 1
10 2
08 3
Solucin
Apartado a)
15 bits
B: 8 P: 7
E: 6 M: 2 P: 7

Apartado b)
Etiqueta Bloque en MP Rango de direcciones
35 11010100D4 110101000000000.. 110101001111111=6A00..6A7F
10 0100000141 010000010000000.. 010000011111111=2080..20FF
10 0100001042 010000100000000.. 010000101111111=2100..217F
08 0010001123 001000110000000.. 001000111111111=1180..11FF
Apartado c)
(1) 2080 a 209F 010000010000..01000001001F Bloque 41, ACIERTO
(2) 2880 a 289F 010100010000..01010001001F Bloque 51, FALLO en Marco 1
(3) 03F0 a 0410 000001111110..000010000010 Bloques 07 y 08, FALLO en Marcos 3 y 0

Etiqueta Bloque en MP
02 08
14 51
10 0100001042
01 07

5
7) Ejercicio 3 (3 puntos). Sea un computador con una memoria principal de 1MB, con una memoria
cache de emplazamiento directo de 1KB con bloques de 128 bytes. La memoria es direccionable
por bytes y el tamao de palabra es de 4 bytes. Se pide:
a) (0,5 puntos) Indicar el formato de la direccin para MP y para MC.
b) (1 punto) En un momento dado slo cuatro de las entradas de la cache contienen datos
vlidos, los contenidos del array de etiquetas de la cache (en hexadecimal) son los indicados
en tabla inferior. Expresar en hexadecimal el rango de direcciones de memoria principal
ubicadas en la memoria cache.

Bloque de MC Etiqueta

2 0x3A7

4 0x100

5 0x100

7 0x0D2

c) (1,5 puntos) Partiendo de la situacin indicada en la tabla anterior, supongamos que un

programa realiza la siguiente cadena de referencias en lectura (en hexadecimal): todas las
palabras entre E9C38 y E9D7C ambos incluidos, todas las palabras entre las direcciones
4019C y 402AC, ambas incluidas, y todas las palabras entre las direcciones 34A84 y 34BC0,
ambas incluidas. Indicar en cada caso los fallos que se producen e indicar cmo se queda el
array de etiquetas de la memoria cache despus de acceder a la ltima direccin.

Apartado a), 2 parcial y final

20 bits
MP
B P

13 bits 7 bits

20 bits
MC
ETIQ M P

10 bits 3 bits 7 bits

6
Apartado b)
Bloque de cache 2: corresponde a 0xE9D00 a 0x E9D7F
Bloque de cache 4: corresponde a 0x 40200 a 0x 4027F
Bloque de cache 5: corresponde a 0x 40280 a 0x 402FF
Bloque de cache 7: corresponde a 0x 34B80 a 0x 34BFF

Apartado c)
Todas las palabras entre 0xE9C38 y 0x E9D7C ambos incluidos: son accesos
consecutivos entre el bloque con etiqueta 0x3A7 y M=0 hasta el bloque con etiqueta
0x3A7 y M=2. Se producen dos fallos, para traer los bloques de etiqueta 0x3A7 con
M=0 y M=1. El tercer bloque ya est en cache.
Todas las palabras entre las direcciones 0x4019C y 0x402AC, ambas incluidas: suponen
accesos a direcciones consecutivas desde el bloque con etiqueta 0x100 y M=3, hasta el
bloque con etiqueta 0x100 y M=4. Se produce un fallo en el primer acceso al bloque
con M=3, ya que no est. Se emplaza en el bloque de cache 3 con etiqueta 0x100. El
resto son aciertos.
Todas las palabras entre las direcciones 0x34A84 y 0x34BC0, ambas incluidas: son
accesos consecutivos desde el bloque con etiqueta 0x0D2 y M=5 hasta el bloque con
etiqueta 0x0D2 y M=7. El primer bloque no est, es un fallo y supone un reemplazo de
la entrada 5. El segundo bloque es otro fallo, mientras que el tercer bloque ya est en
la entrada 7, por lo que es un acierto.
Todas las entradas quedan marcadas como vlidas. El directorio queda como sigue:

Bloque de MC Etiqueta

0 0x3A7

1 0x3A7

2 0x3A7

3 0x100

4 0x100

5 0x0D2

6 0x0D2

7 0x0D2

7
8) Ejercicio 3 (2 puntos). Supongamos una jerarqua de memoria que consta de una Mp direccionable
por palabras, donde cada palabra tiene una anchura de 32 bits, y una Mc de emplazamiento directo
con 128 bloques, siendo cada bloque de 512 palabras. Adems sabemos que:
Las direcciones de Mc tienen un campo de etiqueta de 8 bits.
El tiempo de acceso a la Mc es 1 ciclo de reloj.
La penalizacin por fallo es 130 ciclos de reloj.
El tiempo de acceso a Mp es 10 ciclos de reloj.

Sobre esta jerarqua se ejecuta 10 veces seguidas una cadena de referencias entre las direcciones
0xF59600 y 0xF698C7, ambas inclusive, estando la cache inicialmente vaca.

a) (0,5 puntos) Cul es el tamao de la Mp expresado en megabytes?

b) (1 punto) Determina el nmero total de fallos producidos.
c) (0,5 puntos) Teniendo en cuenta la siguiente definicin, determina la Tasa de Fallos en este
problema.

=

d) (0,5 puntos) Determina el tiempo medio de acceso a memoria.
e) (0,5 puntos) Calcula la mejora de velocidad que se obtiene al emplear esta jerarqua de
memoria, en comparacin con la alternativa de usar solamente la Mp.

a) Anchura campo N BLOQUE = 7 bits; Anchura campo PALABRA = 9 bits

Anchura direccin: 8 + 7 + 9 = 24 bits
La Mp tiene 224 palabras = 226 bytes el tamao de la Mp es 226/ 220 = 64 megabytes
b) Tamao de la Mc = 128 bloques
Tamao de la cadena de referencias :
0xF59600 = 1111 0101 1001 0110 0000 0000 => Bloque Mp = 0x7ACB
0xF698C7 = 1111 0110 1001 1000 1100 0111 => Bloque Mp = 0x7B4C
Tamao = 7B4C 7ACB +1 = 0x82 = 130 bloques
La cadena de referencias no cabe ntegra en la Mc y los dos ltimos bloques de la
cadena ocupan los mismos marcos de bloque que los dos primeros
1 iteracin : 130 fallos
Resto de iteraciones: 4 fallos por iteracin 4 x 9 = 36
Total Fallos = 166
c) Tasa de fallos = N fallos / N referencias
N referencias = 10 x (129 bloques x 512 pal/bloque) + 10 x (0xC8) = 10 x ( 66048+200)
= 662480
Tasa de fallos = 166 / 662480 = 0,00025 = 0,025 %
d) TMAM = Tacierto + (1-H) Tpenal = 1 + 0,00025x130 = 1,0325 ciclos (en tr. de
teora)
e) Mejora = Tiempo con solo Mp / Tiempo con jerarqua
T con Mp = N referencias x 10 = 6624800 ciclos
T con jeraqua = N referencias x TMAM = 662480x1,0325 = 684011 ciclos
Mejora = 9,68 veces ms rpido

8
9) Sea un computador con un procesador ARMv4. EL procesador cuenta con una memoria cache de
emplazamiento directo de 256 bytes con bloques de 64 bytes, unificada para datos e instrucciones
(se almacenan en la misma cache los bloques de instrucciones accedidos en la etapa FETCH y los
bloques de datos accedidos durante las etapas que hacen acceso a memoria en las instrucciones ldr
y str).
a) En dicho sistema se quiere ejecutar el siguiente programa. Explique razonadamente lo que
hace el cdigo.
.equ N, 16
.data
A: .word N valores enteros separados por comas
B: .word N valores enteros separados por comas
.text
start: ldr r0, =A
ldr r1, =B
mov r4, #N
L1: ldr r2, [r0]
ldr r3, [r1]
add r2, r2, r3
and r2, r2, #0xF
str r2, [r0]
add r0, r0, #4
add r1, r1, #4
sub r4, #1
cmp r4, #0
bne L1
end: b .

b) Con direcciones de 32 bits, indicar el formato de la direccin para MP y para la MC.

c) El programa se enlaza ubicando la seccin .data a partir de la direccin 0x0C000000, y la
seccin .text se coloca a continuacin de la seccin .data. Obtenga los rangos de direcciones
que ocupan el array A, el array B y las instrucciones, indicando para cada rango el/los
bloques de memoria correspondientes, y el marco de bloque (bloque de cache) y la etiqueta
asociados.
d) Determine el nmero de aciertos y fallos de cache que se produciran al ejecutar el cdigo
anterior, hasta la primera vez que se ejecuta la instruccin que est en la etiqueta end.
e) Suponga que el programador cambia el valor N por 32. Obtenga de nuevo los bloques de
memoria en que se ubicaran los datos y las instrucciones. Explique cualitativa y
razonadamente cmo afectara este cambio a los fallos de cache (No es necesario calcular el
nuevo nmero de fallos, slo explicar lo que sucedera).

a) El programa suma elemento a elemento los arrays A y B mdulo 256, guardando en A

e resultado. Es decir, sera equivalente al siguiente cdigo C
for( i=0; i < N; i++ ) A[i] = (A[i] + B[i]) % 256;
b)
MP 32 bits
B P

26 bits 6 bits
32 bits
MC
ETIQ M P

24 bits 2 bits 6 bits

9
c) El cdigo + la tabla de literales son 16 palabras, es decir, cabe en un bloque.
Cada array ocupa 16 enteros, es decir, 64 bytes, con lo que cada uno cabe en un bloque.

rango bloque (hex) marco de etiqueta

bloque
Cdigo 0x0c000000 - 0x0300000 0 0x0c0000
0x0c00003F
Array A 0x0c000040 - 0x0300001 1 0x0c0000
0x0c00007F
Array B 0x0c000080 - 0x0300002 2 0x0c0000
0x0c0000BF

d)
Fetchs: en la primera instruccin se produce fallo, se trae a cache el bloque 0x0300000, que tiene
todo el cdigo. Va al marco de bloque 0. El resto de fetchs no supone fallos, a menos que haya
reemplazo. Como todo cabe en cache no lo habr.

ldrs: Los dos primeros ldrs no producen fallo, ya que los literales estn en cache. Las dos
primeras instrucciones del bucle, son loads a los arrays A y B. La primera iteracin provocan fallo,
trayndose todo el array a la cache, en los marcos 1 y 2. El resto de iteraciones no producen fallo.

strs: Slo hay un str y no produce fallo, ya que cuando se ejecuta los bloques accedidos estn en
cache.
Resultado: 3 fallos.
4 + N*10 (fetchs) + N*3 (ldr/str) = 212 aciertos
e) En este caso ya no cabe todo en cache:

rango bloque (hex) marco de etiqueta

bloque
Cdigo 0x0c000000 - 0x0300000 0 0x0c0000
0x0c00003F
Array A 0x0c000040 - 0x0300001 y 1y2 0x0c0000
0x0c0000BF 0x0300002
Array B 0x0c0000C0 - 0x0300003 y 3y0 0x0c0000 y
0x0c00013F 0x0300004 0x0c0001

Cada array ocupa dos bloques, los 16 ltimos elementos del array B compiten por el marco 0 con
el cdigo, por lo tanto aumentar significativamente la tasa de fallos.

* Comienzo:
1 fallo: en primer fetch
4 aciertos: 2 nuevos fetch y ejecucin de dos loads

10
* Las 16 primeras iteraciones del bucle:
2 fallos para traer las dos primeras mitades de los arrays A y B
16*10 (fetch) + 15*2 (ldr) + 16 (str) = 206 aciertos

* Iteracin 16 (17)
la ejecucin de las tres primeras instrucciones del bucle produce:
1 fallo en la ejecucin del primer load, se trae la segunda mitad del array A a cache
(marco 2)
1 fallo en la ejecucin del segundo load, se trae la segunda mitad del array B a cache
(marco 0), reemplazando el bloque de cdigo
1 fallo en el fetch de la instruccin add, se trae el bloque de cdigo a la cache (marco 0),
reemplazando el bloque con la segunda mitad del array B.
El resto de fetch son aciertos, y la ejecucin del str tambin.
Total: 3 fallos
9 (fetch) + 1(str) = 10 aciertos.

* Resto de iteraciones:
1 fallo en la ejecucin del segundo load, con reemplazo del bloque de cdigo
1 fallo en el fetch de la instruccin add.

Total: fallos: 15*2 = 30

aciertos: 15*(9 (fetch) + 2 (ldr/str)) = 165

* Ultima instruccin (b . ): 1 acierto.

Resultado total: 36 fallos y 386 aciertos.

11
10) El cdigo de un determinado programa est constituido por instrucciones mquina con la
siguiente frecuencia de ejecucin: aritmticas 50%, carga 20%, almacenamiento 10% y salto
condicional 20% (donde la mitad de los saltos se toman). En cierto procesador las instrucciones
consumen los siguientes ciclos: aritmticas 4, carga 5, almacenamiento 4, salto no tomado 3, salto
tomado 4.
a) Calcula el CPI del procesador al ejecutar este programa.
b) Sabiendo que el programa se ha ejecutado en 8.2ms, y que la frecuencia del procesador es
de 1GHz, calcula el nmero de instrucciones que se han ejecutado.
c) Suponiendo que por cada 100 instrucciones ejecutadas se produce 1 fallo de cache, que
implica una penalizacin de 300 ciclos de reloj, calcula el nuevo tiempo de ejecucin del
programa. Cul sera entonces el nuevo CPI?

a) CPI= 0.5*4+0.2*5+0.1*4+0.2*(0.5*3+0.5*4)=4.1 ciclos/instr

b) 8.2*10^-3 s * 1*10^9 ciclos/s /(4.1 ciclos/instr)=2*10^6 instr
c) Tiempo= 8.2 ms + 2*10^6 /100 fallos* 300 ciclos/ (10^9 ciclos/s)=8.2ms+6ms=14.2ms
CPI=14.2*10^-3 s * 1*10^9 ciclos/s /(2*10^6 instr) = 7.1 ciclos/instr

12
11) Sea un computador con un procesador ARMv4. EL procesador cuenta con una memoria cache de
emplazamiento directo de 512 bytes con bloques de 64 bytes, unificada para datos e instrucciones
(se almacenan en la misma cache los bloques de instrucciones accedidos en la etapa FETCH y los
bloques de datos accedidos en la ejecucin de las instrucciones ldr y str).
a) En dicho sistema se quiere ejecutar el siguiente programa. Explique razonadamente lo que
hace el cdigo (debe darse un pseudo-cdigo tipo C/C++ equivalente).
.equ N, 32

.data
A: .word N valores enteros separados por comas
B: .word N valores enteros separados por comas

.bss
C: .space N*4

.text
start: ldr r0, =A
ldr r1, =B
ldr r2, =C
mov r4, #N
L1: ldr r5, [r0]
ldr r6, [r1]
add r5, r5, r6
mov r5, r5, lsl #2
str r5, [r2]
add r0, r0, #4
add r1, r1, #4
add r2, r2, #4
sub r4, #1
cmp r4, #0
bne L1
end: b.

b) Con direcciones de 32 bits, indicar el formato de la direccin para MP y para la MC.

c) El programa se enlaza ubicando la seccin .data a partir de la direccin 0x0C000000, con la
seccin .bss colocada justo despus de la seccin .data y la seccin .text a continuacin de la
seccin .bss. Obtenga los rangos de direcciones que ocupan el array A, el array B, el array C y
las instrucciones, indicando para cada rango el/los bloques de memoria correspondientes, y
el marco de bloque (bloque de cache) y la etiqueta asociados.
d) Determine el nmero de aciertos y fallos de cache que se produciran al ejecutar el cdigo
anterior, hasta la primera vez que se ejecuta la instruccin que est en la etiqueta end.
e) Suponga que el programador cambia el valor N por 16. Obtenga de nuevo los bloques de
memoria en que se ubicaran los datos y las instrucciones. Explique razonadamente cmo
afectara este cambio a los fallos de cache y a la tasa de fallos (cociente entre fallos y accesos
totales)

a) El programa suma elemento a elemento los arrays A y B, multiplicando el resultado

por 4 y guardndolo en el array C. Es decir, sera equivalente al siguiente cdigo C

for( i=0; i < N; i++ )

C[i] = (A[i] + B[i]) * 4;

13
b)
32 bits
MP
B P

26 bits 6 bits

32 bits
MC
ETIQ M P

23 bits 3 bits 6 bits

c) El cdigo son 16 palabras, es decir, cabe en un bloque. Si se cuenta tambin la tabla de

literales, requiere 2 bloques. Cada array ocupa 32 enteros, es decir, 128 bytes, con lo que cada
uno cabe en dos bloque.

rango bloques (hex) marcos de etiqueta

bloque
Array A 0x0c000000 - 0x0300000 y 0y1 0x060000
0x0c00007F 0x0300001
Array B 0x0c000080 - 0x0300002 y 2y3 0x060000
0x0c0000FF 0x0300003
Array C 0x0c000100 - 0x0300004 y 4y5 0x060000
0x0c00017F 0x0300005
Instrucciones 0x0c000180 - 0x0300006 6 (y 7 si 0x060000
0x0c0001BF (y 0x300007 si contamos la
(0x0c0001CB si contamos la tabla de
contamaos tabla de literales)
tabla de literales)
literales)

d)

Fetchs: en la primera instruccin se produce fallo, se trae a cache el bloque 0x0300006, que tiene
todo el cdigo. Va al marco de bloque 6. El resto de fetchs no supone fallos, a menos que haya
reemplazo. Como todo cabe en cache no lo habr.

ldrs: Los tres primeros ldrs no producen fallo, ya que los literales estn en cache. Las dos
primeras instrucciones del bucle, son loads a los arrays A y B. La primera iteracin provocan fallo,
trayndose la mitad de cada array a la cache, en los marcos 0 y 2. En la iteracin 16 vuelve a
producirse fallo, trayndose la segunda mitad de cada array a los marcos 1 y 3. El resto de
iteraciones no producen fallo.

14
strs: Slo hay un str, produce fallo en la primera iteracin y en la iteracin 16. El primer fallo trae
la primera mitad del array C al marco 4 y el segundo fallo trae la segunda mitad al marco 5. En el
resto de iteraciones no produce fallo
Fallos: 7 (8 si contamos la tabla de literales, falla tambin el primer load)
Aciertos = Accesos - Fallos = 3 + 32*3 + 5 + 32* 11 - 7= 449 aciertos (448 si contamos la tabla de
literales)

e) En este:

rango bloque (hex) marco de etiqueta

bloque
Array A 0x0c000000 - 0x0300000 0 0x060000
0x0c00003F
Array B 0x0c000040 - 0x0300001 1 0x060000
0x0c00007F
Array B 0x0c000080 - 0x0300002 2 0x060000
0x0c0000BF
Cdigo 0x0c0000C0 - 0x0300003 (y 3 (y 4 si 0x060000
0x0c0000FF 0x0300004 si contamos la
(0x0c00010B si contamos la tabla de
contamos la tabla de literales)
tabla de literales)
literales)

Se reducen a la mitad los fallos, ya que cada array cabe ahora en un slo bloque. Los accesos se
reducen tambin casi a la mitad, ya que el nmero de iteraciones (y por tanto de ldr, str y fetch)
se reduce a la mitad. La tasa de fallos queda por tanto ms o menos igual.

15