Arquitectura de

computadoras

Final

2021
 Índice
Ejercicio integrador: 3

Final 1 PL 10
Pipeline y speedup 11

A) Pipeline de 5 etapas ⇒ F D E M WB 11

Memoria virtual 14
Memoria virtual 18
Ejercicio memoria virtual 18

Matrices 21
Ejercicio de matriz 21

For 24
Reloj / CPI / Frecuencia 28

Ejercicio de final: Sumador 32

Sumador 1 32

Final 25/2/22 (Presencial) 34

Coloquio Ejercicio 1 38
Ejercicio 2 42
Ejercicio 3 43

2
Ejercicio integrador:
Suponiendo el siguiente escenario:
• Direccionamiento al byte.
• Dirección física de 16 bits y dirección lógica de 24 bits
• Memoria virtual implementada con paginación. Los últimos 8 bits de la
dirección representan el desplazamiento dentro de la página → tamaño
del offset.
• Memoria caché física, 2-way set associative, con 8 líneas de 32 bytes
de datos, implementada con políticas de escritura writeback y
write-allocate y reemplazo LRU.
- writeback es política de escritura cuando esta en caché
- write-allocate es política de escritura cuando NO está en cache
Si se cuenta con el fragmento de memoria principal del cuadro 1, que
comienzan en la dirección lógica 010800H y es un texto de 640
caracteres ASCII, un TLB de solo 4 entradas inicializado como indica el
cuadro 2 y una caché física inicializada como indica el cuadro 3.
1. ¿Cuál es el tamaño en bytes de cada página? ¿En cuántos frames se
puede dividir como máximo el espacio de direccionamiento físico?
¿Cuántas páginas tiene el espacio de direccionamiento lógico?

2. ¿En cuántas páginas se dividiría el fragmento de texto? Indique y

calcule qué cambiaría si el texto estuviera codificado en UTF-32, donde
cada carácter ocupa 32 bits.

3. Explique cuál es la semántica del bit U en esta caché y qué indica.

4. Indique los valores finales de los registros y explique qué cambios

ocurren en la memoria y en la caché al ejecutar la siguiente secuencia
de instrucciones. Muestre cómo queda finalmente la caché. Desde el
cuadro 1, obtengo lo que va en caché y me desplazo para poder
reemplazar
▪ R1 ← Mem[010802H]
▪ R2 ← Mem[010822H]
▪ Mem[010845H] ← “%”
▪ Mem[010913H] ← “$”
▪ Mem[010983H] ← “&”
▪ R3 ← Mem[0108D2]
▪ R4 ← Mem[010953]
▪ R5 ← Mem[0109E3]

5. Indique qué ocurre si se accede a la dirección 010A4F

6. Si los accesos a memoria caché exitosos (o determinar que hay un

fallo) demoran 1 ciclo y los accesos a memoria principal para leer o
escribir un bloque demandan 100 ciclos, ¿cuánto demora la etapa
Memory en cada una de las instrucciones anteriores? EXPLICADO EN
CONSULTA DANA 24/8

3
Cuadro 3, bit D. Es el dirty bit. Esto indica que modificaste esa línea de cache, lo que implica es que no es
igual a lo que tenes en memoria principal.

1. ¿Cuál es el tamaño en bytes de cada página? ¿En cuántos frames se puede dividir como
máximo el espacio de direccionamiento físico? ¿Cuántas páginas tiene el espacio de
direccionamiento lógico?

Paginación:
- Tamaño de página en bytes: 2^(offset)
- Los últimos 8 bits de la dirección representan el desplazamiento dentro de la página (offset)
- → tamaño de página en bytes: 2^(8) = 256 Bytes

Espacio de direccionamiento físico = 2 ^ (dirección física) = 2 ^ 16 = 65536 Bytes

→ cantidad de frames = espacio de direccionamiento físico / el tamaño del frame (pagina) =
65536 Bytes / 256 Bytes = 256 páginas / frames

Espacio de direccionamiento lógico = 2 ^ (dirección lógica) = 2^24 = 16777216 Bytes = 16384 KB = 16 MB

Cant de páginas = espacio de direccionamiento lógico / tamaño de la página o frame

= 16777216 Bytes / 256 Bytes = 65536 páginas

2. ¿En cuántas páginas se dividiría el fragmento de texto? Indique y calcule qué cambiaría si el texto
estuviera codificado en UTF-32, donde cada carácter ocupa 32 bits.

Datos:
- 640 caracteres ASCII → cada carácter ASCII ocupa 1 byte
- 640 caracteres x 1 byte = 640 bytes ocupa todo el texto

640 bytes de texto / 256 bytes tamaño de página = 2.5 páginas → redondeo a 3 páginas

Datos:
- 640 caracteres UTF-32 → cada caracter UTF-32 ocupa 32 bits
- 640 caracteres x 4 bytes (32 bits) = 2560 bytes ocupa todo el texto

2560 bytes de texto / 256 bytes tamaño de página = 10 páginas

3. Explique cuál es la semántica del bit U en esta caché y qué indica.

El bit U indica cuál de las 2 líneas del conjunto es la última que hace más tiempo que no se usa. (la menos
usada recientemente) (Least Recently Used)
Indica en qué Way se debe modificar la línea de caché.
Si U = 1, se debe modificar el way 1. Si U = 0, se debe modificar el way 0.
4
4. Indique los valores finales de los registros y explique qué cambios ocurren en la memoria y en la
caché al ejecutar la siguiente secuencia de instrucciones. Muestre cómo queda finalmente la caché.
Desde el cuadro 1, obtengo lo que va en caché y me desplazo para poder reemplazar
▪ R1 ← Mem[010802H]
▪ R2 ← Mem[010822H]
▪ Mem[010845H] ← “%”
▪ Mem[010913H] ← “$”
▪ Mem[010983H] ← “&”
▪ R3 ← Mem[0108D2]
▪ R4 ← Mem[010953]
▪ R5 ← Mem[0109E3]

Datos de la caché:
- S (tamaño de caché) = L x C = 256 Bytes
- L (tamaño de línea) = 32 Bytes
- m (grado de asociatividad) = 2
- C (cantidad de líneas de caché) = 8 bytes

Luego,
- Offset: log2 (32 bytes) = 5 bits
- Index: log2 (8 lineas / 2) = 2 bits
- Tag: 16 - 5 - 2 = 9 bits
- Tamaño de dirección (física): 16 bits

A memoria cache física siempre se accede con la dirección física, para esto, dada una determinada
instrucción generada por el CPU (dirección lógica) tendríamos que pasar por el TLB para realizar el mapeo de
la dirección, esto es, cambiar el numero de pagina por el numero de frame y mantener el offset, de esta
manera obtenemos la dirección física para acceder a cache.

● Para la instrucción 1: R1 ← Mem[010802H] R1 = ‘u’

0108H → 14H = 14 02H

0101000 00 00010 → pasamos 01010002 a octal: 508 TAG

tag index offset

Tomamos los primeros cuatro valores de la dirección lógica y chequeamos si se corresponde con alguna
entrada del TLB. Comprobamos que sí, y traducimos 0108H a 14H. Formamos la dirección final (dirección física
= 1402H) y la convertimos a binario (010100000000102).
Con la dirección en binario, obtenemos el tag, el index y el offset, con la cantidad de bits calculados
previamente.
Luego, con el index chequeamos a que set pertenece de la caché y pasamos el tag a octal (508). Con el valor
del tag en octal, miramos si ese valor está almacenado en caché y si su información es válida (el bit V este en
1). Si todo esto se verifica, nos desplazamos la cantidad de bits que indique el offset, 3 bits en este caso en
particular.
Como último, comprobamos a qué bit de la línea de caché queda apuntando el offset (en la instrucción 1,
apunta al bit ‘u’).

5
 ● Para la instrucción 2: R2 ← Mem[010822H] R2 = ‘ e ‘

0108H → 14H = 14 22H luego lo pasamos a binario:

000101000 01 00010 → pasamos 01010002 a octal: 508 TAG

tag index offset
Como el bit de valido de la caché está en 0, esa dirección no es válida y no podemos acceder a su
información.
Por lo tanto se produce un miss.

Dirección física
| Nro. de frame | offset |
11 bits 5 bits
00010100001 00010

010822H = 100001000001 000102

Nosotros tenemos una memoria principal y queremos acceder a ella. Además, cada línea ocupa 32 bytes (2
oraciones). 32 en decimal, equivale a 20 en hexadecimal. Por este motivo, las líneas van pasando de 20 en
20.
Cuando queremos acceder a memoria tomamos la dirección en hexa y le sumamos y el desplazamiento.
Ejemplo → 010822 buscamos el 10820 (el inicio de la línea) y sumamos 2 de desplazamiento para llegar al bit
solicitado.

● Para la instrucción 3: Mem[010845H] ← “%”

0108H → 14H = 14 45H

14 45 H → 000101000 10 00101B
tag index offset

Luego pasamos el tag a octal para acceder a la caché

0101000B = 0508
Quedariamos en la quinta oración, caracter 5 → ‘d’

Cache Way 0 Way 1

Set Tag 0 V Data 0 D Tag 1 V Data 1 D U

0 050 1 Aquí_me_pongo a_ cantar_al 0 3278 0 a_vista;_pido_a_mi_Dios_que_me 1 1

compás

1 050 0 Mas_ande_otro_criollo_pasa_Martí 0 7508 1 _de_la_vigüela,_que_el_hombre_qu 0 0

