Paralelismo a Nivel de Instrucciones

ILP Multiple-issue Speculation Static Multiple-issue

Organizacion de ComputadoresCapıtulo II: Paralelismo a Nivel de

Instrucciones

Erika Rosas [email protected]

Departamento de Ingenierıa InformaticaUniversidad de Santiago de Chile

Primer Semestre 2014

Organizacion de Computadores 1 / 36


Paralelismo a nivel de instrucciones

• Pipeline explota el paralelismo a nivel de instrucciones (ILP).

• Incrementar la profundidad del pipeline para traslapar masinstrucciones.

• Replicar componentes internos del computador para lanzarmultiples instrucciones en cada etapa del pipeline.



Multiple issue

Esquema donde multiples instrucciones son lanzadas en un ciclo dereloj.

• CPI puede ser menor a 1.

• Metrica IPC (Instructions per clock cycle).

• Ej. un microprocesador de 4GHz con un multiple issue de 4instrucciones puede ejecutar un maximo de 16 billones deinstrucciones por segundo. IPC es 4 y CPI 0.25.

• Actualmente se intenta de 3 a 6 instrucciones por ciclo dereloj.



Multiple issue

Hay dos formas principales de implementar procesadores demultiple-issue.La diferencia principal es la division de trabajo entre el compiladory el hardware.

• Decisiones estaticas, hechas por el compilador: StaticMultiple-issue.

• Decisiones dinamicas, hechas durante la ejecucion: DynamicMultiple-issue.



Multiple issue

Problemas:

1 Las instrucciones deben ser empaquetadas: Cuantas? Cualesse pueden empaquetar juntas?

2 Se debe lidiar con hazard de datos y de control.



Issue slots

Issue slots se llama a las posiciones desde las cuales lasinstrucciones pueden emitirse en un ciclo de reloj dado.



Especulacion

Tecnica donde el compilador o procesador adivina la salida de unainstruccion para removerla como una dependencia al ejecutar otrasinstrucciones.

• Especular sobre un branch, para que las instrucciones que lesiguen puedan ejecutarse antes.

• Especular que un store que precede un load no se refiere a lamisma direccion. Lo que permitirıa ejecutar el load antes queel store.



Especulacion

• La especulacion puede fallar.

• Metodo para chequear is la especulacion fue correcta.

• Metodo para retractar los efectos de las instruccionesejecutadas de manera especulativa.

• Especulacion puede hacerse a nivel del compilador o delhardware.



Especulacion

• Compilador: se insertan otras instrucciones para chequearvalidez, con una rutina para arreglar en caso de falla.

• Hardware: Los resultados especulados son almacenados en unbuffer y el contenido escrito cuando se verifique que laespeculacion es correcta.

• Se pueden introducir excepciones.



Very Long Instruction Word

Issue packet

Conjunto de instrucciones que pueden ser emitidas juntas en unciclo de reloj, el paquete puede ser determinado estaticamente porel compilador o dinamicamente por el procesador.

VLIW

Un estilo de arquitectura de conjunto de instrucciones que lanzamuchas operaciones que son definidas independientes en una so-la instruccion larga, generalmente con muchos campos de opcodeseparados.



Simple multiple issue code scheduling

Simple two-issue MIPS processor



Simple multiple issue code scheduling





Code SchedulingLoop: lw $t0, 0($s1)

addu $t0, $t0, $s2

sw $t0, 0($s1)

addi $s1, $s1, -4

bne $s1, $zero, Loop

Reordenar



Code SchedulingLoop: lw $t0, 0($s1)

addu $t0, $t0, $s2

sw $t0, 0($s1)

addi $s1, $s1, -4

bne $s1, $zero, LoopReordenar



Loop unrolling for Multiple-issue pipelines

Tecnica para obtener mejor rendimiento de loops que acceden arre-glos en los cuales multiples copias del cuerpo del loop son hechas einstrucciones de distintas iteraciones son planificadas juntas.



Loop unrolling for Multiple-issue pipelines

• 4 copias de cada instruccion.• Renombrar registros ($t1, $t2, $t3) para eliminar

dependencias de nombre.• Dependencia de nombre o antidependencia: Orden forzado

por rehusar un nombre de un registro (no hay flujo real entreinstrucciones).



Dynamic Multiple-issue Processors

