Memoria virtual

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

Datos: Espacio virtual = 2^32
Memoria RAM limitada por hardware (por ej 16 MiB)
Si 1 MiB = 2^20 bytes → 16 MiB = 16 x 2^20 bytes = 16.777.216 bytes

Respuesta: Dirección física= log2(espacio direccionable en bytes)=

= log2(16.777.216) = 24 bits

b)
Datos: Espacio virtual -> 2^32 bytes
Memoria RAM limitada por hardware -> 16 MiB
Tamaño de dirección física -> 24 bits

1
Para que la tabla de páginas entre en una página entonces:
tabla de páginas <= tamaño de página

Para sacar el tamaño de página se debe hacer

Tamaño de página: espacio virtual / cantidad de páginas
2^32 / cantidad de páginas

Cantidad de páginas = 2^(num pág) = 2^(dirección lógica-offset) = 2^(32-offset)

Tamaño de la tabla de páginas es = ((numero de frame + 2(bits extra))*cantidad

de páginas)
Número de frame = 24 - offset (ya que la dirección física es 24). PONE NÚMERO
DE FRAME XQ EN LA TABLA DE PÁGINAS SE ALMACENAN NÚMEROS DE FRAME.

Entonces, en función del offset, la ecuación sería

(((24-offset) + 2) * 2^(32-offset) <= 2^32 / = 2^(32-offset)
tabla de páginas <= tamaño de página
c)
4KiB = 4096 bytes = 2^12, donde 12 = offset

((24-12+2)*2^(32-12) <= 2^32 / 2^32-12

14680064 bytes <= 4096 bytes

Luego, la tabla de páginas no entra en una página.

Una estrategia para solucionar ese problema sería implementar la tabla de

páginas con multinivel. Esta sirve para evitar la sobrecarga de traer una
tabla de páginas de gran tamaño a la memoria ya que la paginación se
aplica en las tablas de página y, en lugar de traer todas las tablas de página
a la memoria, las páginas de la tabla de página se llevan a la memoria
principal. La paginación multinivel se realiza hasta que se alcanza el nivel
en el que se puede almacenar toda la tabla de páginas en una sola página.

2
Otra opción podría ser la tabla de páginas invertida. En este tipo de
implementación hay una entrada por cada frame de la memoria principal.
Por lo tanto, en el sistema solo habrá una tabla de páginas invertida y esta
solo tendrá una entrada por cada frame en la memoria física. La principal
ventaja es que reduce la memoria física ocupada por la tabla de páginas
(reduce el tamaño de la tabla de páginas). Luego, al ser la tabla de menor
tamaño, esta podría llegar a entrar en una sola página.

Página -> 2048 bytes = L (tamaño de la línea)

Espacio lógico -> 8192 páginas
Espacio físico -> 128 frames

a) offset = log2(L) = log2(2048 bytes) = 11 bits

b) 128 frames = log2(128) = 7 = número frame

Dirección física = número de frame + offset = 7 + 11 = 18 bits

8192 páginas = log2(8192) = 13 bits = número página

Dirección lógica= numero pagina + offset =13 + 11 = 24 bits

3
 c) 80% de 1720 → 0,8 x 1720 = 1376 x 2 bytes =2752 bytes
20% de 1720 → 0,2 x 1720 = 344 x 4 bytes = 1376 bytes

2752 + 1376 = 4128 bytes tamaño del texto.

Como cada página ocupa 2048 bytes entonces
4128 / 2048 = cant de páginas que ocupara el texto = 2,01 páginas

Luego, se necesitarán como mínimo 3 páginas.

d)
TLB = cantidad de entradas x (TAG + VALOR(numero de frame,
bit de valido, etc))
= cantidad entradas TLB x (número páginas + número frame +
bits extra)
= 10 x (13bits + 7bits) = 200 bits para 10 entradas TLB

Tamaño en bytes = 200 / 8 = 25 bytes.

Asumiendo que no hay bits extras como por ejemplo bit de valido, dirty
bit, etc.

Punto extra:

d. Si el mapeo entre páginas y frames se almacena en una tabla de

páginas convencional con 5 bits adicionales por cada entrada (1 bit
de válido, 1 bit de dirty y 3 bits de protección que necesita el sistema
operativo), ¿cuál es el tamaño de la tabla de páginas? ¿esta tabla
presenta algún inconveniente a la hora de implementarla? En caso de
una respuesta afirmativa a esta última pregunta, ¿cómo podría
solucionarse?