2 0508 1 e_lo_%esvela_una_pena_estraordin 1 2748 1 _Santos_milagrosos,_vengan_todos 0 1

3 050 1 aria,_como_la ave_solitaria_con 0 2758 1 to_muchos_cantores,_con_mañas_ 1 1

bi

50 en octal es 28 hexadecimal.
0108H → 28H 28 45H = 001010000 10 00101B

6
TLB
0108H 28H 1

0109H B1H 0b

010AH A1H 0

0109H 5EH 1

Para obtener la clave-valor para la nueva entrada del TLB, tomamos el tag de la caché que está en octal y lo
convertimos a hexadecimal. Es decir, el paso inverso. Luego a eso, le concatenamos el resto de la dirección
de memoria (quedaría 28 45H).
Para la instrucción 3: formamos la dirección en hexa con la entrada del TLB (14 45H), la pasamos a binario
(0101000 10 00101B). Obtenemos el tag, index y offset. El tag lo pasamos a octal (0508). Luego, para
reemplazar en el TLB, transformamos el tag a hexadecimal nuevamente (508 → 28H) y armamos la nueva
entrada del TLB.
0108H 28H 1b

● Para la instrucción 4: Mem[010913H] ← “$”

0109H → 5EH = 5E 13H

5E 13H → 010111100 00 100112

tag index offset

tag = 010111100B → 2748 (no se encuentra en caché)

Entonces buscamos en MP, accedemos a la dirección 010913H , esto es, acceder al “bloque” 010900 y
desplazarte 13H posiciones, en decimal serían 19 posiciones y por lo tanto caemos en el carácter “a”
Ahora reemplazamos ese carácter por “$”.
Finalmente nos quedaría actualizar la memoria caché y luego el TLB.

Cache Way 0 Way 1

Set Tag 0 V Data 0 D Tag 1 V Data 1 D U

0 050 1 Aquí_me_pongo a_ cantar_al 0 3278 0 a_vista;_pido_a_mi_Dios_que_me 1 1

compás

1 050 0 Mas_ande_otro_criollo_pasa_Martí 0 7508 1 _de_la_vigüela,_que_el_hombre_qu 0 0

2 0508 1 e_lo_%esvela_una_pena_estraordin 1 2748 1 _Santos_milagrosos,_vengan_todos 0 1

3 050 1 aria,_como_la ave_solitaria_con 0 2758 1 to_muchos_cantores,_con_mañas_ 1 1

bi

Luego, antes de traer la dirección de MP y reemplazarla por lo que hay en la línea way 1 del set 0 de caché.
Como esa línea fue modificada anteriormente (D = 1) entonces hay que llevarla a MP. Para esto, pasamos el
tag = 3278 a hexadecimal, quedaría D7H y ahora armamos la dirección lógica: 0109D7H
Cómo 0109D7H está dentro del rango de 0109C0H y 0109E0H reemplazamos esa linea en memoria principal.

7
Cache Way 0 Way 1
Set Tag 0 V Data 0 D Tag 1 V Data 1 D U

0 0508 1 Aquí_me_pongo a_ cantar_al 0 2748 1 ria_me_refresquen_l$_memoria,_y_ 1 0

compás

1 0508 0 Mas_ande_otro_criollo_pasa_Martí 0 7508 1 _de_la_vigüela,_que_el_hombre_qu 0 0

2 0508 1 e_lo_%esvela_una_pena_estraordin 1 2748 1 _Santos_milagrosos,_vengan_todos 0 1

3 0508 1 aria,_como_la ave_solitaria_con 0 2758 1 to_muchos_cantores,_con_mañas_ 1 1

bi

En la dirección original de la línea que trajimos, la modificamos por la que estaba en caché
→ a_vista;_pido_a_mi_Dios_que_me

2748 → BCH 109H → BCH

TLB
0108H 28H 1

0109H B1H 0b

010AH A1H 0

0109H BCH 1

● Para la instrucción 5: Mem[010983H] ← “&”

BC 83 H → 101111001 00 00011
tag = 5718 index=0

Se produce un miss, entonces vamos a MP y traemos la línea al set 0 y way 0.

Cache Way 0 Way 1

Set Tag 0 V Data 0 D Tag 1 V Data 1 D U

0 5718 1 e_a&uda_y_se_me_turba_la_vista;_ 1 2748 1 ria_me_refresquen_l$_memoria,_y_ 1 1

1 0508 0 Mas_ande_otro_criollo_pasa_Martí 0 7508 1 _de_la_vigüela,_que_el_hombre_qu 0 0

2 0508 1 e_lo_%esvela_una_pena_estraordin 1 2748 1 _Santos_milagrosos,_vengan_todos 0 1

3 0508 1 aria,_como_la ave_solitaria_con 0 2758 1 to_muchos_cantores,_con_mañas_ 1 1

bi

8
 ● Para la instrucción 6: R3 ← Mem[0108D2]

28D2H → 1010001 10 100102

tag = 1218

Cache Way 0 Way 1

Set Tag 0 V Data 0 D Tag 1 V Data 1 D U

0 5718 1 e_a&uda_y_se_me_turba_la_vista;_ 1 2748 1 ria_me_refresquen_l$_memoria,_y_ 1 1

1 0508 0 Mas_ande_otro_criollo_pasa_Martí 0 7508 1 _de_la_vigüela,_que_el_hombre_qu 0 0

2 0508 1 e_lo_%esvela_una_pena_estraordin 1 2748 1 _Santos_milagrosos,_vengan_todos 0 1

3 0508 1 aria,_como_la ave_solitaria_con 0 2758 1 to_muchos_cantores,_con_mañas_ 1 1

bi

● Para la instrucción 7: R4 ← Mem[010953] : ‘ _ ’

0109H → BCH BC 53H → 101111000 10 10011

tag = 5708 index offset = 19

Tenemos un hit en el TLB, pero tenemos un miss en la caché cuando indexamos y buscamos el tag. Por lo
cual, hay que ir a memoria.

R4 = ‘_’

● Para la instrucción 8: R3 ← Mem[0109E3] : ‘ m ‘

0109H → BCH BC E3H → 101111001 11 00011
tag = 5718 index = 3 offset = 3

Tenemos un hit en el TLB, pero tenemos un miss en la caché cuando indexamos y buscamos el tag. Por lo
cual, hay que ir a memoria.
;;;;;;

5. Indique qué ocurre si se accede a la dirección 010A4F

Con la información original y/o modificada, se produce un miss en el TLB. Ya que su bit de validez está en
cero.
En estos casos, hay que ir con la dirección a la tabla de páginas y dejar que se encargue el sistema operativo
(ya que nosotros la tabla de páginas no la conocemos)

6. Si los accesos a memoria caché exitosos (o determinar que hay un fallo) demoran 1 ciclo y los
accesos a memoria principal para leer o escribir un bloque demandan 100 ciclos, ¿cuánto demora la
etapa Memory en cada una de las instrucciones anteriores?
Instruccion 1: 1 ciclo (hit)
Instrucción 2: 1 ciclo (miss) + 100 ciclos para leer el dato = 101 ciclos
Instrucción 3: 1 ciclo (miss) + 100 ciclos para leer el dato = 101 ciclos
Instrucción 4: 1 ciclo (miss) + 100 ciclos para leer el dato + 100 ciclos para escribir en MP = 201 ciclos
Instrucción 5: 1 ciclo (miss) + 100 ciclos para leer el dato = 101 ciclos
Instrucción 6: 1 ciclo (miss) + 100 ciclos para leer el dato = 101 ciclos
Instrucción 7: 1 ciclo (miss) + 100 ciclos para leer el dato = 101 ciclos
Instrucción 8: 1 ciclo (miss) + 100 ciclos para leer el dato = 101 ciclos
En total: 1 + 101 + 101 + 201 + 101 + 101 + 101 + 101 = 808 ciclos
9
Final 1 PL
Cache 4-way set associative:
- Cada conjunto tiene 4 líneas.
- Cada conjunto tiene 3 bits, B0,B1 Y B2.
¿Las 4 líneas del conjunto son válidas?
- Si

- ¿B0 = 0?
- Si. Entonces L0 o L1 son las menos usadas recientemente. ¿B1 = 0?
- Si. Reemplazo L0.
- No. Reemplazo L1.8
- No. Entonces L2 o L3 son las menos usadas recientemente. ¿B2 = 0?
- Si. Reemplazo L2.
- No. Reemplazo L3.
- No. Reemplazó la línea inválida.

1. Los bits B0, B1 y B2 sirven para saber qué línea es la menos utilizada recientemente. En particular el
bit B0 indica en qué par de líneas se encuentra la línea menos utilizada recientemente, ya sea el par
L0,L1 o el par L2,L3. Una vez que obtenemos el par, los bits B1 y B2 nos indican que línea exacta es
la menos utilizada recientemente para poder reemplazarla.

2. Dado que cada conjunto tiene 4 líneas, en

Pseudo-LRU no es posible determinar cuál es la línea
exacta menos utilizada recientemente haciendo uso de
un único bit, solo se puede determinar dentro de qué
conjunto de líneas está y después este algoritmo
reemplaza una línea al azar. En cambio, teniendo 3
bits, además de saber cual es el grupo en el que se
encuentra la línea menos utilizada recientemente es posible reconocer cual es la línea exacta.
10
Pipeline y speedup

1) A) Pipeline de 5 etapas ⇒ F D E M WB

