Arquitectura de computadoras

Finales

Punto 1 (Empezado)

Matriz cuadrada de enteros de NxN

N=16
cada entero ocupa 4 bytes

i representa la fila
j la columna

A[i][j]=dirBase + (j*N+i)* tamaño del elemento

a) Si la dirección base de la matriz es 0A20 h

● ¿Cual es la dirección base de la segunda fila?

dirección base de segunda fila => i = 1, j=0

 0A20+(0*16 + 1)*4
Rta:la dirección base de la segunda fila es 0A24

● ¿Cuál es la dirección de la componente A[N-1][N-1]?

0A20 +(15*16 + 15)*4

Rta:la dirección A[N-1][N-1] es 0E1C h

Asumiendo:
● direcciones físicas de 16 bits
● Caché con mapeo directo
○ 512 bytes para datos
○ 32 bytes de datos por línea

b)Indique cómo se divide la dirección física para acceder a cache

Rta: se divide en Tag, Index y Offset

¿Cuántos bits tiene cada parte?

32 bytes por línea => bits del offset = log2(32) = 5 =>offset de 5 bits

32 bytes por línea y 512 bytes en total => 512/32 = cantidad de líneas = 16 =>
bits de index =log2(16)= 4 =>index de 4 bits

Tag= 16 - 4 - 5 =>Tag de 7 bits

c)

Punto 2 (Terminado)

Datos:
espacio virtual de 2^32 bytes
RAM de 16 MiB 2^24 bytes
 a) ¿Cuántos bits tiene la dirección física ?

24 bits

b) T=tamaño

T tabla de página < T pagina = T Frame

Cada página tiene qué almacenar el número de frame, el bit de valido y el bit de dirty

T Linea de tabla de pagina =log2(cant frame) +2

memoria virtual = 2^32

memoria virtual/Tframe=cant frames
Tframe = 2^offset

2^32/2^offset=cant frames

T Línea de tabla de pagina = log2(2^32/2^offset) +2

T Tabla de página = T Línea de tabla de página * cant Líneas de tabla de página

cant Líneas de tabla de página =2^32 / T Frame = 2^offset

cant Líneas de tabla de página =2^32 /2^offset

T tabla de página = log2(2^32/2^offset) +2 * 2^32 /2^offset

T Frame = 2^offset

T tabla de página < T Frame

( log2(2^32/2^offset) +2 ) *( 2^32 /2^offset) < 2^offset

c)
( log2(2^32/2^12) +2 ) *( 2^32 /2^12) < 2^12

(log2(2^20) +2) * (2^20) <2^12

22* 2^20 <2^12 => FALSO

es decir con esté tamaño de página la tabla de página no entraría en una página

para qué la tabla entre habría qué hacer las páginas más grandes
Punto 3 (Terminado)

Datos:
pipeline de 5 etapas
● 20% de predicciones de branch erróneas
● Solo forwarding para operaciones aritméticas
● branch y jump actualizan el PC en la etapa memory
● De las instrucciones el 30% son Load, 10% son branch y 2 % son jump

a) Calcule qué porcentaje debe haber de load seguidos de una instrucción qué usa el
dato para obtener un speed up de 4 en comparación con una implementación sin
pipeline

Stall provocados por branch :

0.1*0.2*3
Stall provocados por jump :
0.02*3
Stall provocados por load :
0.3*2*(la cantidad promedio de veces qué lo qué sigue es una instrucción qué usa el
dato(X))

k=5 (las 5 etapas del pipeline)

Speedup= k/(1+ciclos stall por instrucción)

4 = 5 / (1+ 0.1*0.2*3 + 0.02*3 + 0.3*2*X)

4 = 5/ (1.12 + 0.6 * X)

4*(1.12 + 0.6*X) = 5

0.6*X= 5/4 -1.12

X = 0.13/0.6

X = 0.216