d)
Tamaño de la tabla de páginas = (número de frame + BITS EXTRA) x cantidad pág

Número de frame = log2(128) = 7

Bits extra = 5

4
Cantidad de páginas = 8192

Luego:
Tamaño de la tabla de páginas = (7 + 5) x 8192 = 106496 bits = 13312 bytes
= 6,5 páginas

El inconveniente que presenta es que posee un gran tamaño; la desventaja

de esto es que en la paginación, la tabla de páginas se almacena en
memoria principal ocupando un espacio considerable. Por lo tanto es
conveniente que la tabla de páginas sea de un menor tamaño. Esto se
puede solucionar aplicando paginación multinivel o tabla de páginas
invertida (descrito en página 3).

5
a) 1 MiB = 2^20
8 MiB = 8 x 2^20 = 8388608 bytes espacio físico direccionable.
dirección física = log2(8388608)= 23 bits

b) Espacio Virtual = 2^32

Páginas de 4KiB = 4096 bytes
log2(4096) = 12 = offset

La cantidad de páginas = 2^(32-12) = 2^20 =1 048 576 páginas.

c) 1 MiB = 2^20
8 MiB = 8 x 2^20 = 8388608 bytes espacio físico direccionable (MEMORIA
PRINCIPAL)
tamaño página <-> tamaño de frame = 4096 bytes
Cant frames = tamaño mem ppal / tamaño pag
= 8388608 / 4096 bytes = 2048 frames

FORMA MÁS SIMPLE DE HACERLO:

Cantidad de frames = 2^número de frame

Número de frame = dirección física - offset = 23 - 12 = 11

Por lo tanto, Cantidad de frames = 2^11 = 2048 frames

d) Número de frame = Dirección Física - Offset = 23 bits - 12 = 11 bits

Dirección lógica = 32 (porque dice que el espacio virtual = 2^32)

Numero de pagina = 32 - 12 = 20 bits

e) Si tuviera un mapeo directo entre páginas y frames indirectamente estaría

obligado a tener la misma cantidad de páginas y frames.

6
 El mapeo al utilizar los últimos bits de la página reduce la cantidad de
páginas, esto es, reduciendo las direcciónes lógicas para memoria física y
disco. A su vez reduce la cantidad de frames en función de la RAM
disponible, resultando en que la tabla no podrá representar todas las
direcciones físicas necesarias para cubrir el hardware.

F) Datos: Páginas de 4KiB = 4096 bytes

log2(4096) = 12 = offset
Bits extra = 2
Direccion logica = log2(2^32) = 32 bits
Dirección física = log2( 8388608) = 23 bits
Número de Frame = Dirección Física - Offset = 23 - 12 = 11
Cantidad de páginas = 2^(dirección lógica-offset) = 2^(32 - 12) =2^(20)

Tamaño de tabla de páginas = (número de frame + BITS EXTRA) x cant pág

= (11+2) x 2^20 = 13.631.488 bits = 17.039 bytes = 16.639648 KiB

g) 0.016249657 MiB -> 17.039 bytes

8 MiB ->

Con la tabla de páginas solo puedo direccionar 0.016249657 MiB,

quedando los (8 MiB-0.016249657 MiB) de la memoria RAM restantes sin
poder ser direccionados.

^^dudoso^^

7
1) Dirección virtual = 25 bits
Dirección física = 22 bits
Tamaño de página = 2^16 bytes
Cada entrada de la tabla tiene: numero de frame, bit de valido y dirty bit.

Tamano de tabla de páginas = (número de frame + BITS EXTRA) * cant pág

Número de frame = Dirección física - Offset = 22 - 16 = 6 bits

Offset = log2(tamaño de página) = log2(2^16) = 16 bits

Cantidad de páginas = 2^número de página = 2^9 = 512 bits

Numero de pagina = Direccion logica - Offset = 25 - 16 = 9 bits

Por lo tanto:
Tamano de tabla de páginas = (número de frame + BITS EXTRA) x cant pág
= (6 + 2) x 512 = 4096 bits = 512 bytes

2) Porque es costoso a nivel de hardware reducir el tamaño de las páginas

Menor tamaño de página → más páginas → la tabla de páginas ocupa más →

cuesta más hardware y más espacio en memoria principal.