𝐶𝑃𝐼 𝐼𝐷𝐸𝐴𝐿 * 𝑃𝑅𝑂𝐹𝑈𝑁𝐷𝐼𝐷𝐴𝐷 𝐷𝐸𝐿 𝑃𝐼𝑃𝐸

𝑆𝑝𝑒𝑒𝑑𝑢𝑝 = 𝐶𝑃𝐼 𝐼𝐷𝐸𝐴𝐿 + 𝐶𝐼𝐶𝐿𝑂𝑆 𝑆𝑇𝐴𝐿𝐿

● LOAD, el porcentaje de loads se multiplica por un X%, porque no me aclara el % de instrucciones

siguientes al load que utilizan el dato, y esto se multiplica por 2 ya que tengo que esperar 2 ciclos para
poder utilizar el dato (por ejemplo: si en el ciclo 5 se realiza la etapa de Memory y en el ciclo 6 la etapa
de WriteBack, recién voy a poder hacer uso del dato en el ciclo 7).
F D E M WB
F D stall stall E M WB (se pierden 2 ciclos, stalls = 2)

● BRANCH, el porcentaje de branches se multiplica por 20%, porque el 20% de las predicciones fallan,
y se multiplica por 3, porque el PC se actualiza en memory (se pierden 3 ciclos, FETCH, DECODE Y
EXECUTE).
F D E M WB
F D E -
F D - (se pierden 3 ciclos)
F -
F
● JUMPS, el porcentaje de jumps se multiplica por 3 porque el PC se actualiza en la etapa memory (se
pierden 3 ciclos, FETCH, DECODE Y EXECUTE) (no vamos a tener fallos de predicción porque los
jump son saltos incondicionales, entonces salta siempre, se multiplica por 100%).
F D E M WB
F D E -
F D - (se pierden 3 ciclos)
F -
F

La suma de todo esto, nos va a permitir saber el porcentaje de ciclos que se pierden (ciclos stall)

11
Ciclos de Stall:
- 30% load * X% * 2 = 0.6 * X%
- 10% branches * 20 % * 3 = 0.06
- 2% jumpss * 100% * 3 = 0.06
----------------------------------------
0,6 * X% + 0.06 + 0.06 = 0.6 * X% + 0,12

Profundidad del pipeline = 5, ya que el pipeline es de 5 etapas

CPI Ideal = 1, por la teoría.
Ciclos stall = ciclos perdidos.

𝐶𝑃𝐼 𝐼𝐷𝐸𝐴𝐿 * 𝑃𝑅𝑂𝐹𝑈𝑁𝐷𝐼𝐷𝐴𝐷 𝐷𝐸𝐿 𝑃𝐼𝑃𝐸

𝑆𝑝𝑒𝑒𝑑𝑢𝑝 = 𝐶𝑃𝐼 𝐼𝐷𝐸𝐴𝐿 + 𝐶𝐼𝐶𝐿𝑂𝑆 𝑆𝑇𝐴𝐿𝐿
= 4
1*5
𝑆𝑝𝑒𝑒𝑑𝑢𝑝 = 1 + 0.6 * 𝑋 + 0,12
= 4
5
𝑆𝑝𝑒𝑒𝑑𝑢𝑝 = 0.6 * 𝑋 + 1,12
= 4
5
𝑆𝑝𝑒𝑒𝑑𝑢𝑝 = 4
= 0. 6 * 𝑋 + 1, 12
5
𝑆𝑝𝑒𝑒𝑑𝑢𝑝 = 4
− 1, 12 = 0. 6 * 𝑋
𝑆𝑝𝑒𝑒𝑑𝑢𝑝 = 0, 13 = 0. 6 * 𝑋
0,13
𝑆𝑝𝑒𝑒𝑑𝑢𝑝 = 0,6
= 𝑋 = 0, 216 ⇒ 21, 6 %
Debe haber 21,6% de loads seguidos de una instrucción que necesita el dato para que el Speed
up sea de 4.

b)
Al agregar forwarding en las instrucciones que utilicen load, vamos a obtener el dato en la etapa de Memory
access (Mem) en vez de en la etapa Writeback (WB), por lo tanto se necesita un ciclo menos de Stall en
comparación al inciso a)
Como se adelanta a la etapa de Decode la resolución de los jumps, se pierde solo 1 ciclo (fetch)

- 30% load * 21,6% * 1 = 0.0648

- 10% branches * 20 % * 3 = 0.06
- 2% jumpss * 1 = 0.02
---------------------------------------------------------------
0,0648 + 0,06 + 0,02 = 0,1448

En los análisis anteriores se calculó el speedup de los sistemas A y B en comparación a un sistema sin
pipeline, pero el speedup es una medida de ganancia obtenida por mejorar un sistema. Si el sistema B es una
mejora del sistema A el speedup de esta mejora es:

Versión 2022

𝑅𝑒𝑛𝑑𝑖𝑚𝑖𝑒𝑛𝑡𝑜 𝑀𝑒𝑗𝑜𝑟𝑎𝑑𝑜 𝐸𝑋 𝐶𝑃𝑈 𝑂𝑅𝐼𝐺𝐼𝑁𝐴𝐿 4

Speedup =
𝑅𝑒𝑛𝑑𝑖𝑚𝑖𝑒𝑛𝑡𝑜 𝑂𝑟𝑖𝑔𝑖𝑛𝑎𝑙
= 𝐸𝑋 𝐶𝑃𝑈 𝑀𝐸𝐽𝑂𝑅𝐴𝐷𝑂
= 4.36
= 0. 91

12
2)

cambia el inciso b:
En este caso, además, se adelanta a la etapa de Execute la resolución de los branch, por ende se descartan
2 instrucciones (o ciclos) en vez de 3 como en el punto anterior.

JUMPS. Se resuelve en decode.

F D E M WB
F - (Se pierde 1 ciclo)
F
BRANCHS. Se resuelven en execute.
F D E M WB
F D - (Se pierde 2 ciclos)
F -
F
LOADS. Con forwarding
F D E M WB
F D stall E M WB (Se pierde 1 ciclo, hay 1 stall)

Ciclos de stall:
- 30% load * 21,6% * 1 = 0.068
- 10% branches * 20 % * 2 = 0.04
- 2% jumpss * 100% * 1 = 0.02
---------------------------------------------------------------
0,0648 + 0,04 + 0,02 = 0,1248
Luego:
1*5
𝑆𝑝𝑒𝑒𝑑𝑢𝑝 = 1 + 0,1248
= 4, 445

13
Memoria virtual

DATOS:
- tamaño de páginas = 2048 B → bloques de memoria de MS (memoria secundaria)
- tamaño de frames = 2048 B → bloques de memoria de MP
- tamaño frame = tamaño página

espacio lógico = 8192 páginas x 2048 B = 16777216 B → 16384 KB

espacio físico = 128 frames x 2048 B = 262144 B → 256 KB

a) (Cuando habla de bits de direccionamiento se refiere al desplazamiento → offset)

log2(tamaño de página o frame)
offset = log2(2048 B) = 11 bits

b) Dirección física = log2 (espacio físico)

Dirección física = log2 (262144 B)
Dirección física = 18 bits

Dirección lógica = log2 (espacio lógico)

Dirección lógica = log2 (16777216 B)
Dirección lógica = 24 bits

c) 1720 caracteres UFT-16

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

Cantidad de páginas que ocupa = (1376 caracteres * 2 B + 344 caracteres * 4 B) / 2048 ( ← tam. pag)
= 2.01 ⇒ 3 páginas

14
d) número de frame = dirección física - offset
número de frame = 18 bits - 11 bits
número de frame = 7 bits
Tamaño de la tabla de páginas = (número de frame + BITS EXTRA) x cantidad pág
= (7 + 5) x 8192 páginas
= 98304 bits → 12288 Bytes

Luego podemos obtener cuantas entradas tiene la tabla de páginas

12288 Bytes / 2048(tamaño de página) ⇒ 6 entradas

Uno de los inconvenientes es que la tabla de páginas se sitúa en memoria ram y ocupa espacio, y
todas las dirección lógicas deberían acceder al menos una vez para poder recuperar la dirección física
del frame. Entonces al implementarla dentro de la ram, tenemos esos costes de accesos a memoria
principal afectando gravemente a la performance del sistema, entonces la solución sería tener una
caché, separada de la memoria ram, llamada TLB que ayuda a tener las últimas direcciones utilizadas
siguiendo el funcionamiento de una caché típica. (Temas de políticas y demás).

El TLB básicamente es una memoria caché específica para almacenar una parte de la tabla de
páginas.

e) TLB = cantidad de entradas x (TAG + VALOR(numero de frame + bit de valido + etc))

TLB = 10 x (TAG + VALOR(numero de frame + bit de valido + etc))

número de frame = dirección física - offset

número de frame = 18 bits - 11 bits
número de frame = 7 bits

En paginación: TAG ⇒ número de página

número de página = dirección lógica - offset
número de página = 24 bits - 11 bits
número de página = 13 bits → tag

Tamaño del TLB = (tag + número de frame + bits extras) * 10

Tamaño del TLB = (13 bits + 7 bits + 5 bits) * 10 entradas
Tamaño del TLB = 250 bits = 31,25 Bytes ⇒ 32 Bytes

15
4)

Datos:
- Branch se resuelve en Execute cuenta con predicción de branchs en etapa Decode
- NT/PNT: 0 ciclos
- T/PT: 1 ciclo
- NT/PT, T/PNT: 2 ciclos

