Arquitecturas Avanzadas
Curso 10/11
Horas
1 INTRODUCCIÓN
5
2 CONECTIVIDAD
6
3 MÁQUINAS MIMD
7
4 MÁQUINAS SIMD
2
5 SUPERESCALARES
3
arqAva
Temario
Superes-2
6 AUMENTO DE PRESTACIONES
1 Límites de las arquitecturas escalares “Pipeline”
2 Visión global de una arquitectura Superescalar
3 Flujo de instrucciones
4 Flujo de datos en registros
5 Flujo de datos en memoria
6 Microarquitectura del Pentium II, III y 4
7 Microarquitectura del Core 2
8 Microarquitectura del Itanium (IA64)
Bibliografía:
“Modern Processor Design. Fundamentals of Superscalar Processors”
J. P. Shen y M. H. Lipasti McGraw-Hill-2004 [Caps. 4 y 5]
arqAva
Límites de las arquitecturas escalares “Pipeline” Superes-3

Aplicable a:
• Instrucciones
• Aritmética
• Acceso a
memoria
d
¡ Todas las instrucciones siguen mismo camino a la misma marcha, salvo parones !
¡ Demasiado rígido !
¿Alcanzable?
• Límite superior IPC=1=CPI
• Unificación ineficiente en un único pipeline
• Pérdida de eficiencia por ejecución tan “en orden”
arqAva
Límite superior IPC=1=CPI ¿Realidad?
Superes-4
• 1987 – Agerwala y Cocke => CPI ≈ 1,77 .. 1,15
¿ Qué rendimiento se espera ?
k etapas
dn, dn-1,..., d2, d1
d’n, d’n-1,..., d’2, d’1