3) En caso de necesitar un dato de la memoria principal, primero lo busco en la

caché con la dirección virtual, en caso de no estar ahí, con esa dirección busca en
la tabla de páginas y de ahí a memoria principal. Así podrían trabajar en conjunto
con las direcciones virtuales.

4) Si es posible, para esto el número de tag debería ser igual al número de página ya
que si son iguales podría buscar al mismo tiempo en caché y en tabla de páginas.
Si no fuese así, primero debería buscar en caché con el tag, y recién ahí, si el tag
no se encuentra en cache, tendría que buscar en la tabla de paginas con el
numero de pagina.

8
Además de las políticas LRU y Pseudo-LRU en caché, otras políticas de
reemplazo pueden ser First-in-First-Out (FIFO) o Random. Una política
FIFO reemplaza el bloque que está hace más tiempo en la caché,
independientemente de cuán recientemente haya sido accedido. La
política Random elige al azar una bloque para reemplazar.

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

Justifique
b) Describa un caso en el que una política FIFO sea mejor que una
LRU.
c) Indique qué información adicional debería almacenar la cache
para poder implementar una política FIFO y como se actualizaria
en el caso de un acceso y en el caso de un reemplazo.

a)
FIFO:
Ventajas:
● Es más económico de implementar ya que no necesita de un bit
U, como en el caso del LRU.
● Si el bloque menos accedido es el que lleva más tiempo en
caché, entonces es conveniente que se elimine.
● Mantiene los datos recientemente accedidos.
Desventajas:
● Al no llevar un control de los bloques menos recientemente
usados, es posible que se eliminen bloques que usan
constantemente, generando así, que haya que ir a buscarlos a
memoria principal cada vez que se los necesite; lo cual es muy
costoso.
● Poco eficiente, ya que no ahorra accesos a memoria.
● Puede generar PAGE FAULT temprano.

9
RANDOM:
Ventajas:
● Posee las ventajas de que por un lado su implementación
requiere un mínimo de hardware y por otro lado no es
necesario almacenar información alguna para cada bloque.
● Bajo costo.
● Poco consumo de recursos.
● Útiles para sistemas con poder de procesamiento limitado.
● Al ser al azar existe la posibilidad (en un caso ideal) de que se
reemplacen siempre los datos que no van a ser necesarios
próximamente (aunque esto es un caso poco probable).
Desventajas:
● No es eficiente.
● Es posible que se reemplacen datos útiles.
● Mayor Miss Rate y Menor Hit Rate con respecto a otras
políticas.

b) FIFO es más conveniente que LRU en el caso de que la caché no necesite

acceder a un mismo bloque varias veces, sino que acceda a este una única
vez y luego pueda ser descartado inmediatamente.

c) Para que la caché implemente una política FIFO es necesario saber cual
es la cabeza y cual es la cola de la Cola de caché. De este modo podremos
saber cual es el bloque hay que eliminar (cabeza) y cual es el bloque donde
hay que insertar el nuevo elemento (cola). El sistema operativo se encarga
de realizar un seguimiento de todas las páginas de la memoria en la cola,
por lo que no es necesario que la caché deba almacenar algún tipo de
información extra como por ejemplo el bit U en la política Pseudo LRU.

COMO SE ACTUALIZA EN EL CASO DE UN ACCESO Y REEMPLAZO:

El algoritmo FIFO mantiene una cola de objetos en el orden que fueron
insertados en el caché. Tras una falta de caché, desaloja uno o más objetos
de la cabeza e inserta un nuevo objeto en la cola de la cola.

10
11
1)¿Cuál es el tamaño en bytes de cada página?
Tamaño en bytes de cada página = 2^8 = 256 bytes

¿En cuantos frames se puede dividir, como máximo, el espacio de

direccionamiento físico?
Dirección Física = Número de frame + Offset
Como dice que tenemos 8 bits de desplazamiento entonces Offset = 8.
Por enunciado, Dirección Física = 16 → núm frame+offset
16 → num frame + 8
16-8 = num frame
8 = núm frame
El número de frames es de 8 bits
Frames = 2^8 = 256 frames

¿Cuántas páginas tiene el espacio de direccionamiento lógico?

Dirección Lógica = Número de página + Offset
Como dice que tenemos 8 bits de desplazamiento entonces Offset = 8.
Por enunciado, Dirección Lógica = 24 → núm pagina + offset
24 = núm página + 8
24 - 8 = núm página
16 = núm página
Páginas = 2^16 = 65536 páginas.

