LibroPracticas17 18
Uploaded by
Sergio Ruiz VillafrancaLibroPracticas17 18
Uploaded by
Sergio Ruiz VillafrancaPrácticas de Organización de
Computadores
Manual de Laboratorio
Organización de Computadores
Departamento de Sistemas Informáticos
Escuela Superior de Ingeniería Informática de Albacete
Universidad de Castilla-La Mancha
Organización de Computadores
c Pedro Javier García García, Francisco José Alfaro Cortés, José Luis Sánchez García, María Teresa
López Bonal 2016
I.S.B.N.: 978-84-697-2041-7
Documento para el seguimiento de las prácticas de la asignatura Organización de Computadores, asig-
natura troncal de 2o curso del Grado en Informática de la Escuela Superior de Ingeniería Informática
de Albacete de la Universidad de Castilla-La Mancha.
Departamento de Sistemas Informáticos de la Universidad de Castilla-La Mancha
Escuela Superior de Ingeniería Informática de Albacete
Campus Universitario, s/n
02071 Albacete, España
Índice general
1. Práctica 1: Unidad de Instrucción Segmentada 5
1.1. Objetivos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.2. Desarrollo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2. Práctica 2: Riesgos de Datos 9
2.1. Objetivos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.2. Desarrollo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
3. Práctica 3: Riesgos de Control I: Implementación del Salto 13
3.1. Objetivos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
3.2. Desarrollo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
4. Práctica 4: Riesgos de Control II: Estrategias a Usar en los Saltos 17
4.1. Objetivos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
4.2. Desarrollo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
5. Práctica 5: Unidad de Instrucción Segmentada para Punto Flotante 21
5.1. Objetivos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
5.2. La codi cación IEEE 754 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
5.2.1. Precisión simple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
5.2.2. Precisión doble . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
5.3. Desarrollo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
5.3.1. Parte 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
5.3.2. Parte 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
6. Práctica 6: Introducción a la Evaluación de Jerarquías de Memoria 29
6.1. Objetivos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
6.2. Desarrollo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
7. Práctica 7: Análisis de la in uencia de los parámetros de diseño de la caché
en su rendimiento 31
7.1. Objetivos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
7.2. Desarrollo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
8. Práctica 8: Evaluación de cachés multinivel y separadas 33
8.1. Objetivos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
8.2. Desarrollo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
3
Manual de laboratorio - Organización de Computadores
9. Práctica 9: Evaluación de Jerarquías de Memoria Virtual 35
9.1. Objetivos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
9.2. Desarrollo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
A. Lenguaje ensamblador del procesador MIPS 37
A.1. La arquitectura . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
A.2. Registros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
A.3. La unidad de punto otante . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
A.4. La memoria . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
A.5. Formatos de instrucciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
A.6. Modos de direccionamiento . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
A.7. Directivas del ensamblador . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
A.8. Juego de Instrucciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
A.9. Llamadas al Sistema . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
A.10.Programación de subrutinas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
B. Simula3MS 49
B.1. Guía rápida . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
B.2. Manual extendido . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
B.2.1. Edición del código . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
B.2.2. Con guración del camino de datos del simulador . . . . . . . . . . . . . 58
B.3. Ventana de registros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
B.4. Memoria . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
B.4.1. Segmento de datos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
B.4.2. Segmento de texto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
B.5. Llamadas al sistema . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
B.6. Punto de ruptura . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
B.7. Simulación con el procesador monociclo . . . . . . . . . . . . . . . . . . . . . . 63
B.8. Simulación con el procesador multiciclo . . . . . . . . . . . . . . . . . . . . . . . 66
B.9. Simulación con el procesador segmentado . . . . . . . . . . . . . . . . . . . . . 68
B.9.1. Segmentación básica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68
B.9.2. Simulación con plani cación dinámica . . . . . . . . . . . . . . . . . . . 69
C. SJM 77
C.1. Guía rápida . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
C.1.1. Cargando archivos de accesos a memoria . . . . . . . . . . . . . . . . . . 78
C.1.2. Con gurando la jerarquía de memoria . . . . . . . . . . . . . . . . . . . 80
C.1.3. Realizando simulaciones . . . . . . . . . . . . . . . . . . . . . . . . . . . 84
C.1.4. Resultados de la simulación . . . . . . . . . . . . . . . . . . . . . . . . . 88
C.2. Otros detalles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
C.2.1. Rango de valores de los parámetros de con guración . . . . . . . . . . . 89
C.2.2. Manejo de ventanas otantes . . . . . . . . . . . . . . . . . . . . . . . . 90
C.2.3. Ayuda . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
4
Práctica 1
Unidad de Instrucción Segmentada
Prácticas de Organización de Computadores
2
o curso del Grado en Ingeniería Informática
1.1. Objetivos
Conocer el funcionamiento de la segmentación del procesador MIPS de enteros.
Comparar un cauce monociclo con uno cuya ruta de datos está segmentada.
Comparar un cauce multiciclo sin segmentar con uno cuya ruta de datos está segmentada.
1.2. Desarrollo
A lo largo de toda la práctica deberéis ir anotando los resultados y conclusiones obtenidas
para luego poder completar el examen que se realizará al nal de la sesión de prácticas en el
laboratorio usando la plataforma Moodle.
→
− →
− → −
El siguiente fragmento de código MIPS realiza la operación vectorial Z = a+X + Y y
lo tenéis disponible en el archivo APXPY_MIPS_1v.s en Moodle.
# Z= a + X + Y
# Vector X
.data
x: .word 1
# Vector Y
y: .word 100
# Vector Z:
z: .space 64
# Escalar a
a: .word -10
# El código
.text
.globl main
main:
la $t1, x
addi $t4, $t1, 64
la $t2, y
la $t3, z
la $t5, a
lw $t5, 0($t5)
5
Manual de laboratorio - Organización de Computadores
loop:
lw $t6, 0($t1)
add $t6, $t5, $t6
lw $t7, 0($t2)
add $t7, $t6, $t7
sw $t7, 0($t3)
addi $t1, $t1, 4
addi $t2, $t2, 4
addi $t3, $t3, 4
addi $v0,$0, 10 # Fin del programa
syscall
Como sabéis, la instrucción syscall no es realmente una instrucción MIPS, sino una
llamada al sistema para terminar la ejecución del programa. Por tanto, no deberéis tener
en cuenta esta psudoinstrucción a la hora de calcular las estadísticas de las prácticas.
Utilizando la versión Simula3MSv5.01 del simulador del procesador MIPS Simula3MS ,
1
cuyo manual tenéis disponible en el anexo B, realiza las siguientes tareas:
1. Analiza qué está pasando al ensamblar el programa con las instrucciones la y por qué
pasa eso.
2. Modi ca la con guración del simulador para que el camino de datos sea monociclo sin
segmentar:
Ejecuta el programa ciclo a ciclo y realiza un cronograma que indique cómo se van
ejecutando las instrucciones en el tiempo.
Anota el número de ciclos de ejecución y calcula el número total de instrucciones
ejecutadas y con eso el CPI obtenido. Comprueba que los números que has obtenido
coinciden con las estadísticas que proporciona el simulador.
3. Modi ca la con guración del simulador para que el camino de datos sea multiciclo
sin segmentar con una unidad de suma, otra de multiplicación y otra de división con
latencias de 4, 7 y 10 ciclos, respectivamente:
Ejecuta el programa ciclo a ciclo, observando cómo se van ejecutando las instruc-
ciones.
Estudia y analiza la diferencia entre ejecutar Paso siguiente y Ciclo siguiente.
Realiza un cronograma que indique cómo se van ejecutando las instrucciones en el
tiempo.
Analiza cuántos ciclos tardan en ejecutarse cada uno de los siguientes tipos de
instrucciones: cargas, almacenamientos y aritmético-lógicas.
Anota el número de ciclos de ejecución y calcula el número total de instrucciones
ejecutadas y con eso el CPI obtenido. Comprueba que los números que has obtenido
coinciden con las estadísticas que proporciona el simulador.
1
Simula3MS es un proyecto del grupo de Arquitectura de Computadores de la Universidad de La Coruña
(http://simula3ms.des.udc.es/).
6
Práctica 1: Unidad de Instrucción Segmentada
Suponiendo que la duración del ciclo en la implementación monociclo es T y en la
T
implementación multiciclo es
5 , calcula la aceleración que se consigue en este caso
respecto a la con guración del procesador como monociclo.
Repite la simulación pero poniendo a las unidades funcionales de la suma, mul-
tiplicación y división latencia de uno, y analiza cómo varían los resultados y por
qué.
4. Modi ca la con guración del simulador para que el camino de datos sea segmentado
básico sin adelantamiento y con una unidad sumadora, otra multiplicadora y otra
de división con latencias de 4, 7 y 10 ciclos, respectivamente, estando las dos primeras
unidades segmentadas pero no la de división :
2
Ejecuta el programa ciclo a ciclo, observando cómo se van ejecutando las instruc-
ciones y las detenciones que se ocasionan.
Realiza un cronograma que indique cómo se van ejecutando y solapando las ins-
trucciones en el tiempo.
Clasi ca los riesgos que ocurran durante la ejecución del programa.
Anota el número total de ciclos de ejecución y calcula el número total de ciclos de
parada.
Calcula el número total de instrucciones ejecutadas y con eso el CPI obtenido, y la
degradación de prestaciones que supone cada uno de los tipos de riesgos ocurridos.
Comprueba que los números que has obtenido coinciden con las estadísticas que
proporciona el simulador.
Suponiendo que la duración del ciclo en la implementación monociclo es T y en
T
la implementación multiciclo es
5 , calcula la aceleración que se consigue en este
caso respecto a la con guración del procesador como monociclo sin segmentar y
respecto a la con guración del procesador como multiciclo sin segmentar.
Repite la simulación pero poniendo a las unidades funcionales de la suma, mul-
tiplicación y división latencia de uno, y analiza cómo varían los resultados y por
qué.
2
Es posible que tengas que cerrar la aplicación y volver a iniciarla para que realmente se ejecute el cauce
segmentado.
7
Manual de laboratorio - Organización de Computadores
8
Práctica 2
Riesgos de Datos
Prácticas de Organización de Computadores
2
o curso del Grado en Ingeniería Informática
2.1. Objetivos
Entender la problemática de los riesgos de datos.
Saber detectar los riesgos de datos y aplicar detenciones para resolverlas.
Comparar el uso de adelantamiento hardware con aplicar detenciones.
2.2. Desarrollo
Al igual que en la práctica anterior, a lo largo de toda la práctica deberéis ir anotando los
resultados y conclusiones obtenidas para luego poder completar el examen que se realizará al
nal de la sesión de prácticas en el laboratorio usando la plataforma Moodle.
→
− →
− → −
El siguiente fragmento de código MIPS realiza la operación vectorial Z = a+X + Y y
lo tenéis disponible en el archivo APXPY_MIPS_1v.s en Moodle.
# Z= a + X + Y
# Vector X
.data
x: .word 1
# Vector Y
y: .word 100
# Vector Z:
z: .space 64
# Escalar a
a: .word -10
# El código
.text
.globl main
main:
la $t1, x
addi $t4, $t1, 64
la $t2, y
la $t3, z
la $t5, a
lw $t5, 0($t5)
9
Manual de laboratorio - Organización de Computadores
loop:
lw $t6, 0($t1)
add $t6, $t5, $t6
lw $t7, 0($t2)
add $t7, $t6, $t7
sw $t7, 0($t3)
addi $t1, $t1, 4
addi $t2, $t2, 4
addi $t3, $t3, 4
addi $v0,$0, 10 # Fin del programa
syscall
Utilizando el simulador del procesador MIPS Simula3MS realiza las siguientes tareas:
1. Modi ca la con guración del simulador para que el camino de datos sea segmentado
básico SIN adelantamiento y con una unidad sumadora, otra multiplicadora y otra de
división con latencias de 4, 7 y 10 ciclos, respectivamente, estando las dos primeras
unidades segmentadas pero no la de división:
Ejecuta el programa ciclo a ciclo, observando cómo se van ejecutando las instruc-
ciones y las detenciones que se ocasionan.
Realiza un cronograma que indique cómo se van ejecutando las instrucciones en el
tiempo.
Clasi ca los riesgos que ocurran.
Anota el número total de ciclos de ejecución y calcula el número total de ciclos de
parada.
Calcula el número total de instrucciones ejecutadas y con eso el CPI obtenido, y la
degradación de prestaciones que supone cada uno de los tipos de riesgos ocurridos.
Comprueba que los números que has obtenido coinciden con las estadísticas que
proporciona el simulador.
2. Manteniendo la misma con guración del simulador, modifícala sólo para que ahora el
camino de datos sea CON adelantamiento:
Ejecuta el programa ciclo a ciclo, observando cómo se van ejecutando las instruc-
ciones y las detenciones que se ocasionan.
Realiza un cronograma que indique cómo se van ejecutando las instrucciones en el
tiempo.
Observa los adelantamientos que se van produciendo, entre qué instrucciones son y
qué dato es el que se adelanta.
Clasi ca los riesgos que ocurran y compáralos con los que obtuvistes con la con -
guración anterior.
10
Práctica 2: Riesgos de Datos
Calcula el número total de instrucciones ejecutadas, el número total de ciclos de
ejecución y el número total de ciclos de parada. Calcula el CPI obtenido, la ace-
leración respecto a la con guración anterior, y la degradación de prestaciones que
supone cada uno de los tipos de riesgos ocurridos.
Comprueba que los números que has obtenido coinciden con las estadísticas que
proporciona el simulador.
Compara los resultados obtenidos con los que obtuviste en el caso anterior y analiza
de dónde procede la mejora obtenida.
11
Manual de laboratorio - Organización de Computadores
12
Práctica 3
Riesgos de Control I: Implementación del Salto
Prácticas de Organización de Computadores
o curso del Grado en Ingeniería Informática
2
3.1. Objetivos
Entender la problemática de los riesgos de control.
Comparar la diferencia en la implementación del salto con tres huecos o con un único
hueco en el salto.
3.2. Desarrollo
Al igual que en las prácticas anteriores, a lo largo de toda la práctica deberéis ir anotando
los resultados y conclusiones obtenidas para luego poder completar el examen que se reali-
zará al nal de la sesión de prácticas en el laboratorio usando la plataforma Moodle. Se ha
detectado que en algunas ocasiones los resultados de las estadísticas que muestra el simulador
no son totalmente correctos. Así pues, estudia detalladamente la ejecución y saca tus propias
conclusiones.
→
− →
− → −
El siguiente fragmento de código MIPS realiza la operación vectorial Z = a+X + Y y
lo tenéis disponible en el archivo APXPY_MIPS.s en Moodle.
# Z= a + X + Y
# Vector X
.data
x: .word 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15
# Vector Y
y: .word 100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100
# Vector Z: 16 elementos son 64 bytes
z: .space 64
# Escalar a
a: .word -10
# El código
.text
.globl main
main:
la $t1, x
addi $t4, $t1, 64
13
Manual de laboratorio - Organización de Computadores
la $t2, y
la $t3, z
la $t5, a
addi $t8, $0, 0
lw $t5, 0($t5)
loop:
lw $t6, 0($t1)
lw $t7, 0($t2)
add $t6, $t5, $t6
add $t7, $t6, $t7
sw $t7, 0($t3)
addi $t1, $t1, 4
addi $t2, $t2, 4
addi $t3, $t3, 4
bne $t4, $t1, loop
addi $v0,$0, 10
addi $t8, $t8, 1
addi $t8, $t8, -1
syscall
Utilizando el simulador del procesador MIPS Simula3MS realiza las siguientes tareas:
1. Modi ca la con guración del simulador para que el camino de datos sea segmentado bási-
co con adelantamiento y con una unidad sumadora, otra multiplicadora y otra de división
con latencias de 4, 7 y 10 ciclos, respectivamente, estando las dos primeras unidades seg-
mentadas pero no la de división. Fija la estrategia para el salto como predecir-no-tomado
con TRES HUECOS en el salto:
Ejecuta el programa ciclo a ciclo para la primera iteración del bucle, observan-
do cómo se van ejecutando las instrucciones y las detenciones que se ocasionan,
dedicando especial atención al comportamiento del salto condicional.
Señala qué elementos de la ruta de datos intervienen en la ejecución de la instrucción
de salto condicional y estudia qué implicaciones tiene el uso de la estrategia de
predecir-no-tomado.
Ejecuta el programa completamente, anota el número total de ciclos de ejecución
y calcula el número total de ciclos de parada.
Calcula el número total de instrucciones ejecutadas y con eso el CPI obtenido, y la
degradación de prestaciones que supone cada uno de los tipos de riesgos ocurridos.
Comprueba que los números que has obtenido coinciden con las estadísticas que
proporciona el simulador.
2. Modi ca la con guración del simulador para que el camino de datos sea segmentado bási-
co con adelantamiento y con una unidad sumadora, otra multiplicadora y otra de división
con latencias de 4, 7 y 10 ciclos, respectivamente, estando las dos primeras unidades seg-
mentadas pero no la de división. Fija la estrategia para el salto como predecir-no-tomado
con UN HUECO en el salto:
14
Práctica 3: Riesgos de Control I: Implementación del Salto
Ejecuta el programa ciclo a ciclo para la primera iteración del bucle, observan-
do cómo se van ejecutando las instrucciones y las detenciones que se ocasionan,
dedicando especial atención al comportamiento del salto condicional.
Señala qué elementos de la ruta de datos intervienen ahora en la ejecución de la
instrucción de salto condicional y qué se ha modi cado en dicha ruta desde la
implementación de tres huecos a la actual.
Estudia qué implicaciones tiene en este caso el uso de la estrategia de predecir-no-
tomado.
Ejecuta el programa completamente, anota el número total de ciclos de ejecución
y calcula el número total de ciclos de parada.
Calcula el número total de instrucciones ejecutadas y con eso el CPI obtenido, y la
degradación de prestaciones que supone cada uno de los tipos de riesgos ocurridos.
Comprueba que los números que has obtenido coinciden con las estadísticas que
proporciona el simulador.
15
Manual de laboratorio - Organización de Computadores
16
Práctica 4
Riesgos de Control II: Estrategias a Usar en los Saltos
Prácticas de Organización de Computadores
2
o curso del Grado en Ingeniería Informática
4.1. Objetivos
Entender la problemática de los riesgos de control.
Comparar las diferencias entre predecir no tomado y salto retardado.
4.2. Desarrollo
Al igual que en las prácticas anteriores, a lo largo de toda la práctica deberéis ir anotando
los resultados y conclusiones obtenidas para luego poder completar el examen que se reali-
zará al nal de la sesión de prácticas en el laboratorio usando la plataforma Moodle. Se ha
detectado que en algunas ocasiones los resultados de las estadísticas que muestra el simulador
no son totalmente correctos. Así pues, estudia detalladamente la ejecución y saca tus propias
conclusiones.
→
− →
− → −
El siguiente fragmento de código MIPS realiza la operación vectorial Z = a+X + Y y
lo tenéis disponible en el archivo APXPY_MIPS_1H.s en Moodle.
# Z= a + X + Y
# Vector X
.data
x: .word 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15
# Vector Y
y: .word 100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100
# Vector Z: 16 elementos son 64 bytes
z: .space 64
# Escalar a
a: .word -10
# El código
.text
.globl main
main:
la $t1, x
addi $t4, $t1, 64
la $t2, y
17
Manual de laboratorio - Organización de Computadores
la $t3, z
la $t5, a
addi $t8, $0, 0
lw $t5, 0($t5)
loop:
lw $t6, 0($t1)
lw $t7, 0($t2)
add $t6, $t5, $t6
add $t7, $t6, $t7
sw $t7, 0($t3)
addi $t1, $t1, 4
addi $t2, $t2, 4
addi $t3, $t3, 4
bne $t4, $t1, loop
addi $v0,$0, 10
syscall
Utilizando el simulador del procesador MIPS Simula3MS realiza las siguientes tareas:
1. Modi ca la con guración del simulador para que el camino de datos sea segmentado bási-
co con adelantamiento y con una unidad sumadora, otra multiplicadora y otra de división
con latencias de 4, 7 y 10 ciclos, respectivamente, estando las dos primeras unidades seg-
mentadas pero no la de división. Fija la estrategia para el salto como PREDECIR NO
TOMADO con un único hueco en el salto:
Ejecuta el programa ciclo a ciclo para la primera iteración del bucle, observan-
do cómo se van ejecutando las instrucciones y las detenciones que se ocasionan,
dedicando especial atención al comportamiento del salto condicional.
Señala qué elementos de la ruta de datos intervienen en la ejecución de la instrucción
de salto condicional y estudia qué implicaciones tiene el uso de la estrategia de
predecir-no-tomado.
Ejecuta el programa completamente, anota el número total de ciclos de ejecución
y calcula el número total de ciclos de parada.
Calcula el número total de instrucciones ejecutadas y con eso el CPI obtenido, y la
degradación de prestaciones que supone cada uno de los tipos de riesgos ocurridos.
Comprueba que los números que has obtenido coinciden con las estadísticas que
proporciona el simulador.
2. Modi ca la con guración del simulador para que el camino de datos sea segmentado
básico con adelantamiento y con una unidad sumadora, otra multiplicadora y otra de
división con latencias de 4, 7 y 10 ciclos, respectivamente, estando las dos primeras uni-
dades segmentadas pero no la de división. Fija la estrategia para el salto como SALTO
RETARDADO con un único hueco en el salto:
Ejecuta el programa ciclo a ciclo para la primera iteración del bucle, observan-
do cómo se van ejecutando las instrucciones y las detenciones que se ocasionan,
dedicando especial atención al comportamiento del salto condicional.
18
Práctica 4: Riesgos de Control II: Estrategias a Usar en los Saltos
Señala qué elementos de la ruta de datos intervienen ahora en la ejecución de la
instrucción de salto condicional y si se ha modi cado algo en dicha ruta respecto a
la implementación del apartado anterior.
Estudia qué implicaciones tiene en este caso el uso de la estrategia de salto retar-
dado.
Ejecuta el programa completamente, anota el número total de ciclos de ejecución
y calcula el número total de ciclos de parada.
Calcula el número total de instrucciones ejecutadas y con eso el CPI obtenido, y la
degradación de prestaciones que supone cada uno de los tipos de riesgos ocurridos.
Comprueba que los números que has obtenido coinciden con las estadísticas que
proporciona el simulador.
Estudia qué está pasando con la instrucción que está situada debajo del salto.
¾Podrían mejorarse las prestaciones de este código alterando el orden de las ins-
trucciones? En ese caso modi ca el código como consideres oportuno siempre que
el resultado nal que realiza el bucle sea el mismo y estudia las estadísticas que
obtengas para la primera iteración y para la ejecución completa.
Calcula la aceleración conseguida tras esta plani cación respecto a la primera con-
guración del salto como predecir no tomado.
19
Manual de laboratorio - Organización de Computadores
20
Práctica 5
Unidad de Instrucción Segmentada con
Cauce para Punto Flotante
Prácticas de Organización de Computadores
2
o curso del Grado en Ingeniería Informática
5.1. Objetivos
Manejo y programación de la codi cación de los datos en punto otante en el procesador
MIPS.
Analizar la in uencia de los riesgos de datos en las unidades de punto otante.
Entender las características particulares de una unidad MIPS de punto otante.
5.2. La codi cación IEEE 754
El estándar de la IEEE para aritmética en coma otante (IEEE 754 ) es el estándar más
extendido para las computaciones en coma otante, y es seguido por la mayoría de los pro-
cesadores actuales. El estándar de ne formatos para la representación de números en coma
otante (incluyendo el cero) y valores desnormalizados, así como valores especiales como in-
nito y NaN (Not a Number ), con un conjunto de operaciones en coma otante que trabaja
sobre estos valores. De los formatos para la representación de valores en coma otante que es-
peci ca la norma IEEE 754 , nosotros sólo vamos a tratar aquí dos de esos formatos: precisión
simple (32 bits) y precisión doble (64 bits)
5.2.1. Precisión simple
La representación en coma otante está basada en la notación exponencial o notación
cientí ca. Todo número N se puede expresar como N = m × Be, donde m es la mantisa, B la
base y e el exponente. Un número en coma otante de precisión simple se almacena en una
palabra de 32 bits que sigue el siguiente formato:
donde S es el bit de signo y su signi cado es: 0=Positivo ; 1=Negativo. Para los números
de precisión simple, el exponente es desplazado en el rango -126 a +127 mediante la suma
de 127 (que se llama Polarización) para obtener un valor en el rango 1 a 254 (que se llama
Característica). Cuando se interpreta el valor en coma otante, el número es desplazado de
nuevo para obtener el exponente real.
Para números normalizados, los más comunes, el número se codi ca así:
valor = (−1)S × 2Exponente × M antisa
valor = (−1)S × 2Característica−P olarización × 1.F racción
21
Manual de laboratorio - Organización de Computadores
La mantisa es la parte fraccional del número normalizado. Un número en base dos está
normalizado si el exponente está ajustado de forma que el 1 más signi cativo de la mantisa
binaria queda justo a la izquierda del punto separador de la parte entera y fraccionaria de la
misma. Además, ese 1 no se almacena (queda implícito) y cuando se producen los cálculos es
restituido.
Ejemplo: Obtener el número decimal representado por esta palabra de coma otante de
simple precisión:
C0A00000H = 1 10000001 0100 0000 0000 0000 0000 0002
Es fácil observar lo siguiente:
El bit de signo es 1 con lo cual el número es negativo.
Los 8 bits del exponente son 10000001 y por tanto tienen codi cado el valor 129, y al
restarle 127, que previamente se le había sumado, nos da el valor de 2 para el exponente.
La parte fraccionaria comienza con 01 a lo que hay que añadirle la parte entera, lo cual
nos da 1,01.
Juntandolo todo nos da:
valor = (−1)1 × 22 × 1,01 = −1012 = −510
5.2.2. Precisión doble
Un número en coma otante de doble precisión se almacena en dos palabras de memoria,
es decir en 64 bits, que sigue el siguiente formato:
Para los números de doble precisión, el exponente es desplazado en el rango -1022 a +1023
mediante la suma de 1023 para obtener un valor en el rango 1 a 2046. Al igual que en el caso
de precisión simple, cuando se interpreta el valor en coma otante, el número es desplazado
de nuevo para obtener el exponente real.
Ejemplo: Obtener el número decimal representado por esta palabra de coma otante de
doble precisión:
4039000000000000H = 0 10000000011 10010000000000000000000000000000000000000000000000002
Es fácil observar lo siguiente:
El bit de signo es 0 con lo cual el número es positivo.
Los 11 bits del exponente son 10000000011 y por tanto tienen codi cado el valor 1027,
y al restarle 1023, que previamente se le había sumado, nos da el valor de 4 para el
exponente.
La parte fraccionaria comienza con 1001 a lo que hay que añadirle la parte entera, lo
cual nos da 1,1001.
Juntandolo todo nos da:
valor = (−1)0 × 24 × 1,1001 = 110012 = 2510
22
Práctica 5: Unidad de Instrucción Segmentada para Punto Flotante
5.3. Desarrollo
Vamos a dividir el desarrollo de esta práctica en dos partes distintas. En todos los casos
hay que con gurar el procesador para que utilice adelantamiento y resuelva el salto con
un único hueco.
5.3.1. Parte 1
Utilizando las opciones apropiadas del simulador Simula3MS de ne un computador MIPS
donde el salto se trata con la estrategia de predecir no tomado y que tiene las siguientes
unidades funcionales:
1 sumador punto otante segmentado con 4 ciclos de latencia
1 multiplicador punto otante segmentado con 7 ciclos de latencia
1 divisor punto otante no segmentado con 10 ciclos de latencia
→
− →
− →
− →
− →− →
−
a× X + Y
El programa Practica5_Parte1.s hace la operación Z = b , donde Z, X e Y
son vectores de cien elementos de doble precisión y a y b son constantes de simple precisión.
Tenéis disponible el chero en Moodle y su código es:
#los datos
.data
a: .float 10
b: .float 5
#vector x
x: .double 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
x1: .double 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
x2: .double 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
x3: .double 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
x4: .double 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
#vector y
y: .double 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10
y1: .double 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10
y2: .double 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10
y3: .double 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10
y4: .double 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10
#vector z
z: .space 800
#el código: z[i]=(a*x[i]+y[i])/b
.text
.globl main
main:
la $t1, x #carga la dir de x[0] en $t1
la $t2, y #carga la dir de y[0] en $t2
la $t3, z #carga la dir de z[0] en $t3
23
Manual de laboratorio - Organización de Computadores
la $t4, a #carga la dir de "a" en $t4
la $t5, b #carga la dir de "b" en $t5
addi $t6,$t1,800 #preparamos el contador para detectar el final
lwc1 $f0, 0($t4) #carga "a" en f0
cvt.d.s $f0, $f0 #convertimos "a" en DP y lo guardamos en $f0:$f1
lwc1 $f2, 0($t5) #carga "b" en f2
cvt.d.s $f2, $f2 #convertimos "b" en DP y lo guardamos en $f2:$f3
loop:
lwc1 $f4,0($t1) #f4=x[i]
lwc1 $f6,0($t2) #f6=y[i]
mul.d $f8,$f0,$f4 #f8=a*x[i]
add.d $f8,$f8,$f6 #f8=a*x[i]+y[i]
div.d $f8,$f8,$f2 #f8=(a*x[i]+y[i])/b
swc1 $f8, 0($t3) #z[i]=(a*x[i]+y[i])/b (Parte baja)
swc1 $f9, 4($t3) #z[i]=(a*x[i]+y[i])/b (Parte alta)
addi $t1,$t1,8 #actualizamos todos los índices
addi $t2,$t2,8
addi $t3,$t3,8
bne $t1, $t6, loop #comprobamos si hemos terminado el bucle
addi $v0, $0, 10 #llamada para salir del programa
syscall
Partiendo de este código se pide:
→
− →
− →
−
a× X + Y
1. Comprueba que el código realiza la operación Z = b , y anota los valores para
→
−
el vector Z. Realiza la conversión de punto otante a decimal de algunos de los valores
almacenados en memoria.
2. Ensambla el código y calcula el número de instrucciones que se ejecutarán en total.
Ejecuta el programa paso a paso hasta el nal de la primera iteración del bucle y anota
las detenciones que se producen en esa primera iteración y de qué tipo es cada detención.
3. Utilizando la vista Diagrama monociclo que ofrece el simulador, cuanti ca el uso de
cada una de las unidades funcionales y de la memoria cache de instrucciones y datos, en
ciclos y en porcentaje. Ejecuta el programa completo y anota el tiempo de ejecución total.
Observa también los adelantamientos que se van produciendo, entre qué instrucciones
son y qué dato es el que se adelanta. Calcula también el CPI obtenido y la degradación
de prestaciones que supone cada uno de los riesgos que se presenten. Comprueba que los
números que has obtenido coinciden con las estadísticas que proporciona el simulador.
4. Trata de plani car el bucle para minimizar las detenciones que se producen (sin alterar
los desplazamientos en las instrucciones de los accesos a memoria), y evalúa el CPI de
esta nueva versión, así como la ganancia que se consigue respecto a la versión original.
5. Ahora de ne un computador MIPS con 2 unidades funcionales de cada tipo y con las
mismas latencias que antes. Ejecuta el programa realizado en la primera parte de la
práctica y cuanti ca la reducción en el tiempo de ejecución, así como la mejora obtenida
en rendimientos. Encuentra explicación a los resultados que has obtenido.
24
Práctica 5: Unidad de Instrucción Segmentada para Punto Flotante
5.3.2. Parte 2
Utilizando las opciones apropiadas del simulador Simula3MS de ne un computador MIPS
con adelantamiento hardware, donde el salto se resuelve con un hueco y se aplica la estrategia
de salto retardado y que tiene las siguientes unidades funcionales:
2 unidades sumadoras de punto otante con 4 ciclos de latencia
2 unidades multiplicadoras de punto otante con 7 ciclos de latencia
2 unidades divisoras de punto otante con 10 ciclos de latencia
→
− →
− →
− →
− →
−
El programa Practica5_parte2.s realiza la operación Z = a× A +b× B +c× C +d× D
→
− → − → − → − → −
donde a, b, c y d son constantes de simple precisión y A , B , C , D y Z son vectores de doble
precisión de longitud 10. Tenéis disponible el chero en Moodle y su código es:
#los datos
.data
a: .float 1
b: .float 2
c: .float 3
d: .float 4
va: .double 1,2,3,4,5,6,7,8,9,10
vb: .double 11,12,13,14,15,16,17,18,19,20
vc: .double 21,22,23,24,25,26,27,28,29,30
vd: .double 31,32,33,34,35,36,37,38,39,40
z: .space 80
#el código
.text
.globl main
main:
la $t1, va #carga la dir vector va en $t1
la $t7, vb #carga la dir vector vb en $t7 para comprobar fin bucle
la $t2, vb #carga la dir vector vb en $t2
la $t3, vc #carga la dir vector vc en $t3
la $t4, vd #carga la dir vector vd en $t4
la $t5, z #carga la dir vector z en $t5
la $t6, a #carga la dir de "a" en $t6
lwc1 $f1, 0($t6) #carga "a" en f0
cvt.d.s $f0, $f1 #convertimos "a" en DP y lo guardamos en $f0:$f1
la $t6, b #carga la dir de "b" en $t6
lwc1 $f3, 0($t6) #carga "b" en f3
cvt.d.s $f2, $f3 #convertimos "b" en DP y lo guardamos en $f2:$f3
la $t6, c #carga la dir de "c" en $t6
lwc1 $f5, 0($t6) #carga "c" en f5
cvt.d.s $f4, $f5 #convertimos "c" en DP y lo guardamos en $f4:$f5
la $t6, d #carga la dir de "d" en $t6
25
Manual de laboratorio - Organización de Computadores
lwc1 $f7, 0($t6) #carga "d" en f7
cvt.d.s $f6, $f7 #convertimos "d" en DP y lo guardamos en $f6:$f7
loop:
lwc1 $f8, 0($t1) #f8=va[i]
lwc1 $f9, 4($t1) #f8=va[i]
lwc1 $f10,0($t2) #f10=vb[i]
lwc1 $f11,4($t2) #f10=vb[i]
lwc1 $f12,0($t3) #f12=vc[i]
lwc1 $f13,4($t3) #f12=vc[i]
lwc1 $f14,0($t4) #f14=vd[i]
lwc1 $f15,4($t4) #f14=vd[i]
mul.d $f8,$f8,$f0 #f8=a*va[i]
mul.d $f10,$f10,$f2 #f10=b*vb[i]
mul.d $f12,$f12,$f4 #f12=c*vc[i]
mul.d $f14,$f14,$f6 #f14=d*vd[i]
addi $t1,$t1,8 #actualizamos todos los indices
addi $t2,$t2,8
addi $t3,$t3,8
addi $t4,$t4,8
addi $t5,$t5,8
add.d $f16,$f8,$f10 #f16 = a*va[i] + b*vb[i]
add.d $f18,$f12,$f14 #f18 = c*vc[i] + d*vd[i]
add.d $f20,$f16,$f18 #f20 = a*va[i] + b*vb[i] + c*vc[i] + d*vd[i]
swc1 $f20, -8($t5) #almacenamos la parte baja del resultado z[i]
bne $t1, $t7, loop #comprobamos si hemos terminado el bucle
swc1 $f21, -4($t5) #almacenamos la parte alta del resultado z[i]
addi $v0, $0, 10 #llamada para salir del programa
syscall
Podemos comprobar como el programa que realiza esta operación hace uso de las dos
unidades funcionales sumadoras y de las dos unidades funcionales multiplicadoras. Lo que se
pide para este código es:
→
− →
− →
− →
− →
−
1. Comprueba que el código realiza la operación Z = a × A + b × B + c × C + d × D, y
→
−
anota los valores para el vector Z.
2. Ejecuta el programa paso a paso hasta el nal de la primera iteración del bucle y anota
las detenciones que se producen y decide de qué tipo es cada detención.
3. Ejecuta el programa hasta el nal y cuanti ca el tiempo total de simulación, los ciclos
de detención y las instrucciones ejecutadas. Calcula el CPI obtenido.
4. Compara los resultados con los que se obtienen al tener una única unidad sumadora y
multiplicadora sin segmentar.
5. ¾Cómo variarán los resultados de ambas opciones si las unidades funcionales sumadoras
y multiplicadoras están segmentadas o no?
26
Práctica 5: Unidad de Instrucción Segmentada para Punto Flotante
6. Con las mismas latencias que en los apartados anteriores, incrementa el número de
unidades funcionales de punto otante al valor mínimo que consideres necesario para
conseguir evitar las detenciones sin reorganizar el código. ¾Qué CPI se obtiene en este
caso? ¾Cuántas detenciones hay y de qué tipo son?
7. ¾Cuántas unidades funcionales de punto otante serían necesarias para conseguir las
mismas prestaciones que en el apartado anterior si la unidad funcional sumadora sólo
tuviera 2 ciclos de latencia y la de multiplicación 4 ciclos? ¾Cuál es el número total de
ciclos de ejecución y el número de detenciones en este caso?
27
Manual de laboratorio - Organización de Computadores
28
Práctica 6
Introducción a la Evaluación de Jerarquías de Memoria
Prácticas de Organización de Computadores
2
◦ curso del Grado en Ingeniería Informática
6.1. Objetivos
Aprender a manejar el simulador SJM
Familiarizarse con el uso de trazas de memoria
Iniciarse en la evaluación de jerarquías de memoria sencillas
6.2. Desarrollo
Para el desarrollo de esta práctica (y las siguientes) se empleará el simulador SJM, que
permite modelar de forma intuitiva distintas jerarquías de memoria, con gurar las caracterís-
ticas de sus elementos y obtener medidas de sus prestaciones para evaluar su e ciencia. Antes
de comenzar con el desarrollo de la práctica se explicará el manejo básico de esta herramienta.
Tanto el simulador SJM como un breve manual de usuario del mismo están disponibles en el
espacio Moodle de la asignatura. También pueden encontrarse en el mismo espacio las trazas
de memoria que deben usarse durante la práctica.
Al igual que en las prácticas anteriores, a lo largo de toda la práctica deberéis ir anotando
los resultados y conclusiones obtenidas para luego poder completar el cuestionario de evalua-
ción que se realizará al nal de la sesión de prácticas en el laboratorio usando la plataforma
Moodle.
Parte 1 Cargando trazas
Descarga de Moodle la traza de memoria 1 (contenida en el chero traza1 ) y cárgala en
SJM (Menú Archivo → Abrir chero de accesos a memoria ). Observa la secuencia de
accesos en el panel Accesos a memoria de la ventana principal de SJM y responde a
las siguientes cuestiones:
1. Analiza a qué direcciones se accede en los accesos a instrucción que se realizan entre
los accesos 20 y 59. ¾Puede decirse que existe localidad en los accesos a instrucción
en ese intervalo? ¾Por qué?
2. A partir de las direcciones (todas) en ese intervalo de accesos ¾puede extraerse
alguna conclusión sobre la estructura del programa?
Parte 2 Con gurando una jerarquía de memoria sencilla
En la ventana de con guración de SJM (Menú Con gurar → Jerarquía ) selecciona la
opción Añadir caché uni cada . La ventana de con guración mostrará la estructura de
la jerarquía de memoria más sencilla que puede con gurarse con SJM.
Teniendo en cuenta la estructura de la jerarquía que puedes observar, calcula teóricamente
(es decir, sin usar el simulador SJM) el tiempo medio de acceso a memoria de esta je-
rarquía, suponiendo que la tasa de fallos de caché es de 0.04, su tiempo de acierto es de
2 ciclos y el tiempo de acceso a memoria principal es de 6 ciclos.
29
Manual de laboratorio - Organización de Computadores
A continuación, en la ventana de con guración, pulsa en la memoria caché para acceder
a su ventana de parámetros y cambiar su tiempo de servicio (tiempo de acierto) a dos
ciclos. Deja el resto de parámetros con su valor por defecto y pulsa luego Aceptar . De
nuevo en la ventana de con guración, pulsa en la memoria principal para acceder a su
ventana de parámetros, y cambiar su tiempo de accesos a 6 ciclos (pulsa luego Aceptar ).
Fíjate que los valores temporales son los mismos que hemos usado en el cálculo teórico del
tiempo medio de acceso. Finalmente, pulsa Aceptar en la ventana de con guración.
De este modo hemos con gurado los elementos que componen la jerarquía y el valor
de algunos de los parámetros de dichos elementos. Llamaremos a esta con guración
Jerarquía 1.
Parte 3 Simulando jerarquías de memoria
Con la traza 1 y la Jerarquía 1 que acabas de con gurar, realiza una simulación completa
pulsando el botón Completo en la ventana principal. Una vez terminada, accede a la
ventana de estadísticas y contesta a las siguientes cuestiones:
1. ¾Cuál es la tasa de fallos de caché?
2. ¾Cuál es el tiempo medio de acceso a memoria?
Compara estos resultados con los datos del cálculo teórico realizado en la parte 2. ¾Coin-
ciden los resultados?
Siguiendo un procedimiento similar al anterior, obtén estadísticas para los siguientes
escenarios:
Sin cambiar la con guración de la jerarquía (es decir, sigue usando la Jerarquía 1),
carga la traza 2 (contenida en el chero traza2 ) y realiza una simulación paso a
paso hasta el nal. Observa en cada paso la ventana detallada de estado de caché.
Responde a las siguientes cuestiones:
1. ¾Cuál es la tasa nal de fallos de caché?
2. ¾Cuál es el tiempo medio de acceso a memoria al nal de la simulación?
3. Observando cómo se llenan los bloques de caché, ¾podría decirse que esta traza
presenta localidad para esta jerarquía?
Cambia la con guración de la jerarquía de modo que el tamaño de la caché sea
ahora de 512 bytes y su tiempo de acceso sea de 3 ciclos, pero mantén la con gura-
ción de memoria principal igual que para la Jerarquía 1. Llamaremos a esta nueva
con guración Jerarquía 2. Carga de nuevo la traza 1 ( chero traza1 ) y realiza
una simulación completa. Responde a las siguientes cuestiones:
1. ¾Cuál es la tasa de fallos de caché?
2. ¾Cuál es el tiempo medio de acceso a memoria?
3. Compara estos resultados con los obtenidos previamente para la traza 1 con la
Jerarquía 1. ¾Mejora la Jerarquía 2 las prestaciones de la jerarquía respecto a
la Jerarquía 1? ¾Por qué?
30
Práctica 7
Análisis de la In uencia de los Parámetros
de Diseño de la Caché en su Rendimiento
Prácticas de Organización de Computadores
2
◦ curso del Grado en Ingeniería Informática
7.1. Objetivos
A anzar el manejo del simulador SJM
Comprobar la in uencia de distintos parámetros de la caché en su rendimiento
7.2. Desarrollo
En esta práctica se estudiará cómo afecta al rendimiento de una memoria caché la modi -
cación de distintos parámetros. Concretamente, se evaluará cómo el rendimiento de la memoria
caché se ve afectado cuando varía el tipo de correspondencia, el tamaño de la memoria caché o
el tamaño del bloque. Para ello, se modelará en el simulador una jerarquía de memoria sencilla,
compuesta sólo por una caché uni cada y la memoria principal. A continuación, se evaluarán
dos casos de estudio mediante diversas simulaciones en las que se variará el valor de ciertos
parámetros de la caché y se mantendrá jo el valor de otros (los parámetros jos y variables
dependen del caso de estudio y se indican más adelante). La idea es que, al simular distintas
combinaciones de valores de parámetros, se podrá evaluar el impacto de la variación de dichos
parámetros. De todas las métricas que ofrece el simulador SJM para evaluar la jerarquía, en
cada simulación nos quedaremos con la tasa de fallos de caché como indicador del rendimiento
de la con guración de caché simulada. Los resultados de todas las simulaciones se recogerán
en tablas, de modo que pueda comprobarse en ellas fácilmente cómo la modi cación del valor
de los parámetros condiciona la tasa de fallos de la caché.
Al igual que en las prácticas anteriores, a lo largo de toda la práctica deberéis ir anotando
los resultados y conclusiones obtenidas para luego poder completar el cuestionario de evalua-
ción que se realizará al nal de la sesión de prácticas en el laboratorio usando la plataforma
Moodle.
Teniendo en cuenta este planteamiento, a continuación se indican algunas instrucciones
más detalladas para el desarrollo de la práctica:
Con guraciones de la jerarquía:
Como se ha mencionado, la jerarquía constará simplemente de un nivel de memoria caché
uni cada y la memoria principal. Respecto a los valores de los parámetros de memoria
principal, se dejarán jos los que vienen por defecto. En cuanto a los valores de los
parámetros de caché, unos serán jos y otros variables dependiendo del caso de estudio
a evaluar. Concretamente, se realizarán dos estudios: en el primero de ellos vamos a
variar el tipo de correspondencia en la caché y su tamaño, y en el segundo vamos a
variar el tamaño de caché y el tamaño del bloque. Para cada uno de los estudios los
valores concretos de los parámetros de caché serán (los valores de los parámetros de
caché que no se indican deben dejarse a su valor por defecto):
31
Manual de laboratorio - Organización de Computadores
Estudio 1
1. Tamaño de bloque ( jo): 16B
2. Algoritmo de reemplazo ( jo): LRU
3. Política de correspondencia (variable): directa, asociativa por conjuntos de 2
vías, asociativa por conjuntos de 4 vías, totalmente asociativa.
4. Tamaño de caché (variable): 256B, 512B, 1K, 2K
Estudio 2
1. Política de correspondencia ( ja): directa
2. Algoritmo de reemplazo ( jo): LRU
3. Tamaño de bloque (variable): 8B, 16B, 32B, 64B
4. Tamaño de caché(variable): 256B, 512B, 1K, 2K
Evaluando las con guraciones:
Deben simularse todas las con guraciones correspondientes a todas las posibles combi-
naciones de valores de los parámetros de la caché indicados en cada caso de estudio. En
todas las simulaciones se empleará la traza 3, disponible en Moodle bajo el epígrafe de
la Práctica 7 ( chero traza3 ).
Para cada con guración de caché, se anotará la tasa de fallos como medida de su ren-
dimiento (anota al menos 3 dígitos decimales). Para facilitar la recogida de resultados
puedes utilizar las tablas que aparecen abajo, o utilizar una tabla Excel en el ordenador
(en este último caso, podrás gra car los resultados, lo que puede ayudarte a apreciar
mejor el impacto de variar el valor de los parámetros de caché).
Además, deben extraerse conclusiones de cada estudio. Principalmente, piensa en por
qué la tasa de fallos evoluciona de una u otra forma al cambiar el valor de los parámetros
variables (esto es, piensa en qué fenómenos se están poniendo de mani esto para que se
den esos resultados). En el cuestionario habrá preguntas de test en este sentido.
Tabla Estudio 1
Tamaño de caché
256B 512B 1K 2K
Correspondencia directa
Asociativa 2 vías
Asociativa 4 vías
Totalmente Asociativa
Tabla Estudio 2
Tamaño de bloque
8B 16B 32B 64B
Caché 256B
Caché 512B
Caché 1K
Caché 2K
32
Práctica 8
Evaluación de Cachés Multinivel y Separadas
Prácticas de Organización de Computadores
2
◦ curso del Grado en Ingeniería Informática
8.1. Objetivos
Reforzar los conceptos de cachés multinivel y separadas
Iniciarse en la evaluación de cachés multinivel y separadas mediante SJM
Reforzar el dominio de la relación entre direccionamiento y correspondencia en memoria
caché
8.2. Desarrollo
Con esta práctica se pretende, por una parte, que los estudiantes a ancen sus conocimientos
sobre varios tipos de con guraciones de caché, concretamente, cachés multinivel y cachés
separadas (para instrucciones y datos). Para ello, se evaluará mediante el simulador SJM el
comportamiento de dichas con guraciones, y se comparará, respectivamente, con el que tienen
las cachés mononivel y las cachés uni cadas. Por otra parte, se pretende a anzar el dominio
de los estudiantes sobre la relación entre las direcciones de los accesos a memoria y la política
de correspondencia en caché. Para ello, deben analizarse las trazas con las que evaluarán las
con guraciones indicadas, de cara a encontrar las razones por las que los resultados son los
obtenidos. Teniendo en cuenta este planteamiento, en las siguientes secciones se indican qué
con guraciones deben evaluarse y compararse, las trazas a emplear en las simulaciones, y qué
resultados concretos deben analizarse.
Al igual que en las prácticas anteriores, a lo largo de toda la práctica deberéis ir anotando
los resultados y conclusiones obtenidas para luego poder completar el cuestionario de evalua-
ción que se realizará al nal de la sesión de prácticas en el laboratorio usando la plataforma
Moodle.
Caché mononivel vs. Caché multinivel:
Se modelará en SJM una caché mononivel, es decir, que consista en un único nivel de
caché (L1). Luego se modelará una caché multinivel, manteniendo la caché anterior L1
en el primer nivel y añadiéndole un segundo nivel de caché (L2). Las con guraciones
concretas para la L1 y la L2 son las siguientes (los valores de los parámetros de caché
que no se indican deben dejarse a su valor por defecto):
L1: Tamaño de caché 64 KBytes, tamaño de bloque 16 Bytes, correspondencia
asociativa de dos vías, política de reemplazo LRU, escritura inmediata y no carga
en escritura.
L2: Tamaño de caché 256 KBytes, tamaño de bloque 16 Bytes, correspondencia
asociativa de cuatro vías, política de reemplazo LRU, escritura inmediata y no
carga en escritura.
La caché mononivel y la caché multinivel se simularán empleando la traza TrazaL. A
partir de los resultados de estas simulaciones, contesta a las siguientes cuestiones:
33
Manual de laboratorio - Organización de Computadores
1. ¾Cuál es la tasa de fallos de la caché mononivel?
2. ¾Cuál es la tasa de fallos local de la caché L1 en la caché multinivel?
3. ¾Cuál es la tasa de fallos local de la caché L2 en la caché multinivel?
4. Calcula la tasa de fallos global de la caché multinivel.
Además, a la vista de la estructura de la caché multinivel (y de la correspondencia que
establece), y de las direcciones de los accesos de la traza empleada en las simulaciones,
analiza cuáles son las razones por las que el segundo nivel de caché es capaz de resolver
muchos de los fallos que se producen en el primer nivel. Observar en el simulador cómo
se van ocupando los bloques de caché te será de gran ayuda.
Caché uni cada vs. Caché separada:
Se modelará en SJM una caché uni cada, es decir, que almacene por igual datos e
instrucciones, y luego se modelará una caché separada, es decir, que almacene separa-
damente datos e instrucciones. Las con guraciones concretas para la cache uni cada y
la separada son las siguientes (los valores de los parámetros de caché que no se indican
deben dejarse a su valor por defecto):
Uni cada: Tamaño de caché 128 KBytes, tamaño de bloque 16 Bytes, corres-
pondencia directa, política de reemplazo LRU, escritura inmediata y no carga en
escritura.
Separada: Caché de datos de tamaño 64 KBytes, tamaño de bloque 16 Bytes,
correspondencia directa, política de reemplazo LRU, escritura inmediata y no carga
en escritura. Caché de instrucciones idéntica a la de datos, salvo en que no hay que
indicar políticas de escritura.
Nótese que, para que la comparativa sea justa, la suma del tamaño de las cachés de ins-
trucciones y datos es el mismo que el de la caché uni cada. La caché uni cada y la caché
separada se simularán cada una empleando dos trazas (esto es, cada con guración se si-
mulará dos veces, cada vez con una traza distinta). Concretamente, las trazas a emplear
en las simulaciones son TrazaU (diseñada para que la caché uni cada ofrezca mejores
prestaciones que la separada) y TrazaS (diseñada para que la caché separada ofrezca
mejores prestaciones que la uni cada). A partir de los resultados de estas simulaciones,
contesta a las siguientes cuestiones:
1. Cuando se simula con TrazaU ¾Cuál es el número de fallos en la caché uni cada?
¾Cuál es la suma total de fallos de las cachés de instrucciones y datos?
2. Cuando se simula con TrazaS ¾Cuál es el número de fallos de la caché uni cada?
¾Cuál es la suma total de fallos de las cachés de instrucciones y datos?
Además, a la vista de la estructura de las cachés uni cada y separada (y de la corres-
pondencia que establecen), y de las direcciones de los accesos de las trazas empleadas
en las simulaciones, analiza cuáles son las razones por las que TrazaU hace que la ca-
ché uni cada ofrezca mejores prestaciones que la separada y TrazaS hace que la caché
separada ofrezca mejores prestaciones que la uni cada. Observar en el simulador cómo
se van ocupando los bloques de caché te será de gran ayuda.
34
Práctica 9
Evaluación de Jerarquías de Memoria Virtual
Prácticas de Organización de Computadores
2
◦ curso del Grado en Ingeniería Informática
9.1. Objetivos
Reforzar el dominio de la relación entre direcciones virtuales y físicas
Reforzar la asimilación de los conceptos de tabla de páginas y TLB
Iniciarse en la evaluación de jerarquías de memoria que empleen memoria virtual me-
diante SJM
9.2. Desarrollo
Con esta práctica se pretende que el alumno a ance sus conocimientos sobre memoria
virtual en general, y más concretamente, sobre el funcionamiento de tablas de páginas y
TLBs y sobre la correspondencia entre direcciones virtuales y físicas. Para ello, se evaluará
mediante el simulador SJM el rendimiento de con guraciones de jerarquía de memoria que
usan memoria virtual paginada (SJM no permite otro tipo de gestión del espacio de direcciones
virtuales), con y sin TLB. Esta evaluación se realizará mediante el análisis, teórico y simulado,
de con guraciones de la jerarquía concretas con una traza dada.
Al igual que en las prácticas anteriores, a lo largo de toda la práctica deberéis ir anotando
los resultados y conclusiones obtenidas para luego poder completar el cuestionario de evalua-
ción que se realizará al nal de la sesión de prácticas en el laboratorio usando la plataforma
Moodle. IMPORTANTE: para esta práctica debe usarse la versión antigua (anterior a 2011)
del simulador SJM.
Teniendo en cuenta este planteamiento, a continuación se indican qué con guraciones de
jerarquías de memoria deben analizarse, y los resultados que deben obtenerse en cada caso.
Parte 1 Memoria Virtual Paginada sin TLB
En este caso se con gurará una jerarquía con los siguientes elementos y características:
Memoria Caché: Uni cada de 1 nivel, totalmente asociativa y con tiempo de
acceso 2 ciclos. Debe con gurarse como física en la opción Tipo de caché. Los
parámetros no mencionados deben dejarse con su valor por defecto.
Memoria Principal: 20 ciclos de tiempo de acceso y 8 marcos físicos.
Tabla de páginas: 20 ciclos de tiempo de acceso y 16 entradas. En la misma
ventana de con guración de la tabla de páginas debe indicarse el tiempo de acceso
a memoria secundaria (disco), que deberá realizarse en caso de fallo en la tabla.
Este valor incluye el tiempo de cargar la página en memoria principal en caso de
fallo, y debe jarse en 2000 ciclos.
Recordemos que con esta con guración (caché física) todas las direcciones virtuales
deben traducirse antes de acceder a caché, por lo que el tiempo medio de acceso a
memoria puede calcularse como:
tma = tT raduccion + tAccesoCache
Teniendo esto en cuenta, responde a las siguientes cuestiones:
35
Manual de laboratorio - Organización de Computadores
1. Suponiendo que la tasa de fallos de caché es de 0.2222, calcula teóricamente (es
decir, sin usar el simulador SJM) cuál es el tiempo medio de acceso a caché.
2. Teniendo en cuenta el resultado anterior, calcula teóricamente (es decir, sin usar el
simulador SJM) cuál debe ser el tiempo medio de traducción para que el tiempo
medio de acceso a memoria sea de 359.778 ciclos.
3. Teniendo en cuenta el resultado anterior, calcula teóricamente (es decir, sin usar el
simulador SJM) cuál debe ser la tasa de fallos en la tabla de páginas para obtener
ese tiempo medio de traducción.
A continuación, y una vez con gurada en SJM la jerarquía indicada, carga la traza 4
(contenida en el chero traza4 y disponible en Moodle bajo el epígrafe de la Práctica
9) y realiza una simulación paso a paso hasta el nal. Observa en cada paso la ventana
detallada de estado de la tabla de páginas, así como las direcciones virtuales y físicas de
cada acceso en formato binario que aparecen en la ventana principal de la simulación.
Una vez completa la simulación, accede a la ventana de estadísticas y contesta a las
siguientes cuestiones:
1. ¾Cuál es la tasa de fallos de caché?
2. ¾Cuál es el tiempo medio de acceso a memoria?
3. ¾Cuál es la tasa de fallos de la tabla de páginas?
Compara estos resultados con los teóricos calculados anteriormente.
Parte 2 Memoria Virtual Paginada con TLB
En este caso se añadirá a la jerarquía de memoria con gurada anteriormente un TLB
con las siguientes características:
TLB: 1 ciclo de tiempo de acceso y 4 entradas.
Teniendo en cuenta este añadido, responde a las siguientes cuestiones:
1. Asumiendo que se sigue utilizando la traza 4 y teniendo en cuenta tanto la estructu-
ra del TLB añadido como los resultados de la simulación sin TLB, intenta adivinar
(es decir, sin usar el simulador SJM) cuál sería la tasa de fallos del TLB.
2. Teniendo en cuenta lo anterior, intenta adivinar (es decir, sin usar el simulador
SJM) cuál sería ahora la tasa de fallos de la tabla de páginas.
3. Teniendo en cuenta las estimaciones anteriores, calcula teóricamente (es decir, sin
usar el simulador SJM) cuál sería ahora el nuevo tiempo medio de traducción y el
nuevo tiempo medio de acceso a memoria.
A continuación, y una vez con gurada en SJM la jerarquía con el TLB, realiza una
simulación paso a paso hasta el nal usando la traza 4. Observa en cada paso la ventana
detallada de estado del TLB. Una vez completa la simulación, accede a la ventana de
estadísticas y contesta a las siguientes cuestiones:
1. ¾Cuál es la tasa de fallos del TLB?
2. ¾Cuál es la tasa de fallos de la tabla de páginas?
3. ¾Cuál es el tiempo medio de acceso a memoria?
Compara estos resultados con los estimados anteriormente.
36
Apéndice A
Lenguaje ensamblador del procesador MIPS
A.1. La arquitectura
Con el nombre de MIPS (siglas de Microprocessor without Interlocked Pipeline Stages ) se
conoce a toda una familia de microprocesadores de arquitectura RISC desarrollados por MIPS
Technologies. Debido a que los diseñadores crearon un conjunto de instrucciones tan claro, los
cursos sobre arquitectura de computadores en universidades y escuelas técnicas a menudo se
basan en la arquitectura MIPS. El diseño de la familia de CPU's MIPS in uiría de manera
importante en otras arquitecturas RISC posteriores como los DEC Alpha.
En 1981, un equipo liderado por John L. Hennessy en la Universidad de Stanford comenzó
a trabajar en lo que se convertiría en el primer procesador MIPS. La idea básica era mejorar
drásticamente el rendimiento mediante el uso de la segmentación, una técnica que ya era en-
tonces muy conocida pero también difícil de implementar. Su funcionamiento puede resumirse
en que la ejecución de una instrucción es dividida en varias etapas, comenzando la etapa 1
de una instrucción antes de que haya nalizado la ejecución de la instrucción anterior. En
contraste, los diseños tradicionales esperaban la nalización por completo de una instrucción
antes de pasar a la siguiente, de modo que grandes áreas de la CPU permanecían inactivas
mientras el proceso continuaba. Además, la frecuencia de reloj de toda la CPU venía dictada
por la latencia del ciclo completo, en lugar de por el llamado camino crítico, latencia de la
etapa de segmentación que más tarda en completarse.
En 1984 Hennessy se convenció del futuro potencial comercial del diseño, dejando Stanford
para formar MIPS Computer Systems. La empresa presentó su primer diseño, el R2000, en
1985, siendo mejorado con el R3000 de 1988. En 1991 MIPS presentó su primer procesador de
64 bits, el R4000. Desde entonces la empresa ha continuado sacando evoluciones muy utilizadas
en sistemas empotrados y como núcleos de otros sistemas más complejos.
La principales características de la arquitectura MIPS se resumen en la gura A.1 y son:
Una máquina RISC de 32 bits.
Una arquitectura de carga/almacenamiento
Figura A.1: Resumen de la arquitectura de los procesadores MIPS.
37
Manual de laboratorio - Organización de Computadores
El manejo de excepciones, interrupciones y del sistema de memoria virtual lo realiza el
coprocesador 0
El coprocesador 1 se encarga del manejo de los datos en coma otante
A.2. Registros
El procesador MIPS tiene 32 registros de propósito general de tamaño una palabra (32
bits). En la gura A.2 se recogen los registros que incorpora el procesador MIPS.
Figura A.2: Los registros que incorpora el procesador MIPS.
A.3. La unidad de punto otante
Las principales características de la unidad de punto otante (FPU) de los procesadore
MIPS son:
La arquitectura MIPS soporta el estándar IEEE 754 que de ne los formatos de simple
y doble precisión para números en coma otante.
La unidad de coma otante contiene sus propios registros, que se enumeran como f 0,f1,
f 2, ...,f31.
Como estos registros son de 32 bits, se necesitan dos de ellos para almacenar un valor
de 64 bits.
Para simpli car el diseño de la unidad, las instrucciones que operan sobre variables en
coma otante sólo pueden utilizar registros pares, incluyendo tanto instrucciones que
operan sobre números en doble precisión como en simple precisión.
La unidad de coma otante también utiliza un juego de instrucciones basado en carga
almacenamiento.
38
Lenguaje ensamblador del procesador MIPS
A.4. La memoria
En el procesador MIPS la memoria está estructurada según el grá co mostrado en la gura
A.3. Las principales características son:
El ensamblador MIPS direcciona byte a byte, aunque una palabra es de 32 bits.
La memoria direccionable tiene un tamaño de 230 palabras.
Las direcciones comienzan en 0.
Una dirección de memoria es la dirección de 1 byte de memoria. Si esa dirección es la
del primer byte de una palabra (00), es como si fuera la dirección de la palabra.
Los procesadores deben numerar los bytes dentro de una palabra. Existen dos posibli-
lidades: little endian (asignar la dirección más baja al byte de más a la derecha) o big
endian.
La arquitectura MIPS puede operar en cualquiera de los dos modos anteriores, depen-
diendo de la máquina en que se incluya el procesador.
El espacio de direcciones de un programa se divide en tres partes accesibles: Segmento
de datos, Segmento de texto, Segmento de pila.
Los segmentos de pila y de datos son expandibles dinámicamente.
Figura A.3: Estructura de la memoria en el procesador MIPS.
39
Manual de laboratorio - Organización de Computadores
A.5. Formatos de instrucciones
Toda instrucción MIPS tiene 32 bits, igual que una palabra de datos y un registro.
A.6. Modos de direccionamiento
Una de las cosas que más complica la gestión de las instrucciones x86 es la variedad de
modos de direccionamiento disponibles. De cara a simpli car esto los procesadores MIPS sólo
tienen disponibles unos pocos modos de direccionamiento (los más comunes). Esto no di culta
la programación del procesador pues cualquier acceso de los utilizados en los procesadores x86
puede descomponerse en varias instrucciones MIPS que incluyan uno o más accesos a memoria
con direccionamientos sencillos.
Figura A.4: Modos de direccionamiento en el procesador MIPS.
40
Lenguaje ensamblador del procesador MIPS
Los diversos modos de direccionamiento disponibles en el procesador MIPS se recogen en
la tabla de la gura A.4. Sus principales características son:
En el MIPS sólo las instrucciones de carga y almacenamiento acceden a memoria
Casi todas las instrucciones de carga/almacenamiento operan sólo sobre datos alineados .
1
La máquina virtual puede proporcionar los siguientes modos de direccionamiento:
A.7. Directivas del ensamblador
Las directivas del ensamblador permiten al programador interactuar con el procesador y
de nir las variables y constantes que se vayan a utilizar. Todas las directivas del ensamblador
deben comenzar siempre con un punto:
Directiva Descripción
.align n Alinea el siguiente dato sobre un límite de 2n byte (.align 2, .align 0.,..)
.ascii str Almacena la cadena str en memoria, pero no la termina con el caracter nulo.
.asciiz str Almacena la cadena str en memoria, y la termina con el caracter nulo.
.byte/half/word Almacena los n valores de 8/16/32 bits en bytes/medias palabras/palabras
b1, ..., bn consecutivas de memoria.
.double/ oat Almacena los n números de punto otante de doble/simple precisión en
f1,....,fn posiciones consecutivas de memoria.
.data Los elementos siguientes son almacenados en el segmento de datos.
.kdata Los elementos siguientes son almacenados en el segmento de datos del núcleo.
.text Los elementos siguientes son almacenados en el segmento de texto. Estos
elementos sólo pueden ser instrucciones o palabras.
.ktext Los elementos siguientes son almacenados en el segmento de texto del núcleo.
Estos elementos sólo pueden ser instrucciones o palabras.
.space n Asigna n bytes de espacio en el segmento actual (debe ser seg. datos en SPIM)
Declara que el dato almacenado en sym ocupa size bytes y es un
.extern sym size global. El ensamblador lo pone en parte del segmento de datos
fácilmente accesible vía $gp
.globl sym Declara sym como global: se puede referenciar desde otros archivos.
Cuadro A.1: Directivas del ensamblador del procesador MIPS.
1
Alineación: Una cantidad está alineada si su dirección de memoria es múltiplo de su tamaño en bytes.
41
Manual de laboratorio - Organización de Computadores
A.8. Juego de Instrucciones
El lenguaje ensamblador incrementa el número de instrucciones disponibles a los progra-
madores en lenguaje ensamblador y a los compiladores, mediante las pseudoinstrucciones:
Son instrucciones del lenguaje ensamblador que no necesitan ser implementadas en hardware
42
Lenguaje ensamblador del procesador MIPS
43
Manual de laboratorio - Organización de Computadores
44
Lenguaje ensamblador del procesador MIPS
A.9. Llamadas al Sistema
La instrucción que la arquitectura MIPS proporciona para acceder al conjunto de servicios
que aporta al sistema operativo se denomina syscall. Para acceder a un servicio, el programa
debe realizar los siguientes pasos:
1. Escribir el tipo de llamada en el registro $2 ($v0)
2. Escribir los parámetros en los registros $4..$7 ($f2 si se usa coma otante)
3. Ejecutar la orden syscall
Ejemplo sencillo: hello.asm
.text
.globl main
main: li $v0, 4
la $a0, str
syscall # print string
li $v0, 10
syscall # exit
.data
str: .asciiz "Hello World!!!"
45
Manual de laboratorio - Organización de Computadores
A.10. Programación de subrutinas
Los lenguajes de alto nivel como el lenguaje C dan una serie de facilidades en forma de
abstracciones que simpli can mucho la labor del programador. La noción de función supuso
una revolución
2 y un gran avance en los años 70, ya que nos permite dividir el problema en
partes más fáciles de abordar (divide y vencerás).
Estas ideas pueden ser aprovechadas igualmente en lenguajes de bajo nivel (como el en-
samblador de procesadores MIPS) siendo metódicos y atendiendo a una serie de convenciones
entre desarrolladores, y de esta forma crear un mecanismo similar, que nos permita:
Hacer una correspondencia entre los parámetros (registros) que tienen la información
que queremos utilizar y los parámetros formales que por convención utilicemos en este
mecanismo.
Reserva e inicialización de almacenamiento temporal. Esto es particularmente interesante
si queremos que nuestros programas puedan hacer uso de recursión: cada llamada a la
función debe tener su propia copia de las variables locales, para evitar que se pisen entre
ellas.
La información que describe el estado de una función durante su ejecución (los parámetros
que tenga en ese momento incluido la dirección del programa desde la que fue llamada, los
valores de sus variables locales, el puntero a la instrucción que se ejecuta en ese momento,
etc.) conforman lo que llamaremos el entorno de la función. En un programa de ensamblador
MIPS el entorno de una función viene dado por el valor de todos los registros a los que se hace
referencia en la función.
De forma genérica, justo antes de que una función A llame a una función B, ésta vuelca
todo su entorno en la pila y luego ya salta a la función B. Cuando la función B termina y
devuelve el control a la función A, ésta última recupera su entorno extrayéndolo de la pila.
Si bien las funciones de los procesadores MIPS pueden ejecutarse con cualquier registro,
los programadores y desarrolladores han llegado a una especie de convenio implícito para el
uso de los registros, de modo que el código que escriban sea compatible y respetuoso con el
de los demás en entornos de programación funcional con o sin sistema operativo. En la tabla
de la gura A.5 se recogen dichos convenios.
Siendo conservadores en la arquitectura de los procesadores MIPS esto puede realizarse
atendiendo a estas reglas:
La función que llama:
• Pone los parámetros en los registros a0, a1, a2 y a3. Si hubiera más de tres pará-
metros, éstos se colocarían en la pila.
• Guardar cualquiera de los registros temporales t0 a t7 que pudiera ser utilizado
por la función que se va a llamar.
• Ejecutar jal (o jalr ) para llamar a la función (esta función se encarga de guardar
la posición del contador de programa en el registro 31 ra ).
2
Además, en aquella época se programaba casi todo en lenguajes de muy bajo nivel (ensabladores) depen-
dientes de la maquina y su arquitectura. De modo que la falta de lenguajes protables hacía que fuera necesario
reescribir todo el código cada vez que se cambiaba/actualizaba el hardware.
46
Lenguaje ensamblador del procesador MIPS
Figura A.5: Listado de registros en la arquitectura MIPS y la convención que se suele aplicar
a la hora de programar con subrutinas.
3
La función llamada , debe antes de ejecutar su código:
• Crear un marco de pila, restando el tamaño del marco de la posición del puntero
a pila (sp ). Date cuenta que el tamaño mínimo de marco en la arquitectura MIPS
es de 32 bytes, por tanto aún cuando el espacio de memoria que vayamos a utilizar
sea menor, deberíamos utilizar este tamaño.
• Guardar en la pila cualquiera de los registros que se deben preservar según la tabla
de arriba (s0 s7, fp y ra ), para evitar efectos colaterales con la función (o serie
de funciones) que ha/n dado lugar a la llamada. Preservar ra es especialmente
importante en funciones que se llaman a sí mismas (recursivas).
• Colocar el puntero de marco en la posición del puntero de pila más el tamaño del
mismo.
La función llamada ejecuta su código propiamente dicho.
Antes de devolver el control y volver a la función que la llamó, la función invocada debe:
• Poner los valores de los resultados en los registros v0 (y v1 ).
• Recuperar los registros que se habían guardado en la pila (indicados en la tabla).
• Devolver el control a la función que la llamó saltando a ra con jr (muy importante
no utilizar de nuevo jal ).
Una vez recupera el control la función que había llamado, debe:
3
En el enunciado de esta práctica no se distingue entre el concepto de función y procedimiento, aunque la
distinción implique ciertas diferencias.
47
Manual de laboratorio - Organización de Computadores
• Recuperar los registros que se habían guardado en la pila.
• Si se habían pasado argumentos en la pila (en vez o además de a0, a1, a2 y a3 ) se
ha de recolocar su posición.
• Extraer el valor del resultado devuelto en v0 (y v1 ).
48
Apéndice B
Simula3MS
En este manual se explica como utilizar Simula3MS. En la sección B.1 se enumeran los
pasos básicos para usar la herramienta. A continuación se describen de forma más detallada
la edición de programas en lenguaje ensamblador para este procesador, los distintos elementos
del simulador: el segmento de texto, el segmento de datos, los registros, etc. así como las
distintas con guraciones.
B.1. Guía rápida
A continuación se indican los pasos básicos para empezar a trabajar con Simula3MS :
1. Una vez abierta la ventana de Simula3MS , existen dos opciones:
Cargar un chero que ha sido editado con anterioridad.
Editar un nuevo código en lenguaje ensamblador.
2. Una vez editado o cargado el chero, el siguiente paso es ensamblarlo, para ello hay que
pulsar el botón Ensamblar. A partir de aquí hay dos posibles resultados:
Si el código que queremos ejecutar no tiene errores sintácticos se activará el botón
Ejecutar que permite acceder a la ventana de la simulación de la ejecución del
código analizado.
En caso de que el código no sea correcto, en la parte inferior de la ventana aparecerá
un listado con todos los errores y el primero de ellos aparecerá remarcado. Se puede
acceder a los siguientes, en caso de que los hubiera, por medio del botón Error
siguiente. Una vez corregidos estos fallos se vuelve a pulsar botón Ensamblar y se
repite este paso.
3. El paso siguiente, previo a ejecutar, será escoger la con guración del simulador sobre la
que queremos que se ejecute el código. Para ello, en el menú Con guración tenemos tres
posibles opciones: Entrada/Salida, Camino de datos y Técnicas de salto. Por defecto la
opción activada es el camino de datos Monociclo con la Entrada/Salida deshabilitada.
Entrada/Salida. La Entrada/Salida aparece inicialmente desactivada. En caso de
querer realizar una simulación orientada al estudio de los mecanismos de Entra-
da/Salida se puede elegir entre Entrada/Salida con encuesta o Entrada/Salida con
interrupciones.
Camino de datos. La opción seleccionada por defecto es el camino de datos Mo-
nociclo. Al escoger Multiciclo o cualquiera de las implementaciones del procesador
Segmentado, se abrirá una nueva ventana formulario que permite con gurar la la-
tencia de las operaciones en punto otante.
Técnicas de salto. Actualmente hay implementadas en Simula3MS dos técnicas de
salto: Salto retardado y Salto jo. Ambas aparecen inicialmente desactivadas y la
selección de cualquiera de estas técnicas implica escoger el pipeline básico.
49
Manual de laboratorio - Organización de Computadores
4. Una vez obtenido, el código correcto y con gurado el simulador, se pulsa Ejecutar y
tenemos acceso a la ventana en la cual se simula la ejecución del código escogido. En
esta ventana se puede observar la ejecución del programa completo usando el botón
ejecutar, de modo que se mostrarán sólo los valores nales, o bien ciclo a ciclo, mediante
los botones ciclos siguiente y ciclo anterior, pudiendo ver así las modi caciones que cada
instrucción realiza en cada ciclo.
B.2. Manual extendido
B.2.1. Edición del código
El primer paso al iniciar Simula3MS es editar un código en lenguaje ensamblador, para
ello se puede cargar el código de un chero o bien editarlo. La sintaxis básica utilizada por
Simula3MS tiene las siguientes características:
Los comentarios empiezan por el símbolo #, todo lo que aparezca en la misma línea a
continuación de este símbolo es ignorado.
Los programas se dividen en dos partes:
• .text: sección obligatoria en todos los programas, contiene el conjunto de las ins-
trucciones del programa.
• .data: sección opcional, aunque normalmente necesaria. Es la sección de declaración
de las variables del programa.
Características de .text
La sección .text es obligatoria en todos los programas, contiene el conjunto de instrucciones
del programa. Los elementos siguientes se guardan en el segmento de texto.
Las primeras líneas de la sección .text, obligatorias ya que indican al simulador donde debe
empezar la ejecución del programa, son:
.globl main
.main:
A continuación se escribe el código del programa, siguiendo estas reglas:
Las etiquetas van seguidas por dos puntos (:). Una etiqueta válida es una secuencia de
caracteres alfanuméricos, subrayados (_) y puntos (.).
En la línea de la etiqueta no puede haber una instrucción, las instrucciones se situarán
a partir de la línea siguiente a la etiqueta.
Las instrucciones válidas implementadas en este simulador se muestran en tablas según
su tipo. Las enteras tipo R en el cuadro B.1, las tipo I en el B.2 y las tipo J en la tabla
B.3. En cuanto a las de punto otante, las de tipo R se muestran en los cuadros B.4,
B.5 y B.6, mientras que las de tipo I están en el cuadro B.7.
50
Simula3MS
Figura B.1: Ventana del editor
51
Manual de laboratorio - Organización de Computadores
Los registros enteros pueden indicarse por su número de orden o por su nombre, por
ejemplo $t1=$9. Las equivalencias se muestran en el cuadro B.9. En el caso de los regis-
tros de punto otante, también se permiten ambas nomenclaturas pero la equivalencia
se limita a suprimir la f. Ejemplo: $f6=$6.
Por defecto los números se representan en base 10.
Se pueden incluir llamadas al sistema operativo (syscall ), para solicitar algún servicio
como impresión por pantalla, ver sección B.5.
Con el objetivo de ayudar al usuario a cargar variables, Simula3MS tiene también im-
plementadas las pseudoinstrucciones la y li. Por ejemplo:
la $1, variable
carga en el registro $1 la dirección de memoria donde está almacenada la variable. La
ejecución de está pseudoinstrucción se divide en dos instrucciones:
lui $1, 0x1001 (representa los 16 bits de mayor peso de la dirección de memoria)
ori $ra, 0x0004 (16 bits de menor peso de la dirección de memoria)
Características de .data
La sección .data contiene la declaración de las variables del programa. Los elementos
siguientes se guardan en el segmento de datos, en concreto en la memoria. Esta sección es
opcional.
La declaración de las variables del programa se ajusta a las siguientes reglas:
En cada línea no puede haber más de una etiqueta.
La declaración de una variable sigue este formato:
• En primer lugar debe ir un identi cador de variable válido (etiqueta). Se considera
válida cualquier secuencia de caracteres alfanuméricos, subrayados y puntos.
• A continuación se indica el tipo de variable. La tabla B.8 muestra una relación de
los tipos implementados en Simula3MS , sus características y la estructura de la
de nición.
• Finalmente se inicializa la variable.
Las cadenas de caracteres se encierran entre comillas dobles.
Los números se consideran en base 10 por defecto. Si van precedidos del pre jo 0x se
interpretan en hexadecimal.
La Figura B.1 muestra un ejemplo de código.
Ensamblar
Una vez editado o cargado el código del programa es necesario ensamblarlo, para ello
se utiliza el botón Ensamblar. Si el código es sintácticamente correcto se activará el botón
Ejecutar y se puede avanzar a la simulación del programa, si no es necesario corregir el
código teniendo en cuenta los errores. Para facilitar esta tarea podemos ayudarnos del botón
ErrorSiguiente que, como su nombre indica, avanza al siguiente error de forma cómoda.
52
Simula3MS
Inst. De nición Formato
add Almacena en el registro $1 el valor de la suma add $1, $2, $3
de los otros dos
sub Almacena en el $1 el valor de la resta de $2 sub $1, $2, $3
(minuendo), menos el $3 (sustraendo)
and Almacena en el $1 el resultado de hacer una and $1, $2, $3
operación AND entre los otros dos registros
or Almacena en el $1 el resultado de hacer una or $1, $2, $3
operación OR entre los registros $2 y $3
slt Coloca un 1 en el registro $1 si el valor alma- slt $1, $2, $3
cenado en $2 es menor que el de $3. Si no lo es
se almacena un 0 en $1.
jr Modi ca la dirección del PC, por aquel valor jr $1
almacenado en el registro $1
div Se almacena en el HI el resto y en LO el cociente div $1, $2.
de dividir $1 (dividendo) entre $2(divisor).
mult Se almacena en el registro LO los 32 bits de mult $1, $2.
menor peso y en HI los 32 de mayor peso de la
multiplicar $1 y $2.
mfhi Copia el valor almacenado en el registro HI en mfhi $1.
$1
m o Copia el valor almacenado en LO en el registro m o $1.
$1
mfc0 Trans ere el registro $2 del coprocesador 0 al mfc0 $1, $2
registro $1 de la CPU.
sll Almacena en el registro $1 el valor del registro sll $1, $2, n
$2 desplazado n bits a la izquierda
srl Almacena en el registro $1 el valor del registro srl $1, $2, n
$2 desplazado n bits a la derecha
sra Almacena en el registro $1 el valor del registro sra $1, $2, n
$2 después de hacer un desplazamiento aritmé-
tico de n bits a la derecha
Cuadro B.1: Instrucciones tipo R
53
Manual de laboratorio - Organización de Computadores
Inst. De nición Formato
addi Se almacena en el registro $1 la suma del registro $2 y el valor de addi $1, $2, constante
la constante
andi El registro $1 tiene el resultado de una operación AND entre $2 andi $1, $2, constante
y la constante
ori El registro $1 tiene el resultado de una operación OR entre $2 y ori $1, $2, constante
la constante
slti Almacena en $1 un 1 si el valor registro $2 es menor que el de la slti $1, $2, constante
constante. En caso contrario almacena un 0
lui Carga la constante en los 16 bits más signi cativos del registro $1 lui $1, constante
lw Carga en el registro $1 la palabra almacenada en la dirección de lw $1, desplazamien-
memoria que contiene el registro $2 más el desplazamiento. La to($2)
nueva dirección calculada debe ser múltiplo de cuatro
lb Carga en el registro $1 el byte de memoria apuntado por la direc- lb $1, desplazamien-
ción almacenada en el registro $2 más el desplazamiento to($2)
sw Almacena en memoria en la posición obtenida de sumarle el des- sw $1, desplazamien-
plazamiento a la dirección del registro $2, la palabra del registro to($2)
$1. La dirección debe ser múltiplo de 4.
sb Almacena en la posición de memoria correspondiente al valor de sb $1, desplazamien-
$2 más el desplazamiento, el primer byte de la palabra almacenada to($2).
en $1.
beq Si el valor de $1 y $2 es igual se modi ca el valor del PC para beq $1, $2, etiqueta.
pasar a ejecutar el trozo de código apuntado por la etiqueta.
bne Si el valor de $1 y $2 no es igual se modi ca el valor del PC para bne $1, $2, etiqueta.
pasar a ejecutar el trozo de código apuntado por la etiqueta.
Cuadro B.2: Instrucciones tipo I
Inst. De nición Formato
j Modi ca el valor del PC para ejecutar las ins- j etiqueta
trucciones siguientes a la etiqueta
jal Modi ca el valor del PC por aquel al que apun- jal etiqueta
ta la etiqueta y almacena la dirección actual del
PC en $ra
Cuadro B.3: Instrucciones tipo J
54
Simula3MS
Inst. De nición Formato
add.s Se almacena en el registro $f1 el valor add.s $f1, $f2, $f3
de la suma de los otros dos (precisión
simple)
add.d Se almacena en el registro $f0 el valor add.d $f0, $f2, $f4
de la suma de los otros dos (precisión
doble)
sub.s Se almacena en el registro $f1 el valor sub.s $f1, $f2, $f3
de la resta de los otros dos (precisión
simple)
sub.d Se almacena en el registro $f0 el valor sub.d $f0, $f2, $f4
de la resta de los otros dos (precisión
doble)
mul.s Se almacena en el registro $f1 el va- mul.s $f1, $f2, $f3
lor de la multiplicación de los otros dos
(precisión simple)
mul.d Se almacena en el registro $f0 el va- mul.d $f0, $f2, $f4
lor de la multiplicación de los otros dos
(precisión doble)
div.s Se almacena en el registro $f1 el valor div.s $f1, $f2, $f3
de la división de los otros dos (precisión
simple)
div.d Se almacena en el registro $f0 el valor div.d $f0, $f2, $f4
de la división de los otros dos (precisión
doble)
Cuadro B.4: Instrucciones tipo R con 3 argumentos
55
Manual de laboratorio - Organización de Computadores
Inst. De nición Formato
mov.s Trans ere el número en punto otante de precisión simple mov.s $f1, $f2
del registro $f2 al $f1
mov.d Trans ere el número en punto otante de precisión doble del mov.s $f0, $f2
registro $f2 al $f0
abs.s Calcula el valor absoluto del número en punto otante de abs.s $f1, $f2
precisión simple del registro $f2 y lo almacena en $f1
abs.d Calcula el valor absoluto del número en punto otante de abs.d $f0, $f2
precisión doble del registro $f2 y lo almacena en $f0
neg.s Niega el número en punto otante de precisión simple del neg.s $f1, $f2
registro $f2 y lo almacena en $f1
neg.d Niega el número en punto otante de precisión doble del neg.d $f0, $f2
registro $f2 y lo almacena en $f0
c.eq.s Si los valores de los registros de precisión simple $f1 y $f2 c.eq.s $f1, $f2
son iguales se escribe un 1 en el registro status
c.eq.d Si los valores de los registros de precisión doble $f0 y $f2 son c.eq.d $f0, $f2
iguales se escribe un 1 en el registro status
c.le.s Si el valor del registro $f1 es menor o igual que el del registro c.le.s $f1, $f2
$f2, ambos de precisión simple, se escribe un 1 en el registro
status
c.le.d Si el valor del registro $f0 es menor o igual que el del registro c.le.d $f0, $f2
$f2, ambos de precisión doble, se escribe un 1 en el registro
status
c.lt.s Si el valor del registro $f1 es menor que el del registro $f2, c.lt.s $f1, $f2
ambos de precisión simple, se escribe un 1 en el registro sta-
tus
c.lt.d Si el valor del registro $f0 es menor que el del registro $f2, c.lt.d $f0, $f2
ambos de precisión doble, se escribe un 1 en el registro status
cvt.d.s Convierte el número en punto otante de precisión simple cvt.d.s $f2, $f1
del registro $f1 a un número de precisión doble y lo guarda
en $f2
cvt.s.d Convierte el número en punto otante de precisión doble del cvt.s.d $f1, $f2
registro $f2 a un número de precisión simple y lo guarda en
$f1
Cuadro B.5: Instrucciones tipo R con 2 argumentos
56
Simula3MS
Inst. De nición Formato
mtc1 Trans eren el registro $t1 de la CPU al registro $f1 mtc1 $f1, $t1
del coprocesador de punto otante
mfc1 Trans eren el registro $f1 del coprocesador de punto mfc1 $t1, $f1
otante al registro $t1 de la CPU
cvt.d.w Convierte el número entero del registro $t1 a un cvt.d.w $f2, $t1
número de precisión doble y lo guarda en $f2
cvt.s.w Convierte el número entero del registro $t1 a un cvt.s.w $f1, $t1
número de precisión simple y lo guarda en $f1
cvt.w.d Convierte el número en punto otante de precisión cvt.w.d $t1, $f2
doble del registro $f2 a un número entero y lo guar-
da en $t1
cvt.w.s Convierte el número en punto otante de precisión cvt.w.s $t1, $f1
simple del registro $f1 a un número entero y lo guar-
da en $t1
Cuadro B.6: Instrucciones que usan registros enteros
Inst. De nición Formato
lwc1 Carga en el registro $f1 la palabra alma- lwc1 $f1, desplazamiento($s2)
cenada en la dirección de memoria que
contiene el registro $s2 más el despla-
zamiento.La nueva dirección debe ser
múltiplo de 4
swc1 Se almacena la palabra del registro $f1 swc1 $f1, desplazamiento($s2)
en la posición de memoria obtenida al
sumar la dirección que contiene el re-
gistro $s2 más el desplazamiento.La di-
rección debe ser múltiplo de 4
bc1t Si status=1 se modi ca el valor del PC bc1t etiqueta
para ejecutar el trozo de código apun-
tado por la etiqueta
bc1f Si status=0 se modi ca el valor del PC bc1f etiqueta
para ejecutar el trozo de código apun-
tado por la etiqueta
Cuadro B.7: Instrucciones tipo I
57
Manual de laboratorio - Organización de Computadores
Tipo De nición Estructura de la de nición
.ascii Almacena en memoria el string como variable: .ascii "string a almacenar"
una lista de caracteres
.asciiz Almacena en memoria el string como variable: .asciiz "string a almacenar"
una lista de caracteres y lo termina
con 0
.word Almacena la lista de palabra en posi- variable: .word palabra1, palabra2, ...
ciones secuenciales de memoria
.space Reserva n bytes de espacio en la me- variable: .space n
moria.
. oat Almacena la lista de números en pun- variable: . oat f1, f2, . . .
to otante de simple precisión en po-
siciones sucesivas de memoria.
.double Almacena la lista de números en pun- variable: .double d1, d2, . . .
to otante de doble precisión en posi-
ciones sucesivas de memoria.
Cuadro B.8: Tipos de datos en Simula3MS
B.2.2. Con guración del camino de datos del simulador
Por defecto al inicializar Simula3MS la con guración del procesador es monociclo, pero
puede cambiarse en cualquier momento, bien antes de editar el código o después de terminar
de escribir el programa en ensamblador, o bien después de realizar cualquier simulación previa.
Para cambiar la con guración acceder al menú Con gurar/Camino de datos en la barra de
herramientas y seleccionar la opción adecuada. En caso de escoger la con guración multiciclo,
o cualquiera de las opciones de la con guración segmentada, se mostrará una nueva ventana en
la que además, podremos con gurar la latencia de las unidades funcionales de punto otante.
B.3. Ventana de registros
Los registros se agrupan en tres clases:
Registros especiales:
• PC es el contador del programa (program couter ). Este registro se inicializa por el
sistema operativo apuntando a la dirección de la primera instrucción del programa
en memoria. Al cargar cualquier instrucción de memoria el PC se incrementa de
forma que la CPU tendrá el valor de la dirección de la siguiente instrucción que va
a ser cargada.
• EPC, Cause, Status y BadVaddr son registros utilizados para el manejo de instruc-
ciones e interrupciones.
◦ El registro EPC contiene la dirección de la instrucción que ha causado la ex-
cepción. En el caso de Entrada/Salida con interrupciones indica la instrucción
que se estaba ejecutando en el momento que se produjo la interrupción.
58
Simula3MS
Figura B.2: Ventana de la con guración monociclo 59
Manual de laboratorio - Organización de Computadores
◦ El registro Cause almacena el tipo de excepción y bits de interrupción pen-
diente.
◦ El registro Status se usa como condición de salto en las instrucciones bc1t y bc1f.
En la Entrada/Salida con interrupciones almacena la máscara de interrupciones
y los bits de autorización.
◦ El registro BadVaddr contiene la dirección en la que ha ocurrido la referencia
de memoria. Este registro no se usa actualmente en Simula3MS .
• Hi y Lo son dos registros para poder operar con operandos de 64 bits, como sucede
en el caso de la multiplicación y la división.
Registros generales: La arquitectura MIPS posee 32 registros genéricos de 32 bits ($0-
$31) para uso del programador (ver tabla B.9). Existen reglas de uso de los registros,
también llamadas convención de llamada a procedimiento, que indican cual debe ser
el uso de los registros, especialmente en las llamadas a procedimientos, que hace el
programa. Tal como indica su nombre, estas reglas son, en su mayor parte, convenciones
seguidas por los programas más que reglas forzadas por la circuitería. De todos modos la
mayoría de los programadores se esfuerzan por seguir estas convenciones porque violarlas
sería fuente de un mayor número de errores.
Nombre Número Uso
$zero 0 Valor constante 0. Sólo es de lectura.
$at 1 Reservado por el ensamblador.
$v0-$v1 2-3 Valores para resultados y evaluación de expre-
siones.
$a0-$a3 4-7 Argumentos.
$t0-$t7 8-15 Registros temporales.
$s0-$s7 16-23 Registros salvados.
$t8-$t9 24-25 Registros temporales.
$k0-$k1 26-27 Reservados por el Sistema Operativo.
$gp 28 Puntero global. No implementado en
Simula3MS .
$sp 29 Puntero de pila.
$fp 30 Puntero de bloque de activación. No implemen-
tado en Simula3MS .
$ra 31 Dirección de retorno de las subrutinas.
Cuadro B.9: Convención de los registros MIPS
Registros de punto otante: La arquitectura MIPS R2000 (que simula esta herra-
mienta) no dispone de unidad de punto otante incluida en el microprocesador si no que
implementa estas funciones en coprocesadores separados. La arquitectura MIPS tiene
en cada coprocesador 32 registros de 32 bits para punto otante ($f0-$f31), que pueden
ser organizados en 16 registros de doble precisión, con 64 bits (para ello se toman las
designaciones par de los registros).
60
Simula3MS
B.4. Memoria
Simula3MS divide la memoria en cuatro partes.
La primera parte, junto al extremo inferior del espacio de direcciones, es el segmento de
texto, que contiene las direcciones del programa y empieza en la dirección 0x00400000.
La segunda parte, sobre el segmento de texto, es el segmento de datos, que se divide en
dos partes:
• Los datos estáticos, a partir de la dirección 0x10010000. Estos datos contienen
objetos cuyo tamaéo es conocido por el compilador y su tiempo de vida es la
ejecución entera del programa.
• Inmediatamente después de los datos estáticos están los datos dinámicos. Como su
nombre indica, estos datos son reservados por el programa durante su ejecución.
Como el compilador no puede predecir cuánta memoria va a reservar un programa
el sistema operativo extiende el área de datos dinámicos para satisfacer la demanda.
La tercera parte, la pila del programa reside en el extremo superior del espacio de
direcciones virtual, situado en la dirección 0x70000000. El tamaño máximo de la pila
que usará un programa no se puede conocer previamente, por lo tanto es necesario que
el usuario desplace el puntero de pila hacia abajo antes de insertar nuevos elementos.
Las direcciones de Entrada/Salida se sitúan a partir de la dirección 0x0000. Un pro-
cesador MIPS R2000 utiliza Entrada/Salida mapeada en memoria. Simula3MS cuenta
con cuatro posiciones de memoria de Entrada/Salida, dos de ellas dedicadas a la entrada
y las otras dos a la salida.
• Control del receptor, se encuentra en la posición 0x0000. Se pone a 1 el último
bit para indicar que ha llegado un carácter del teclado que todavía no se ha leído.
Se pone a 0 en cuanto se lee el dato de Datos del receptor. Por otro lado, el segundo
bit menos signi cativo indica si las interrupciones están activadas.
• Datos del receptor, se encuentra en la posición 0x0004 y contiene el último ca-
rácter escrito en el teclado.
• Control del transmisor, se encuentra en la posición 0x0008. Un 0 en el último bit,
indicaría que el transmisor todavía está ocupado escribiendo el carácter anterior,
pero esto no se contempla en Simula3MS , por lo que siempre tendrá a 1 el último
bit. Al igual que en el caso de Control del receptor, el segundo bit menos signi cativo
indica si las interrupciones están activadas.
• Datos del transmisor, se encuentra en la posición 0x000c. Esta posición de me-
moria almacena en sus 8 bits menos signi cativos el valor en ASCII del carácter
que será visualizado por el monitor.
Esta división de la memoria no es la única posible. De todos modos, tiene como caracte-
rística más importante que la pila y la memoria están lo más alejadas posibles, de forma que
la pila puede crecer hasta ocupar el espacio de direcciones del programa por entero.
61
Manual de laboratorio - Organización de Computadores
B.4.1. Segmento de datos
En la representación de Simula3MS , la pila y el segmento de datos explicado anteriormente
se agrupan en segmento de datos ya que ambos almacenan los datos necesarios durante la
ejecución del programa.
En Simula3MS la memoria está dividida en palabras de 32 bits, por lo que hay 4 bytes
almacenado en cada palabra. Debido a esta organización de la memoria nos encontramos con
un requisito denominado restricción de alineación para el acceso a las palabras de memoria,
ya que las direcciones deben ser siempre múltiplo de 4 y la dirección de una palabra es la de su
primer byte. Esta restricción de alineación facilita la transferencia de datos más rápidamente.
Otro aspecto curioso está relacionado con la forma en que se representan y referencian los
bytes dentro de una palabra. En Simula3MS se sigue el convenio Little Endian ya que se usa
la dirección del byte de más a la derecha o de menor peso como dirección de palabra.
Cada línea del segmento de texto de Simula3MS (ver gura B.2) sigue el formato:
El primer valor, entre corchetes, indica la dirección en memoria a partir de la cual se
almacena la primera palabra, las otras palabras están situadas en posiciones sucesivas de
memoria.
Las restantes cuatro palabras representan los valores, en hexadecimal, de los datos alma-
cenados en esas direcciones.
En la pila el formato es aproximadamente el mismo, pero sólo se indica la dirección a la que
apunta el puntero de pila. Hay que recordar que para que la pila crezca es necesario desplazar
el puntero de pila hacia posiciones inferiores.
B.4.2. Segmento de texto
El segmento de texto muestra las instrucciones del programa que se cargan automática-
mente cuando se empieza la simulación. Cada instrucción se muestra en una línea (ver gura
B.2) de la siguiente forma:
El primer número de la línea, entre corchetes, es la dirección de memoria hexadecimal
de la instrucción.
El segundo número es la codi cación numérica de la instrucción, es decir, el valor que
almacenaría el procesador para la instrucción en lenguaje máquina (también se muestra
en hexadecimal).
En último lugar se muestra la descripción de la instrucción. En todos los casos la des-
cripción de la instrucción coincide con la instrucción del código del programa, excepto
en el caso de las pseudoinstrucciones la y li, las únicas aceptadas por Simula3MS .
B.5. Llamadas al sistema
Simula3MS ofrece un pequeño conjunto de servicios de llamada al sistema operativo a
través de la instrucción de llamada al sistema (syscall ). Para pedir un servicio el programa
carga el código de llamada al sistema (tabla B.10) en el registro $v0 y los argumentos en
los registros $a0 y $a1 (o $f12 para valores de punto otante). Las llamadas al sistema que
62
Simula3MS
devuelven valores ponen sus resultados en el registro $v0 (o $f0 para resultados de punto
otante).
Existen llamadas al sistema para salida de datos:
A la llamada al sistema print_int se le pasa un valor y lo muestra como un entero en
un diálogo de información.
print_ oat muestra en el diálogo el valor en punto otante que se le pasa.
print_double hace lo mismo que print_ oat pero permite un rango más amplio de
números en punto otante.
print_string muestra en el diálogo la cadena almacenada a partir de la dirección que
indica $a0 hasta que encuentra el carácter de nalización de cadena.
También hay llamadas al sistema para entrada de datos, estos datos se solicitan al usuario
a través de diálogos. Son:
read_int almacena el entero que introduce el usuario en $v0.
read_ oat almacena el número de punto otante que le introduce el usuario en el registro
$f0 con formato de simple precisión.
read_double almacena el número de punto otante que le introduce el usuario en los
registros $f0 y $f1, puesto que el formato de doble precisión necesita dos registros para
almacenar un valor.
read_string almacena la dirección de comienzo de la cadena que introduce el usuario en
el registro $a0 y la longitud de dicha cadena en $a1. Estos datos son reservados por el
programa durante su ejecución y por tanto se consideran datos dinámicos.
Otra llamada al sistema muy utilizada es exit utilizada para indicar al procesador que se
ha terminado la ejecución del programa.
B.6. Punto de ruptura
Los puntos de ruptura se utilizan para parar la ejecución del simulador en una instrucción
determinada.
En el caso de Simula3MS pueden insertarse y desactivarse en cualquier momento de la
ejecución mediante un menú desplegable que contiene una lista de las direcciones de memoria
donde están almacenadas las instrucciones. Esta lista de direcciones comprende desde la de la
instrucción siguiente a la que está en ejecución hasta la última del código.
B.7. Simulación con el procesador monociclo
Un procesador monociclo se caracteriza por la ejecución de cada instrucción en un ciclo
de reloj.
La simulación de este procesador en Simula3MS se representa en la gura B.2 cuyas
características han sido detalladas en los apartados anteriores.
63
Manual de laboratorio - Organización de Computadores
Código Nombre Operación
1 print_int Imprime como un entero aquello que se encuentra en $a0.
2 print_ oat Imprime como un número en punto otante de aquello
que se encuentra en $f12.
3 print_double Imprime como un número en punto otante aquello que
se encuentra en $f12 y $f13, considerando que forman un
sólo registro de doble precisión.
4 print_string Imprime como un string aquello que se encuentra en la
posición indicada por $a0.
5 read_int Solicita un entero que se almacenará en el registro $v0.
6 read_ oat Solicita un número en punto otante que se almacenará
en el registro $f0 con formato de simple precisión.
7 read_double Solicita un número en punto otante que se almacenará
en el registro $f0 (y $f1) con formato de doble precisión.
8 read_string Solicita un string que se almacena en $a0 y cuya longitud
se guarda en $a1.
10 exit Finaliza la ejecución.
Cuadro B.10: Códigos asociados a syscall
Figura B.3: Primer modelo de camino de datos
64
Simula3MS
Tanto en el procesador monociclo como en el muticiclo, podemos distinguir 3 tipos de
caminos de datos. En primer lugar están los correspondientes a instrucciones enteras (ver
gura B.3) que constan de una ALU y un banco de registros enteros.
Figura B.4: Segundo modelo de camino de datos
Figura B.5: Tercer modelo de camino de datos
La mayoría de las instrucciones de punto otante usan un camino de datos que substituye
la ALU por una FPU (Floating Point Unit) y los registros enteros por los de punto otante.
Este modelo incluye además la representación del registro especial Status (ver gura B.4).
Por último, existe un modelo híbrido de los dos. Se trata de un camino de datos con una
ALU y un banco de registros enteros, pero incluyendo el registro Status (con sus líneas de
control correspondientes) y unas líneas que nos indican cuando leer o escribir en un registro
65
Manual de laboratorio - Organización de Computadores
de punto otante. Este modelo ( gura B.5) es necesario en instrucciones de punto otan-
te que operen con ambos tipos de registros, como pueden ser las instrucciones de carga o
almacenamiento de punto otante.
El funcionamiento de los botones de esta herramienta es el siguiente:
Volver al editor. En el caso de que se produzca algún error en ejecución será el único botón
que permanecerá activado.
Paso anterior. Sólo aparece habilitado en la con guración multiciclo.
Paso siguiente. Sólo aparece habilitado en la con guración multiciclo.
Ciclo anterior. Retrocede un ciclo en la ejecución. Si se trata de una operación aritmética
en punto otante y se encuentra en la etapa de ejecución del simulador multiciclo,
retrocederá el número de ciclos que se haya especi cado en la con guración.
Ciclo siguiente. Avanza un ciclo en la ejecución. Si se trata de una operación aritmética en
punto otante y se encuentra en la etapa 2 del simulador multiciclo, avanzará el número
de ciclos que se haya especi cado en la con guración.
Ejecutar. Ejecuta la totalidad del código, a menos que se haya insertado un punto de ruptura
en cuyo caso se ejecutará hasta ese punto.
Breakpoint. Si el botón de selección correspondiente está activado se despliega una lista con
los PCs comprendidos entre el de la instrucción que en ese momento se está ejecutando
y el último. La identi cación de las instrucciones por medio de su PC correspondiente
no resulta complicado, ya que en el segmento de texto ambos aparecen relacionados.
Ciclos Contador del número de ciclos que ha consumido la ejecución de las instrucciones
hasta ese momento.
B.8. Simulación con el procesador multiciclo
Un procesador multiciclo se caracteriza por subdividir las instrucciones en diferentes eta-
pas, cada una de las cuales se ejecuta en un ciclo de reloj. Si la instrucción que se está eje-
cutando es una suma, resta, multiplicación o división en punto otante, la etapa de ejecución
ocupará tantos ciclos de reloj como se le especi que en la con guración.
El entorno grá co asociado a esta simulación (ver gura B.6) es análogo al de una simu-
lación monociclo, la diferencia más signi cativa es la activación de los botones Paso siguiente
y Paso anterior.
Paso anterior. Sitúa la ejecución en el primer ciclo de la instrucción anterior.
Paso siguiente. Sitúa la ejecución en el último ciclo de la instrucción actual. Si ésta instruc-
ción está en el último ciclo avanza hasta el último de la instrucción siguiente.
66
Simula3MS
Figura B.6: Con guración multiciclo 67
Manual de laboratorio - Organización de Computadores
B.9. Simulación con el procesador segmentado
Un procesador segmentado se caracteriza por la ejecución solapada de diferentes instruc-
ciones.
B.9.1. Segmentación básica
Es necesario destacar que:
Los saltos se deciden en la segunda etapa de la segmentación, y su comportamiento
va a ser diferente según cual fuese la técnica de salto escogida en la fase previa de
con guración.
• Con la estrategia de salto retardado la instrucción que va a continuación del salto
se ejecutará siempre, tanto si se realiza el salto como si no lo hace. En ocasiones
será útil utilizar una instrucción nop después de instrucciones de salto para evitar
que el programa funcione erróneamente.
• La técnica de salto jo no efectivo permite que la instrucción posterior al salto
empiece su ejecución. Si el salto es no efectivo, no se toma, se continúa con la
ejecución de dicha instrucción. Si es efectivo dicha instrucción es eliminada del
cauce creando una burbuja.
Para gestionar riesgos RAW el procesador usa dos técnicas:
• Anticipación : permite adelantar un dato obtenido en las etapas EX o MEM en un
ciclo t a la etapa EX en el ciclo t+1.
• Detección : se detiene la ejecución de la instrucción con riesgo en la etapa ID, in-
sertando burbujas, hasta que éste se resuelve.
Los riesgos WAW se gestionan con la técnica de detección. Si una instrucción va a alcanzar
la etapa WB antes que otra instrucción previa que tiene el mismo registro destino, se
detiene la primera en la última etapa de EX hasta que la anterior avance a la etapa
MEM.
Los riesgos de postescritura aparecen cuando dos instrucciones en punto otante al-
canzan la etapa WB en el mismo ciclo de reloj. Para gestionarlos, cuando dos o más
instrucciones en punto otante alcanzan la última etapa de ejecución en el mismo ciclo
de reloj son detenidas, a excepción de aquélla que está en la unidad funcional de mayor
latencia.
Antes de realizar una llamada al sistema el procesador espera a que el cauce se vacíe. Se
ha considerado que la ejecución de una llamada al sistema consume un ciclo de reloj y
no se contabilizan los ciclos que consume el SO al realizar el servicio requerido. Después
de una llamada al sistema se sigue ejecutando el resto del código secuencialmente.
Si la ejecución del programa en ensamblador no terminase con la llamada al sistema
de nalización, sino porque en el segmento de texto no hay más instrucciones o porque
se ha insertado un punto de ruptura, el cauce parará antes de terminar la ejecución de
todas las instrucciones, por lo que no se ejecutará el programa completo.
68
Simula3MS
La segmentación se puede representar grá camente mediante tres tipos de diagramas.
• Diagrama ”camino de datos”: muestra el estado del camino de datos durante
un ciclo de reloj, identi cando cada instrucción con etiquetas encima de la etapa
correspondiente.
Se usa este tipo de diagrama para mostrar con más detalle que está ocurriendo en
el procesador durante cada ciclo del reloj, ver gura B.7.
• Diagrama monociclo: muestra el estado general del cauce durante un ciclo de
reloj, incluyendo tanto el procesador como el co-procesador de punto otante. En los
diagramas de este tipo se ve con más detalle que está ocurriendo en la segmentación
durante cada ciclo de reloj. Para diferenciar las unidades funcionales segmentadas
de las no segmentadas, las primeras se representan separadas por echas, mientras
que las últimas están todas unidas, ver gura B.8.
• Diagrama multiciclo ( gura B.9): se utiliza para dar una perspectiva general de
diferentes situaciones dentro de la segmentación. Muestra la evolución de todas las
instrucciones que están en ese momento en el cauce hasta el ciclo actual de ejecución.
Se considera que el tiempo avanza de izquierda a derecha y las instrucciones se
colocan siguiendo el orden de las etapas del cauce.
El simulador dispone de botones que permiten ejecutar el programa escrito en ensambla-
dor completo, o bien ciclo a ciclo. También se tiene la posibilidad de retroceder a ciclos
anteriores. En cualquier momento de la ejecución se podrá poner un punto de ruptura.
B.9.2. Simulación con plani cación dinámica
Dentro de la con guración segmentada se puede escoger dos técnicas de plani cación di-
námica: las técnicas de Tomasulo y Marcador.
Es necesario destacar que:
Las instrucciones aparecerán en la tabla de instrucciones desde la etapa de búsqueda.
Los saltos enteros se deciden en la segunda etapa, pero los saltos en punto otante se
deciden en la etapa de ejecución correspondiente a cada una de las técnicas. La ejecución
de un salto en punto otante supone la detención de todo el procesador hasta que éste se
haya resuelto, mientras que la ejecución de un salto entero sólo detendrá el co-procesador
otante.
Aunque la ejecución de un programa en ensamblador no terminase con la correspondiente
llamada al sistema, sino porque en el segmento de texto no hay más instrucciones o
porque se ha insertado un punto de ruptura, el procesador segmentado terminará la
ejecución de todas las instrucciones.
Al nalizar la ejecución de estas técnicas se activará el botón de informe, que muestra
un pequeño resumen con las características más relevantes de la ejecución.
69
Manual de laboratorio - Organización de Computadores
Figura B.7: Diagrama ”camino de datos” para un solo ciclo de ejecución en procesador seg-
mentado
70
Simula3MS
71
Figura B.8: Diagrama monociclo de la ejecución en procesador segmentado
Manual de laboratorio - Organización de Computadores
72
Figura B.9: Diagrama que muestra multiples ciclos en un procesador segmentado
Simula3MS
Figura B.10: Informe
Informe
Estas técnicas ofrecen la posibilidad de generar un informe (ver Figura B.10) que resume
las características más relevantes de la ejecución de ese código.
Este informe se puede dividir en cuatro secciones. La primera de ellas se encuentra en
la parte superior izquierda e indica las características hardware de la con guración escogida.
En la esquina superior derecha aparecen el CPI. En la parte inferior izquierda un grá co
muestra un porcentaje de los riesgos detectados en la ejecución que aparecen más detallados
a la derecha.
Técnica de Marcador
La representación especí ca de la técnica de Marcador consta de tres tablas, como se puede
ver en la Figura B.11. En la primera de ellas es la tabla de las instrucciones y se muestra la
etapa en la que se encuentra actualmente cada una de las instrucciones.
La segunda tabla es la de las unidades funcionales. En ella se representa toda la información
de las unidades funcionales que el usuario ha escogido. Esta información variará en función de
si la unidad funcional está ocupada o no, y en caso a rmativo, también in uirá la etapa en la
que se encuentre la instrucción que ocupa la unidad.
73
Manual de laboratorio - Organización de Computadores
Figura B.11: Con guración Marcador
La última tabla es una representación de los registros en punto otante e indica si alguno
de ellos va a ser escrito por una instrucción que se encuentre actualmente en ejecución.
Técnica de Tomasulo
Al igual que la técnica de Marcador, ésta también se representa con tres tablas (ver Figura
B.12). A pesar de que la implementación del algoritmo de Tomasulo no incluye la representa-
ción de la información en tablas, aquí se añade de todas formas debido a que la información
que muestran sobre el estado actual de cada una de las instrucciones, las estaciones de reserva
y registros resultado es muy útil para seguir la ejecución de un código. La primera tabla es
la tabla de instrucciones, similar a la que se usa en el caso del Marcador, con la excepcion de
que en este caso hay sólo tres pasos en la ejecución.
La segunda tabla se corresponde con las estaciones de reserva. Aquí se incluyen también
los buers de carga y almacenamiento, ya que aunque su funcionamiento no es igual que el de
las estaciones de reserva, es bastante similar.
Al igual que las unidades funcionales su estado variará en función de la instrucción que
está ocupándola. La principal diferencia con las unidades funcionales de Marcador, es que aquí
sólo puede estar en ejecución una estación de reserva de cada tipo.
Las tablas de los registros indica cuales de ellos son el registro destino de alguna estación
74
Simula3MS
de reserva.
Figura B.12: Con guración Tomasulo
Por último, destacar que aunque en el informe asociado a esta técnica no aparecen nunca
re ejados riesgos WAW, ya que sólo se producen cuando existen problemas de accesos ambiguos
a memoria (varios registros diferentes apuntan a la misma dirección), estos si están controlados
y se producirán detenciones en las estaciones de reservas correspondientes cuando se detecte
alguno.
75
Manual de laboratorio - Organización de Computadores
76
Apéndice C
SJM
El simulador SJM (Simulador de Jerarquías de Memoria) permite modelar de forma intui-
tiva distintas jerarquías de memoria, modi car fácilmente sus características y obtener medidas
de sus prestaciones, de cara a evaluar la e ciencia de las distintas jerarquías. A diferencia de
otros simuladores, SJM permite integrar memoria caché y memoria virtual en una misma
jerarquía, por lo que puede tenerse una visión completa de la misma con una única aplicación.
En este manual se explica brevemente cómo utilizar SJM. En la sección C.1 se enumeran
los pasos básicos para usar la herramienta. A continuación, en la sección C.2 se describen otros
detalles adicionales del simulador.
C.1. Guía rápida
A continuación se indican los pasos básicos para empezar a trabajar con SJM .
Cuando se ejecuta el simulador lo primero que aparece es la ventana principal ( gura
C.1) donde aparecen distintos elementos diferenciados: la tabla de accesos a memoria, los
paneles de contenido del TLB y de la tabla de páginas, las direcciones física y virtual, y los
indicadores de tiempo de la simulación. Además, en la ventana principal aparecen distintos
menús desplegables, cada uno permitiendo varias acciones que se irán explicando a lo largo
de esta guía. También existe una barra de herramientas con accesos directos a las acciones de
los menús desplegables.
Figura C.1: Ventana principal.
77
Manual de laboratorio - Organización de Computadores
Ésta será la ventana que controlará la simulación, así como en la que se irá mostrando
el progreso de la misma. Ahora bien, en el momento de ejecutar el simulador, esta ventana
aparece deshabilitada, de forma que no se puede tener acceso a ninguno de sus elementos.
Para realizar una simulación, y por tanto para que se habiliten los elementos de la ventana
principal, son imprescindibles dos pasos previos (que pueden realizarse en cualquier orden):
Cargar un archivo de accesos a memoria.
Con gurar la jerarquía de memoria.
En las subsecciones C.1.1 y C.1.2 se indica respectivamente cómo realizar estos pasos
previos, y a continuación se indica cómo lanzar las simulaciones (subsección C.1.3) y cómo se
re ejan los resultados de las mismas (subsección C.1.4).
C.1.1. Cargando archivos de accesos a memoria
Una secuencia de accesos a memoria debe re ejar una lista ordenada temporalmente de pe-
ticiones de acceso a direcciones de memoria concretas, que el procesador solicita a la jerarquía
de memoria. Habitualmente, esta secuencia de accesos es denominada traza de memoria .
Figura C.2: Menú Archivo.
El simulador SJM no permite de nir desde dentro la traza de memoria que se modelará
para una simulación, sino que es necesario cargar un archivo que contenga la traza (el formato
de estos archivos se indica más adelante). Para cargar un archivo de accesos, se emplea la
opción Abrir chero de accesos a memoria en el menú Archivo ( gura C.2).
Si se selecciona esta opción en el menú, se mostrará una ventana contextual que permitirá
seleccionar un archivo de entrada de la forma habitual en los exploradores de archivos. Una
vez cargada la traza, cada uno de los accesos a memoria se mostrará en el panel de accesos
de memoria de la ventana principal ( gura C.3), y esta parte de la ventana principal quedará
habilitada.
Más en detalle, esta tabla nos informa sobre el tipo de acceso (instrucción, lectura de datos
o escritura) y la dirección correspondiente a cada acceso. Durante la simulación, esta tabla
informa sobre el próximo acceso que se va a realizar.
78
SJM
Figura C.3: Panel de accesos a memoria de la ventana principal.
tipo-acceso1 dirección-acceso1
tipo-acceso2 dirección-acceso2
tipo-acceso3 dirección-acceso3
...... ......
tipo-acceson−1 dirección-acceson−1
tipo-acceson dirección-acceson
Tabla C.1: Estructura de chero de accesos a memoria.
Formato de los archivos de accesos a memoria
Como se ha indicado, la secuencia de accesos con la que se trabaja debe estar contenida
en un archivo que debe cargarse. Dichos archivos pueden crearse fácilmente con cualquier
editor de texto, siempre que se graben en formato de texto plano. Cada línea de este archivo
representará un acceso a memoria, y constará de dos campos, indicando respectivamente y en
este orden el tipo de acceso y la dirección de memoria (en formato hexadecimal) a la que se
accede. Es decir, una traza de memoria de n accesos tendría la estructura que se muestra en
la tabla C.1.
En cada línea, el tipo de acceso debe indicarse mediante un número del 0 al 2, de acuerdo
con la siguiente codi cación:
0 Lectura de datos.
1 Escritura de datos.
2 Extracción de instrucción.
79
Manual de laboratorio - Organización de Computadores
C.1.2. Con gurando la jerarquía de memoria
En el menú Archivo, además de la opción de cargar trazas de memoria, aparecen otras
opciones que permiten respectivamente guardar o cargar cheros de con guración de la je-
rarquía (ver gura C.2). Estos cheros tienen por defecto con la extensión .cfg, y contienen
datos sobre una con guración concreta de una jerarquía de memoria, que puede almacenarse
o recuperarse mediante las opciones mencionadas.
Si se escoge la opción Cargar con guración , la jerarquía estará totalmente de nida según
los datos contenidos en el archivo. Nótese que esto afecta no sólo a qué elementos componen la
jerarquía, sino también a qué valores toman las características de cada uno de estos elementos
(por ejemplo, cuántos bloques tiene una caché).
Sin embargo, no es habitual disponer de cheros que re ejen exactamente la jerarquía de
memoria que queremos modelar. Por ello, es necesario contar con alguna forma de con gurar
desde cero la jerarquía, o bien de modi car de algún modo una jerarquía ya creada. Para
ello, se emplea el menú Con gurar ( gura C.4). Desde este menú y pulsando sobre la opción
Jerarquía se puede con gurar toda la jerarquía de memoria.
Figura C.4: Menú Con gurar.
Una vez escogida dicha opción en el menú, aparece la ventana de con guración. En ella
siempre se muestra un círculo rojo con una P en su interior, que representa al procesador, y
un rectángulo amarillo que representa a la memoria principal. Se pueden añadir elementos a
la jerarquía pulsando sobre los botones que hay a la derecha. De esta forma se pueden añadir
hasta 4 niveles de memoria caché, un TLB, que podrá ser uni cado, de datos o instrucciones,
y una tabla de páginas. La inclusión de ciertos elementos hace obligatoria la inserción de otros
(por ejemplo un TLB necesita una tabla de páginas), aunque hay ciertas combinaciones que
son opcionales.
La representación grá ca de la jerarquía en esta ventana dependerá de la con guración
escogida. A continuación se muestran dos con guraciones de jerarquía de memoria. La primera
de ellas ( gura C.5) es la más sencilla: existe una única caché uni cada y no hay memoria
virtual. La segunda ( gura C.6) es más compleja e incluye dos niveles de caché (separado el
primero para instrucciones y datos), tabla de páginas y TLB.
Pulsando sobre cualquier elemento de la ventana de con guración, excepto en el procesador,
se puede acceder a una ventana contextual que permite con gurar ciertos parámetros, según el
elemento. La gura C.7 muestra la ventana de parámetros de la caché. Dentro de esta ventana
se pueden con gurar todos los datos para una caché: asociatividad, algoritmos, políticas de
búsqueda, políticas de escritura, tiempo de acceso y tipo de caché.
La opción de con guración de tipo de caché sólo aparece en la con guración de caché de
nivel 1 (como es el caso de la gura C.7). Esta opción determina la forma en que se va a
acceder a la caché: caché física, caché virtualmente indexada y físicamente etiquetada, ó caché
virtual. Según este tipo de acceso la forma de mostrar la jerarquía en esta ventana cambiará.
80
SJM
Figura C.5: Ventana de con guración 1.
Figura C.6: Ventana de con guración 2.
81
Manual de laboratorio - Organización de Computadores
Figura C.7: Ventana de parámetros de caché.
Figura C.8: Ventana de con guración para una caché separada y con distintos tipos de acceso.
82
SJM
Además, en el caso de una caché separada (datos e instrucciones) con distintos tipos
de acceso en las dos partes, se mostrarán ambos tipos de acceso mediante una opción que
aparecerá en la ventana de con guración ( gura C.8).
El resto de elementos de la jerarquía requiren muchos menos parámetros. Ahora bien,
como mínimo, se necesitan los tiempos de acceso de todos los componentes de la jerarquía.
Por ejemplo, en la gura C.9 se muestra la ventana de parámetros de memoria principal, donde
sólo se puede con gurar el tiempo de acceso a la misma.
Figura C.9: Ventana de parámetros de memoria principal.
Un TLB necesita ( gura C.10), además del tiempo de acceso, el número de entradas y
determinar su tipo, esto es, si se accede de forma separada para datos e instrucciones o si
se considera un único TLB tanto para datos como instrucciones. Si se selecciona la primera
opción, la ventana cambia ( gura C.11), permitiendo con gurar separadamente el tiempo de
acceso y el número de entradas.
Figura C.10: Ventana de parámetros de un TLB uni cado.
Figura C.11: Ventana de parámetros de un TLB separado para datos e instrucciones.
83
Manual de laboratorio - Organización de Computadores
Respecto a los parámetros de tabla de páginas, debe indicarse el número de entradas de la
misma y su tiempo de acceso, así como determinar el número de marcos físicos que se pueden
alojar en memoria y el tiempo de acceso a disco ( gura C.12).
Figura C.12: Ventana de parámetros de la tabla de páginas.
Una vez completa la con guración de la jerarquía (se supone completa al pulsar en la
misma el botón Aceptar ), ya se puede acceder a los elementos de la ventana principal y
realizar la simulación.
Cabe recordar que en cualquier momento se pueden almacenar todos los datos de la je-
rarquía en un archivo, mediante la opción Guardar chero de con guración en el menú
Archivo. De este modo, una con guración puede ser recuperada posteriormente, agilizándose
así la tarea de repetir la simulación en las mismas condiciones.
C.1.3. Realizando simulaciones
Una vez con gurada la jerarquía de memoria a simular, la herramienta muestra la ventana
principal con sus elementos ya habilitados y estructurados según la con guración establecida
( gura C.13). En esta vista, no es posible modi car las características de ninguno de los ele-
mentos de la jerarquía de memoria. Para cambiar el valor de estos parámetros, sería necesario
emplear de nuevo la ventana de con guración previamente descrita.
La simulación se puede llevar a cabo de dos formas: paso a paso o completamente. Para
seleccionar cada opción, debe pulsarse el botón correspondiente (ambos botones se encuentran
en la parte superior derecha de la ventana principal). La simulación paso a paso permite ir
estudiando las repercusiones de cada nuevo acceso sobre los niveles de la jerarquía de memoria
y sobre el tiempo total. A su vez, la simulación completa se detiene sólo cuando se han realizado
todos los accesos de la traza.
Si se selecciona la simulación paso a paso, los distintos paneles que muestra la ventana
principal permiten realizar un seguimiento de la evolución de los distintos elementos de la
jerarquía a medida que se lleva a cabo la secuencia de accesos a memoria. Para realizar cada
nuevo acceso, es necesario volver a pulsar el botón Paso a paso .
Por ejemplo, en la parte inferior de la ventana se muestran unos paneles que re ejan el
estado, tras cada acceso, de los niveles de caché de nidos, organizados cada uno en conjuntos
y en bloques. Según la con guración de cada nivel, se muestran cachés separadas en datos
e instrucciones ( gura C.14.a), o uni cadas ( gura C.14.b). En el caso de estas guras, las
cachés de instrucciones y datos del primer nivel son de correspondencia totalmente asociativa
(cada una tiene un solo conjunto de varios bloques), mientras que la caché de segundo nivel
es uni cada y de correspondencia directa (varios conjuntos de un solo bloque).
84
SJM
Figura C.13: Ventana principal con elementos habilitados.
(a) (b)
Figura C.14: Paneles de estado de los niveles de caché.
85
Manual de laboratorio - Organización de Computadores
Seleccionando con el ratón cualquiera de las cachés aparecerá una ventana otante que
muestra, de forma más detallada, su estado en cada momento ( gura C.15). Nótese que en
esta ventana detallada se muestra el formato de dirección para operar con la caché, esto es,
se indica cuáles son los campos etiqueta, índice y desplazamiento ( gura C.16).
Figura C.15: Ventana de estado detallada de la caché de datos del nivel 1.
Figura C.16: Formato de dirección de la caché de datos del nivel 1.
Por su parte, el TLB ( gura C.17) y la tabla de páginas ( gura C.18) se muestran en
forma de tabla en la zona central de la ventana principal. En dichas tablas, además de la
correspondencia entre página virtual y física, se indica el valor de los bits de validez y suciedad
y el valor del contador mediante el que se implementa el algoritmo de reemplazo LRU.
Figura C.17: Panel TLB en la ventana principal.
Figura C.18: Panel de la Tabla de Páginas en la ventana principal.
86
SJM
Las direcciones física ( gura C.19) y virtual ( gura C.20) con las que se está trabajando en
un momento dado se muestran (en formato página + desplazamiento) respectivamente bajo el
panel de tabla de páginas y sobre el panel TLB. En el caso de que no se use memoria virtual,
la parte de la dirección correspondiente a las páginas aparecerá en blanco. Esta vista también
recoge en todo momento los ciclos de simulación consumidos ( gura C.21).
Figura C.19: Dirección física en la ventana principal.
Figura C.20: Dirección virtual en la ventana principal.
Figura C.21: Información temporal en la ventana principal.
Además, en la ventana principal también aparece, como ya se ha mencionado, la tabla de
accesos a memoria. Durante la simulación paso a paso, la tabla nos informa sobre el tipo de
acceso (instrucción, lectura de datos o escritura) y la dirección correspondiente a cada acceso.
Nótese que el acceso actualmente en curso se muestra en rojo en dicha tabla.
Por último, cabe mencionar que es posible volver al principio de una simulación ya co-
menzada, o incluso terminada. De este modo vuelve a comenzar la secuencia de accesos desde
el estado inicial de la jerarquía. Para ello, debe pulsarse el botón Reiniciar en la ventana
principal.
87
Manual de laboratorio - Organización de Computadores
C.1.4. Resultados de la simulación
Además de la información que se muestra en la ventana principal, SJM muestra las esta-
dísticas completas de todo el proceso de simulación en la ventana de estadísticas ( gura C.23).
Se puede acceder a ella desde el icono colocado en la barra de herramientas.
Figura C.22: Ventana de estadísticas.
En esta ventana, para cada elemento de la jerarquía de memoria se muestran las métricas
habitualmente empleadas: tasa de aciertos y fallos, tiempos medios de acceso, etc. Nótese que
la información sobre aciertos y fallos aparece desglosada según los tipos de accesos de la traza
(fallos de lecturas, escrituras, etc.).
Además, desde la ventana de estadísticas se permite guardar o imprimir el informe completo
de estadísticas. Para estas opciones existen sendos iconos dentro de la propia ventana de
estadísticas.
88
SJM
C.2. Otros detalles
A continuación se indican otros detalles adicionales de SJM.
C.2.1. Rango de valores de los parámetros de con guración
La lista completa de características de las jerarquías de memoria que permite con gurar
SJM están recogidas en la tabla C.2. Para cada parámetro, se indica el rango de valores que
puede tomar el mismo.
Parámetro Rango de valores
Tamaño de caché mínimo 1, máximo 230 bytes
Tamaño de bloque mínimo 1, máximo 2
30 bytes
Niveles de caché mínimo 1, máximo 4
Bloques por conjunto para caché mínimo 1 (correspondencia directa), máximo
ilimitado, pero los tamaños parciales están
limitados por el tamaño de caché y de bloque
N? de conjuntos para caché mínimo 1 (correspondencia asociativa), máximo
ilimitado, pero los tamaños parciales están
limitados por el tamaño de caché y de bloque
Algoritmos de reemplazo para caché LRU, FIFO y aleatorio
Escritura en caso de acierto en caché Postescritura y escritura inmediata
Escritura en caso de fallo en caché Carga en escritura y no carga en escritura
Tipo de acceso a caché Física, virtual y virtualmente indexada pero
físicamente etiquetada
Tipo de caché Uni cada o separada
TLB Uni cado o separado
Número de entradas en TLB mínimo 1, máximo 50000
Número de entradas de la tabla de páginas mínimo 1, máximo 5 × 107
Algoritmo de reemplazo de páginas en MV LRU
Escritura en caso de acierto en MV Postescritura
Escritura en caso de fallo en MV Carga en escritura
Tabla C.2: Parámetros que permite manipular SJM y rango de valores de los mismos.
89
Manual de laboratorio - Organización de Computadores
C.2.2. Manejo de ventanas otantes
En ciertos momentos, el trasiego entre ventanas puede resultar muy pesado. Para evitar
tener que recorrer gran parte de las ventanas cuando se quiera acceder a una en particular, o
en el caso de que se quieran ver todas, más o menos a la vez, existe un menú Ventanas ( gura
C.23). Este menú permite organizar las ventanas (en cascada, de forma horizontal, vertical o
a gusto del usuario) o moverse entre ellas.
Figura C.23: Menú Ventanas.
C.2.3. Ayuda
Por último, cabe mencionar que, para facilitar el manejo del simulador, se dispone de un
menú Ayuda, además de la existencia de ventanas contextuales de ayuda, de forma que el
usuario pueda resolver rápidamente sus dudas.
90
You might also like
- Analysis of Forensic Artifacts of Tinder On IphoneNo ratings yetAnalysis of Forensic Artifacts of Tinder On Iphone30 pages
- Risk Management in the Air Cargo Industry: Revenue Management, Capacity Options and Financial IntermediationFrom EverandRisk Management in the Air Cargo Industry: Revenue Management, Capacity Options and Financial IntermediationNo ratings yet
- A Pipelined Multi-Core MIPS Machine Hardware Implementation and Correctness Proof (Mikhail Kovalev, Silvia Melitta Muller, Wolfgang J. Paul)No ratings yetA Pipelined Multi-Core MIPS Machine Hardware Implementation and Correctness Proof (Mikhail Kovalev, Silvia Melitta Muller, Wolfgang J. Paul)359 pages
- Basic Research and Technologies for Two-Stage-to-Orbit Vehicles: Final Report of the Collaborative Research Centres 253, 255 and 259From EverandBasic Research and Technologies for Two-Stage-to-Orbit Vehicles: Final Report of the Collaborative Research Centres 253, 255 and 259No ratings yet
- Smart Card Applications: Design models for using and programming smart cardsFrom EverandSmart Card Applications: Design models for using and programming smart cardsNo ratings yet
- Simulation Manual For Configurable Mapreduce Accelerator: Gheorghe M. S TefanNo ratings yetSimulation Manual For Configurable Mapreduce Accelerator: Gheorghe M. S Tefan78 pages
- Quality and Performance Measurement in National Sport-Governing BodiesFrom EverandQuality and Performance Measurement in National Sport-Governing BodiesNo ratings yet
- Presentations with LaTeX: Which package, which command, which syntax?From EverandPresentations with LaTeX: Which package, which command, which syntax?No ratings yet
- 40 EN- Computer Architecture Complexity And CorrectnessNo ratings yet40 EN- Computer Architecture Complexity And Correctness565 pages
- Programming the Photon: Getting Started with the Internet of ThingsFrom EverandProgramming the Photon: Getting Started with the Internet of Things5/5 (1)
- Securing ChatGPT: Best Practices for Protecting Sensitive Data in AI Language ModelsFrom EverandSecuring ChatGPT: Best Practices for Protecting Sensitive Data in AI Language ModelsNo ratings yet
- Chapter 5: Using Configurable Logic Blocks (CLBS)No ratings yetChapter 5: Using Configurable Logic Blocks (CLBS)1 page
- Programming the Intel Galileo: Getting Started with the Arduino -Compatible Development BoardFrom EverandProgramming the Intel Galileo: Getting Started with the Arduino -Compatible Development Board5/5 (1)
- Project 3: Writing A Kernel From Scratch: 15-410 Operating SystemsNo ratings yetProject 3: Writing A Kernel From Scratch: 15-410 Operating Systems44 pages
- United under SAP: The process of eliminating information islands for ThyssenKrupp in China (Zhongshan)From EverandUnited under SAP: The process of eliminating information islands for ThyssenKrupp in China (Zhongshan)No ratings yet
- Motorola PowerPC RISC CPU Reference ManualNo ratings yetMotorola PowerPC RISC CPU Reference Manual554 pages
- Quasi-Monte Carlo Methods in Finance: With Application to Optimal Asset AllocationFrom EverandQuasi-Monte Carlo Methods in Finance: With Application to Optimal Asset AllocationNo ratings yet
- Price formation in the cryptocurrency market. A hypotheses driven econometric analysis of cryptocurrency price determinantsFrom EverandPrice formation in the cryptocurrency market. A hypotheses driven econometric analysis of cryptocurrency price determinantsNo ratings yet
- AMD-K5 Processor Technical Reference Manual (November 1996)No ratings yetAMD-K5 Processor Technical Reference Manual (November 1996)406 pages
- A Highly Productive Implementation of An Out-Of-OrderNo ratings yetA Highly Productive Implementation of An Out-Of-Order157 pages
- Computer Architecture Embedded ApproachNo ratings yetComputer Architecture Embedded Approach524 pages
- MC68020 32-Bit Microprocessor User's ManualNo ratings yetMC68020 32-Bit Microprocessor User's Manual473 pages
- מעבדה למיקרו מחשבים- חוברת של החומר התיאורטי מאת שלמה אנגלברגNo ratings yetמעבדה למיקרו מחשבים- חוברת של החומר התיאורטי מאת שלמה אנגלברג136 pages
- Programming Arduino: Getting Started with Sketches, Third EditionFrom EverandProgramming Arduino: Getting Started with Sketches, Third EditionNo ratings yet
- Advanced Multiplayer Game Development with Ureal Engine 5: A Comprehensive Guide to C++ ScriptingFrom EverandAdvanced Multiplayer Game Development with Ureal Engine 5: A Comprehensive Guide to C++ ScriptingNo ratings yet
- How Useful is the Information Ratio to Evaluate the Performance of Portfolio Managers?From EverandHow Useful is the Information Ratio to Evaluate the Performance of Portfolio Managers?No ratings yet
- The Berkeley Out-of-Order Machine (BOOM) Design SpecificationNo ratings yetThe Berkeley Out-of-Order Machine (BOOM) Design Specification70 pages
- Biennial Report on Operations Evaluation: Assessing the Monitoring and Evaluation Systems of IFC and MIGAFrom EverandBiennial Report on Operations Evaluation: Assessing the Monitoring and Evaluation Systems of IFC and MIGANo ratings yet
- Family Manual: 16-Bit Digital Signal ControllersNo ratings yetFamily Manual: 16-Bit Digital Signal Controllers448 pages
- Stream Control Transmission Protocol (SCTP) : Robust and Efficient For Data Centre ApplicationsNo ratings yetStream Control Transmission Protocol (SCTP) : Robust and Efficient For Data Centre Applications5 pages
- Republic of The Philippines Philippine Statistics Authority Quezon CityNo ratings yetRepublic of The Philippines Philippine Statistics Authority Quezon City1 page
- Mysterys of The Goths Edred Thorsson Signed First Edition Part 4100% (2)Mysterys of The Goths Edred Thorsson Signed First Edition Part 47 pages
- 4' X 4' Security Cabin (035 08 - 23) Rev00No ratings yet4' X 4' Security Cabin (035 08 - 23) Rev001 page
