En esta práctica haremos uso del programa WinDLXV, que simula la segmentación dentro de un PC.
•Desarrollo de la práctica:
En el apartado de Arquitectura del programa, modifico la latencia y desactivo las casillas
de segmentación de las unidades funcionales señaladas en la práctica. Además,
en la pestaña de configuración, desactivo la función de adelantamiento de
resultados.
Con estos pasos, ya hemos cambiado las condiciones
de partida y ya estamos listos para realizar los ejemplos de la práctica.
Ejemplo 1 : Dependencias
de datos tipo RAW
Este tipo de dependencia provoca la creación de burbujas que detienen el flujo de instrucciones tantos ciclos como sea necesario a la espera del dato que necesite la instrucción.
Este tipo de dependencia provoca la creación de burbujas que detienen el flujo de instrucciones tantos ciclos como sea necesario a la espera del dato que necesite la instrucción.
En la pestaña de Herramientas, le damos a Editar y
escribimos el programa de este ejemplo:
;***********
WINDLXV *************
;***********
Ejemplo 1 *************
;-----------------------------------------------------------------------------
;
Ejemplo para ilustrar dependencias de datos tipo RAW
;-----------------------------------------------------------------------------
.text
main:
add r1,r2,r3 ;almacena un nuevo valor en r1
sub r4,r1,r5 ;usa r1
and r6,r1,r7 ;usa r1
or r8,r1,r9 ;usa r1
xor r10,r1,r11 ;usa r1
nop
nop
nop
nop
add r1,r2,r3 ;almacena un nuevo valor en r1
sub r4,r1,r5 ;usa r1 y almacena un nuevo valor en
r4
and r6,r4,r7 ;usa r4 y almacena un nuevo valor en
r6
or r8,r6,r9 ;usa r6 y almacena un nuevo valor en
r8
xor r10,r8,r11 ;usa r8 y almacena un nuevo valor en r10
Finish: trap
6
La latencia de emisión son los ciclos que hay entre
una instrucción y la siguiente. En este caso, hay 2 ciclos entre una operación
aritmético-lógica y la siguiente.
Fijándonos en la ventana de estadísticas aparecen
los resultados pedidos:
a) Número total de ciclos de ejecución: 29 ciclos
Ciclos
de reloj por instrucción (CPI): 1933 ciclos
b) En 10 ciclos se han producido detenciones al
decodificar las instrucciones (fase ID).
c) Al activar el adelantamiento de resultado se
producen los siguiente resultados:
Número
total de ciclos en ejecución: 19 ciclos
Ciclos
de reloj por instrucción (CPI): 1.267 ciclos
No
se producen detenciones
El
aumento de rendimiento se nota en la disminución de ciclos en ejecución y de
reloj
Ejemplo 2 : dependencia de datos tipo RAW
Cargo el programa del ejemplo 2:
;*********** WINDLXV*************
;*********** Ejemplo 2 *************
;-----------------------------------------------------------------------------
; Ejemplo para ilustrar dependencias de datos
tipo RAW
;-----------------------------------------------------------------------------
.text
main:
add
r1,r2,r3
lw
r4, 0(r1)
;carga en r4 usando r1
sub r5,r4,r3 ;usa r4
sw 14(r2),r5 ;almacena r5 usando r2
nop
nop
nop
nop
lw r1, 2(r2)
sub r4,r1,r5
and r6,r1,r5
or r8,r1,r5
Finish:
En las ventanas de “Registros” y “Datos” modifico
los valores de los registros y de las posiciones de memoria pedidas.
R1: 0x1f
R4: 0x5
R5: 0x1a
R6: 0x1a
R8: 0x1f
Posición de memoria del contenido de R5: 0x1010
En este caso, la latencia de emisión de las
instrucciones aritmético-lógicas es de 1 ciclo, mientras que en las
instrucciones de carga es de 3 ciclos.
a) Número total de ciclos de ejecución: 25 ciclos
Ciclos por instrucción (CPI): 1.923 ciclos
b) En 8 ciclos se han producido detenciones al
decodificar las instrucciones (fase ID)
c) Con adelantamiento de resultado:
Número total de ciclos de ejecución: 19 ciclos
Ciclos por instrucción (CPI): 1.462 ciclos
En 2 ciclos se han producido detenciones
al ejecutar las instrucciones (fase EX)
d) Con adelantamiento de resultados, la latencia de
emisión para las instrucciones aritmético-lógicas es de 1 ciclo, mientras que
para las instrucciones de carga es de 2 ciclos.
Ejemplo 3 : Dependencias
de tipo estructural
;*********** WINDLXV *************
;*********** Ejemplo 3 *************
;-----------------------------------------------------------------------------
; Ejemplo para ilustrar dependencias de tipo
estructural
;-----------------------------------------------------------------------------
.text
main:
addf f1,f2,f3
multf f2,f4,f5
addf f3,f3,f4
multf f6,f6,f6
addf f1,f3,f5
addf f2,f3,f4
Finish:
Ciclos
por instrucción (CPI): 3 ciclos
b) No hay detenciones
c) Con unidades funcionales de punto
flotante segmentadas:
15
ciclos de ejecución
2.5
ciclos de reloj por instrucción (CPI)
El
rendimiento es mayor ya que ha disminuido el número de ciclos de ejecución y el
número de ciclos de reloj por instrucción.
Ejemplo 4 : Reordenación
de datos
Para este ejemplo, modifico la latencia en las
unidades funcionales señaladas en Arquitectura.
;*********** WINDLXV *************
;*********** Ejemplo 4 *************
;------------------------------------------------------------------------------------------------------
; Ejemplo para ilustrar la reordenación de
instrucciones – PROGRAMA ORIGINAL
;------------------------------------------------------------------------------------------------------
.data
ONE: .word 1
.text
main:
lf f1,ONE ;convierte divf en move al
almacenar
cvti2f f7,f1 ; 1 en f7 en formato de
punto flotante
nop
divf f1,f8,f7 ;mueve Y=(f8) a f1
divf f2,f9,f7 ;mueve Z=(f9) a f2
addf f3,f1,f2
divf f10,f3,f7 ;mueve f3 a X=(f10)
divf f4,f11,f7 ;mueve B=(f11) a f4
divf f5,f12,f7 ;mueve C=(f12) a f5
multf f6,f4,f5
divf f13,f6,f7 ;mueve f6 a A=(f13)
Finish: trap 6
;*********** WINDLXV *************
;*********** Ejemplo 4 *************
;------------------------------------------------------------------------------------------------------------
; Ejemplo para ilustrar la reordenación de
instrucciones – PROGRAMA REORDENADO
;------------------------------------------------------------------------------------------------------------
.data
ONE: .word 1
.text
main:
lf f1,ONE ;convierte divf en move
al almacenar
cvti2f f7,f1 ; 1 en f7 en formato de punto flotante
nop
divf f1,f8,f7 ;mueve Y=(f8) a f1
divf f2,f9,f7 ;mueve Z=(f9) a f2
divf f4,f11,f7 ;mueve B=(f11) a f4
divf f5,f12,f7 ;mueve C=(f12) a f5
addf f3,f1,f2
multf f6,f4,f5
divf f10,f3,f7 ;mueve f3 a X=(f10)
divf f13,f6,f7 ;mueve f6 a A=(f13)
Finish:
a) Número total de ciclos de ejecución: 86
ciclos
Ciclos
por instrucción (CPI): 7.167 ciclos
b) Número de ciclos perdidos por dependencia
RAW: 35 ciclos
c) Se produce un aumento del rendimiento al
reordenar las instrucciones ya que se reduce el número de ciclos de
ejecución(de 86 a 73 ciclos), el número de ciclos por instrucción (de 7.167 a
6.083 ciclos) y el número de detenciones (de 35 a 17).
•Mejoras/Errores:
La latencia que
se indica en el apartado de “Arquitectura” es una unidad menor que la latencia
que se visualiza en la ventana de “Estadísticas”.
He tenido muchas
dudas con el programa que con el manual, que aunque es extenso, no las pude resolver.
Adjunto Pdf original para su consulta offline.
No hay comentarios:
Publicar un comentario