a. CPI = CPI IDEAL + Ciclos Stall por Instrucción

16
 ciclos stall = % de instrucciones qué son branch * (%de branch qué resultan en NT/PT, T/PNT * 2 + %
de branch qué resultan en T/PT * 1) * 1 + Ciclos stall de las demás instrucciones
Datos que necesito:
% de branches totales, % branches que se predicen erróneamente (NT/PT y T/PNT) y % branches
que se predicen correctamente (T/PT)

b. Datos:
CPIBASE = 1.2
20% de las instrucciones son branchs 65 % son tomados, 35% no tomados
predice erróneamente 12% de las veces, el 88 % predice correctamente

NT/PNT: 0
T/PT: 0.88 * 1 * 0.65 = 0.572
NT/PT: 0.12 * 2 * 0.35 = 0.084
T/PNT: 0.12 * 2 * 0.65= 0.156

CPI = 1.2 + (0.572 + 0.084 + 0.156) * 0.20

=1.2 + 0.812 * 0.20
=1.2 + 0.162
CPI = 1.362
c.
- NT/PNT: 0 ciclos
- T/PT: 2 ciclos
- NT/PT, T/PNT: 3 ciclos

NT/PNT: 0
T/PT: 0.88 * 2 * 0.65 = 1.144
NT/PT: 0.12 * 3 * 0.35 = 0.126
T/PNT: 0.12 * 3 * 0.65= 0.234

CPI = 1.2 + (1.144 +0.126 + 0.234) * 0.20

=1.2 +1.504 * 0.20
=1.2 + 0.3008
CPI = 1.5008

EXcpu(original) = CPI * Periodo del reloj

=1.362 * 1/0.5 Ghz
= 2.374 ns
EXcpu(mejorado) = CPI * Periodo del reloj
= 1.5008 * 1/0.6 Ghz
= 2.501 ns

𝑅𝑒𝑛𝑑𝑖𝑚𝑖𝑒𝑛𝑡𝑜 𝑀𝑒𝑗𝑜𝑟𝑎𝑑𝑜 𝐸𝑋 𝐶𝑃𝑈 𝑂𝑅𝐼𝐺𝐼𝑁𝐴𝐿

Speedup =
𝑅𝑒𝑛𝑑𝑖𝑚𝑖𝑒𝑛𝑡𝑜 𝑂𝑟𝑖𝑔𝑖𝑛𝑎𝑙
= 𝐸𝑋 𝐶𝑃𝑈 𝑀𝐸𝐽𝑂𝑅𝐴𝐷𝑂

Speedup = 2.374/2.501
= 0.949 → La razón de mejora es de 0.949

17
 Memoria virtual

Ejercicio memoria virtual

Datos:
- Direcciones virtuales: 25 bits
- Direcciones físicas: 22 bits
- Tamaño de página: 216 bytes ⇒ 65536 bytes ⇒ 64KB
- Cada entrada de la tabla de páginas contiene el número de frame + bit de valido + bit de dirty

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

Offset: Log2 (216) = 16 bits
número de frame = 22 - 16 = 6 bits

cantidad de páginas = 2(direccion logica - offset) = 2(25-16) = 29 = 512

Luego
Tamaño de la tabla de páginas = (6 bits + 2 bits(válido y dirty)) x 512 páginas
= 4096 bits
b.
antes: 65536 bytes
ahora: tamaño de página = 16KB ⇒ 16384 Bytes

Como se reduce el tamaño de página debe aumentar la cantidad de páginas, esto implica tener que
aumentar la cantidad de entradas en la tabla de página, para lo cual se requiere mayor cantidad de
hardware y aumenta el costo.

Respuesta 2022
Lo que variaría es como lo dividis. Tenes un offset más chiquito. Vas a tener más páginas. Usa una tabla de
páginas con un único nivel, (tabla de páginas enorme) implementada en hardware dedicado. Necesitas una
memoria SRAM más grande, ya que vas a tener una tabla de página con muchas entradas, entonces tenes
una tabla de página más grande.

La tabla de pagina seria 4 veces más grande, porque aumentó en 4 la cantidad de entradas, esto ocurre si
reduzco en 4 el tamaño de la página.
Para la tabla de páginas es “caro” tener muchas entradas, por lo cual, aumentar en cuatro la cantidad de
entradas incrementa el tamaño total de la tabla de páginas. Como tenemos hardware dedicado, necesitamos
más recursos para manejar el incremento de tamaño de la tabla de páginas (es decir, más RAM).

18
c y d)
Respuesta 2022
Concurrentemente no es posible ya que la memoria caché en esta caso es física, por lo tanto se necesita
obtener la dirección física para poder acceder. Por otro lado, a la tabla de páginas se puede acceder con la
dirección lógica, y en esta se genera la traducción a dirección física. Entonces, se necesita primero acceder a
la tabla de páginas para luego acceder a caché.
Para que sea posible lo enunciado deberíamos tener una cache lógica, a la cual se puede acceder con la
dirección lógica como en el caso de la tabla de páginas. Entonces, si se quiere buscar su frame se divide a la
dirección lógica en num de pagina y offset, mientras que para acceder a caché se divide la dirección virtual en
tag, index y offset. De esta manera, concurrentemente se está accediendo al set correcto (o comparando el
tag) y se está accediendo a la tabla de páginas, ya que ambas acciones se realizan con la misma dirección
virtual.

FINAL PL

2) Se tiene un sistema con paginado donde la dirección lógica es de 24 bits, y se direcciona al byte.
Las páginas tienen 1024 bytes. En total hay 64 frames.

Datos:
- Direccion logica = 24 bits
- Se direcciona al byte
- Tamaño de página = 1024 bytes → 2^10
- Cantidad de frames = 64

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

Podemos asumir un offset de 10 bits, ya que tenemos una página de 1024 bytes → 2^10

Direccion logica: nro de pagina | offset Necesito 14 bits para direccionar en la página
14 10

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

Dirección física: nro de frame | offset nro de frame: log2(cant frames) = log2(64) = 6
6 10

Tamaño de dirección física = 16 bits

19
 c) ¿Cuántas páginas tiene el espacio lógico?

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

2^(24 bits - 10 bits) = 2^(14) = 16384 páginas

El espacio lógico está compuesto de 16384 páginas

d) Se tiene un fragmento de texto 720 caracteres en UTF 32, cada carácter ocupa 32 bits. ¿Cuantas
paginas ocupará el texto si empieza en la dirección 010800H cuantas ocupa si empieza en la
dirección 010980h ?

Tenemos 720 caracteres en UTF-32, cada carácter ocupa 32 bits

720 caracteres x 32 bits = 23040 bits → 2880 bytes

Nuestra página almacena 1024 bytes

2880 bytes / 1024 bytes = 2,812 paginas → necesito una cantidad entera, 3 páginas

frame offset
010800H → 100001 000000000002

010980H → 100001 001100000002

Tamaño de nuestra página: 1024 bytes, cada carácter ocupa 4 bytes.

Entonces cada página almacena 256 caracteres.

Nuestra dirección lógica tiene un tamaño de 24 bits, es decir, 3 bytes.

010800H + 256 caracteres 010800H = 6758410

Tamaño de página = 1024 bytes.

Tamaño de texto = 2880 bytes.

Ya que nos desplazamos 96 bytes dentro de la página, empezamos a contar desde aca cuantas
páginas vamos a tener que utilizar para poder almacenar el texto.

1024 - 96 = 928 bytes

2880 bytes - 928 bytes = 1952 bytes nos faltan almacenar

1952 / 1024 = 1.90

1 página + 1.90 = 3 páginas

En conclusión, el desplazamiento no nos implica usar más páginas que si no te desplazas

20
Matrices

Ejercicio de matriz
Datos:
- N = 16 bits
Dirección base: 0280H
Enteros: 4 bytes
Dirección física = 16 bits
Cache física = 512 bytes
m=1
Líneas = 32 bytes

a) Indique cómo se divide la dirección física para acceder a caché y que cantidad de bits tiene
cada parte.

Geometría de la cache: (S, m, L) → (0.5 KB, 1, 32 Bytes)

- S (tamaño de caché) = 512 Bytes

- L (tamaño de línea) = 32 Bytes
- m=1
- C = 16 líneas

- Index: log2(C/m) = 4 bits

- Offset:log2 L = log2 32 = 5 bits Dirección física:
| Tag | Index | Offset |
7 bits 4 bits 5 bits
- Tag: 16 bits - 5 bits - 4 bits = 7 bits

21
 b) Indique en cuántos bloques se divide la matriz, cual es la dirección base de cada bloque (al
menos para las primeras cuatro filas) y cual es el index de caché asociado a cada uno.

Tamaño total de la matriz:

N x N = 16 x 16 = 256 enteros → cada uno de esos enteros es de 4 bytes
→ 256 enteros x 4 bytes = 1024 bytes

Sabemos que el tamaño del bloque es equivalente al tamaño de la línea, por lo tanto:
Cant de bloques = 1024 bytes (tamaño de la matriz) / 32 bytes (el tamaño de la línea) = 32 bloques

Como cada fila es de 16 enteros y cada entero es de 4 bytes entonces tenemos 64 Bytes por fila de matriz,
siendo así, tenemos 2 bloques de 32 bytes por fila de matriz.
Como cada fila de matriz es de 16 enteros, tenes 8 enteros en cada línea de cache.
Cada bloque es 32 bytes y cada elemento es de 4 bytes, entonces entran 8 elementos por bloque o línea.