2) Texto de 640 caracteres ASCII → 8 bits por carácter.

Tamaño en bytes de cada página = 2^8 = 256 bytes

Cantidad de páginas en las que se divide un fragmento de texto = Tamaño de

texto / tamaño de página

= 640 x 8 bits / 256 bytes = 2,5 = 3 páginas en ASCII

En UTF-32 → cada carácter ocupa 32 bits:

Texto de 640 caracteres en UTF-32 = 640x32 bits = 20480 bits = 2560 bytes
Cantidad de páginas en las que se divide un fragmento de texto = Tamaño de
texto / tamaño de página

= 2560 bytes / 256 bytes = 10 páginas en UTF-32.

12
3) El bit U es el bit de “Último usado” e indica cuál “way” fue el menos
recientemente usado, se utiliza para llevar a cabo el algoritmo de reemplazo LRU.

4)
L = 32 bytes (Memoria caché con 8 líneas de 32 bytes)
d = log2(32) = 5
M = 2 ( 2 way associative)
C = 8 (cant de líneas de la caché 8)

Tag = 16-2-5 = 9 bits

Index = log2(C/M) = log2(4) = 2 bits
Offset = 5 bits

R1 ← Mem[010802 H]

Primero ingreso a la tabla TLB y busco la dirección 010802 H.

En este caso como 0108 H es traducido a 14 H, entonces

la dirección resultante es 14H seguido de lo que restaba de 010802
H → 14 02 H y además hay TLB HIT.

Paso 14 02 H a binario = 0001 0100 0000 0010

Tag Index Offset
Index = 00 → 0 (decimal)
Tag = 000101000 → 50 (octal)
Offset = 00010 → 2 (decimal)
Ahora voy a cache, entro a la línea 0 (index 0) y me fijo el Tag = 50.

Como el bit de válido es 1,

procedo a buscar el byte
número 2 dentro de Data
(ya que el offset
direcciona al byte 2),
como lo encuentro, ocurre
un HIT.

13
Finalmente obtengo la letra “u” (referenciada por el byte 2) y la guardó en
memoria de R1 (R1 ← ‘u’).

Mismo razonamiento para cada uno…

5) 010A4F

Me fijo en tabla TLB la dirección 010A que está traducida como A1 H

Busco en caché la dirección A14F H (A seguido de lo que resta de la dirección).

Para eso la paso a binario:

A14F H = 1010 0001 0100 1111

Tag Index Offset

Tag = 1 0100 0010 = 502 (octal)

Index = 10 = 2 (decimal)
Offset = 1111 = 15 (decimal)

Procedo a buscar en la línea 2 (ya que index = 2) y el Tag = 502. Como ocurre que
ese tag no se encuentra dentro de la línea de caché ocurre un Miss.

14
PIPELINE

Suponiendo el siguiente escenario para una implementación simple del pipeline

de 5 etapas:
● Predicción de Branch y branch target buffer con 20% de predicciones
erróneas.
● Hay forwarding sólo para datos generados por operaciones aritméticas y
todos los demás conflictos se resuelven con stall.
● Tanto las instrucciones Branch como Jump actualizan el PC en la etapa
Memory.
● De las instrucciones, 30% son load, 10% son branch y 2% son jump.

a) Calcule qué porcentaje debe haber de load seguidos de una instrucción

que usa el dato para obtener un speed up de 4 en comparación de una
implementación de pipeline.
b) Si se mejora el hardware agregando forwarding también para datos leídos
de memoria y adelantando a la etapa de Decode la resolución de los Jumps.
¿Cuál es el Speed Up de esta implementación en comparación a la
anterior?

15
a) Datos:

Como Branch y Jump actualizan el PC en Memory entonces tenemos 3

ciclos perdidos.
Ciclos: F D EX M WB

● Branch con 20% de predicciones erróneas

● De las instrucciones 10% son branch y 2% jump

De las instrucciones, 30% son load

Hay forwarding sólo para datos generados por operaciones aritméticas y
todos los demás conflictos se resuelven con stall (no hay forwarding para
Load), por lo tanto hay 2 ciclos stall.

F D E M WB instrucción que hace load de un registro r1

F D DS DS E M WB instrucción que utiliza el registro r1
No hay forwarding, debo esperar al WB