Rta:para qué haya un speed up de 4 debe el 21.66% de los load deben estar
seguidos de una instrucción qué utilice el dato
b) ¿Si se le agrega forwarding a las lecturas de memoria y la resolución del jump se
realiza en el dcode y la del branch en el execute cual es el speed up comparado con
el anterior?

Asumiendo qué la cantidad el % calculado en el inciso anterior es cierto

Stall provocados por branch:

0.1*0.2*2
Stall provocados por jump :
0.02*1
Stall provocados por load :
0.3*1* 0.216

Speedup= k/(1+ciclos stall por instrucción)

Speedup = 5/(1+0.1*0.2+0.02+0.3*0.216)

Speedup = 4.525

4 - 4.525 = 0.525 es la mejora del speedup

Punto 4 (Terminado)

Datos:
2 arreglos (A y B), cada arreglo contiene 1024 enteros
cada entero ocupa 4 bytes
El primer elemento de A está en 0000 4000 h
El primer elemento de B está en 0001 0800 h

caché mapeo directo

políticas writeback y write allocate
4 Kb de datos
16 bytes de datos por línea

a) ¿Cuántas líneas hay en la caché?

4 Kb de datos en total y 16 bytes de datos por línea => 4 Kb / 16 bytes = 256 líneas

b) ¿En qué campos se divide la dirección física para acceder a la caché? ¿cuantos bits
tiene cada parte?

Se divide en Tag, index y offset

como hay 256 líneas el index es de log2(256) = 8 bits

 como cada línea es de 16 bytes el offset es de log2(16) = 4 bits
Tag = T dirección física - index - offset
Tag = 32 -8 - 4 = 20 bits

c) ¿En cuantos bloques se dividen los arreglos? ¿ Qué set les corresponde?

tamaño del arreglo = 1024 * 4 bytes = 4096 bytes

tamaño de los bloques es 16 bytes

cada arreglo se divide en 4096/16 = 256 bloques

Los 2 arreglos ocupan 512 bloques

Para el arreglo A

0000 4000 h -> 0000 0000 0000 0000 0100 0000 0000 0000
0000 4016 h -> 100 0000 0001 0110
tag = 0100
index= 0000

set 0 -> bloque 0

set n ->bloque n , para 0<=n<256

Para el arreglo B
0001 0800 h -> 0000 0000 0000 0001 0000 1000 0000 0000
index=128

bloque 0 -> set 128

bloque n ->mod (set n + 128, 256) ,para 0<=n<256

d) ¿Cuántos fallos de lectura y escritura ocurren?

A memoria principal se buscan 4 enteros (16 bytes=L) y se guardan en la caché

cada vez que se accede a la componente de un arreglo.

Para el arreglo A :

en el ciclo 0
los 16 bytes se almacenan en el set 0 (un miss)
ciclos de 1 al 3
se accede a los datos qué se encuentran en el set 0 ( 3 hits)

en el ciclo n ( para 0<= n < 256, n múltiplo de 4)

los 16 bytes se almacenan en el set n (un miss)
ciclos de n+1 al n+3
se accede a los datos qué se encuentran en el set n ( 3 hits)
 Para el arreglo B:

en el ciclo 0
los 16 bytes se almacenan en el set 128 (un miss)
ciclos de 1 al 3
se accede a los datos qué se encuentran en el set 128 ( 3 hits)

en el ciclo n ( para 0<=n<256 n múltiplo de 4 )

los 16 bytes se almacenan en el set mod(n+128,256) (un miss)
ciclos de n+1 al n+3
se accede a los datos qué se encuentran en el set mod(n+128,256) ( 3 hits)

Posibles conflictos:
la caché se llenará en el ciclo 512 ya qué los set de la caché de 0 a 127 estarán
ocupados por componentes del arreglo A y los set de la caché de 128 a 255 estarán
ocupados por componentes del arreglo B