k
T1
nk
Sk =
=
=
Tk
(k+n–1) 
Lim Sk = k
n 
Sin
Pipeline
nk
k+n–1
¿ Es ésto tan
bueno ?
• Límites tecnológicos:
k  (2..15..); < 10
•  k =>  n
arqAva
Límite superior IPC=1=CPI ¿Realidad?
Superes-5
Aceleración como función de ‘k’ y ‘n’
SK
Sk =
10
nk
k+n–1
8
k=6
k=10
6
4
¡ Saltos !
1 cada 5/6 Inst.
Predicción OK => 90%
¿Conclusión?
2
0
0
50
Necesario n45
para eficiencia 90%
100
Necesario n89
para eficiencia 90%
150 n
¿Puedo alimentar el pipe
con tantas instrucciones
seguidas?
arqAva
Unificación ineficiente en un único pipeline
Superes-6
Operaciones: ALU + Load/Store
F
D
I
E
W
F
D
I
E
E
W
F
D
I
E
M
W
F
D
I
E
E
M
W
Operaciones: Coma flotante, Coma fija (mul,div) => Multiciclos
Unificación imposible o muy ineficiente
Ejecución “en orden” ineficiente
arqAva
I8 I7 I6
I1
I2
I3
I4
I5
I6
I7
I8
I5
I4
I3
F
D
I
Superes-7
I2
E
E
E
W
Prog. ejemplo
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
r1
= M[Y]
r2
= M[Z]
F D I E E EW
F D I E E EW
F D — — — I E E EW
F—
? ——D—
? — — I E E EW
F — — — D I E E EW
F D I E E EW
F D — — — I E E EW
F — — — D — — — I E E EW
r3
RAW
= r1+r2
M[X] = r3
r4
= M[B]
r5
= M[C]
r6
= r4*r5
M[A] = r6
¿Es necesario retener a I5, I6, … ?
¡ Permitir ejecución fuera de orden !
Ejecución “en orden” ineficiente
arqAva
Programa ejemplo
I1:
I2:
I3:
I4:
I5:
I6:
I7:
I8:
r1
r2
r3
M[X]
r4
r5
r6
M[A]
=
=
=
=
=
=
=
=
Superes-8
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
M[Y] F D I E E E W
M[Z]
F D I E E E W
r1+r2
F D I — — —
r3
F D I — —
M[B]
F D I E
?
M[C]
F D I
r4*r5
F D
r6
F
E E E W
— — — E E E W
E E W
E E E W
I — — — E E E W
D I — — — — — E E E W
Permitiendo ejecución fuera de orden: 26 a 19 ciclos
arqAva
Visión global … (Escalar => Superescalar)
Superes-9
• Romper límite IPC=1
Pipelines paralelos
• Paralelismo temporal y espacial
ID
• Coste hw adicional:
S2 Crossbar entre etapas
Accesos paralelos Reg y Cache
RD
• ¿Rendimiento IPC?
ALU
Observado
2  0,6..1,45
4  1 .. 2
6  1,2..2,3
IF
MEM
WB
Grado = 3
Pentium4
3
Core2
4
Teórico
Unos  1,58..8
Otros  51..90
Itanium PowerG5
6
8
arqAva
Visión global … (Escalar => Superescalar)
Superes-10
• ¿Rendimiento IPC?
Observado
2  0,6..1,45
4  1 .. 2
6  1,2..2,3
Benchmark
IPC
0 Fetch
Benchmark
IPC
0 Fetch
bzip2
1,36
14,3
ammp
1,11
43,2
eon
1,24
16,4
apsi
1,12
45,1
gap
1,32
10,4
equake
1,05
39,2
gcc
1,14
12,2
mesa
1,31
21,4
gzip
1,08
19,6
wupwise
1,84
19,7
parser
0,89
25,3
perlbmk
1,10
42,2
Media INT
1,16
20,1
Media FP
1,29
33,7
Simulación con:
• PTLsim/X arquitectura tipo x86-64 grado 4
• SPEC CPU2006
• 200 millones de instrucciones simuladas: datos “Fetch”
Visión global … (Escalar => Superescalar)
arqAva
Superes-11
• Evitar unificación ineficiente
• Diseño adhoc + eficiente:
Mejor latencia
Menos hardware
Pipelines diversificados
IF
• Control cauces EX:
Distribuido e independiente
ID
RD
EX
ALU
MEM1
FP1
MEM2
FP2
FP3
WB
BR
• ¿Cuánta diversidad?
1965
1990
1995
2000
2006
CDC6600
M88110
Pentium
Itanium
Core 2 Duo
10
10
2
23
14
arqAva
Visión global … (Escalar => Superescalar)
Superes-12
• Permitir ejecución fuera de orden => Pipelines dinámicos
IF
ID
en
orden
RD
Dispatch
buffer
EX
ALU
MEM1
MEM2
FP1
FP2
BR
fuera de
orden
FP3
Reorder
buffer
WB
en
orden
arqAva
Visión global … (Modelo Superescalar)
Superes-13
Extraer
Buffer de instrucciones
Decodificar
Buffer de dispatch
Cada instrucción a
U.F. adecuada
Despachar
Buffer de issuing
Ejecutar
Buffer de completar
Forzar terminación
en orden
Completar
Buffer de store
Optimizar acceso
a memoria
Retirar
Visión global … (Etapa Fetch)
arqAva
Superes-14
• ¡ La etapa Fetch no es trivial ! (Caché simple “línea = 4 Inst.”)
CACHE
4
I
8
F
4
D
E
E
W
W
sub add xor sub
rol mul add mov
E
E
W
W
or bra --- ---
• Caché extendida “línea = 8 Inst.”
--- --- sub lsl add load asr sub
para etapa D guardar
add load --- --- --- --- --- ---
--- add call ---
• Caché autoalineada
PC
Bancos de memoria
0
1
2
3
--add
--load
sub
asr
lsl
sub
Buffer --- asr sub
para etapa D
asr sub add load
sub lsl add load
arqAva
Visión global … (Etapa Decodificación)
Superes-15
• ¡ Mucho trabajo !
• Identificar las instrucciones concretas y su tipo
• Detectar dependencias con instrucciones cercanas
• Identificar saltos
RISC lo facilita mucho
• Leer operandos
• ¿Acelerar? => Predecodificación (parcial) previa [miss cacheI]
Memoria
principal
Lógica
Cache
Pre
I
Deco.
4b
Inst1 Inst2 Inst3 Inst4
4
Inst1
4b
Inst2
F
4
4b
Inst3
D
4b
Inst4
Tiene su sobrecarga
Saltos
Independencia
Visión global … (Etapa Despachar)
arqAva
Superes-16
• Decidir a qué U.F. enviar cada instrucción
• Transición centralizado a distribuído
• Buffer de espera operando(s) no disponible(s)
Extraer
Decodificar
I7
Tomasulo
central Estación
de reserva
Despachar
ALU I6 MEM1
FP1
I5 MEM2
FP2
I5: r4
I6: r5
I7: r6
= M[B]
= M[C]
= r4*r5
distribuidas
BR
FP3
dispatch
issue
ALU
Reorder buffer “Completar”
MEM1
FP1
MEM2
FP2
FP3
BR
arqAva
Visión global … (Etapa Ejecutar)
Superes-17
• Tendencia a diversificar más => más U.F. más especializadas
ALU TI SuperSPARC
FPU IBM RS/6000
• Salto
• Load / Store
• Multimedia
(a+e+1) + (b+f+1) +
2
2
(c+g+1) + (d+h+1)
2
2
• ¿Cuántas U.F. de qué tipo?
Regla 4 / 2 / 4
Instrucciones
%
Tipo
40
ALU
20
saltos
40 load/store
• U.F. > Grado
• O(N2)
arqAva
Visión global … (Etapa Ejecutar)
Superes-18
• ¿Cuántas U.F. de qué tipo?
Instrucciones
%
Tipo
40
ALU
20
saltos
40 load/store
Bench
ld
st
salto
bzip2
17,4
7,7
11,5
eon
21,3
16,4
8,6
gap
24,4
10,5
gcc
21,1
gzip
Bench
ld
st
salto
ammp
21,1
6,4
7,6
apsi
23,2
5,3
6,6
13,4
equake
18,4
8,7
7,2
10,8
15,2
mesa
23,3
10,8
9,0
17,1
7,7
8,6
wupwise
22,2
10,5
10,1
parser
24,3
9,2
12,8
perlbmk
23,2
12,0
15,4
INT
21,3
10,6
12,2
FP
21,6
8,3
8,1
Simulación con:
• PTLsim/X arquitectura tipo x86-64 grado 4
• SPEC CPU2006
• 200 millones de instrucciones simuladas: datos “Commit”
Visión global … (Etapas Completar y Retirar) Superes-19
arqAva
1: r0=r1-r2
2: r3=r4/r0
F
?
3:r5=r5+#1
E
E
C
Excepciones
precisas
Estado
máquina
R
Prioridad a
load vs store
Estado
memoria
X
O
O
N
E
E
T
D
C
U
R
B
N
T
E
A
N
C
D
K
I
O
N
Flujo de instrucciones (Problemática de los saltos) Superes-20
arqAva
Programa ejemplo
• Por simplicidad:
F
D
I1, I2, I3, I4, I5, I5, I6
vs
I1, I2, I3, I5, I6
E
W
I1:
I2:
I3:
I4:
I5:
I6:
r1
r3
beq
r2
r5
M[B]
= M[A]
= r3-1
I5
= r2+r4
= r5-r6
= r5
1 2 3 4 5 6 7 8 9 10
I1:
I2:
I3:
I4:
I5:
I5:
I6:
r1
r3
beq
r2
r5
r5
M[B]
= M[A] F D E W
= r3-1
F D E W
I5
F D E W
= r2+r4
F D E W
= r5-r6
F D E W
= r5-r6
F D E W
= r5
F D E W
! Hasta fin ciclo
5 no se sabe
dirección del
salto !
¿Cómo afecta a
nuestro modelo?
Flujo de instrucciones (Penalización por saltos)
arqAva
Superes-21
• Incondicionales: bra 28(PC) => Determinar dirección destino
• Condicionales: beq 55(R5) => + Evaluar condición de saltar
?
desp(PC)
Modo de
direccionamiento
• bra 28(PC)
(Ri)
• bra (R5)
• bra 55(R5)
desp(Ri)
salto
¿ Perder siempre
3 ciclos ?
21 Instrucciones
arqAva
Flujo de instrucciones (Penalización por saltos)
Superes-22
• Incondicionales: bra 28(PC) => Determinar dirección destino
• Condicionales: beq 55(R5) => + Evaluar condición de saltar
Registro
Cond.
¿ Flags, Registros ?
Registros
generales
salto
¡ Demasiada
pérdida !
Flujo de instrucciones (Técnicas especulativas)
arqAva
• Predecir (especular)
• Mecanismo para validar acierto o fracaso
Dirección del salto
• Mecanismo de recuperación ante un fallo
Condición del salto
Cache
Inst.
El salto sigue
su ejecución
Branch Target Buffer
Dir. Inst. Salto
$00F5A4
Dir. Destino Historia
Mux
T
$00F5AC 0 1
TT/T
T
N NT/T
N
PC
+
Superes-23
Saltar
T
TN/T T NN/N
N
• Hit BTB 86,5%
• ¿ Aliasing ?
Saltar FSM
$00F5A4: beq 4(PC)
N
OK
86,8 .. 97,0
Flujo de instrucciones (Técnicas especulativas)
arqAva
Superes-24
• Mecanismo de recuperación ante un fallo
a
T (tag 01)
T
a
01 inst1
01 inst2
01 inst3
01 inst1
01 inst2
01 inst3
(tag 02) N
02 inst4
c
N
b
¿ Gestión de
etiquetas ?
b
02 inst4
T (tag 03)
c
03 inst5
03 inst6
¡Etiquetar!
T
Retirar éstas
T
+ ¡Redirigir!
inst7
inst8
e
03 inst5
03 inst6
T
01 inst9
¡Anular!
d
d
f
arqAva
Flujo de instrucciones (Técnicas especulativas)
Superes-25
PowerPC 604
• BTB dividida en dos
• BTAC [64] saltos tomados y 1 ciclo
• BHT [512] correctora y 2 ciclos
• Actualización en Back-End
• Estación de reserva Branch [4]
Flujo de instrucciones (¿Qué se consigue?)
arqAva
• 2 bits historia y 4K entradas [Hennesy …]
Aritmética
Coma flotante
Media 4%
Aritmética
Entera
Media 11%
Más frecuentes los bcc
Superes-26
arqAva
Flujo de instrucciones (Otras técnicas especulativas) Super-27
• ¿Cómo mejorar en la condición?
• Más bits de historia
Apenas mejora
• Más saltos recordados
• Mejorar la función de predicción
• Predictores correlacionados
if (d==0)
d = 1;
if (d==1)
------
Historia de otros
saltos influyen en la
predicción del salto
actual [globalidad]
• Predictores múltiples: local + global ….
Local 2 bits
=> 7%
Correlacionado => 4%
Múltiple
=> 3%
Flujo de instrucciones (Otras técnicas especulativas) Super-28
arqAva
• Algunos problemas del predictor simple con 2 bits de historia:
Sea un patrón de salto => T N T N T N T N T………
Historia
¿Guardar dos+ comportamientos?
0 10
Historia
PC
PC
50%
T
NN/N
NT/T
01 10 01 1
0
Registro histórico
de saltos con
desplazamiento
0 0
1 1
N
T
TN/T
TT/T
¿Cuántos?
Idealmente uno por salto
arqAva
Flujo de instrucciones (Otras técnicas especulativas) Super-29
• Algunos problemas del predictor simple con 2 bits de historia:
2 instrucciones distintas y mismo patrón de saltos => ¡Aliasing!
Historia
$A350 bne 4(PC)
1010
PC
1 1
0 0
1010
$B684 beq 8(PC)
¿Guardar dos+ historias?
Flujo de instrucciones (Otras técnicas especulativas) Super-30
arqAva
• 1992 Yeh y Patt => Predictor adaptativo de dos niveles
PC
• g Global [1]
• p Individual [1 * bcc]
• s Shared [n * bcc]
PentiumPro
Adaptativo
• G Global [1]
• P Individual [varios]
GAg, PAg, PAs
90%  95..97%
arqAva
Flujo de instrucciones (Otras técnicas especulativas) Super-31
• 1993 Scott McFarling => Predictor gshare
Además:
Return
Address
Stack
DEC Alpha 21264
• ISCA’04 Ayosé Falcon y … => Prophet/Critic hybrid branch predictor
arqAva
Flujo de instrucciones (Otras técnicas especulativas) Super-32
90%  95..97%
GAg, PAg, PAs
Bench
Hit
Bench
salto
bzip2
95,9
ammp
98,9
eon
93,3
apsi
99,3
gap
96,0
equake
92,3
gcc
92,6
mesa
97,8
gzip
92,2
wupwise
97,7
parser
99,9
perlbmk
98,8
INT
95,5
FP
97,2
Simulación con:
• PTLsim/X arquitectura tipo x86-64: bimodal(2)+Gshare
• SPEC CPU2006
• 200 millones de instrucciones simuladas: cond, indir, ret
arqAva
Flujo de datos en registros
Superes-33
arqAva
Flujo de datos en memoria
Superes-34
• Problemática del acceso a memoria
disponible r1
r1
$000F3A58
ld r2,35(r1)
$000F3A8D
TLB
1 000F3 3F25
¿ st r3,20(r4) ?
$3F25A8D
arqAva
Flujo de datos en memoria
Superes-35
• ¿Ejecución en orden de los accesos a memoria?
DAXPY :: LINPAC
Y(i) = A * X(i) + Y(i)
LD
F0  LD,a
R4  ADDI,Rx,#512
;last address
F2  LD,0(Rx)
;load X(i)
F2  MULTD,F0,F2
;A*X(i)
F4  LD,0(Ry)
;load Y(i)
F4  ADDD,F2,F4
;A*X(i)+Y(i)
0(Ry)  SD,F4
;store into Y(i)
Rx  ADDI,Rx,#8
;inc. index to X
Ry  ADDI,Ry,#8
;inc. Index to Y
R20  SUB,R4,Rx
;compute bound
BNZ,R20,Loop
;check if done
Loop:
1ª iteración
2ª iteración
ld, multd, ld, addd, sd ld, multd, ld, addd, sd
MULTD
LD
ADDD
SD
¿Fuera de
orden?
arqAva
Flujo de datos en memoria
Superes-36
• Load Bypassing, Load Forwarding y colas LSQ
st
L
D
Q
ld
STQ
STQ
L1D
reissue
Load bypassing
Load forwarding
Store ?X
Store X
Store Y
Store Y
Load Z
Load X
11..19%
1..4%
• Tag con menos bits “aliassing”
• Forwarding  Tag Addr completa
• Predictor de dependencia LdSt
 Mejoras