Nuestra dirección base es 0280H = 64010 direccion_base_de_A + (i x N + j) x tamaño_elemento

Fila 0:
- Bloque 1: 64010 + [(0 x 16 + 0) x 4 Bytes] = 64010 → 0280H → 0000001 0100 00000 Index = 4
tag index offset
- Bloque 2: 64010 + [(0 x 16 + 8) x 4 Bytes] = 67210 → 0000001 0101 00000 Index = 5

Fila 1:
- Bloque 1: 64010 + [(1 x 16 + 0) x 4 Bytes] = 70410 → 0000001 0110 00000 index = 6
- Bloque 2: 64010 + [(1 x 16 + 8) x 4 Bytes] = 73610 → 0000001 0111 00000 index = 7

Fila 2:
- Bloque 1: 64010 + [(2 x 16 + 0) x 4 Bytes] = 76810→ 0000001 1000 00000 index = 8
- Bloque 2: 64010 + [(2 x 16 + 8) x 4 Bytes] = 80010→ 0000001 1001 00000 index = 9

Fila 3:
- Bloque 1: 64010 + [(3 x 16 + 0) x 4 Bytes] = 83210→ 00000001 1010 00000 index = 10
- Bloque 2: 64010 + [(3 x 16 + 8) x 4 Bytes] = 86410→ 00000001 1011 00000 index = 11

c) Para cada recorrido cuantos fallos ocurrieron por accesos a datos? ¿Cuál fue la tasa de fallos?
Del total de fallos, ¿cual es el total de fallos compulsivos?

Nosotros tenemos una matriz de 1024 bytes, pero nuestra memoria caché es de
512 bytes. Esto quiere decir, que tendremos que dividir en dos nuestra matriz
para poder recorrerla íntegramente en caché.

Los bloques no se pueden romper.

Asumimos que la caché está vacía inicialmente. Por este motivo, consideramos
que tenemos misses compulsivos en los primeros accesos.

22
Columna 0: 16 misses, 0 hits
Columna 15: 16 misses, 0 hits En conclusión: vamos a tener un miss por cada elemento recorrido.
Columna 1: 16 misses, 0 hits Esto es así porque la matriz se sobreescribe en cada iteración,perdiendo
Columna 14: 16 misses, 0 hits todos los bloques que había traído previamente a cache.

Tasa de fallos: 256 / 256 = 100% Fallos compulsivos: 16 / 256 = 0,062% de los misses son
compulsivos

Tiene 105 hits, y 256 - 105 = 151 miss

Tasa de fallos: 151 / 256 = 58% Fallos compulsivos: 16 / 151 = 10% de los misses son compulsivos
d) ¿Cuál de los dos recorridos es más eficiente? justifique.

El recorrido más eficiente en base a cómo están almacenados los bloques en la matriz es el segundo, ya que
tiene una menor tasa de fallos.
Para el primer recorrido no estaríamos aprovechando la ventaja de almacenar los bloques en row-mayor.
Al momento de leer la segunda mitad de la matriz, sobreescribimos toda la información de la primera mitad,
esto implica que por cada acceso tengamos un miss asociado, es decir, sumamente ineficiente el primer
recorrido. A pesar de que el segundo recorrido no es el ideal, tiene un porcentaje de falla menor.

e) ¿Qué hubiera ocurrido si la matriz estuviera almacenada en memoria siguiendo un orden

column- mayor?

Para el primer recorrido, se estaría aprovechando el orden en el cual se recorre y se almacenan las líneas en
la matriz. Como ambas respetan un orden de column-major se aprovecha mejor su organización interna. Esto
implica que la tasa de fallos sea considerablemente menor.
En cuanto al segundo recorrido, la tasa de fallos sería similar, ya que la matriz es cuadrada. Al recorrerla en
espiral no variaría demasiado el recorrido. Podemos concluir, que su tasa de fallos no se alteraría en exceso.

f) ¿Qué hubiera cambiado si la dirección base de A hubiera sido 0270H ?

Lo que hubiese cambiado es que la ubicación de las direcciones habían quedado desfasadas por lo tanto
ahora al momento de ubicar los bloques deberíamos ver bien en que pagina ubicarlo.
- Bloque 1: 62410 + [(0 x 16 + 0) x 4 Bytes] = 62410 → 000000001 0011 10000 Index = 3
- Bloque 2: 62410 + [(0 x 16 + 8) x 4 Bytes] = 65610 → 000000001 0100 10000 index = 4

23
For

cada entero
ocupa 4 bytes
32 x 32 caracteres ⇒ 64 x 64 bytes

A[0,0] ⇒ 0000 4040H y B[0,0] ⇒ 0000 0800H

tamaño de la cache = 4 KB = 4096 bytes
tamaño de línea = 16 bytes
a) cantidad de líneas en la caché = tamaño de la caché / tamaño de línea
= 4096 bytes / 16 bytes
= 256 líneas

b) La dirección de memoria se descompone en 3 campos:

- Offset: Indica el byte dentro de la línea al cual se está direccionando.

- d = Log2 L = Log2 16 = 4 bits
- L = tamaño de la linea
- index: Identificador del conjunto (set) al que pertenece la línea.
- i = Log2 C/m = Log2; (256) → 8 bits.
m = grado de asociatividad = 1 ⇒ mapeo directo
C = cantidad de líneas
- Tag: Identificador de la línea de caché.
- t = bits restantes
- 32 - index - offset ⇒ 32 - 8 - 4 = 20 bits

24
 c) 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

⇒ Como se trata de mapeo directo, cada conjunto se corresponde con un único bloque/línea

Para el arreglo A 0000 4040 h → 0000 0000 0000 0000 0100 0000 0100 0000
0000 4056 h → 0000 0000 0000 0000 0100 0000 0101 0110
tag | index | offset
tag = 0000 0000 0000 0000 0100
index = 0000 0101
bloque 0 → index 4
bloque 1 → index 5
bloque 2 → index 6
…
bloque 251 → index 255
bloque 252 → index 0
bloque 253 → index 1
bloque 254 → index 2
bloque 255 → index 3

Para el arreglo B 0000 0800 h → 0000 0000 0000 0001 0000 1000 0000 0000
tag | index | offset
index = 128
bloque 0 → index 128
bloque 1 → index 129
....
bloque 127 → index 255
bloque 128 → index 0
bloque 129 → index 1
….
bloque 254 → index 127

d.
Se asume un almacenamiento para las matrices: row major
Como la caché 4096 Bytes y cada matriz también es de 4096 Bytes, solo se podrá almacenar la mitad de
cada matriz en caché. Luego, los datos se irán reemplazando hasta terminar los recorridos.
Cada vez que se busca un dato en caché, como todas las entradas en caché son inválidas se trae un bloque
entero (de 4 enteros) desde MP.

AUMENTAR EL GRADO DE ASOCIATIVIDAD → DISMINUYE LA CANTIDAD DE FALLOS CUANDO HAY

CONFLICTOS.

e. Se usan las políticas write through - write around.

En write through cuando hay una escritura va a escribir en la caché y en memoria principal. En caso de que
no esté en la caché solo escribiría en la MP.

(1024 enteros * 4 bytes c/u) * 2 = 8192 bytes = 2^13 bytes

En conclusión se escriben en memoria principal 2^13 Bytes.

25
DATOS:
- Direccionamiento al byte (?)
- tamaño dir lógica = 32 bits
- tamaño dir fisica = 24 bits
a.
Dirección Física o Dirección Lógica = log2 (espacio direccionable)
Por ejemplo, si me dice que la memoria RAM es de 4096 bytes, entonces Dirección Física = log2(4096).

log2 (tamaño RAM) = 24 bits ( ← dirección física)

tamaño RAM = 224 bytes ⇒ 16777216 bytes ⇒ 16384 KB

b.
Cantidad de páginas = 10242
⇒ Espacio virtual
log2 (Espacio virtual) = 32 bits ( ← dirección lógica)
Espacio virtual= 232 bytes ⇒ 4294967296 bytes ⇒ 4194304 KB
tamaño de página: espacio virtual / cantidad de páginas
: 4294967296 bytes / 10242 páginas
:4294967296 bytes / 1048576 páginas
: 4096 bytes
c. como el tamaño de la página = al tamaño del frame
tamaño de frame = 4096 bytes
como el tamaño de memoria principal (tamaño de RAM) = 16777216 bytes

Entonces la cantidad máxima de frames posibles es:

tamaño de memoria principal / tamaño de frame
16777216 bytes / 4096 bytes = 4096 frames

26
d. Número de Frame = log2(cantidad de frames)
= log2(4096)
= 12

Dirección Física = Número de frame + Offset

Dirección Física - Número de frame = Offset
24 bits - 12 = 12 bits

Número de Página = Dirección lógica - Offset

= 32 - 12
= 20

e. Los argumentos que usaría para convencer de que es una mala idea serían:
- Al perder bits en el número de página no puedo direccionar la misma cantidad que si no los
perdiera, teniendo que agrandar la cantidad de bits para suplementar estos bits perdidos.

f.
DATOS:
- 10 entradas
- 6 bits extra
- 1 bit de paridad por cada entrada
- número de frame = 12

En paginación : TAG = numero de pagina

TLB = cantidad de entradas x (TAG +(numero de frame + bit de valido + etc))