en el ciclo 513 se reemplaza el valor almacenado en en la línea 0 de caché por un valor de

B y el valor almacenado en la línea 128 por un valor almacenado en A,

esto no presentará ningún problema a la hora de calcular los hits ya qué los valores
reemplazados ya fueron utilizados y no se volverá intentar acceder a esta sección de la
memoria

por lo tanto en total habrá (1 miss y 3 hits) * 512

¿Ese valor hubiera variado si la caché, manteniendo la capacidad para datos, hubiera
estado organizada con grado de asociatividad 2?

Al aumentar el grado de asociatividad sin aumentar la capacidad de la caché hace qué

disminuya a la mitad la cantidad de líneas a la mitad en esté caso y por lo tanto qué la
cantidad de bits del index se reduzca a 7 bits (log2(128))
Esto afectará como cuales son los sets qué le corresponden a la dirección base del arreglo
B

por lo tanto el arreglo B y A comenzarán a llenar la caché desde el mismo set (el set 0 ) y
esto sería un problema si la caché fuera de mapeo directo ya qué cuando se acceda a la
componente B en cada ciclo se reemplaza la línea de caché y esto provocaría qué todos los
accesos a memoria sean un miss (ya qué cada vez qué se accede a A o B reemplaza el
otro arreglo y estos se acceden de forma intercalada)

Pero al ser 2 way associative se pueden almacenar 2 datos(con el mismo index) en la

misma línea de caché por lo qué no se producirá ningún problema diferente a los qué ya
ocurrían con mapeo directo por lo qué la cantidad de miss y hits no cambiaría.
 e) Cómo se van enviando ambos arreglos en la caché en simultáneo, cuando se llega a la
mitad de ambos, la caché estaría llena. Por lo tanto, como se utiliza una política WriteBack,
entonces el resto de los datos se escribirán en memoria principal (las mitades restantes de
cada arreglo).

Luego habría 1024 bytes en caché y 1024 bytes en memoria principal.

Punto 5 (Terminado)

a) 4 MHz = 4 millones de ciclos por seg

4 millones /1.6 = 2500000 instrucciones por seg

b) ¿Cuál es la fracción de tiempo utilizada para controlar el mouse?

Controlar mouse 30 veces por seg
1500 instrucciones
CPI 2.5

4 millones/2.5 = 1600000 por seg

1500 instr /1600000 intr * seg =9.37*10^-4 (esto es lo qué se tarda en controlar el
mouse una vez)

9.37*10^-4 * 30 = 0.02811= cuántos seg se pierden por segundo en controlar el

mouse

¿Es significativa?

si se hacen 2500000 instrucciones por seg se estaría perdiendo 70275

instrucciones por segundo en controlar el mouse

(70275*100)/2500000 = 2.811 %

El 2.8 % del tiempo el CPU está controlando el mouse

0.02811*2500000 = 70275
Punto 6 (Terminado con dudas (e y f))

Datos:
espacio virtual de 2^32 bytes
páginas de 4 KiB
RAM de 8 MiB

a) ¿Cuántos bits tiene la dirección física?

La dirección física debe direccionar a los bytes de la RAM

para direccionar 8 MiB de memoria se necesitan direcciones de log2(8 MiB) =23 bits
 d) ¿Cuántos bits tiene el número página y el número de frame?

Si una página tiene 4 KiB de datos entonces el Offset necesita log2(4 KiB) bits

el offset tiene 12 bits

si el offset tiene 12 bits y la dirección física tiene 23 bits entonces el número de

frame es de 23 - 12 = 11 bits

espacio virtual de 2^32 bytes => direcciones virtuales de 32 bits + offset de 12 bits
=> el número de páginas tiene 32 - 12 = 20 bits

c) ¿Cuál es el número máximo de frames posibles?

si el número de frame tiene 11 bits entonces el la cantidad máxima de frames es

2^11 frames

b) ¿En cuántas páginas se divide el espacio virtual ?