36
arqAva
Flujo de datos en memoria
Superes-37
• Load Bypassing, Load Forwarding y colas LSQ [Completo]
STQ
LDQ
37
arqAva
Flujo de datos en memoria
Superes-38
• ¿Cuánto forwarding?
Bench
fwd
Bench
fwd
bzip2
12,0
ammp
1,4
eon
15,4
apsi
5,5
gap
7,5
gcc
10,0
mesa
9,5
gzip
10,2
wupwise
5,0
FP
6,8
parser
8,0
perlbmk
8,3
INT
10,2
equake
12,7
Simulación con:
• PTLsim/X arquitectura tipo x86-64: LSQ [LQ.48+SQ.32]
• SPEC CPU2006
• 200 millones de instrucciones simuladas
arqAva
Flujo de datos en memoria
Superes-39
• Cache con dos puertos y no bloqueante
¿Especulativo?
¡Contienda!
• Puede reducir el 15% de la penalización por fallo de cache
arqAva
Flujo de datos en memoria
Superes-40
• Cache con prefetch
• LdAddr
• ValueAddrAnt
• Stride2Ant
arqAva
Microarquitectura del Pentium II (1)
Caché de
Nivel 2
• Busca compatibilidad a
nivel ISA (Instruction Set
Architecture) con
versiones anteriores
Bus
Caché de
• Máquina de origen CISC:
instrucciones
Difícil utilización de
recursos arquitecturales
Búsqueda y deco.
RISC y superescalares
• Solución: Capa superior
CISC y capa inferior ~
RISC
Superes-41
de instrucciones
Caché de datos
Unidad de
Unidad de
ejecución afianzamiento
Buffer de reordenación
arqAva
Microarquitectura del Pentium II (2)
Mantiene el flujo
de instrucciones
Caché de
instrucciones
Etapa 1 Fetch
Decodifica y determina
longitud de instrucciones
Puntero de instrucciones
128 bits
Predicción dinámica
de salto
Etapa 2 Fetch
128 bits
Alinea las instrucciones
Etapa 3 Fetch
128 bits
Convierte instrucciones CISC
en microinstrucciones RISC
Ordena las
microinstrucciones
Superes-42
Etapa 1 decodificación
Secuenciador
microinst. RISC
6 x 118 bits
Etapa 2 decodificación 3 x 118 bits
3 x 118 bits
Predicción estática
de salto
Asignación de registros
Mapea los 16 registros
CISC sobre 40 registros RISC
Buffer de
reordenación2
Con Exe y WB2
11 etapas
arqAva
Microarquitectura del Pentium II (3)
Superes-43
Hasta 4
microinstrucciones RISC
Etapa 1 de decodificación
Sequenciador de
Microinstrucciones RISC
Decodificador 0 Instrucciones complejas
Decodificador 1 Instrucciones simples
Decodificador 2 Instrucciones simples
Una sóla
microinstrucción RISC
6 x 118 bits
arqAva
Microarquitectura del Pentium II (4)
Superes-44
Afianzamiento
Caché de datos
ALU Compleja
Unidad de carga
ALU MMX
Multiplicador
MMX
ALU MMX
Unidad coma
Desplazador
flotante compleja
MMX
Unidad coma
ALU simple y
flotante simple
recuperación saltos
Unidad de
almacenamiento
Unidad de
almacenamiento
Finalización en
orden
Data forwarding
Desechar ejecución
especulativa
Unidad SSE
Pentium III
Puerto 0
Puerto 1
Puerto 2 Puerto 3 Puerto 4 Puerto 5
Unidad de Ejecución (Estación de Reserva)
Buffer de reordenación
¿Pentium 4?
• 20 etapas
• Caché de traza
arqAva
Microarquitectura del Pentium II (5)
Superes-45
• Evolución del pipeline:
1
2
3
4
Pentium
Busq Dec1 Dec2 Ejec Escr
1
2
3
4
¿Intel Core 2?
5
5
6
7
8
9
10
11
Pentium Pro
Bus1 Bus2 Bus3 Dec1 Dec2 Aloj Reor Prep Ejec Esc1 Esc2
CISC
14
RISC
Pentium 4
Dependencias de Datos
1
2
Bus1 IP
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
Tra1 Tra2 Env1 Aloj Ren1 Ren2 Enc Reo1 Reo2 Reo3 Emi1 Emi2 Lec1 Lec2 Ejec Flag Esc Env2
2004
nunca
¡ Pentium 4 Prescott  31 etapas ! ¿ Tejas 45 etapas y 7 Ghz ?
arqAva
Microarquitectura del Pentium II (6)
Superes-46
• Cache de trazas del Pentium 4
PC
L1-I Convencional
Cache de Trazas
TC
Genera
Trazas
Fallo
arqAva
Microarquitectura del Intel Core [..Nehalem] Superes-47
• Sin cache de trazas
• 14 etapas
Eficiencia
energética
• 4 x ciclo
• LSQ
www.intel.com
arqAva
Microarquitectura del Intel Core
• Incremento del rendimiento SSE
Superes-48
arqAva
Microarquitectura del Intel Core
Superes-49
• Incremento del rendimiento en Prefetch de L1 Datos
d, d+k, d+2k, …
Siguiente línea
arqAva
Microarquitectura del Intel Core
Superes-50
• Incremento del rendimiento: Micro-Fusion + Macro-Fusion
x86
cmp eax,[mem32]
jne target
x86
add eax,[mem32]
µOp
µOp
cmpjne eax,[mem32],target
load reg1,[mem32]
add reg2,reg1
SuperµOp
add reg1,[mem32]
10%
5%
15%
arqAva
Microarquitectura del Intel Core
• Intel Turbo Boost Technology
Vigilando: Núcleos activos, consumo, temperatura
www.intel.com
Superes-51
arqAva
Microarquitectura del Intel Core
Superes-52
• Intel Enhanced Dynamic Acceleration Technology www.intel.com
• Ahorro gasto snoopy [30%]
arqAva
Microarquitectura del Itanium
¡ Nuevo Diseño ! IA32 => IA64-Itanium
Superes-53
Dual
Core
arqAva
Microarquitectura del Itanium
¡ Nuevo Diseño ! IA32 => IA64-Itanium
Superes-54
¿Un éxito?
¿ Retrasado a 2010 o abandonado ?
arqAva
Microarquitectura del Itanium (¿Éxito?)
Superes-55
7/12/2005: “Itanium: A cautionary tale” www.news.com
1,7 millones x86
Topt500 Nov/2009
AMD x86_64
La puntilla
6
EM64T
27/05/2009: “Nehalem-EX is 8-core …, likely to signal end of line for Itanium” geek
22/12/2009: “Red Hat will drop the Itanic” www.theinquirer.net
arqAva
Montecito
1700 mill. Transis. 24MB
3.692$
Dual y Quad Core
L1I
L3 L2 1,6GHz
128
L1D
Itanium 2
Superes-56
• L1 2*16KB
Latencia 1
• L2 256KB
Latencia 5..7
• L3 ..24MB
Latencia 14..17
• Superescalar de grado 6
• 23 unidades funcionales:
6 ALU, 6 MALU,
2+2Mem,
3 Salto, 2+2FPU
• Muchos registros (328):
128 Enteros (64+1 “NaT” bits)
128 Coma Flotante (82 bits)
8 Saltos (64 bits)
64 Predicados (1 bit)
• Pipeline de 8 etapas
• DirVir 64bits y DirReal 50bits
arqAva
Itanium: Límites al ILP
¿Límites al ILP?
• Complejidad de la planificación dinámica (Hw)
Explicitly Parallel Instruction Computer
• Saltos => Dependencias, Errores de predicción
Ejecución predicada (PREDICATION)  Predicción
• Latencia de memoria ¡ Muy lenta !
Cargas especulativas
FIN
Todo junto =>? Mejora del 79%
Superes-57
arqAva
Itanium: complejidad planificación dinámica Superes-58
Código fuente
original
Compilador
Código máquina
secuencial
Código
reordenado
Hardware
Paraleliza
Varias U.F.
?
U.F. desaprovechadas
Los procesadores frecuentemente están el 60% desocupados
arqAva
Itanium: EPIC
Superes-59
• Paralelismo Explícito (EPIC)
Código máquina
paralelo
Código fuente
original
Compilador
(paraleliza)
Hardware
Ventana
más
grande
?
Varias U.F.
U.F. más aprovechadas
Se incrementa la ejecución paralela
arqAva
Itanium: EPIC + VLIW
Superes-60
• Paralelismo Explícito (EPIC + VLIW)
Instrucciones agrupadas en fardos (bundle) de 3 en 3
41
Instrucción 2
41
Instrucción 1
41
Instrucción 0
4 1
Temp S
41
Instrucción 2
41
Instrucción 1
41
Instrucción 0
4 1
Temp S