Load seguidos de una instrucción que usa el dato = X

branch + jump + load

Ciclos de Stall = (0,1 * 0,2 * 3) + (0,02 * 3) + (0,3 * X * 2)

SpeedUp = 4 (enunciado a)
Etapas pipeline = 5
CPI ideal = 1

Speedup = CPI iDEAL * PROFUNDIDAD DEL PIPE

--------------------------------------------
CPI IDEAL + CICLOS STALL

4 = __ 1 x 5____________________________
1 + (0,1 * 0,2 * 3) + (0,02 * 3) + (0,3 * X * 2)

16
 4 = 5 / 1 + (0,06) + (0,06) + (0,6X)
4=5/(1,12) + (0,6X)
4*[(1,12) + (0,6X)]=5
4,48 + 2,4X = 5
2,4X = 0,52
X=0,21

Luego, el porcentaje de loads seguidos de una instrucción que usa el dato para
obtener un SpeedUp de 4 es del 21%.

b) Datos:
Se adelanta a la etapa de Decode la resolución de los Jumps

Entonces, tenemos 1 ciclo perdido para jump.

Ciclos: F D EX M WB

Como Branch se actualiza en Memory, sigo teniendo 3 ciclos perdidos.

Se agrega forwarding también para datos leídos de
memoria, entonces:
→ instrucción que hace load de un registro r1
→ instrucción que utiliza el registro r1 (obtengo el
dato en M, no debo esperar al WB).

R1 [a+b] F D E M WB
load[R1] F D DS E M WB → Instrucción que hace load de un registro R1

1 ciclo de Stall para Load

*Asumo que puedo utilizar el dato obtenido en a)

Ciclos de Stall = (0,1 * 0,2 * 3) + (0,02 * 1) + (0,3 * 0,21 * 1)

Speed Up = 5 / 1 + (0,1 * 0,2 * 3)+ (0,02)+ (0,3 * 0,21)

Speed Up = 5 /1,143
Speed Up = 4,37
El Speed Up es de 4,37, es decir, un 0,37% más que en el anterior.

17
 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 las demás instrucciones

Datos que necesito:

CPI IDEAL
Stall de BRANCH: (La T es de taken y NT not taken)
● NT/PNT → predijo correctamente. → 0 CICLOS
● T/PT → predijo correctamente (TOMADO) → 1 CICLOS
● NT/PT → predijo erróneamente → 2 CICLOS
● T/PNT → predijo erróneamente (TOMADO) → 2 CICLOS
Stall de las demás instrucciones.

18
b) CPI BASE: 1.2
20% instrucciones son branch de los cuales 65% son branch tomados.
35% son branch NO tomados.
Unidad de predicción de branch predice erróneamente 12% veces.
Unidad de predicción de branch predice correctamente 88% veces.

%T/PT = 1 ciclo x 0.65 x 0.88

%NT/PT =2 ciclos x 0.35 x 0.12
%T/PNT =2 ciclos x 0.65 x 0.12
%NT/PNT = 0 ciclos (no lo tengo en cuenta)

*CPI Base= CPI Ideal + Ciclos stall de las demás instrucciones

CPI = CPI Ideal + Ciclos stall por instrucción

CPI = CPI Ideal + Ciclos branch + Stall de las demás instrucciones
CPI = 1,2 + Ciclos branch
CPI = 1,2 + 0,2 x
[(0*0,35*0,88)+(1*0,65*0,88)+(2*0,35*0,12)+(2*0,65*0,12)]
CPI = 1,2 + [0,1624] = 1,3624 :D

c)
%NT/PNT = 0 ciclos (no lo tengo en cuenta)
%T/PT = 2 ciclo x 0.65 x 0.88
%NT/PT =3 ciclos x 0.35 x 0.12
%T/PNT =3 ciclos x 0.65 x 0.12

CPI = 1,2 + 0,2 x

[(0*0,35*0,88)+(2*0,65*0,88)+(3*0,35*0,12)+(3*0,65*0,12)]
CPI = 1,2 + [0,3008] = 1,5008

CPI ANTERIOR = 1,3624

CPI ACTUAL = 1,5008

Paso las frecuencias de reloj a Nanosegundos:

500 MHZ = 0,5 ghz = 1/0,5 = 2 ns *El tiempo en ns es 1/Ghz
600MHZ = 0,6 ghz = 1/0,6 = 1,67 ns