si la cantidad de bits del número de páginas es de 20 bits entonces el espacio virtual se

divide en 2^20 páginas

también se puede comprobar haciendo

espacio virtual / tamaño de página

2^32 / 2^12 = 2^20

e) ¿ Por qué la propuesta de usar los últimos bits de la página para identificar el frame
es mala?

Creo qué esta idea es mala debido a qué cada página estaría limitada a mapear el
frame qué corresponda a sus últimos bits

f) ¿Cuál sería el tamaño de la tabla de páginas?

Tamaño de la tabla = cantidad de líneas * tamaño de la línea

cantidad de lineas es 2^número de pagina = 2^20

tamaño de linea = bits de número de frame + bit de valido + dirty bit = 11+1+1 = 13 bits

tamaño de la tabla = 13* 2^20 = 13631488 bits = 1703936 bytes

g) ¿ Cual es el problema con la tabla de pagina?

la tabla de paginas mide 1703936 bytes

paginas de 4 KiB =2^12 bytes

1703936/2^12 = 416
Punto 7 (Creo qué Incompleto)

Ventajas y desventajas de no permitir utilizar un dato luego de realizar un load

● Ventajas:
○ al no utilizar los datos luego de un load se evitan los stall qué tendría la
instrucción qué utilizará el dato del load
● Desventajas
○ al hacer qué el compilador garantice qué luego de un load no se utilice el
registro destino hace qué las instrucciones no puedan ejecutarse en el orden
en qué fueron hechas
Punto 8 (Terminado)
Punto 9 (Empezado)

Datos:
dirección virtuales de 25 bits
direcciones físicas de 22 bits
páginas de 2^16 bits
1) ¿Cuál es el tamaño total en bits de la tabla de páginas?

Tamaño de tabla de páginas = la cantidad de entradas * tamaño de cada entrada

cantidad de entradas = 2^25

tamaño de cada entrada = bits del número de frame + bit de valido + bit de dirty
bits del número de frame = bits de las direcciones físicas - offset
offset = log2(tamaño de pag) =log2(2^16) = 16 btis
bits del número de frame = bits de las direcciones físicas - offset =22 -16 = 6 bits
tamaño de cada entrada = bits del número de frame + bit de valido + bit de dirty
=6+2 =8 bits

tamaño de tabla de paginas = 2^25 * 8 = 2^28

2) ¿porque es malo reducir el tamaño de pagina a 16 KB ?

Punto 10 (Terminado con dudas (c) )

a) Enumere ventajas y desventajas de la política FIFO y random justifique

FIFO:
● Ventajas:
○ Es más fácil de implementar qué LRU
○ hace qué los últimos datos accedidos no se vaya de la caché
rápidamente por lo qué, lo cual es bueno ya que es probable qué los
datos recientemente accedidos sean requeridos
● Desventajas
○ Datos qué son muy frecuentemente usados pueden ser reemplazados
a pesar de ser usado recientemente ( esto no pasaría con LRU)
○ es posible qué un dato sea utilizado pocas veces y luego se sigan
utilizando otros pero con FIFO estos datos aunque no sean utilizados
no serán reemplazados si ingresaron recientemente.
○ Es más complejo de implementar qué random
● Neutros:
○ Todos datos qué sean enviados a la cache serán reemplazados luego
de la misma cantidad de datos accedidos con el mismo index

Random
● Ventajas:
 ○ Es fácil de implementar
○ Al ser al azar existe la posibilidad de qué reemplace siempre los datos
qué no vas a necesitar próximamente (aunque esto es un caso ideal y
poco probable)
● Desventajas
○ Al ser azar existe la posibilidad de qué reemplace siempre los datos
qué van a ser requeridos a continuación
○ Al no seguir ninguna lógica lo más probable es qué reemplace más
datos útiles qué LRU o FIFO

Tanto las ventajas y desventajas de la política random depende de la suerte