Superscalar

Tecnica de pipeline avanzada que permite al procesador ejecutarmas de una instruccion por ciclo de reloj seleccionandolo durante laejecucion.

• Se garantiza por hardware la ejecucion correcta.



Dynamic pipeline scheduling

• Division 3 unidades: Instruction Fetch and Issue Unit,Unidades Funcionales (12 o mas), y una unidad de Commit.

• Cada unidad funcional tiene buffers.

• Unidad de Commit: Decide si es seguro el resultado de unaoperacion y hacerla visible en los registros y memoria (bufferde reorden).



Dynamic pipeline scheduling



Orden instrucciones

Out-of-order execution

Una situacion de la ejecucion del pipeline cuando una instruccionbloqueada no causa la espera de la instruccion siguiente.

In-Orden Commit

Un commit donde los resultados de la ejecucion en pipeline tiene unestado visible en el mismo orden que las instrucciones son buscadas.



Power efficiency



AMD Opteron X4 (Barcelona)

• Traduce instrucciones en operaciones RISC (Rops) omicro-operaciones.

• Rops son ejecutadas en un pipeline planificado dinamicamentey con especulacion.

• Soporta hasta 3 Rops por ciclo de reloj.

• Microarchitectura: La organizacion del procesador, incluyendolas principales unidades funcionales, su interconeccion ycontrol.












Performance

Problemas de rendimiento se dan por:

• Uso de instrucciones que no se traduzcan en operacionesRISC.

• Branches que son difıciles de predecir llevan a esperas yreinicio cuando falla.

• Dependencias largas, causadas tıpicamente por instrucciones omiss de cache que llevan a esperas.

• Esperas que son causadas por acceso a memoria.



Problema 1

Codigo C:

for i:=1 to 100

Y[i]:=a*X[i]+Y[i];

Ejemplo DAXPY Double-precision aX plus Y:

foo: LD F2, 0(R1) ; load X[i]

MULTD F4,F2,F0 ; multiplicar a*X[i]

LD F6, 0(R2) ; load Y[i]

ADDD F6,F4,F6 ; suma aX[i] + Y[i]

SD 0(R2),F6 ; store Y[i]

ADDI R1,R1,8 ; incrementar ındice X

ADDI R2,R2,8 ; incrementar ındice Y

SGTI R3,R1,done ; test si termino (R3 := (R1>done))

BEQZ R3,foo ; loop no terminado.



Problema 1

Supuestos:

• Operaciones con enteros se completan en un ciclo de reloj.

• No hay esperas por el sistema de memoria.

• No hay esperas por branch.

• Sumas de FP toman 2 ciclos, multiplicaciones FP toman 5 ciclos,divisiones FP toman 19 ciclos.

• Asumir forwarding.

Considerar pipeline de 5 etapas de enteros con unidad de punto flotante, unapara suma y resta y otra para multiplicacion y division.

• Instrucciones de punto flotante (FP) operan solo con registros de puntoflotante.

• Despues de la decodificacion, las instrucciones FP son pasadas a unarama separada del pipeline que maneja solo aritmetica de punto flotante(no accesos a memoria).

• Despues de la ejecucion, las instrucciones FP tienen una etapa de WriteBack para actualizar los registros de punto flotante. Los registros FPpueden ser actualizados en el mismo ciclo que los registros de enteros.



Problema 1: Pipeline estatico

Muestre un diagrama de tiempo del loop. ¿Cuantos ciclos de relojtoma cada iteracion del loop?

Clock 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

LD IF ID EX M WBMULTD IF ID stall EX EX EX EX EX WB

LD IF stall ID EX M WBADDD IF ID stall stall stall EX EX WB

SD IF stall stall stall ID EX MADDI IF ID EX M WBADDI IF ID EX M WBSGTI IF ID EX M WBBEQZ IF ID EX M WB

13 ciclos hasta el siguiente loop.



Problema 1: Loop unrolling

Desenrollar el loop 3 veces. No reusar registros. Eliminar computacion

redundante.foo: LD F2, 0(R1) ; load X[i]

MULTD F4,F2,F0 ; multiplicar a*X[i]

LD F6, 0(R2) ; load Y[i]

ADDD F6,F4,F6 ; sumar aX[i] + Y[i]

SD 0(R2),F6 ; store Y[i]