TLB = 10 x ( 20 + (12 + 6 + 1))
TLB = 390 bits ⇒ cada entrada tiene 39 bits ⇒ 4,875 bytes

Luego, si se desea que cada entrada tenga una cantidad entera de bytes, cada entrada debe
tener 5 bytes. (por lo tanto el tamaño del TLB quedaría en 50 bytes ⇒ 400 bits)

27
Reloj / CPI / Frecuencia

Solución 2022
¿Cómo se calcula el tiempo de ejecución?
Datos:
M1
- frecuencia del reloj = 2GHz
- 40% de las instrucciones: 2 ciclos
- 50% de las instrucciones: 1 ciclo
- 10% de las instrucciones: 3 ciclos
M2
- frecuencia del reloj = X?
- 50% de las instrucciones: 2 ciclos
- 20% de las instrucciones: 2 ciclos
- 30% de las instrucciones: 2 ciclos

Procesador M1, con el programa A:

EXcpu M1 = (40% x 2 + 50% x 1 + 10% x 3) x 1 / 2 GHz = 0.8 segundos

Procesador M2, con el programa A:

EXcpu M2 = (40% x 2 + 50% x 2 + 10% x 2) x (1 / X) = 0.8 segundos
= 2 x (1 / X) = 0.8 segundos
= 1 / X = 0.8 / 2
= 1 / X = 0.4
= 1 / 0.4 = X
= X = 2.5 GHz

Luego, la frecuencia de reloj del procesador M2 tiene que ser igual a 2.5 GHz para que tengan el mismo
tiempo de ejecución en ejecutar el programa A.

28
 Procesador M1, con el programa B:
EXcpu M2 = (50% x 2 + 20% x 2 + 30% x 2) x (1 / 2 GHz) = 1 segundo

Procesador M2, con el programa B:

EXcpu M2 = (50% x 2 + 20% x 2 + 30% x 2) x (1 / X) = 1 segundo
= 2 x (1 / X) = 1 segundo
= 1/X=1/2
= 1 / 0.5 = X
= X = 2 GHz

El programa A corre más rápido que el programa B, es decir, necesita menos tiempo de
ejecución para realizar el trabajo.
El procesador M2 con el programa A, necesita más frecuencia de reloj que el procesador M1
para que su tiempo de ejecución sea el mismo..
El procesador M2 con el programa B, necesita la misma frecuencia del reloj que el procesador
M1 para que sus tiempos de ejecución coincidan.
Los GHz en sí, no

b) Supongamos que la frecuencia del reloj de M1 y M2 es la misma. Ambos programas tienen la misma
cantidad de instrucciones y para realizar la misma tarea encontramos un algoritmo que requiere
ejecutar A y B la misma cantidad de veces. ¿Qué microarquitectura va a ser más rápida?

lo que importa es la cantidad de ciclos promedio

Programa C, en el 100% de la ejecución, ejecuta un 50% el programa A y el otro 50% el programa B.

La microarquitectura que va a ser más rápida va a depender del CPI (Ciclos por instrucción) de sus
instrucciones. Esto es, depende de la distribución de sus instrucciones, cuanto menor sea el CPI por
instrucción, menor va a ser el tiempo de ejecución.
La cantidad de instrucciones también afecta, tener más cantidad de instrucciones con menor CPI va a ser
más rápido que tener muchas instrucciones y que esas instrucciones tengan un CPI grande.
Conclusión: podemos decir que a pesar de que ambos programas y procesadores tengan las mismas
características, la decisión sobre cuál es el procesador más veloz no es única. Depende de la distribución de
las instrucciones y sus CPIs correspondientes.

Datos:
- La frecuencia de reloj de M1 y M2 es la misma = 2 Ghz
- A y B tienen la misma cantidad de instrucciones
- A y B se ejecutan la misma cantidad de veces

Asumimos que ambas microarquitecturas tienen una frecuencia de 2GHz.

ExCPU A y B = #Instrucciones x CPI x 1 / 2 GHz

29
#Instrucc. Programa A #Instrucc. Programa B CPI Procesador M1 CPI Procesador M2
40% 50% 2 2
50% 20% 1 2
10% 30% 3 2

Ciclos totales A con M1 = (0.4 x 2 + 0.5 x 1 + 0.1 x 3) = 1.6 ciclos

Ciclos totales A con M2 = (0.4 x 2 + 0.5 x 2 + 0.1 x 2) = 2 ciclos

Ciclos totales B con M1 = (0.5 x 2 + 0.2 x 1 + 0.3 x 3) = 2.1 ciclos

Ciclos totales B con M2 = (0.5 x 2 + 0.2 x 2 + 0.3 x 2) = 2 ciclos

EXC con M1 = (50% x A + 50% x B) x ½ GHz

(0.5 x 1.6 + 0.5 x 2.1) x ½ GHz = 0.925 segundos

EXC con M2 = (50% x A + 50% x B) x ½ GHz

(0.5 x 2 + 0.5 x 2) x ½ GHz = 1segundo

Conclusión final: Debido a la distribución de las instrucciones la microarquitectura 1 va a ser más rápida.

c) Cuál debería haber sido la relación entre la cantidad de ejecuciones de A y la cantidad de B para
para que en el inciso anterior el resultado fuera que son igual de rápidas?

EXC con M1 = (0.5(A) x 1.6 + 0.5(B) x 2.1) x ½ GHz

EXC con M2 = (0.5(A) x 2 + 0.5(B) x 2) x ½ GHz

(Y% x 1.6 + X% x 2.1) = (Y% x 2 + X% x 2)

1.6Y + 2.1X = 2Y + 2X
2.1X - 2X = 2Y - 1.6Y
0.1X = 0.4Y
X = 0.4 / 0.1 Y
X= 4Y

Conclusión final: la relacion que tendria que haber entre instrucciones de ambos programas seria, 20% de A
y 80% de B

30
SOLUCIÓN 2022

ExCPU = #instrucciones * CPI * periodo del reloj

Datos:
- Periodo del reloj = 1 / 4Mhz = 1 / 0.004GHz = 250 GHz
- CPI = 1.6
a)
1 segundo = X * 1.6 * 250 GHz
1000000000 ns / 250 ns = X * 1.6
4.000.000 / 1.6 = X
2.500.000 = Instrucciones

b) Datos:
P = Ejecuta 30 veces por segundo controla el estado del mouse
CPI = 2.5

EXCPU = 1500 instrucciones * 2.5 * 250 GHz

EXCPU = 937500 ns = 0.0009375 segundos → Tiempo de ejecución de la rutina

La rutina se ejecuta 30 veces por segundos, esto es:

0.0009375 * 30 = 0.0281 segundos

1 segundo ---- 100%

0.0281 -------- 2.81%

Por lo tanto podemos concluir que no es significativa la fracción de tiempo usada para
controlar el estado del mouse.

Multiple Choice

31
Ejercicio de final: Sumador

Sumador 1

a) SOLUCIÓN 2 (mismo resultado pero distinta forma de encararlo)

COUT = w + xyz
S3 = (w + xyz)’
CIN = 0
C1 = xy
C3 = w + c2
C2 = z * c1

Luego, empezamos a reemplazar

C2 = z * c1
C2 = z * xy
C3 = w + c2
C3 = w + zxy
COUT = C3
COUT = w + xyz
S3 = C3’
C3 = 1, Cout = 1, S3 = 0 Por lo tanto, Cout es el complemento de S3

32
 C3 = 0, COUT, = 0, S3 = 1
Entonces,
S3 = C3’ → S3 = (w + zxy)’

b) inciso i)

Inciso ii)

33
Inciso ii)

Final 25/2/22 (Presencial)

Punto 1: Programa que se ejecuta y accede a memoria en hexadecimal
Un tamaño de bloque de 8 bytes y un tamaño de memoria de 1 KB, entonces pregunta:
- ¿Cuál es la tasa de fallos con acceso directo?
- se puede mejorar esa tasa? te dan 4 opciones
--> duplicando el grado de asociatividad
--> duplicar el tamaño de bloque
--> ambas
--> ninguna

Duplicando el grado de asociatividad:

- Disminuye el miss rate, lo que implica que aumente el hit rate. Al tener mayor grado de asociatividad
se genera una dispersión de los valores entre los distintos conjuntos, esto es, hay mas lineas
disponibles para direcciones con el mismo index, por lo tanto, se reduce la cantidad de colisiones y los
Miss Conflictivos, lo cual implica un aumento en el hit rate..

Duplicando el tamaño de la línea:

- Como hay un mayor tamaño de línea, entran más datos en cada línea implicando que se reduzca el
miss rate (se reducen los miss compulsivos: ya que al traer más información en una misma línea eso
34
 hace que abarque más datos, entonces la caché se llena con menos viajes a memoria principal
entonces hay mayor probabilidad de que al acceder a una dirección de memoria, la misma ya esté
ocupada (los miss compulsivos ocurren al acceder por primera vez a una línea vacía), y se
incrementan los miss conflictivos por la posibilidad de que varias direcciones tengan el mismo index →
mayor cantidad de bits para el offset, hace que el index se modifique de forma más lenta, es decir,
comparten el index y hay más chances de una referencia al mismo set) y aumente el hit rate.
En el balance, no sabemos si los miss conflictivos “compensan” los miss compulsivos o si efectivamente los
miss compulsivos eran muchos más que los nuevos miss conflictivos.