por lo qué es posible qué random funcione mejor o peor qué cualquier otra
política pero como las otras políticas siguen una lógica qué hace qué
reemplacen lo qué se cree qué es menos probable qué uses random tenderá
a ser peor qué las demás políticas

b) Describa una caso en el qué la política FIFO sea mejor qué la LRU

Un caso en el qué es mejor una política FIFO qué una LRU es el caso en el qué por
ejemplo cada dato se utilice solo 2 veces y entre esos 2 usos no se llene la cache

en esté caso la politica FIFO seria mejor ya qué el LRU guardaria los datos por más tiempo
al ver qué se volvieron a utilizar pero realmente nunca volveran a ser solicitados

ejemplo una caché full asociativ muy pequeña para el ejemplo

con FIFO con LRU

load R1 guardo R1,miss guardo R1, miss
load R2 guardo R2, miss guardo R2, miss las caches están llenas
add R1, R1 ,R1 hit hit
load R3 remplazo R1, miss

Con FIFO Con LRU

Load R1 guado R1, miss guardo R1 miss

Load R2 guardo R2, miss guardo R2, miss caches llenas

add R1,R1,R1 hit hit

Load R3 reemplazo R1, reemplazo R2,

guardo R3 miss Guardo R3 miss

add R2, R2,R2 hit reemplazo R1,

Guando R2 miss
como se puede ver en esté caso con la política FIFO se obtienen más hit y menos miss qué
con la política LRU

c) ¿Qué información se necesita almacenar para implementar la política FIFO?

Un bit qué apunte al elemento qué se debe reemplazar a continuación y una vez qué
se reemplazó ese elemento se prende el bit de dato siguiente
Punto 11 (Terminado con dudas (d y e))

Datos:
T Pagina: 2048 bytes = T frame
T Espacio lógico : 8192 páginas
T espacio físico : 128 frames = 128 páginas

a) ¿Cuántos bits se necesitan para direccionar dentro de la página?

Como T pagina = 2048 bytes =>Offset = log2(2048) = 11

b) ¿Cuál es el tamaño de las direcciones físicas y lógicas ?

Físicas:
Espacio físico = 128 páginas
T Pagina = 2048 bytes
Espacio físico =128* 2048 bytes =262144 bytes
T Direcciones físicas = log2 ( 262144) = 18 bits

Lógicas:
Espacio lógico = 8192 páginas
T Pagina = 2048 bytes
Espacio lógico=2048 * 2048 bytes =2^22 bytes
T Direcciones lógicas = log2(2^22) = 22 bits

c) ¿Cuántas páginas ocupa un texto con las siguientes características?

Datos del texto:

1720 caracteres
80% de los caracteres (1376) ocupan 2 bytes
20% de los caracteres (344) ocupan 4 bytes

El texto ocupa 1376*2 + 344*4 bytes = 4128 bytes

T Pagina = 2048 bytes
El texto ocupa 4128/2048 páginas = 2.015 páginas
 como el texto no puede estar en 2.015 páginas se utilizaran 3 páginas para
almacenar el texto a pesar de qué una de las páginas apenas sea utilizada
d) ¿Cuál es el tamaño de la tabla de páginas si tiene las siguientes características?
5 bits adicionales(1 valido, 1 dirty, 3 de seguridad)

T tabla de páginas = cant líneas de la tabla de página * T direccion de frame

cant líneas = 8192 páginas
T direccion de frame = 18 -11 = 7 bits

T tabla de páginas = 8192 * 7 = 57344 bits = 7168 bytes = 3.5 páginas

¿Esta tabla tiene algún inconveniente de implementación? ¿Cómo podría

solucionarse?

quizá el inconvenientes es qué la tabla de páginas ocupa 3.5 pág es decir 4 páginas
de las cuales 1 se desperdicia la mitad

se podría solucionar cambiando el tamaño de las páginas para qué ocupara un