Op
14
Se pueden encadenar:
Escalabilidad en cuanto al número de U.F.
PRi
6
R1
7
R2
7
R3
7
arqAva
Itanium: Predication (1)
Superes-61
• Ejecución predicada (IF – THEN – ELSE; NEXT)
Arquitectura tradicional
cmp
IA64
IF
P1=1
P2=0
THEN
ELSE
NEXT
T Cond F
p1,p2 cmp
P1
P2
P1
P2
P1
P2
Permite eliminar saltos
(difíciles de predecir)
P1=0
P2=1
arqAva
Itanium: Predication (2)
Superes-62
V1 := V1 + 1
Ejecución con resultados
a AND b
afirmados mediante <Pri>
T
F
V2 := V2 / 2
V4 := V4 - 4
V3 := V3 * 3
V5 := V5 + 1
Ejecución
Afianzamiento
Ejecución con resultados
V6 := V6 - 1
afirmados mediante <Prj>
arqAva
Itanium: Predication (3)
V1 := V1 + 1;
add RV1, #1
IF (a AND b) THEN
cmp a, #0 --false
BEGIN
cmp b, #0 --false
V3 := V3 * 3;
beq Else
END;
div RV2, #2
ELSE
mul RV3, #3
BEGIN
bra FinIf
V4 := V4 - 4;
END;
V6 := V6 - 6;
Pr1, Pr2 := Condición
<Pr1> Pr1, Pr2 := Condición
beq Else
V2 := V2 / 2;
V5 := V5 + 5;
Superes-63
Else
sub RV4, #4
add RV5, #5
FinIf
sub RV6, #6
add RV1, #1
Pr1, Pr2 := cmp (a = 0)
<Pr2> Pr1, Pr2 := cmp (b = 0)
<Pr2> div RV2, #2
<Pr2> mul RV3, #3
<Pr1> sub RV4, #4
<Pr1> add RV5, #5
sub RV6, #6
Mezcladas
arqAva
Itanium: Cargas Especulativas
Superes-64
• Carga de datos de memoria antes de que se necesiten
• Disminuye el impacto que genera la alta latencia de las memorias
• Se intenta adelantar las cargas lo máximo posible.
Problema:
Puede que la carga
no sea necesaria
Puede que se provoque
una falta de página
add t1 + 1
comp t1 > t2
jump
load r8, a[t1-t2]
add r8 + 1
barrera
add t1 + 1
ld.s r8=a[t1-t2]
comp t1 > t2
jump
check.s r8
add r8 + 1
t1 = t1 + 1
if t1 > t2
j = a[t1 – t2]
j++
Solución: Separar la carga de
la posible excepción generada
ld.s R2, (Dir2)
<Pr2> chk.s R2
Descargar

Sistemas Operativos I