direcciones de memoria:
--> 0x0000 → miss compulsivo (0000 a 0007) 8 Bytes
--> 0x0008 → miss compulsivo(0008 a 0015) 8 Bytes
--> 0x0010 → hit
--> 0x0015 → hit Traemos 32 Bytes en total
--> 0x0020 → miss compulsivo (0016 a 0023) 8 Bytes
--> 0x0028 → miss compulsivo(0024 a 0031) 8 Bytes

RTA:
Cache
- Tamaño de bloque o tamaño de línea: 8 Bytes → L
- Tamaño total de memoria: 1 KB → S
- Mapeo directo → m = 1
- Cantidad de líneas → S / L = 128 líneas
Geometría de la cache (S, m, L) = (1 KB, 1, 8 Bytes)

Tasa de fallos (Miss Ratio) = es la fracción o porcentaje de accesos fallidos

Miss Ratio = cantidad de accesos fallidos / cantidad de accesos totales
= 1 - Hit Ratio
● Asumimos que inicialmente la caché está vacía

Cantidad de accesos fallidos = 4 miss compulsivos

Cantidad de accesos totales = 4 miss + 2 hits = 6 accesos
Miss Ratio = 4 / 6 = 0,66

Punto 2: Verdadero y falso de 3 incisos

1) Una unidad de control microprogramada es más veloz y segura que una cableada F
(por segura se refiere a que tiene menor probabilidad de falla)
→ control cableado: es más veloz
→ control microprogramado: menos propenso a errores
Justificación: a pesar de que la unidad de control microprogramada tiene menor probabilidad de presentar
errores, la unidad de control cableado es más veloz. Como no cumple con ambos postulados, es falsa.

2) el espacio de direccionamiento lógico y el tamaño de la caché están limitados

por la longitud de la dirección de memoria física F
Con la dirección física podemos obtener la máxima capacidad de RAM utilizable
Con la dirección lógica del procesador determina el tamaño de la memoria virtual.
El tamaño de la caché es independiente.
Memoria virtual: El espacio de direccionamiento lógico y la memoria física

35
La longitud de la dirección de memoria física, afecta de cierta forma el tamaño de la caché. Esto es porque: el
tamaño de la línea de la caché es equivalente al tamaño de un bloque de memoria física. Al mismo tiempo,
para obtener el tamaño de la caché, hacemos la longitud (tamaño) de la línea x la cantidad de líneas. A mayor
cantidad de bits, más grande el tamaño total de la caché.
Pero, por otro lado no hay relación entre la MP y la MV, la MP tiene un tamaño de 2^n y la MV tiene un
tamaño de 2^p donde no existe relación entre n y p.

Un poquito de verdadero, un poquito de falso.

3) la organización de la memoria virtual está condicionada por la organización

de la caché F

La memoria virtual solo está limitada por el tamaño de la dirección virtual.

La organización de la memoria caché involucra a la geometría o si está implementada en niveles.
Por otro lado, la organización de la memoria virtual involucra la paginación o segmentación.
Para nosotros, que la memoria caché tenga cierta geometría no nos condiciona a implementar la MV con
paginación o segmentación.

Punto 3: Muestra hardware de un branch on equals (explicación en video). Pedía explicar

el hardware y qué cambios harías para que se resuelva el branch en el decode
¿Qué mejoras harías? (no se acuerda el por qué)

RTA:

En el esquema se puede observar que se hace el fetch de la instrucción y se actualiza el PC, en la siguiente
etapa (Decode) se leen los registros y se hace extensión de signo. Además, se decodifica la instrucción y se
determina si es un branch o no (en este caso es un branch). Luego, en la etapa Execute se evalúa la
condición del branch y se calcula la dirección de salto. Posteriormente, en la etapa Memory en la línea de
36
selección del MUX se decide si toma el branch o resuelve otra instrucción, la salida de este MUX será el PC
del cual se hará fetch el ciclo siguiente. Finalmente, en la etapa Writeback se almacenan los datos en el
banco de registros.

Para determinar de forma temprana el branch en la etapa Decode, hay que hacer un par de modificaciones en
el hardware.
En vez de usar la ALU para realizar una resta, se puede usar un comparador (muchos XOR en paralelo) ya
que un comparador de igualdad es mucho más rápido que restar y detectar resultado 0. Esto conlleva a tener
solo 1 ciclo de penalización. A raíz de esto surge un conflicto Read after Write (RaW) lo que conlleva a
necesitar la lógica de forwarding para adelantar los datos a la etapa de decode. Esto se soluciona agregando
2 MUX y 2 líneas nuevas de selección como salida de la unidad de detección de conflictos.

Punto 4: Plantea una situación

tenías un full adder pero con 5 bits en vez de 3 bits, pedía que hagas el diagrama y
expliques el hardware
Lo que hizo el chico: tenías un full adder con 3 bits para sumar, los otros dos eran
del carry. Al sumar 3 bits podes tener doble carry
Hizo 4 3-full adder y resolver la suma utilizando ese hardware
Números a sumar:
--> 0111
--> 1010
--> 0111

1 1
1 0 1
0 1 1 1 x
1 0 1 0 y
0 1 1 1 z
-----------------------------------------------------------
1 1 0 0 0

1
37
 1 0 1 0 1
1 1 1 1 x
1 1 1 1 y
1 1 1 1 z
-----------------------------------------------------------
1 0 1 1 0 1

Explicar con nuestras palabras cómo funciona.

C1 seria el carry que pasa directo al siguiente full adder y c2 sería el carry que pasaría a la siguiente posición
por lo tanto saltearia el full adder próximo.
En caso de que el último full adder retorne dos carrys, c2 es el dígito más significativo.

Coloquio Ejercicio 1

Datos:
- Jerarquía de memoria de dos niveles (MP y cache)
- Bus de 32 bits
- Tamaño de cache = 512 MB
- Un acceso exitoso en caché (Hit time L1): 1 ciclo del reloj
- Transferencia del bus: 1 ciclo del reloj
- Demora para enviar un bloque a MP: 4 ciclos del reloj → miss penaltyL1
- Dirección física: 32 bits
- Tamaño de línea o bloque = ¿?

a) ¿Qué tamaño de bloque resulta en el menor tiempo de acceso promedio a memoria?

Tiempo de acceso promedio = TAP
TAP = TaccesoCache + miss ratioCache x TaccesoMP

- Tamaño de línea de 4 bytes (32 bits):

TAP = 1 ciclohitCache + 0,045MissRatio x (1 cicloHIT MP + 4 ciclosMP + 1ciclo bus)
38
 TAP = 1.27

- Tamaño de línea de 16 bytes (128 bits):

TAP = 1 ciclo + 0,024 x (1 + 4 + 4)
TAP = 1.216

- Tamaño de línea de 32 bytes (256 bits) :

TAP = 1 ciclo + 0,016 x (1 + 4 + 8)
TAP = 1.208 (esta es la de menor tiempo)

- Tamaño de línea de 64 bytes (512 bits):

TAP = 1 ciclo + 0,010 x (1 + 4 + 16)
TAP = 1.210

- Tamaño de línea de 128 bytes (1024 bits):

TAP = 1 ciclo + 0,0064 x (1 + 4 + 32)
TAP = 1.236

b) Además del tiempo de transferencia , hay que tener en cuenta el tiempo de arbitraje del bus, es
decir, el tiempo que demanda pasar el control del bus de un dispositivo a otro. Si el arbitraje del
bus demanda 2 ciclos de reloj ¿que tamaño de bloque es mejor?

Tiempo de acceso promedio = TAP

TAP = TaccesoCache + miss ratioCache x TaccesoMP

- Tamaño de línea de 4 bytes (32 bits):

TAP = 1 ciclohitCache + 0,045MissRatio x (1 cicloHIT MP + 4 ciclosMP + 1pasaje bus+ 4 arbitraje del bus)
TAP = 1.45

- Tamaño de línea de 16 bytes (128 bits):

TAP = 1 ciclo + 0,024 x (1 + 4 + 4 + 4)
TAP = 1.312

- Tamaño de línea de 32 bytes (256 bits) :

TAP = 1 ciclo + 0,016 x (1 + 4 + 8 + 4)
TAP = 1.272

- Tamaño de línea de 64 bytes (512 bits):

TAP = 1 ciclo + 0,010 x (1 + 4 + 16 + 4)
TAP = 1.25 (esta es la que tarda menos)

- Tamaño de línea de 128 bytes (1024 bits):

TAP = 1 ciclo + 0,0064 x (1 + 4 + 32 + 4)
TAP = 1.2624
c) ¿Qué tamaño de bloque es mejor si el bus entre MP y caché fuera de 64 bits de ancho?
Teniendo en cuenta el arbitraje del bus. Dado el tamaño de la caché justificar si vale la pena, o
no, proponerle al equipo aumentar el tamaño del bus

Tiempo de acceso promedio = TAP

39
 TAP = TaccesoCache + miss ratioCache x TaccesoMP

- Tamaño de línea de 4 bytes (32 bits):

TAP = 1 ciclohitCache + 0,045MissRatio x (1 ciclobus Ida + 4 ciclosMP + 1viaje + 4arbitraje del bus)
TAP = 1.45

- Tamaño de línea de 16 bytes (128 bits):

TAP = 1 ciclo + 0,024 x (1 + 4 + 2 + 4)
TAP = 1.26

- Tamaño de línea de 32 bytes (256 bits) :