número exacto de páginas

e) ¿Cuál sería el tamaño en bytes de un TLB de 10 entradas?

El TLB tiene número de frame, número de página y los 5 bits extras

número de farme son 7 bits

número de página son 11 bits

el tamaño del TLB seria (11+7+5 )*10 = 230 bits = 28.75 bytes (RARO)
Punto 12 (Terminado (Repasar parte 4))

Parte 1
es el punto 3
Parte 2
es el punto 2

Parte 3
es el punto 4

Parte 4
1. Unidad de control cableada( HUC): Las señales de salida (i.e. señales de control )
de la CU son generadas por los circuitos lógicos construidos con compuertas y
flip-flops
2. Unidad de Control Microprogramada(MCU) La secuencia de microprogramas
correspondientes a cada instrucción(o microinstrucción) del set de instrucciones
(ISA) se almacena en una memoria qué permite lecturas y escrituras denominada
memoria control (CM). La secuencia de microinstrucciones se denomina
microprograma y una microinstrucción corresponde a una o más microoperaciones
(dependiendo de la cantidad de instrucciones) qué deben ejecutarse
secuencialmente.

Una MCU es más flexible qué una HCU, debido a qué :

● Permite cambiar fácilmente el ISA
● el hardware es más simple y menos propenso a errores

Todo piola
Punto 13 (Terminado sin ganas)

Una versión más avanzada del pseudo LRU es la usada por interl 80486 para su cache
no-chip. Esta versión asocia 3 bits B0, B1 y B2 a cada conjunto de una caché qué es 4-way
set associative (las líneas asociadas a cada way son L0, L2 y L3), cuando hay qué
reemplazar una línea, el agoritmo de reemplazo opera de la siguiente forma
● Primero, se determina si la línea más recientemente usada está en el par L0-L1 o en
el par L2-L3
● Luego del par qué no contiene a la línea más recientemente usada, se marca para
reemplazo la linea menos recientemente usada

1)Explicar qué indican los bits B0, B1 y B2 y como deben actualizarse acceder a una linea
2) Analizar cómo esté algoritmo es una mejor aproximacion de LRU qué el peseudo LRU
con un único bit (por ejemplo, analizar la secuencia de accesos L0,L2,L3,L1)

1) los bits B0, B1 y B2 sirven para indicar cual es siguiente elemento a reemplazar
(cual es el elemento qué se utilizo hace más tiempo)
funcionan como un árbol binario de decisión

lo qué hay qué hacer para actualizar los valor de B0,B1yB2 es

● si B0 = 0 entonces cambiar el valor de B0 y de B1
● si B0 = 1 entonces cambiar el valor de B0 y de B2
2)Esté algoritmo es mejor qué el pseudo LRU ya qué con esté algoritmo siempre se
reemplaza el qué hace más tiempo qué no se utiliza pero con el pseudo LRU se selecciona
uno al azar de la sección en la qué se encuentra el dato qué lleva más tiempo sin ser usado
por lo qué hay un 50% de probabilidades de qué se reemplace correctamente, esto
claramente es peor qué el 100% de probabilidad de esté algoritmo
Punto 14 (Terminado)

Datos:
Pipeline de 5 etapas
Branch:
Se resuelve en execute

a) CPI = CPI ideal + ciclos de stall

CPIdeal = 1
ciclos de stall = % de instrucciones qué son branch * (%de branch qué resultan en
NT/PT, T/PNT * 2 + % de branch qué resultan en T/PT * 1) + stall provocados por
otras instrucciones (jumps/load seguidos de instrucciones qué utilizan el
dato).
Cami anónimo , Nacho anónimo y Leo anónimo: ESTO EN NEGRITA NOS
PARECE UNA CAGADA, na joda no creemos que debería ir :D <3. Ya que en el
enunciado te pregunta el CPI para tener en cuenta .. de la unidad de los branch