LD F12, 8(R1) ; load X[i+1]

MULTD F14,F12,F0 ; multiplicar a*X[i+1]

LD F16, 8(R2) ; load Y[i+1]

ADDD F16,F14,F16 ; sumar aX[i+1] + Y[i+1]

SD 8(R2),F16 ; store Y[i+1]

LD F22, 16(R1) ; load X[i+2]

MULTD F24,F22,F0 ; multiplicar a*X[i+2]

LD F26, 16(R2) ; load Y[i+2]

ADDD F26,F24,F26 ; sumar aX[i+1] + Y[i+1]

SD 16(R2),F26 ; store Y[i+1]

ADDI R1,R1,24 ; incrementar ındice X para las 3 iteraciones

ADDI R2,R2,24 ; incrementar ındice Y para las 3 iteraciones

SGTI R3,R1,done ; test si terminado (R3 := (R1>done))

BEQZ R3,foo ; loop no terminado.



Problema 1: Loop unrolling

Cada loop toma 3× 10 + 4 = 34, en promedio 11,33 ciclos poriteracion original.Vea si puede modificar la secuencia de instrucciones para reducir elnumero de esperas (stall). ¿Cuantos ciclos de reloj toma cadaiteracion?



Problema 1: Loop unrollingfoo: LD F2, 0(R1) ;

ADDI R1,R1,24 ; Hecho en el tiempo del stall. Ajustar direcciones.

MULTD F4,F2,F0 ;

LD F6, 0(R2) ;

ADDD F6,F4,F6 ;

LD F12, -16(R1) ; Direcciones ajustadas. Swap entre LD y SD.

SD 0(R2),F6 ; 2 stalls, asumiendo que la memoria toma 1 ciclo

MULTD F14,F12,F0 ;

LD F16, 8(R2) ;

ADDD F16,F14,F16 ;

LD F22, -8(R1) ; Direcciones ajustadas. Swap entre LD y SD.

SD 8(R2),F16 ;

MULTD F24,F22,F0 ;

LD F26, 16(R2) ;

ADDD F26,F24,F26 ;

ADDI R2,R2,24 ; Hecho en el tiempo del stall de ADDD

SD -8(R2),F26 ; Direcciones ajustadas

SGTI R3,R1,done ;

BEQZ R3,foo ;

Promedio de 8.67 ciclos por iteracion. Todavıa se pueden eliminar mas stall,

con mas unrolling se pueden eliminar los innecesarios. Los que son hazard

estructurales pueden eliminarse al adicionar mas unidades funcionales.



Problema 2: Planificacion en maquinas VLIW

Codigo C:

#define N 1024

float A[N], B[N], C[N], D[N];

... inicializacion arreglos...

for(int i = 0; i > N; i++)

C[i] = A[i] + B[i];

D[i] = A[i] * C[i];




Traduccion:

addi $n, $0, 1024

addi $i, $0, 0

loop:

flw $a, A($i) #load word para FP

flw $b, B($i)

fadd $c, $a, $b #sumar word FP

fmul $d, $a, $c #multiplicar word FP

fsw $c, C($i) #store word para FP

fsw $d, D($i)

addi $i, $i, 4

addi $n, $n, -1

bnez $n, loop




Maquina VLIW:Int Op1 Int Op 2 Mem Op 1 Mem Op 2 FP Suma FP Multiplicacion

• 2 ALU con 1 ciclo de latencia (branch tambien).

• 2 unidades de memoria, con 3 ciclos de latencia, con pipeline.

• 2 unidades para FP, con 4 ciclos de latencia, con pipeline.

Aplicar loop unrolling una vez, reordenamiento, renombramiento deregistros, agregar o quitar instrucciones y finalmente empaquetarlasen instrucciones de tipo VLIW.



Problema 2: Planificacion en maquinas VLIWClock Int1 Int2 Mem1 Mem2 FP Sum FP Mult

1 addi $n addi $i

2 flw $a0 flw $b0

3 flw $a1 flw $b1

4

5 fadd $c0

6 fadd $c1

7

8

9 fsw $c0 fmul $d0

10 fsw $c1 fmul $d1

11

12

13 add $n fsw $d0

14 addi $i bnez (ins2) fsw $d1


Documents

Paralelismo a Nivel de Instrucciones