TAP = 1 ciclo + 0,016 x (1 + 4 + 4 + 4)
TAP = 1.208

- Tamaño de línea de 64 bytes (512 bits):

TAP = 1 ciclo + 0,010 x (1 + 4 + 8 + 4)
TAP = 1.17

- Tamaño de línea de 128 bytes (1024 bits):

TAP = 1 ciclo + 0,0064 x (1 + 4 + 16 + 4)
TAP = 1.16 (esta es la de menor tiempo)
Como la caché puede almacenar muchas líneas por su tamaño, sería conveniente tener un bus de mayor
tamaño para poder enviar más de una dirección a la vez. Actualmente, con un bus de 32 bits solamente
podemos enviar una dirección en cada uso del bus, en cambio, con un bus de 64 bits tenemos capacidad de
enviar dos direcciones al mismo tiempo. Esto reduciría el tiempo de pasaje de información entre caché y MP a
la mitad. Al tener un tamaño de línea ideal de 128 bytes, toda esta información se podría enviar en 16 viajes
del bus, en lugar de 32 veces. Esto reduciría significativamente el tiempo de transferencia total del bus.

Ejercicio 3
Datos:
- Memoria virtual con paginado y direccionamiento al byte
- Cant de páginas = 8192 páginas
- Offset = 11 bits
- Dirección física = 18 bits

a) ¿Cuál es el tamaño de cada página?

Tamaño de página: 2^(offset) → 2^(11) = 2048 bytes

b) ¿En cuantos frames se divide el espacio de direccionamiento físico?

Espacio de direccionamiento físico = 2^18 = 262144 bytes
Cant de frames = 262144 bytes / 2048 bytes (tamaño de página)
Cant de frames = 128 frames

40
c) ¿Cuál es el tamaño de las direcciones lógicas?
Dirección lógica = num de pagina + offset
Dirección lógica = num de página + 11 bits
Dirección lógica = 13 + 11 = 24 bits

num de pagina = log 2 (8192 cantidad de paginas) = 13

d) ¿Cuántas páginas son necesarias, como mínimo, para almacenar un fragmento de texto de
1722 caracteres UTF-16 si el 60% de los caracteres del texto ocupan 2 bytes y los restantes 4
bytes?

60% de 1722 = 1.033,2 1033,2 x 2 bytes = 2066,4 bytes

40% de 1722 = 688,8 688,8 x 4 bytes = 2755,2 bytes
En total, nuestro texto ocupa 4821,6 bytes.
Cada página puede almacenar 2048 bytes
Entonces, 4821,6 bytes / 2048 bytes = 2,35 páginas, como no puedo tener “media pagina”,
necesito 3 páginas como mínimo

e) Si el mapeo entre páginas y frames se almacena en una tabla de páginas convencional con 5
bits adicionales por cada entrada, incluyendo un bit de valido y un dirty bit, ¿cuál es el tamaño
de la tabla de páginas si cada entrada debe tener una cantidad entera de bytes?. Esta tabla,
presenta algún inconveniente al momento de implementarla? En caso afirmativo, cómo podría
solucionarse?

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

Entrada de la tabla de páginas = bits adicionales + 7 bits para direccionar al frame

Tenemos 5 bits adicionales por cada entrada
Entonces.
Entrada de la tabla de página = 7 + 5 = 12 bits → 1.5 Bytes
Como el enunciado indica que cada entrada debe tener una cantidad entera de bytes entonces
redondeamos en 2 bytes.

Tamaño de tabla de páginas = (num de frame + bits extra) x cantidad de pág

Cantidad de páginas = 8192 páginas

Tamaño de tabla de páginas = (2 bytes) x 8192 = 16384 bytes → 2^14

Direcciones físicas: 7 bits + 11 offset log2(frames) = log2(128) = 7 bits

Uno de los inconvenientes es que la tabla de páginas se sitúa en MP y para poder hacer la traducción
de dirección lógica a física, primero tenemos que pasar por memoria principal para buscar la tabla de
páginas y así poder hacer la traducción, y luego pasar de nuevo a la memoria principal para poder leer
el dato que estamos buscando. Esto demanda 2 accesos a memoria principal. Acá surge la técnica
con TLB para poder minimizar el esfuerzo adicional que lleva a leer la tabla de páginas.
Conclusión: La solución sería tener una caché, separada de la memoria principal, llamada TLB.

f) En este escenario, ¿cuántos bytes ocupará cada entrada del TLB? ¿Cuál sería el tamaño de la
entrada del TLB de 12 entradas?
TLB = cantidad de
41
 Tamaño de la entrada TLB = numero de pagina + frame + bits extra
TLB = cantidad de entradas x tamaño de la entrada
TLB = cantidad de entradas x (TAG + VALOR(numero de frame, bit de valido, etc))
En paginación:
TLB = cantidad de entradas x (número páginas + número frame + bits extra).
Tamaño entrada del TLB: (13 bits + 7 bits + 1 bit de valido) = 21 bits → 3 bytes
Tamaño total del TLB: 12 entradas x (21 bits tamaño de la entrada) = 252 bits → 32 bytes

Ejercicio 2

Datos:
- Frecuencia de M1 = 4GHz
- Cant de instrucciones M1 = Cant instrucciones M2
- Periodo de reloj de M2 = 0.4 ns → 0.4 GHz

Total ciclos A con M1 = cant instrucciones * cant total de ciclos

(2 x 0.10 + 1 x 0.40 + 3 x 0.50) = 2.1 ciclos
Total ciclos B con M1 = cant instrucciones * cant total de ciclos
(2 x 0.20 + 1 x 0.50 + 3 x 0.30) = 1.8 ciclos

Total ciclos C con M1 = cant instrucciones * cant total de ciclos

(50% de A + 50% de B)
50% x 2.1 ciclos + 50% x 1.8 ciclos = 1.95 ciclos

Total ciclos A con M2 = cant instrucciones * cant total de ciclos

(4 x 0.10 + 1 x 0.40 + 1 x 0.50) = 1.3 ciclos

Total ciclos B con M2 = cant instrucciones * cant total de ciclos

(4 x 0.20 + 1 x 0.50 + 1 x 0.30) = 1.6 ciclos
42
Total ciclos C con M2 = cant instrucciones * cant total de ciclos
(50% de A + 50% de B)
50% x 1.3 ciclos + 50% x 1.6 ciclos = 1.45 ciclos

Ejecución total, programa F =

Ejecuciones de A → 60%
Ejecuciones de B → 10%
Ejecuciones de C → 30%

EXF con M1 = (0.60 x 2.1 + 0.10 x 1.8 + 0.30 x 1.95) x 1 / 4 GHZ = 0.50 segundos

EXF con M2 = (0.60 x 1.3 + 0.10 x 1.6 + 0.30 x 1.45) x 0.4GHZ = 0.55 segundos
La microarquitectura que recomendaría al equipo es la M1, ya que es 0.05 segundos más rápida en la
ejecución del programa F.

Ejercicio 3

Datos:
- Espacio virtual de 2^32 bytes
- Memoria RAM de 16 MiB → 16 x 2^20 bytes

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

log2 (espacio direccionable) = 24 bits

b) Si quiero que mi tabla de páginas entre en una página, mi página tiene que ser más grande o igual que
mi tabla de páginas.

Tamaño de la tabla de páginas: (número de frame + bits extra) x cantidad de páginas

((24 bits - offset) + 2 bits extra) x 2^(32-offset)

número de frame: dirección física - offset

24 bits - offset

cantidad de páginas: 2^(número de página)

2^(direccion logica - offset)
2^(32 - offset)

direccion logica: log2(espacio direccionable) = log2(2^32) = 32

43
 ((24 bits - offset) + 2 bits extra) x 2^(32-offset) ESTE ES EL TAMAÑO DE MI TABLA DE PÁGINAS
para respetar el enunciado, necesito que mi pagina sea mas grande.

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

2^32 bytes / cantidad de páginas (ya lo tengo)
2^32 bytes / 2^(32-offset)

Finalmente, para que respete la propiedad pedida en el enunciado:

tamaño de página >= tamaño de la tabla de páginas
2^32 bytes / 2^(32-offset) >= ((24 bits - offset) + 2 bits extra) x 2^(32-offset)

c) Páginas de un tamaño de 4 KiB, la tabla de paginas entra en una pagina? en caso de que no

Tamaño de página: 4 KiB → 4096 bytes = 2^(offset) = 4096 bytes → OFFSET = 12 bits
Tamaño tabla de páginas: (número de frame + bits extra) x cantidad de páginas

número de frame: dirección física - offset

24 bits - 12 bits = 12

cantidad de páginas: 2^(dirección lógica - offset)

2^(32 bits - 12 bits) = 2^20 páginas

Tamaño tabla de páginas: (12 + 2 bits extra) x 2^20 páginas =

14 x 2^20 = 14680064 bits → 1835008 bytes

4096 bytes (tamaño de página) <<< 1835008 bytes (tamaño tabla de página)
→ claramente no entra

¿Qué estrategia propondría para solucionarlo?

Una de las estrategias es la paginación multinivel, donde cada subnivel de la tabla de página sea de
un tamaño menor o igual al tamaño de las páginas.

Otra estrategia también puede ser usar una tabla de páginas invertida pero no te asegura que entre.

Otra puede ser agrandando el offset así se puede direccionar más dentro de la misma página.
Agrandar el offset implica agrandar la página. Al hacer esto también se achica la tabla de páginas.

44
45