19
 Tiempo de mejora = CPI * Tiempo en ns
1,3624 x 2 ns = 2,7748
1,5008 x 1,67 = 2,5063

Calculo el tiempo de cada uno (B siendo la mejora de A):

TiempoDeA/TiempoDeB = 2,7748/ 2,5063 = 1,087

a) 4 MHz = 4 millones de ciclos por segundo

Ciclos por segundo / CPI = cant instrucciones por seg
4 millones /1.6 = 2500000 instrucciones por seg

b) Controlar mouse 30 veces por seg

1500 instrucciones
CPI 2.5

Ciclos por segundo / CPI = cant instrucciones por seg

4 millones/2.5 = 1600000 instrucciones por seg

1500 instrucciones /1600000 instrucciones por 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 segundos se pierden por segundo en

controlar el mouse.
¿Es significativa?

20
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

CACHE

21
 a) Tamaño de caché = 4 KB = 4096 bytes
Tamaño de lineas = 16 bytes
Cantidad de líneas = 4096/16 = 256 líneas de caché.

b) La dirección física se divide en: TAG INDEX OFFSET

Datos:
L = 16 bytes
m=1
C = 256
Dirección: como las direcciones físicas tienen 8 bits en hexa (0000 4000
H), y cada bit en hexa ocupa 4 bits, entonces 8 x 4 = 32. Por lo tanto, las
direcciones son de 32 bits.

Offset = d = log2(L) = log2(16) = 4 bits

Index = i = log2(C/m) = log2(256/1) = 8 bits
Tag = direccion - i - d = 32 - 8 - 4 = 20 bits

c) Tamaño de arreglo = 1024 x 4 bytes = 4096 bytes

Tamaño de línea = 16 bytes

Cantidad de bloques = 4096 / 16 = 256 bloques

Set correspondiente a cada bloque:

Direccion de A[0] = 0000 4000 H

= 0000 0000 0000 0000 0100 0000 0000 0000
Tag Index Offset

El arreglo A va desde el bloque 0 al 255, como su index comienza en 0 entonces:

Bloque 0 → index = 0
Bloque 1 → Index = 1
…
Bloque 255 → Index = 255

En forma genérica: Bloque n (A)→ Index = n , donde 0 <= n < 256

22
El index indica el set al que corresponde cada bloque/línea.
Dirección de B[0] = 0001 0800 H
= 0000 0000 0000 0001 0000 1000 0000 0000
Tag Index Offset

El arreglo B va desde el bloque 0 al 255, como su index comienza en 128 (1000

0000 (2)) entonces:

Bloque 0 → index = 128

Bloque 1 → index = 129
…
Bloque 127 → index = 255
Bloque 128 → Index = 0
...
Bloque 255 → index = 127

d) La cantidad de fallos por lectura y escritura =

(1 miss) x cant bloques A + (1 miss) x cant bloques B = 512 miss

Ya que por cada bloque de A y B, habrá un Miss (en el primer acceso a caché
ya que esta comienza vacía) y 3 Hits debido a que cuando se lleva todo un
bloque hacia caché, en los siguientes 3 ciclos del for, los datos que se
buscan ya van a estar dentro de caché (en cada bloque entran 4 enteros).

EN EL DIBUJO LA MITAD DE LA CACHÉ

ESTÁ EN LA LÍNEA 127 EN REALIDAD.

Si el grado de asociatividad hubiese sido 2, el index, en vez de ser log2(256/1) =

8, sería log2(256/2) = 7. Por lo tanto, cambiaría la cantidad de líneas en caché a
la mitad (de 0 hasta 127 (1111 1111 1 = 127)), dividiéndose en 2 sets por línea.
Sin embargo esto no cambiaría la cantidad de Miss y Hits, solamente afectará a la
manera en la que se distribuyen los datos.

23
e) En memoria principal se escribieron 4096 bytes, ya que como hay una
política Writeback, cada vez que se quiera modificar un dato de un bloque
que ya fue accedido, para no perder esa modificación, se hace una copia
en memoria principal y luego se procede a hacer el reemplazo en caché.
Como en caché entran 4096 bytes, y cada arreglo es también de 4096
bytes, es por eso que a partir de la mitad de cada arreglo los datos se van a
ir reemplazando dentro de la caché y haciendo una copia en memoria
principal.

24