Ingeniera Informtica. Ampliacin de Estructura de Computadores.

Curso 2010-11

6.3.3 Riesgo de Control.

Los riesgos por control en DLX son menos frecuentes que los riesgos por dependencia de datos, pero
al no haber una solucin tan buena como el adelantamiento de datos, se convierten en una de las
principales causas de retrasos en la ejecucin segmentada de las instrucciones.
Tal como definimos cada uno de los segmentos para DLX, si una instruccin actualiza el
valor del PC, este cambio no ser efectivo hasta el cuarto segmento MEM. Recordar:

4. MEM-Paso de completar salto/acceso a memoria:

i) Referencia a memoria:
LMDR Mem[DMAR
Mem[DMAR SMDR
ii) Salto: El valor de PC es sustituido por la direccin de salto.
if (cond) : PC ALU-salida ;
ALU-salida1 ALU-salida

Esto implica que la segmentacin tendr que detenerse durante 3 ciclos de reloj, pues hasta el
final de este cuarto segmento no ser conocida la direccin de la siguiente instruccin. Este riesgo se
conoce como:
Riesgo de salto o de control

En la figura siguiente se muestra un ejemplo de lo que acabamos de comentar. En el se

observa como iniciamos normalmente una instruccin de salto como otra cualquiera, pero cuando en
el segundo segmento la decodificamos y observamos que es un salto incondicional, ya dejamos de
ejecutar instrucciones segmentadas hasta conocer el nuevo valor que tomar el PC, y que lo
sabremos al final del cuarto segmento MEM.

Ciclos de Reloj
Instruccin 1 2 3 4 5 6 7 8 9 10 11

Salto Incondic. IF ID EX MEM WB

Instruccin i+1 IF detencin detencin IF ID EX MEM WB

Instruccin i+2 detencin detencin detencin IF ID EX MEM WB

Instruccin i+3 detencin detencin detencin IF ID EX MEM WB

Hay que resaltar que tres ciclos de reloj perdidos por cada salto es una cifra significativa.
En cualquier mquina, si se modifican valores de los registros o datos de memoria en los primeros
segmentos, hay que detener la segmentacin; tanto para saltos como para bifurcaciones.

Vicente Arnau Llombart 12/12/2011

Ingeniera Informtica. Ampliacin de Estructura de Computadores. Curso 2010-11

Problema: Sea una mquina en la cual la frecuencia de instrucciones de saltos es de un 20%. Y de el total de
saltos un 60% son efectivos (saltan realmente).
Si la maquina ideal posee un IPC de 1, cuanto ms rpida es la mquina ideal frente a esta mquina con riesgos de
control (los nicos).

Solucin: El porcentaje de instrucciones que producen riesgos por control es

(20%)*(60%) = 0.2*0.6 = 0.12 por uno (12%).
por tanto, cada 100 instrucciones, 12 producirn retrasos de 3 ciclos de reloj.
Entonces el CPI de esta mquina se podr calcular como
IPC REAL = N Ins /N Ciclos = 100 / (100+12*3) = 100/136 = 0.735

La relacin entre los CPI de las dos mquinas ser de 1/0.735=1.36, es decir un 36% ms lenta que la mquina
real.

Problema: Cual es la perdida de velocidad si el retraso fuese solo de un ciclo en cada

instruccin de salto.

Por lo visto en el problema, es importantsimo el reducir el nmero de retrasos producidos por

riesgos de control. Para ello deberemos intentan conseguir dos cosas:
Averiguar si el salto es efectivo o no lo antes posible en la segmentacin.
Calcular el PC efectivo lo antes posible.
Para optimizar al mximo la situacin es conveniente hacer las dos cosas.
En DLX los saltos requieren examinar solamente la igualdad con 0. Por lo tanto seria posible
tomar una decisin al final del segmento ID si tuvisemos una lgica especial dedicada a este test, es
decir, un comparador. Necesitaramos adems un sumador independiente para calcular las dos
direcciones, la de salto y la de no salto (PC+4).

Deberamos revisar la definicin de las operaciones realizadas para cada uno de los
segmentos de DLX y dejarlas como se muestra a continuacin:

Vicente Arnau Llombart 12/12/2011

Ingeniera Informtica. Ampliacin de Estructura de Computadores. Curso 2010-11

1. IF-Paso de bsqueda de instruccin:

IR Mem[PC ; PC PC+4
2. ID-Paso de bsqueda del registro/decodificacin de instruccin.
A Rsl ; B Rs2;
16
BTA PC+((IR16 ) ## IR16..31)
IF (Rs1 op 0) PC BTA

3. EX: . . .
4. MEM: . . .
5. WB: . . .

El clculo de la direccin de salto se realizar para todas las instrucciones y se guardar en BTA.
La evaluacin de la condicin de salto tambin se realizara para todas las instrucciones.
La ltima accin a realizar ser la de escribir en el PC la direccin efectiva del salto. Esta accin se
debe realizar ya al final del ciclo y para entonces ya se debe de tener decodificada la instruccin para
saber que es un salto.
En caso de salto, ya no se realizar la ejecucin de los ltimos tres segmentos de la instruccin, tan
solo se pierde as un ciclo de reloj.
En algunas mquinas, poseen riesgos en los saltos de ms ciclos de reloj. Por ejemplo, los
VAX poseen normalmente penalizaciones de 4 ciclos de reloj para los saltos.
Este retardo depende de la profundidad de la segmentacin (n de segmentos por instruccin),
llevando a valer 6 y 7 ciclos de reloj para mquinas con segmentacin muy profunda.
Hemos visto como solo se pierde un ciclo, pero el procesador debe eliminar la instruccin que acaba
de ser leda del cauce segmentado, para ello utiliza una lnea de control llamada IF.Flush, la cual
pone a cero el registro IR, simulando que se ha ledo una instruccin nop. Todo esto puede
observarse en la siguiente figura:

Vicente Arnau Llombart 12/12/2011

Ingeniera Informtica. Ampliacin de Estructura de Computadores. Curso 2010-11

El procesador de DLX, lo que hace es suponer que el salto nunca ser tomado y solo cuando el salto
es efectivo vaca la entrada del cauce segmentado.

Segmentacin para DLX minimizando riesgos de control.

1. IF-Paso de bsqueda de instruccin.

IR Mem[PC; NPC PC + 4;

2. ID-Paso de bsqueda del registro/decodificacin de instruccin.

A Rsl ; B Rs2;
16
BTA NPC+((IR16 ) ## IR16..31)
IF (Rs1 op 0) PC BTA

Imm ((IR16)16 ## IR16..31);

3. EX-Paso de direccin efectiva /ejecucin.

i) Referencia a memoria:
ALUOutput A + Imm;
ii) Instruccin ALU sobre Registros:
ALUOutput A op B;
iii) Instruccin ALU sobre Registro-Dato Inmediato:
ALUOutput A op Imm;

4. MEM-Paso de completar salto/acceso a memoria.

Referencia a memoria: Acede a memoria para leer o escribir un dato.
LMD Mem[ALUOutput
Mem[ALUOutput B

5. WB-Paso de post-escritura (write-back):

Instruccin Aritmtica:
Regs [IR16..20 ALUOutput;
Instruccin ALU sobre Registro-Dato Inmediato:
Regs [IR11..15 ALUOutput;
Instruccin de carga:
Regs [IR11..15 LMD;

Vicente Arnau Llombart 12/12/2011

Ingeniera Informtica. Ampliacin de Estructura de Computadores. Curso 2010-11

Comportamiento dinmico de los saltos.

Las instrucciones de salto son muy utilizadas por los compiladores para la generacin de cdigo.
Veamos primero con que frecuencia son utilizadas en tres mquinas diferentes. (Figura 6.18).

Las frecuencias de saltos condicionales oscilan entre el 11% y el 17%.

Las frecuencias de saltos incondicionales oscilan entre el 2% y el 8%.
- Pero, cuantos saltos condicionales son efectivos?.
- Recordemos el lo visto en temas anteriores: para DLX el 53% de los saltos son efectivos. Es una
valor tpico para la mayora de mquinas.

Vicente Arnau Llombart 12/12/2011

Ingeniera Informtica. Ampliacin de Estructura de Computadores. Curso 2010-11

Problema: Vistos los datos de la grfica anterior, si IPC IDEAL =1 , cuanto ms rpida es esta
mquina ideal respecto a mquina con DLX que posee retardos por saltos y por dependencia
de datos.
Suponer que el n de instrucciones de carga es del 13% y de ellas el 25% produce retrasos en
la segmentacin.
Suponer que el 53% de los saltos condicionales, saltan realmente.

Solucin: Calculmoslo.
N total de Instrucciones que producen retrasos:
2% (saltos) + 11%*53%(bifurcaciones) + 13%*25%(cargas) = 11,08%
El cociente entre los IPC ser:

IPC IDEAL 1 111.08

CocienteIP C 1.1108 11.108%mas _ rpida
IPC REAL 100 100
111.08

La mquina ideal es 11% ms rpida. (El IPC real es de 0.9).

Vicente Arnau Llombart 12/12/2011

Ingeniera Informtica. Ampliacin de Estructura de Computadores. Curso 2010-11

Vicente Arnau Llombart 12/12/2011

Ingeniera Informtica. Ampliacin de Estructura de Computadores. Curso 2010-11

Reduccin de penalizaciones en saltos.

Vamos a analizar 4 mtodos sencillos para tratar las detenciones, en tiempo de compilacin, debidas
a los retrasos por los saltos. Son mtodos estticos y las predicciones son estimaciones en tiempos de
compilacin. Ms adelante ya estudiaremos como prevenirlos por hardware (es ms complejo).
Mtodo 1: Es el ms sencillo y consiste simplemente en parar la segmentacin en el momento que se
sabe que la instruccin es de salto o bifurcacin, y no se reanuda hasta que se conozca la direccin de
salto (ya visto). Es la peor solucin, y se puede realizar sin ms que introducir NOP despus de la
instruccin de salto, hasta que se sepa si se salta o no.
Mtodo 2: Una pequea mejora es suponer que no se va a realizar el salto (predict-not-taken). El
procesador contina como si el salto no se realizara. El peligro est en que las instrucciones de
despus del salto cambien el estado del procesador. Esto no se puede permitir, y se permite, en caso
de realizarse el salto, se deben restaurar estos valores.
Si el salto al final no se realiza, se sigue como si nada. Si se realiza, se empieza de nuevo leyendo la
nueva instruccin en la nueva direccin apuntada por el PC. La figura siguiente muestra ambas
situaciones (6.19).

Mtodo 3: Otro esquema posible es predecir el salto como efectivo y empezar a ejecutar como
instruccin siguiente a la del salto la que indicar el PC en caso de ser efectivo dicho salto. En DLX
esto no se puede hacer pues no se conoce la direccin del salto hasta el final del segundo ( cuarto)
segmento. Pero hay otros procesadores con juegos de instrucciones diferentes (con cdigos de
condicin), ms potentes y lentas, que si que pueden realizar este tipo de prediccin.

Vicente Arnau Llombart 12/12/2011

Ingeniera Informtica. Ampliacin de Estructura de Computadores. Curso 2010-11

Mtodo 4: Este mtodo consiste en realizar lo que se conoce como salto retardado, utilizado
muchas unidades de control microprogramadas. La tcnica consiste adelantar la ejecucin de la
instruccin de salto (si se puede), para que as se sepa antes si se realiza o no el salto. Con ello se
evita los periodos muertos de retardo, pues se rellenan con instrucciones. Si el procesador determina
que el salto es efectivo, la instruccin siguiente no la anula, y sigue con la instruccin apuntada por
el nuevo valor de PC. Esto supone un cambio en la definicin de segmentacin.
Vemos algunos ejemplos del uso de esta tcnica de compilacin:

Caso 1 Caso 2 Caso 3

Antes: Antes: Antes:
ADD R1,R2,R3 SUB R4,R5,R6 ADD R1,R2,R3
si R2=0 entonces MULT r6,r7,r8 si R1=0 entonces
retardo ... retardo
... ADD R1,R2,R3 SUB R4,R5,R6
MULT r6,r7,r8 si R1=0 entonces ...
retardo MULT R14,R15,R16
Ins+1
Despues: Despues: Despues:
si R2=0 entonces SUB R4,R5,R6 ADD R1,R2,R3
ADD R1,R2,R3 MULT r6,r7,r8 si R1=0 entonces
... ... SUB R4,R5,R6
ADD R1,R2,R3 ...
MULT r6,r7,r8 si R1=0 entonces Ins-1
SUB R4,R5,R6 MULT R14,R15,R16
Ins+1

Caso 1: el hueco se llena con una instruccin anterior al salto. Es la mejor estrategia.
Caso 2: si no es posible aplicar el caso 1 por depender la condicin de salto de un registro utilizado
con anterioridad, para este tipo de bucles, podemos llenar el hueco con la instruccin
primera en caso de ser efectivo el salto, es decir, con la primera instruccin del bucle. Dicha
instruccin debe ser copiada pues puede ser utilizada por otra va.
Caso 3: para este tipo de salto se ejecuta en el tiempo de retardo la primera instruccin del bucle. A
de asegurarse el compilador que la ejecucin de esta instruccin no crea ningn problema en
el funcionamiento global del programa ejecutado.

Vicente Arnau Llombart 12/12/2011

Ingeniera Informtica. Ampliacin de Estructura de Computadores. Curso 2010-11

El caso 2 y 3 se pueden aplicar cuando el registro R4 es una variable temporal y la ejecucin de

esta instruccin no altera la programacin realizada.
Tanto en el caso 2 como en el 3 hay que realizar una copia de instruccin, aumentando el tamao
del cdigo final.
La tarea del software (compilador) es hacer que la instruccin sucesora sea vlida y til. Si no lo
consigue y su introduccin puede acarrear problemas, se sustituye por un instruccin de NOP.
Vamos a analizar ahora las restricciones a cada caso y aquellas situaciones en las cuales se
comportan mejor. Para ello veamos la siguiente tabla.

Requerimiento Cuando mejora el rendimiento?

Caso 1: Los saltos deben no depender de la/las Siempre.
instruccin anterior.
Caso 2: Duplicar instruccin. Cuando es efectivo el salto, pues la ya tiene
No alterar el programa por la duplicacin realizada la primera instruccin del bucle.
de esta instruccin.
Caso 3: Duplicar instruccin Mejora cuando el salto no es efectivo, pues
No alterar el programa la ejecucin en este ya tiene ejecutada la primera instruccin
punto de esta instruccin. del bucle.

Insistimos: Cuando los huecos no se pueden planificar se llenan con instrucciones de NOP (Not
Operation).
El principal problema esta en la planificacin de que instrucciones pueden ser ejecutadas en
los huecos de retardo y la capacidad para que el compilador prediga con que frecuencia sern
efectivos los saltos.
En la pgina siguiente se muestra la efectividad de este tipo de planificaciones de saltos en
DLX., con un nico hueco de retardo que se intenta llenar con instrucciones tiles. (F-6.22).
La barra slida indica el porcentaje de huecos que son llenados con instrucciones
diferentes a NOP.
La barra sombrada indica el porcentaje de instrucciones que realizan una tarea til. Cuando
se aplica el caso 1, siempre es til la instruccin insertada, mientras que cuando se aplica
el caso 2 y 3 no siempre lo es, y de ah esta diferencia entre las barras.
Vemos que en un 83%, 85% y 83% de los casos de sustitucin, se realiza un trabajo til.
Este valor es tan alto, recordar que solo el 53% de los saltos son efectivos, por que en la
mayora de los casos la estrategia utilizada es la del caso 1, que siempre es til la
sustitucin.
El resultado final es que aproximadamente se eliminan la mitad de los retardos por saltos.
Para finalizar vamos a analizar una grfica en la cual se hace un resumen de los retardos que
se producen para una mquina DLX de enteros, tanto por cargas como por saltos. Adems se supone
que la cache de memoria no falla y por supuesto no se producen interrupciones.

Vicente Arnau Llombart 12/12/2011

Ingeniera Informtica. Ampliacin de Estructura de Computadores. Curso 2010-11

Vemos como entre el 7 y el 15 por ciento de los ciclos de reloj son prdidas por riesgos de datos o
de saltos.
El CPI efectivo para estas pruebas es de aproximadamente de 1.1.
La mejora aportada por la segmentacin es de un factor 5.3.

Vicente Arnau Llombart 12/12/2011

Ingeniera Informtica. Ampliacin de Estructura de Computadores. Curso 2010-11
Ejemplo: Aplicar los tres casos de la tcnica del Salto retardado.

;===================================================
; SERIE.S :
;===================================================

.data 0x1000
n_dat: .word 16, 0
cte1: .double 6.7
cte2: .double 3.3
Ser_X: .double 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8
.double 1.9, 2.0, 2.1, 2.2, 2.3, 2.4, 2.5

Ser_Y: .double 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8
.double 1.9, 2.0, 2.1, 2.2, 2.3, 2.4, 2.5

Ser_Z: .double 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8
.double 1.9, 2.0, 2.1, 2.2, 2.3, 2.4, 2.5

Ser_W: .space 16*8

.text 0x100
lw R16, n_dat
ld F6, cte1
ld F2, cte2
addi R1, R0, 0

eti: LD F10, Ser_X(R1)

LD F12, Ser_Y(R1)
LD F14, Ser_Z(R1)

MULTD F20, F10, F6

MULTD F22, F12, F2
ADDD F24, F20, F14
ADDD F26, F24, F22

SD Ser_W(R1), F26

ADDI R1, R1, 8

SUBI R16, R16, 1

BNEZ R16, eti

ADDD f28, f26, f26

NOP

TRAP 0

Vicente Arnau Llombart 12/12/2011

Ingeniera Informtica. Ampliacin de Estructura de Computadores. Curso 2010-11

Mas Ejemplos de Salto Retardado:

Caso 1:

Programa inicial Con salto retardado (caso 1)

;==================================== ;====================================
; SALTO.S : INTRUCCIN IF-ELSE = ; SALTO_R.S : INTRUCCIN IF-ELSE =
;==================================== ;====================================

.data .data
dato: .float 1.5, 2.0 dato: .float 1.5, 2.0

CTE: .FLOAT 10.0 CTE: .FLOAT 10.0

num: .word 2 num: .word 2

.text 0x100 .text 0x100

main: LF F10 , CTE main: LF F10 , CTE

LF F4 , dato LF F4 , dato
LW R12, num LW R12, NUM
LF F6 , dato+8
BEQZ R12 , eti
BEQZ R12 , eti
LF F6 , dato+8
MULTF F20 , F4 , F6
MULTF F20 , F4 , F6
SF dato , F20
SF dato , F20
eti: subi R12, R12, 1
eti: subi R12, R12, 1
BEQZ R12 , eti2
BEQZ R12 , eti2

Nop
ADDF F20 , F4 , F6
ADDF F20 , F4 , F6
SF dato+8 , F20
eti2: trap 0 SF dato+8 , F20
eti2: trap 0

Vicente Arnau Llombart 12/12/2011

Ingeniera Informtica. Ampliacin de Estructura de Computadores. Curso 2010-11

Caso 2: Programa inicial Con salto retardado (caso 2)

;==================================== ;====================================
; SALTO.S : INTRUCCIN IF-ELSE = ; SALTO_R.S : INTRUCCIN IF-ELSE =
;==================================== ;====================================

.data .data

dato: .double 1.5, 2.0, 3.3, 4.4 dato: .double 1.5, 2.0, 3.3, 4.4

CTE: .FLOAT 10.0 CTE: .FLOAT 10.0

num: .word 4 num: .word 4

.text 0x100 .text 0x100

main: LD F10 , CTE main: LD F10 , CTE

LW R4, num LW R4, num

ADDI R8, R0, 0 ADDI R8, R0, 0

eti: LD F4 , dato(R8) LD F4 , dato(R8)

LD F6 , dato+8(R8) eti: LD F6 , dato+8(R8)

MULTD F8, F4, F6 MULTD F8, F4, F6

ADDI R8, R8, 8 ADDI R8, R8, 8

SUBI R4, R4, 2 SUBI R4, R4, 2

BEQZ R4 , eti BEQZ R4 , eti

LD F4 , dato(R8)

SD dato , F8 SD dato , F8
trap 0 trap 0

Vicente Arnau Llombart 12/12/2011

Ingeniera Informtica. Ampliacin de Estructura de Computadores. Curso 2010-11

Caso 3: Programa inicial Con salto retardado (caso 3)

;==================================== ;====================================
; SALTO.S : INTRUCCIN IF-ELSE = ; SALTO_R.S : INTRUCCIN IF-ELSE =
;==================================== ;====================================

.data .data

valor: .double 3.0, 4.0 valor: .double 3.0, 4.0

dato: .double 1.5, 2.0 dato: .double 1.5, 2.0
res: .space 8 res: .space 8

CTE: .FLOAT 10.0 CTE: .FLOAT 10.0

num: .word 6 num: .word 6

.text 0x100 .text 0x100

main: LW R12, num main: LW R12, num
LD F4, valor LD F4, valor
LD F6, valor+8 LD F6, valor+8

SUBI R12, R12, 2 SUBI R12, R12, 2

BNEZ R12 , eti BNEZ R12 , eti

NOP

LD F4 , dato(R0) LD F4 , dato(R0)
LD F6 , dato+8(R0) LD F6 , dato+8(R0)

MULTD F20 , F4 , F6 MULTD F20 , F4 , F6

SD res , F20 SD res , F20

eti: addi R12, R12, 2 eti: addi R12, R12, 2

ADDD F20 , F4 , F6 ADDD F20 , F4 , F6

SD res, F20 SD res, F20
eti2: trap 0 eti2: trap 0

Problema: aplica el caso 1 y el 2 del salto retardado al cdigo de la anterior ventana.

Vicente Arnau Llombart 12/12/2011

Ingeniera Informtica. Ampliacin de Estructura de Computadores. Curso 2010-11

Caso 3: Programa inicial Con salto retardado (caso 3)

;==================================== ;====================================
; SALTO.S : INTRUCCIN IF-ELSE = ; SALTO_R.S : INTRUCCIN IF-ELSE =
;==================================== ;====================================

.data .data

valor: .double 3.0, 4.0 valor: .double 3.0, 4.0

dato: .double 1.5, 2.0 dato: .double 1.5, 2.0
res: .space 8 res: .space 8

CTE: .FLOAT 10.0 CTE: .FLOAT 10.0

num: .word 6 num: .word 6

.text 0x100 .text 0x100

main: LW R12, num main: LW R12, num
LD F4, valor LD F4, valor
LD F6, valor+8 LD F6, valor+8

SUBI R12, R12, 2 SUBI R12, R12, 2

BNEZ R12 , eti BNEZ R12 , eti

LD F6 , dato+8(R0)

LD F4 , dato(R0)
LD F6 , dato+8(R0) LD F4 , dato(R0)

MULTD F20 , F4 , F6 MULTD F20 , F4 , F6

SD res , F20 SD res , F20

eti: addi R12, R12, 2 eti: addi R12, R12, 2

ADDD F20 , F4 , F4 ADDD F20 , F4 , F4

SD res, F20 SD res, F20
eti2: trap 0 eti2: trap 0

Vicente Arnau Llombart 12/12/2011