b) CPI base = 1.2

20% de la instrucciones son branch
de los cuales el 65% son tomados
el branch se predice erróneamente el 12% de la veces

para reemplazar en la fórmula anterior hay qué tener en cuenta qué el CPI base
es el
CPIIdeal + los stall provocados por otras instrucciones

por lo qué la formula quedaría

 ciclos de stall = % de instrucciones qué son branch * (%de branch qué resultan en
NT/PT, T/PNT * 2 + % de branch qué resultan en T/PT * 1) + stall provocados por
otras instrucciones (jumps/load seguidos de instrucciones qué utilizan el
dato).

CPI = CPIIdeal +ciclos de stall

CPI = CPIIdeal + stall de branch + stall de otros

CPIBase = CPIideal + stall de otros

CPIBase=1.2

CPI = 1.2 + stall de branch

CPI= 1.2 + %de branchs*((%NT/PT + %T/PNT) * 2 + %T/PT)

%de branch = .2
%T/PT= .65*.88
%NT/PT=.35*.12
%T/PNT=.65*.12

CPI = 1.2 + .2*((.35*.12 + .65*.12)*2 + .65*.88) =1.3624

c) ¿Cuánto más rápido el procesador de 600MHz ?

Datos: antes eran 500 MHz

ahora la penalización por fallar e branch es :

CPI = 1.2 + 2* ((.35*.12 + .65 *.12)*3 + .65*.88 *2 ) = 1.5008

1.3624 / 500 = 0,00272

1.5008 / 600 = 0.00227

es un poco más rápido el de 600

No se bien como especificar cuanto más rápido es

0.00272 - 100%
0.00227 - x = 83,45 %
Punto 1 de nuevo

a)
Dirección base A = 0A20 H
N = 16
Posición en memoria = dirección_de_base_de_A + (j* N + i) *
tamaño elemento

Posición en memoria de la segunda fila:

0A20 + (0*16+1) * 4 bytes (hexa) = 0A24 H

Posición en memoria de A[N-1][N-1]:

0A20 + (15*16+15) * 4 bytes =
0A20 + (F * 10 + F) * 4 (hexa)= 0E1C H
b)
La dirección física de la caché se divide en:
Tag, Index y Offset

Datos:
Memoria física de 16 bits → Dirección = 16 bits
Cache física de 512 bytes → S = 512 bytes = 0,512 kb
Mapeo Directo → m = 1
Líneas de 32 bytes → L = 32 bytes
C = S/L = 512/32 = 16

Geometria = (S, L, m) = (0,512 kb, 32 bytes, 1)

d = log2L = log2(32) = 5 bits = offset

i = log2 C/m = log2 (16/1) = 4 = index
t = dirección - d - i = 16-5-4 = 7 = tag

Luego, TAG = 7, INDEX = 4, OFFSET = 5.

c)
La matriz ocupa 16x 16 x 4 bytes = 1024 bytes
Sabemos que:
L = 32 bytes (tamaño de línea)

Cantidad de bloques = tamaño de caché / tamaño de línea

Entonces 1024 bytes / 32 bytes = 32 bloques.

Dirección base A = 0A20 H

N = 16
Posición en memoria = dirección_de_base_de_A + (j* N + i) *
tamaño elemento

Dirección base de la matriz 0A20

0000 1010 0010 0000
la dirección del bloque de memoria donde se guardan las primeras
celdas de la matriz es 0000 1010 001
Segunda celda:
dirección_de_base_de_A + (j* N + i) * tamaño elemento
[i][j]:[0][1] : 0A20 H + (1*16 (10H) +0) * 4 = 101 0011 00000 → INDEX 3
0A60

Cada bloque guarda 8 celdas

COLUMN-MAJOR
ROW-MAJOR

Finales del 31/8/21

Final 1 (promoción)
Final 2 (Promoción)
Final 3 (promoción)
Final 4 (Regular)