02cpu Handout

Tema 2.
La CPU
Arquitectura de Computadores
Área de Arquitectura y Tecnología de Computadores

Departamento de Informática
Universidad de Oviedo
Curso 2023–2024
Objetivos
1.- Mejoras del rendimiento

Cambios organizativos para mejorar el rendimiento
2.- Soporte a los sistemas operativos multitarea

Funcionalidad necesaria para su correcto funcionamiento
3.- Soporte a la virtualización

Funcionalidad necesaria para ejecución eficiente
A
TC
Arquitectura de ejemplo
MIPS64
• Primera de 64 bits
• Evolución de MIPS 32 bits
• Compatible
• Muy parecida a ARMv8 (dispositivos móviles)
RISC
• Instrucciones sencillas de tamaño fijo
• Pocos modos de direccionamiento
• Gran número de registros
A
TC
MIPS64
ISA (carga/almacenamiento)
• Ancho de la CPU
• ancho de los operandos: 64 bits
• Espacio de memoria (m)
• líneas en el bus de direcciones (64) ⇒ m = 264
• Memoria direccionable al byte
• byte, media palabra, palabra, doble palabra
• solo instrucciones de carga/almacenamiento
• Conjunto de registros (64 bits)
• 32 enteros: r1-r31 (r0= 0)
• 32 reales en coma flotante de precisión doble: f0-f31
A
TC
Tipos de datos
Enteros (complemento a dos)

• Byte: 8 bits
• Media palabra: 16 bits
• Palabra: 32 bits
• Doble palabra: 64 bits
Reales (IEEE-754)
• Precisión simple: 32 bits
• Precisión doble: 64 bits
Acceso a varios bytes

• Endianity
• Accesos alineados
A
TC
Tipos de datos
Carga de byte sin signo
lbu r4, 100(r0)
63 32 31 16 15 8 7 0
0 0 0 ... 0 0 0 1 .. X
byte
media palabra
palabra
doble palabra
A
TC
Tipos de datos
Carga de byte con signo
lb r4, 100(r0)
63 32 31 16 15 8 7 0
1 1 1 ... 1 1 1 1 .. X
byte
media palabra
palabra
doble palabra
A
TC
Accesos alineados
Memoria
Alineado a 32 bits ...
00...1100 A3
00...1101 10
00...1110 9A
00...1111 BF
00...0000 A4
00...0001 5A
No alineado a 32 bits
00...0010 79
No permitido 00...0011 F3
00...0100 FF
00...0101 B3
00...0110 19
00...0111 CD
...
A
TC
Juego de instrucciones
• Aritméticas
• Lógicas
• Carga/Almacenamiento
• Saltos incondicionales
• Saltos condicionales
• Desplazamientos
• Copia/Conversiones
A
TC
Modos de direccionamiento
Ubicación de los operandos

• Código de la instrucción
• Registro
• Memoria
Modos
• Inmediato: daddi r4, r8, -2
• Registro: dadd r2, r18, r3
• Base más desplazamiento: ld r6, 100(r3)
• Relativo al PC: beq r2, r9, -5

• Pseudodirecto: j 1000
A
TC
Codificación
Todas el mismo tamaño: 32 bits

31 26 25 21 20 16 15 11 10 6 5 0
tipo R op rs1 rs2 rd inmediato función
tipo I op rs rd inmediato
tipo J op inmediato
A
TC
Ejecución de instrucciones
Condiciones
• Instrucciones en memoria
CPU • PC apunta a la siguiente
instruccion
Unidad
de control
Fichero Repetir
registros
PC
• Búsqueda de instrucción
• Incrementar PC
• Decodificar la instrucción
SR
• Búsqueda de operandos
ZCOS
• Ejecución de la instrucción
• (carga/almacenamiento)
Acceso a memoria
• Almacenar los resultados
A
TC
Ejemplo
• int32 a; // (en registro r10)
• int32 b; // (en direccion 1534h)
C MIPS64 C. máquina
if (a == b) lw r21, 0x1534(r0) 8C151534h
a = 0; bne r21, r10, skip 15550001h
xor r10, r10, r10 014A5026h
skip:
A
TC
Ejemplo
CPU
Memoria
F. registros
R0 = 0000 0000 U. control
... 1534 ...
00
R10 = 0000 000A
1535 00
...
R21 = xxxx xxxx 1536 00
... PC 1537 0A
... ...
2000 ...
8C
SR 2001 15
2002 15
ZCOS 2003 34
2004 15
2005 55
2006 00
2007 01
2008 01
2009 4A
200A 50
lw r21, 0x1534(r0)
200B 26
bne r21, r10, skip
xor r10, r10, r10 200C 04
skip: 200D 00
200E 00
200F 00
...
A
TC
Ejemplo
CPU
Memoria
F. registros U. control
R0 = 0000 0000
... 8C15 1534 1534 ...
00
R10 = 0000 000A
1535 00
...
R21 = xxxx xxxx 1536 00
... PC 1537 0A
... ...
2000
2000 ...
8C
SR 2001 15
2002 15
ZCOS 2003 34
2004 15
2005 55
2006 00
2007 01
2008 01
2009 4A
1.- Búsqueda de instrucción 200A 50
lw r21, 0x1534(r0)
200B 26
bne r21, r10, skip
xor r10, r10, r10 200C 04
skip: 200D 00
200E 00
200F 00
...
A
TC
Ejemplo
CPU
Memoria
R0 = 0000 0000
... 8C15 1534 1534 ...
00
R10 = 0000 000A
1535 00
...
R21 = xxxx xxxx 1536 00
... PC 1537 0A
... ...
2004
2000 ...
8C
SR 2001 15
2002 15
ZCOS 2003 34
2004 15
2005 55
2006 00
2007 01
2008 01
2009 4A
2.- Incrementar PC (+4) 200A 50
lw r21, 0x1534(r0) 2000 + 4 200B 26
bne r21, r10, skip
xor r10, r10, r10 200C 04
skip: 200D 00
200E 00
200F 00
...
A
TC
Ejemplo
CPU
Memoria
R0 = 0000 0000 lw r21, 0x1534(r0)
... 8C15 1534 1534 ...
00
R10 = 0000 000A
1535 00
...
R21 = xxxx xxxx 1536 00
... PC 1537 0A
... ...
2004
2000 ...
8C
SR 2001 15
2002 15
ZCOS 2003 34
2004 15
2005 55
2006 00
2007 01
2008 01
2009 4A
3.- Decodificar la instrucción 200A 50
lw r21, 0x1534(r0)
200B 26
bne r21, r10, skip
xor r10, r10, r10 200C 04
skip: 200D 00
200E 00
200F 00
...
A
TC
Ejemplo
CPU
Memoria
R0 = 0000 0000 lw r21, 0x1534(r0)
... 8C15 1534 1534 ...
00
R10 = 0000 000A
1535 00
...
R21 = xxxx xxxx 1536 00
... PC 1537 0A
... ...
2004
R0 0x1534 2000 ...

8C
SR 2001 15
2002 15
ZCOS 2003 34
2004 15
2005 55
2006 00
2007 01
2008 01
2009 4A
4.- Búsqueda de operandos 200A 50
lw r21, 0x1534(r0)
200B 26
bne r21, r10, skip
xor r10, r10, r10 200C 04
skip: 200D 00
200E 00
200F 00
...
A
TC
Ejemplo
CPU
Memoria
R0 = 0000 0000 lw r21, 0x1534(r0)
... 8C15 1534 1534 ...
00
R10 = 0000 000A
1535 00
...
R21 = xxxx xxxx 1536 00
... PC 1537 0A
... ...
2004
2000 ...
8C
SR 2001 15
R0+0x1534 2002 15
ZCOS 2003 34
2004 15
2005 55
2006 00
2007 01
2008 01
2009 4A
5.- Ejecución de la instrucción 200A 50
lw r21, 0x1534(r0)
200B 26
bne r21, r10, skip
xor r10, r10, r10 200C 04
skip: 200D 00
200E 00
200F 00
...
A
TC
Ejemplo
CPU
Memoria
R0 = 0000 0000 lw r21, 0x1534(r0)
... 8C15 1534 1534 ...
00
R10 = 0000 000A
1535 00
...
R21 = xxxx xxxx 1536 00
... PC leer 1537 0A
... ...
2004
2000 ...
8C
SR 2001 15
2002 15
ZCOS 2003 34
2004 15
2005 55
2006 00
2007 01
2008 01
2009 4A
6.- Acceso a memoria 200A 50
lw r21, 0x1534(r0)
200B 26
bne r21, r10, skip
xor r10, r10, r10 200C 04
skip: 200D 00
200E 00
200F 00
...
A
TC
Ejemplo
CPU
Memoria
R0 = 0000 0000 lw r21, 0x1534(r0)
... 8C15 1534 1534 ...
00
R10 = 0000 000A
1535 00
...
R21 = xxxx xxxx 1536 00
... PC 1537 0A
... ...
2004
2000 ...
8C
SR 2001 15
2002 15
ZCOS 2003 34
2004 15
2005 55
2006 00
2007 01
2008 01
2009 4A
7.- Almacenar los resultados 200A 50
lw r21, 0x1534(r0)
200B 26
bne r21, r10, skip
xor r10, r10, r10 200C 04
skip: 200D 00
200E 00
200F 00
...
A
TC
Microarquitectura
Simplificación
Instrucción Tipo Descripción

ld Rd,inm_16(Ri) I Carga de doble palabra
sd Rs,inm_16(Ri) I Almacenamiento de doble palabra
beq Rs1,Rs2,inm_16 I Salto condicional si los registros son iguales
daddi Rd,Rs,inm_16 I Suma de registro y valor inmediato
j inm_26 J Salto incondicional
dadd Rd,Rs1,Rs2 R Suma de registros
dsub Rd,Rs1,Rs2 R Resta de registros
and Rd,Rs1,Rs2 R Operación lógica AND
or Rd,Rs1,Rs2 R Operación lógica OR
slt Rd,Rs1,Rs2 R (Rd = Rs1 < Rs2 ? 1 : 0)
A
TC
Requisitos
Idea básica
Replicar hardware
• ejecutar todas las instrucciones con CPI = 1
Fases comunes
• Buscar el código de instrucción
• Decodificar la instrucción
A
TC
Unidades funcionales
Elementos constructivos del camino de datos
• Registro PC
• Memoria de instrucciones/datos
• Fichero de registros
• ALU
• Más: sumadores, desplazadores, multiplexores
Read #1 5
Read #2 5
RegWrite M 64
... Read data 1 Z
64 u
D
Reg 0
Q x Input #1
0 C 64
Write
D Q ALU Result
register 5 1 Reg 1
Deco C
...
30 Q Input #2
...
...
31 64 M 64
Read data 2 4
...
D Q u ALU ctrl
Write Reg n − 1
C 64 x
data 64
D Q
Reg n
C
A
TC
Búsqueda del código de instrucción
Add
4
PC Address
Instruction
Instruction
memory
A
TC
Instrucciones tipo R

dadd Rd,Rs1,Rs2 R Suma de registros (doble palabra)
dsub Rd,Rs1,Rs2 R Resta de registros (doble palabra)
and Rd,Rs1,Rs2 R Operación lógica AND
or Rd,Rs1,Rs2 R Operación lógica OR
slt Rd,Rs1,Rs2 R Comparación entera (if Rs1<Rs2 Rd=1; else Rd=0)
31 26 25 21 20 16 15 11 10 6 5 0
A
TC
Ejecución de instrucciones de tipo R
dadd r2, r5, r8
31 26 25 21 20 16 15 11 10 6 5 0
Instruction [25:21] Z
Read #1
Read
32 Instruction [20:16] data 1 ALU
Instruction Read #2
Result
Register
Instruction [15:11] file Read
Write
register data 2
4
Write ALU ctrl
data
RegWrite
A
TC
Datapath para instrucciones tipo R
Add
4
PC Address Read #1
Read
Instruction Read #2
Result
Register
Instruction Instruction [15:11] file Read
Write
memory register data 2
4
Write ALU ctrl
data
RegWrite
A
TC
Instrucciones carga/almacenamiento

ld Rd,inm_16(Ri) I Carga de doble palabra
sd Rd,inm_16(Ri) I Almacenamiento de doble palabra
31 26 25 21 20 16 15 0
A
TC
Ejec. instr. carga/almacenamiento
ld r4, 200(r2) / sd r2, 100(r4)
31 26 25 21 20 16 15 0
Read #1
MemRead
Read
Read #2 Read
Result Address
Register data
file Read
Write
register data 2 Data
4 memory
Write ALU ctrl
data Write
data
RegWrite
MemWrite
Instruction [15:0] 16 64
Sign
extend
A
TC
Datapath inst. R y carga/almac.
31 26 25 21 20 16 15 11 10 6 5 0
31 26 25 21 20 16 15 0
Add
4
Read #1
MemRead
Read MemToReg
PC Address
Instruction [20:16] data 1 ALU
Read #2 ALUSrc Read 1
Register Result Address M
Instruction 0 data
M file Read 0 u
Write x
u data 2 M Data
Inst. Inst. [15:11] register 0
x u 4 memory
memory 1 x
Write ALU ctrl
RegDst 1 Write
data
data
RegWrite
MemWrite
Sign
extend
A
TC
Ejec. de la instrucción beq Rs1,Rs2,inm_16
31 26 25 21 20 16 15 0
New PC
0
M
PC + 4 u
Add
x
Result
1
Shift
left 2 PCSrc
Read #1
Read
32 data 1 ALU Branch
Instruction [20:16]
Inst. Read #2
Register Result
file Read
Write
register data 2
4
Write ALU ctrl
data
RegWrite
Sign
extend
A
TC
Camino de datos: Tipo R, carga/alm.,
beq
0
M
Add Add u
x
4
Result
1
Shift
left 2
PCSrc
Z
Instruction [25:21]
Read #1
MemRead
Read MemToReg
PC Address
Instruction 0 data
M file Read 0 u
Write x
u data 2 M Data
x u 4 memory
memory 1 x
Write ALU ctrl
RegDst 1 Write
data
data
RegWrite
MemWrite
Sign
extend
A
TC
Ejec. de la instrucción j inm_26
31 26 25 0
tipo J op inmediato
New PC
Instruction [25:0] Shift 1

left 2
26 28 64 M
u
x
PC + 4 36
0
Jump
A
TC
Camino de datos completo

left 2
26 28 64 0 M
PC+4 [63:28] u
36 M x
Add Add u
x 0
4
Result Jump
1
Shift
left 2
PCSrc
Z
Instruction [25:21]
Read #1
MemRead
Read MemToReg
PC Address
Instruction 0 data
M file Read 0 u
Write x
u data 2 M Data
x u 4 memory
memory 1 x
Write ALU ctrl
RegDst 1 Write
data
data
RegWrite
MemWrite
Sign
extend
A
TC
Ejemplo
dadd r2, r3, r6

left 2
26 28 64 0 M
PC+4 [63:28] u
36 M x
Add Add u
x 0
4
Result
1
Shift
left 2
RegDst Jump
Branch
MemWrite
MemToReg
Inst. [31:26]
Control MemRead
ALUOp
ALUSrc
RegWrite
Instruction [25:21]
Read #1 Z
Read
PC Address
Read #2 Read 1
Instruction 0 data
M file Read 0 u
Write x
u data 2 M Data
x u 4 memory
memory 1 x
Write
1 Write
data
data
2
Sign
extend ALU
control
Instruction [5:0]
A
TC
Monociclo
Inconvenientes
TCPU = Instrucciones del programa × CPI × T
• Diseño sencillo
• CPI = 1
• Ciclo largo
• Imposible optimizar las instrucciones comunes
A
TC
Mejoras de rendimiento
Reducción de tiempo de CPU

Reduce el tiempo de respuesta
T. respuesta
T. E/S T. multitarea
T. CPU
TCPU usuario TCPU sistema
Aceleración definida en la ley de Amdahl

• Tiempo de CPU
A
TC
TCPU = Nº instrucciones × CPI × T
Reducción del tiempo de CPU

1 Número de instrucciones de los programas
• Juego de instrucciones
• Compilador
2 El periodo de reloj (incrementar frecuencia)
• mejoras en las tecnologías de fabricación
• mejoras organizativas (pipeline)
3 El CPI
• número medio de ciclos por instrucción
Segmentación ⇒ CPI=1 y ↓ T
A
TC
CPI
Microarquitectura CPI Duración del ciclo (T )

Monociclo 1 Ciclo largo
Multiciclo >1 Ciclo corto
Segmentada 1 (ideal) Ciclo corto
A
TC
Segmentación de instrucciones
(pipeline)
Símil
Tarea = Hacer la colada
1 Lavar
2 Secar
3 Planchar
4 Colocar
Clave
Dividir la ejecución de las instrucciones en etapas que funcionan en
paralelo
• transparente al software
• muy usada hoy en día
A
TC
Símil
• No segmentada
18:00 19:00 20:00 21:00 22:00 23:00 00:00
A
B
C
• Segmentada
18:00 19:00 20:00 21:00 22:00 23:00 00:00
A
B
C
A
TC
Pipeline
Crucial: Etapas en paralelo
• tiempos distintos
• etapas rápidas esperan por lentas
• balanceo de las etapas
• se mejora productividad, no el tiempo de respuesta
Caso ideal: colada 120 minutos

Etapas balanceadas: 30, 30, 30, 30 (minutos)
• tiempo de colada (t. respuesta): 120 minutos
• productividad: 1 colada cada 30 minutos
• aceleración = número de etapas
Caso real: colada 155 minutos

Tiempos: 40, 50, 45, 20 (minutos)
• ciclo del pipeline: 50 minutos
• tiempo de colada: 200 minutos (frente a 155)
• aceleración = 155/50 = 3.1
A
TC
Pipeline MIPS
Etapas
1 IF: carga código instrucción + incremento de PC
2 ID: decodificación de instrucción + lectura registros
3 EX: ejecución + cálculo de direcciones efectivas
4 MEM: acceso a memoria
5 WB: escritura diferida de registros
Número de etapas
• duración de etapas = 1 ciclo
• ↑ número etapas ⇒ ↓ duración ciclo
• imposible incrementar indefinidamente (muro energía, balanceo,
control)
A
TC
Ejecución de instrucciones
Monociclo
Ciclo de reloj 1 2
dadd r4, r3, r2
dsub r12, r13, r14
xor r5, r5, r5
and r13, r14, r15
Segmentada
Ciclo de reloj 1 2 3 4 5 6 7 8 9 10
dadd r4, r3, r2 IF ID EX MEM WB
dsub r12, r13, r14 IF ID EX MEM WB
xor r5, r5, r5 IF ID EX MEM WB
and r13, r14, r15 IF ID EX MEM WB
A
TC
La segmentación de instrucciones
¿Cuánto tarda en ejecutarse una instrucción?

Medida de tiempo de respuesta (latencia)
¿Cada cuánto la CPU completa una instrucción?

Instrucciones ejecutadas por unidad de tiempo (retiradas)
Medida de productividad
Caso ideal
Aceleración = número de etapas
• aumenta la complejidad de la unidad de control de la CPU
• riesgos de la segmentación ⇒ ↑ CPI medio
• muro de energía
• típicamente entre 10 y 20 etapas
A
TC
Camino de datos identificando etapas
Instruction fetch (IF) Instruction decode (ID) Execute (EX) Memory access (MEM) Write back (WB)
Instruction [25:0] Shift

left 2
26 28 64
PC+4 [63:28]
36
Add Add
4
Result
Shift
left 2
Z
1
Instruction [25:21]
M Read #1
0 Read
u PC Address
M x
Read #2 Read 1
u Result Address M
0 0 Register data
x Instruction u
M file Read 0
Write x
1 u data 2 M Data
Instruction Inst. [15:11] register 0
x u memory
memory 1 x
Write
1 Write
data
data
Sign
extend
A
TC
Camino de datos segmentado
Registros de segmentación
• independizar etapas
• cauce avanza de registro de segmentación al siguiente
IF/ID ID/EX EX/MEM MEM/WB
Add Add
4
36 Result
Shift Shift
left 2 left 2
26 28 64
Z
0
M Read #1
Read
1u PC Address
data 1 ALU
x
Read #2 Read 1
2 Instruction 0 data
M file Read 0 u
Write x
u data 2 M Data
Instruction register 0
x u memory
memory 1 x
Write
1 Write
data
data
16 64
Sign
extend
A
TC
Camino segmentado con señales de
control
Sin riesgos
PCSrc
ID/EX
WB EX/MEM
Instruction
Control M WB MEM/WB
IF/ID EX M WB
36
Add Add
4
Result
Shift Shift
left 2 left 2 Branch
26 28
1 RegWrite Z
MemToReg
0
M Read #1
Read MemRead
1u PC Address
data 1 ALU
x
2 Instruction data
file Read 0 u
Jump 2 Write x
data 2 M Data
u 4 memory
memory x
Write
1 Write
data
data
Inst. [15:0] 16 64 6 MemWrite

Sign ALU
extend control
Instruction [20:16] 0
M 2 ALUOp
u
Instruction [15:11]
x
1
ALUSrc
A
TC
Ejemplo
dadd r3, r5, r8
PCSrc
ID/EX
WB EX/MEM
Instruction
Control M WB MEM/WB
IF/ID EX M WB
36
Add Add
4
Result
Shift Shift
26 28
1 RegWrite Z
MemToReg
0
M Read #1
Read MemRead
1u PC Address
data 1 ALU
x
2 Instruction data
file Read 0 u
Jump 2 Write x
data 2 M Data
u 4 memory
memory x
Write
1 Write
data
data

Sign ALU
extend control
M 2 ALUOp
u
Instruction [15:11]
x
1
ALUSrc
A
TC
Ejemplo
andi r1, r7, 8 dadd r3, r5, r8
PCSrc
ID/EX
WB EX/MEM
Instruction
Control M WB MEM/WB
IF/ID EX M WB
36
Add Add
4
Result
Shift Shift
26 28
1 RegWrite Z
MemToReg
0
M Read #1
Read MemRead
1u PC Address
data 1 ALU
x
2 Instruction data
file Read 0 u
Jump 2 Write x
data 2 M Data
u 4 memory
memory x
Write
1 Write
data
data

Sign ALU
extend control
M 2 ALUOp
u
Instruction [15:11]
x
1
ALUSrc
A
TC
Ejemplo
or r2, r9, r17 andi r1, r7, 8 dadd r3, r5, r8
PCSrc
ID/EX
WB EX/MEM
Instruction
Control M WB MEM/WB
IF/ID EX M WB
36
Add Add
4
Result
Shift Shift
26 28
1 RegWrite Z
MemToReg
0
M Read #1
Read MemRead
1u PC Address
data 1 ALU
x
2 Instruction data
file Read 0 u
Jump 2 Write x
data 2 M Data
u 4 memory
memory x
Write
1 Write
data
data

Sign ALU
extend control
M 2 ALUOp
u
Instruction [15:11]
x
1
ALUSrc
A
TC
Ejemplo
xor r3, r5, r8 or r2, r9, r17 andi r1, r7, 8 dadd r3, r5, r8
PCSrc
ID/EX
WB EX/MEM
Instruction
Control M WB MEM/WB
IF/ID EX M WB
36
Add Add
4
Result
Shift Shift
26 28
1 RegWrite Z
MemToReg
0
M Read #1
Read MemRead
1u PC Address
data 1 ALU
x
2 Instruction data
file Read 0 u
Jump 2 Write x
data 2 M Data
u 4 memory
memory x
Write
1 Write
data
data

Sign ALU
extend control
M 2 ALUOp
u
Instruction [15:11]
x
1
ALUSrc
A
TC
Riesgos de la segmentación
Riesgos
Fuerza la detención del cauce
• En la práctica: introducir nop
Tipos
• Estructurales
• Dependencia de datos
• Control (dependencia sobre PC)
A
TC
Riesgos estructurales
Definición
Dos etapas requieren el mismo hardware
• Imposibles en la microarquitectura MIPS64
Ejemplo asumiendo memoria única

Ciclo de reloj 1 2 3 4 5 6 7 8 9 10
ld r11, 120(r0) IF ID EX MEM WB
dsub r4, r1, r9 IF IF ID EX MEM WB
A
TC
Riesgos por dependencia de datos
Dependencia de datos
• RAW: Read After Write
• WAR: Write After Read
• WAW: Write After Write
Entre instrucciones del cauce segmentado ⇒ riesgos por
dependencias de datos
Ejemplo RAW
Ciclo de reloj 1 2 3 4 5 6 7 8 9 10
dsub r1, r10, r2 IF ID ID ID EX MEM WB
or r12, r11, r14 IF IF IF ID EX MEM WB
A
TC
Riesgos por dependencia de datos
Ejemplo WAR
Ciclo de reloj 1 2 3 4 5 6 7
or r12, r11, r14 IF ID EX MEM WB
Ejemplo WAW
A
TC
Riesgos de control
Definición
Cambio en el flujo del programa
• Vaciar el pipeline
• Costoso
• Dependencia de datos sobre PC
Ejemplo
beq r0, r3, loop
daddi r1, r0, 1
and r3, r2, r4
xor r8, r8, r8
loop: dsub r3, r1, r2
A
TC
Riesgos de control
No tomado
Ciclo de reloj 1 2 3 4 5 6 7 8 9 10 11 12
beq r0, r3, loop IF ID EX MEM WB
daddi r1, r0, 1 IF IF IF IF ID EX MEM WB
loop: dsub r3, r1, r2 IF ID EX MEM WB
Tomado
Ciclo de reloj 1 2 3 4 5 6 7 8 9 10 11 12
daddi r1, r0, 1 IF IF IF
and r3, r2, r4
xor r8, r8, r8
A
TC
Riesgos de control
Salto incondicional
j loop IF ID EX MEM WB
daddi r1, r0, 1 IF
and r3, r2, r4
xor r8, r8, r8
A
TC
Operaciones multiciclo
Operaciones complejas
Etapa EX compleja
• Multiplicaciones, divisiones, punto flotante ...
8 Alargar ciclo de reloj
4 Solución: varios ciclos en EX
EX
mult./div. enteros
IF ID EX (5 ciclos) MEM WB
punto flotante
EX (7 ciclos)
A
TC
Optimización: emisión múltiple

Ciclo de reloj 1 2 3 4 5 6 7 8 9 10
dmul r1, r2, r3 IF ID EX MEM WB
Estados de instrucciones (en orden / fuera de orden)

• Emitida (Preparada para EX)
• Ejecutada (Ha terminado EX)
• Retirada (Ha terminado MEM + WB)
A
TC
Problema: dependencias WAW y WAR

Ciclo de reloj 1 2 3 4 5 6 7 8 9 10 11
dadd r1, r11, r12 IF ID EX EX EX EX EX MEM WB
Problema
Aparecen riesgos estructurales
Ciclo de reloj 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
dmul r8, r9, r10 IF ID ID ID ID ID EX MEM WB
dadd r9, r11, r12 IF IF IF IF IF ID EX MEM WB
A
TC
Mejora
Segmentar unidades EX complejas
Ciclo de reloj 1 2 3 4 5 6 7 8 9 10 11 12 13
dmul r1, r2, r3 IF ID EX1 EX2 EX3 EX4 EX5 MEM WB
A
TC
Excepciones
Cambios en el flujo del programa

Errores / interrupciones
• División por cero, código de instrucción inválido, etc.
• El S.O. toma el control del sistema
• Guarda el contexto
• Restaura y continua transparentemente
• Asíncrono (Se producen en cualquier momento)
Excepciones precisas
Hardware se encarga
• Lidiar con instrucciones a medio ejecutar
• Comportamiento esperado como no segmentado
A
TC
Excepciones
Ocurrencia
En cualquier momento y varias al mismo tiempo
Ciclo de reloj 1 2 3 4 5 6
¡Excepción!

¡Excepción!
Procesar en orden
• Todas en la etapa WB
A
TC
Excepciones
Problema: ejecución fuera de orden

Ciclo de reloj 1 2 3 4 5 6 7 8 9 10 11

¡Excepción!
ddiv r8, r9, r7 IF ID EX1 EX2 EX3 EX4 EX5 MEM WB
ld r6, 120(r10) IF ID EX MEM WB ld termina antes que ddiv

¡Excepción!
Solución
• Ejecución fuera de orden
• Deben terminar en orden (MEM y WB)
A
TC
Excepciones
Ejemplo
Ciclo de reloj 1 2 3 4 5 6 7 8 9 10 11 12
ddiv r8, r9, r7 IF ID EX1 EX2 EX3 EX4 EX5 MEM WB
ld r6, 120(r10) IF ID EX EX EX EX EX MEM WB
A
TC
Mejoras en la segmentación
Rendimiento CPU segmentada
TCPU = Instrucciones del programa × CPI × T
Idealmente CPI = 1
• Detenciones por riesgos aumentan CPI
• MIPS64: solo RAW y control
Posibles mejoras
• ↓ T ⇒ ↑ Profundidad de segmentación
• ↓ CPI ⇒ ↓ Detenciones
• Reducir riesgos de datos
• Reducir riesgos de control
A
TC
Reducción detenciones datos
Dependencias
• RAW: dependencia verdadera
• WAR: antidependencia
• WAW: dependencia de salida
Estrategias
• Planificación de instrucciones
Reduce detenciones
• Rutas de reenvío
• Renombrado de registros → Elimina dependencias
A
TC
Planificación de instrucciones
HW y SW
Reordenar instrucciones
• Reducir detenciones
• Sin cambiar semántica
• Software: recompilar para cada microarquitectura
Ciclo de reloj 1 2 3 4 5 6 7 8 9 10
Ciclo de reloj 1 2 3 4 5 6 7 8

RAW sobre r2
dsub r1, r10, r2 IF ID ID EX MEM WB

A
TC
Rutas de reenvío
Forwarding
• Reducir/eliminar detenciones por dependencias de datos
• Adelantar uso de registros calculados en el cauce
• No esperar a WB
• Detenciones en la etapa EX en lugar de ID
Situaciones
• Escritura sin carga y lectura consecutivas
• Escritura sin carga y lectura separadas 1 instrucción
• Escritura de carga y lectura consecutivas
• Escritura de carga y lectura separadas 1 instrucción
A
TC
Rutas de reenvío
Escritura y lectura consecutivas
Sin forwarding
Ciclo de reloj 1 2 3 4 5 6 7 8 9 10
Con forwarding

Salida EX → Entrada EX
A
TC
Rutas de reenvío
Escritura y lectura separadas 1 instrucción
Sin forwarding
Ciclo de reloj 1 2 3 4 5 6 7 8 9
or r12, r11, r4 IF IF ID EX MEM WB
Con forwarding

Salida MEM → Entrada EX
A
TC
Rutas de reenvío
Escritura y lectura separadas 2 instrucciones
No necesario forwarding
Ciclo de reloj 1 2 3 4 5 6 7 8 9
Escribe r2

Lee r2
A
TC
Rutas de reenvío
Carga y lectura consecutivas
Sin forwarding
Ciclo de reloj 1 2 3 4 5 6 7 8 9
Con forwarding
Ciclo de reloj 1 2 3 4 5 6 7 8 9

dsub r1, r10, r2 IF ID EX EX MEM WB
or r12, r11, r14 IF ID ID EX MEM WB
A
TC
Rutas de reenvío
Carga y lectura separadas 1 instrucción
Sin forwarding
Con forwarding

A
TC
Rutas de reenvío
Mejora del rendimiento con detenciones en la etapa EX
Detención en la etapa ID
Ciclo de reloj 1 2 3 4 5 6 7 8 9

dadd r2, r1, r5 IF ID ID EX MEM WB
dmul r5, r4, r7 IF IF ID EX1 EX2 MEM WB
Detención en la etapa EX
Ciclo de reloj 1 2 3 4 5 6 7 8 9

dadd r2, r1, r5 IF ID EX EX MEM WB
dmul r5, r4, r7 IF ID EX1 EX2 MEM WB
A
TC
Rutas de reenvío
Activación de múltiples rutas reenvío
Una instrucción con dos registros fuentes puede:

• Activar dos rutas de reenvio en el mismo instante, o
• Activar dos rutas de reenvio en instantes diferentes
Activación de dos rutas de reenvío en la misma

instrucción

dsub r4, r1, r2 IF ID EX EX MEM WB
A
TC
Reciclado de registros
Dependencias RAW
• Semántica del programa
• Dependencias verdaderas
Dependencias WAR y WAW

• Debidas a reciclado de registros
• Número limitado de registros
• Impacto en ejecución fuera de orden
• Evitables
A
TC
Ejemplo
Con reciclado
a = 1; (1) ori r5, r0, 1 ; r5 <- a 1
b = 3 * a; (2) ori r6, r0, 3 ; r6 <- 3
RAW RAW 2
c = 7; (3) dmul r4, r6, r5 ; r4 <- b
d = 6; (4) ori r4, r0, 7 ; r4 <- c 3 WAW
(5) ori r6, r0, 6 ; r6 <- d WAW WAR 5

4
Ciclo de reloj 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
(1) ori r5, r0, 1 IF ID EX MEM WB
(3) dmul r4, r6, r5 IF ID ID ID EX MEM WB
(4) ori r4, r0, 7 IF IF IF ID EX EX EX EX EX MEM WB
(5) ori r6, r0, 6 IF ID ID ID ID ID EX MEM WB
A
TC
Ejemplo
Sin reciclado
a = 1; (1) ori r5, r0, 1 ; r5 <- a 1
b = 3 * a; (2) ori r6, r0, 3 ; r6 <- 3
RAW RAW 2
c = 7; (3) dmul r4, r6, r5 ; r4 <- b
d = 6; (4) ori r7, r0, 7 ; r7 <- c 3
(5) ori r8, r0, 6 ; r8 <- d 5
4
Ciclo de reloj 1 2 3 4 5 6 7 8 9 10 11 12 13
(3) dmul r4, r6, r5 IF ID ID ID EX MEM WB
(4) ori r7, r0, 7 IF IF IF ID EX MEM WB
A
TC
Renombrado de registros
Ideal
• Disponer de muchos registros
8 Problema: muchos bits en el código de instrucción
Solución
• Separar registros arquitectónicos de físicos
• Arquitectónicos ⇒ simbólicos
• Gran número de registros físicos
• Tabla de renombrado: mapeo inicial por defecto
A
TC
Tabla renombrado
• Asociación registro físico - arquitectónico
• Estado registro físico
• Asociado y en uso
• Asociado y en desuso
• Disponible
Funcionamiento
1 Arranque: mapeo por defecto y en desuso (r6→rr6)
2 Etapa ID: identificar registros arquitectónicos
• Renombrar registro destino
• Incrementar contador de registros origen
• r0 no se renombra
3 Etapa WB: decrementar contador uso
• Liberar registros físicos
A
TC
Ejemplo
Ciclo de reloj 1 2 3 4 5 6 7 8 9 10 11 12 13
ori r5, r0, 1 IF ID EX MEM WB

r5→rr32:0

r6→rr33:0
dmul r4, r6, r5 IF ID ID ID EX MEM WB

r4→rr34:0 rr34:0
r6→rr33:1 rr33:0
r5→rr32:1 r5→rr32:0
ori r4, r0, 7 IF IF IF ID EX MEM WB

r4→rr35:0

r6→rr36:0
A
TC
Reducción detenciones control
Se producen
• Saltos condicionales (MEM) e incondicionales (ID)
• Excepciones (WB)
Estrategias
• Evaluación agresiva de saltos
• Predicción de saltos
A
TC
Evaluación agresiva de saltos
Idea
• Adelantar evaluación salto
• Etapa ID
8 Puede alargar duración del ciclo
8 Nuevas rutas de reenvío
Ciclo de reloj 1 2 3 4 5 6 7 8 9
daddi r1, r0, 1 IF
and r3, r2, r4
xor r8, r8, r8
A
TC
PCSrc
IF/ID ID/EX
Add Add
4
Result
Shift
left 2
Shift
left 2
1 RegWrite
Branch
0
M Read #1
Read
1u PC Address
data 1
x
Read #2
2 Register
=
Instruction
file Read
2 Write
register data 2
Instruction
Jump
memory
Write
data
Inst. [15:0] Sign

extend
Instruction [20:16]
Instruction [15:11]
A
TC
Ruta reenvío
Ciclo de reloj 1 2 3 4 5 6 7 8 9 10 11
daddi r1, r1, 4 IF ID EX MEM WB

Salida EX → Entrada ID
beq r1, r6, target IF ID ID EX MEM WB
target: and r12, r2, r5 IF ID EX MEM WB
A
TC
Predicción de saltos
Objetivo
Reducir penalización por riesgos de control
• No necesaria participacion del compilador (pero aconsejable)
Ejecución especulativa
Por una de las dos ramas (salto/no salto)
• Acierto ⇒ no hay detención
• Fallo ⇒ deshacer trabajo (registros/memoria)
A
TC
Ejemplo
beq r4, r5, target

dadd r9, r0, r7
dsub r11, r10, r5
or r12, r5, r14
target:
dadd r7, r1, r3
Algoritmo: siempre no tomado

• Simple
• Asume que nunca se toma el salto
A
TC
Ejemplo
Acierto: no hay salto

Predicción: no tomado Evaluación: no tomado (acierto)
beq r4, r5, target IF ID EX MEM WB
target: dadd r7, r1, r3 IF ID EX MEM WB
Fallo: hay salto

Predicción: no tomado Evaluación: tomado (fallo)
beq r4, r5, target IF ID EX MEM WB
dadd r9, r0, r7 IF ID EX
dsub r11, r10, r5 IF ID
or r12, r5, r14 IF
target: dadd r7, r1, r3 IF ID EX MEM WB A

TC
Siempre no tomado
• Baja efectividad (≈33 %)
• Predicción estática
• Posible: colaborar con el compilador para especular o no
Ejemplo
.....
ori r1, r0, 100 ; r1 = 100
startf:
daddi r1, r1, -1 ; r1 = r1-1
bnez r1, startf ; jump to startf if r1 is not zero
endf:
.....
A
TC
Predictor dinámico de dos bits

• Estado: dos bits (contador)
• Aumenta si tomado / decrementa si no tomado
• BHT (Branch History Table)
• BTB (Branch Target Buffer)
• Acierto ≈90 %
Primera ejecución de salto

Nueva entrada en tabla BHT: BHT + BTB (simplificacion)
• Dirección memoria de instrucción (acceso en IF)
• Dirección destino salto (cuando se evalúa)
• Bits de predicción (por defecto 01)
A
TC
Estados
BHT
Dirección Destino del salto Historial

T 1010101... 0011101... 01
T T T 0111010... 1100010... 10
00 01 10 11
N N N
1010101... 0111011... 11
N
A
TC
Ejemplo
BHT
Ciclo de reloj 1 2 3 4 5 6 7 8 9 10 11
Dirección Destino Historial
Fallo de BHT: predice no tomado (01)
0 : ori r1, r0, 1 IF ID EX MEM WB
Predicción correcta | dec. historial

4 : beq r1, r0, 2 IF ID ID EX MEM WB 4 16 00
Fallo de BHT
8 : daddi r1, r1, -1 IF IF ID EX MEM WB 4 16 00
4 16 00
12 : j -3 IF ID EX MEM WB Escritura
12 4 11
Acierto de BHT: predice no tomado (00)
16 : ld r3, 80(r8) IF 4 16 00
12 4 11
4 : beq r1, r0, 2 IF ID EX MEM WB
4 16 01
Pred. incorrecta | inc. historial
8 : daddi r1, r1, -1 IF 12 4 11
16 : ld r3, 80(r8) IF ID EX MEM WB
A
TC
Profundidad segmentación
Aumentar número de etapas

4 Más etapas ⇒ menor tiempo de ciclo
4 Mayor producitividad
8 Más retardo por registros de segmentación
8 Replicar recursos hardware (multipuerto)
8 Efectos de riesgos de control
8 Mayor frecuencia ⇒ mayor disipación calor
Típicamente: 10 a 20 etapas
A
TC
CPU segmentada
• Nº instrucciones: fijo por la ISA
• CPI ≥ 1
• T limitado por muro de potencia
Solución: nuevas microarquitecturas

CPI < 1
• Nueva métrica: IPC=CPI−1
• Objetivo: IPC>1
A
TC
Tipos de paralelismo
A
TC
Emisión múltiple
Requisitos
Ancho de emisión
Número instrucciones simultáneas por etapa
• Mínimo para todas las etapas
• Algunas etapas mayor ancho
Planificación de instrucciones
• Decidir qué cauce usar (HW y/o SW)
• Resolver dependencias cruzadas
A
TC
Emisión múltiple
Micrarquitecturas
VLIW (Very Large Instruction Word)

• Planificación estática (compilador)
• Compilador respeta dependencias
• Compilador se adapta a microarquitectura
• Necesario apoyo del compilador
Superescalar
• Planificación dinámica (CPU)
• CPU resuelve riesgos
• Conveniente apoyo del compilador pero no imprescindible
A
TC
Paralelismo a nivel de instrucción (ILP)
ILP
Independencia entre instrucciones
• Riesgos control minimizables (predicción)
• Riesgos RAW inevitables
• Límite máximo paralelismo (muro ILP)
A
TC
Paralelismo a nivel de instrucción (ILP)
(1) dadd r1, r3, r4 (1) dadd r3, r2, r1

(2) xor r2, r5, r1 (2) xor r6, r4, r1
(3) dsub r2, r4, r7 (3) dsub r8, r4, r7
(4) movz r7, r4, r6 (4) movz r9, r4, r5
(5) slt r9, r7, r6 (5) slt r10, r7, r5
1 1 2
RAW en r1
3
2
WAW en r2
4 5
3
WAR en r7
4
RAW en r7
A
TC
CPU superescalar
Lectura (IF)
Buffer de decodificación
Decodificación (ID)
En orden
Buffer de distribución
Distribución (DT)
Estaciones de reserva
Fuera de orden
Carga/almacen. Enteros ×2
Saltos Multiplicación y
2 ciclos 1 ciclo
1 ciclo división enteros
Punto flotante
5 ciclos Ejecución (EX)
5 ciclos
Buffer de reordenación
En orden
Retirada (RT)
A
TC
CPU superescalar
Ciclo de reloj 1 2 3 4 5 6 7 8 9 10
dadd r1, r3, r4 IF ID DT EX RT
xor r2, r5, r2 IF ID DT EX RT
dsub r6, r5, r4 IF ID DT EX RT

Reenvío
slt r9, r3, r6 IF ID DT EX RT
dadd r3, r4, r8 IF ID DT EX RT
ld r10, 240(r2) IF ID DT EX EX RT
ori r11, r12, 5 IF ID DT EX RT
xor r1, r15, r14 IF ID DT EX RT
A
TC
Seguridad
Ejecución especulativa
Revertir los efectos de las instrucciones
• Prediccón de saltos (fallo)
• Ejecución OoO (excepción)
Problema
Deja huellas
• Puede ser utilizado para leer cualquier posición de memoria
• Utilizando canales laterales
• Ejemplos: Spectre, Meltdown
A
TC
Construcción de procesador
Usando circuitos integrados

• Oblea de silicio
• Estampación litográfica/química
• Varios chips en la misma oblea
• Varias capas
• Mejorar tecnología de fabricación ⇒ transistores más pequeños
Resumen
Ritmo exponencial:
• Aumento potencia computacional
• Reducción de costes
A
TC
Mejora tecnología fabricación
Unidad de
Registros
control
ALU E/S
Opción 1: misma funcionalidad,
misma frecuencia y reducción
del tamaño (mejora el consumo)
Opción 2: misma funcionalidad,

Unidad de
control incremento de frecuencia y reducción del tamaño Unidad de
Registros
Registros
(mejora el rendimiento) control
ALU E/S
ALU E/S
Opción 3: incremento de la
funcionalidad y mismo tamaño Unidad de
Registros
(mejora el rendimiento si se control
FPU
aprovecha la nueva funcionalidad)
ALU E/S Caché
L2
Caché L1
GPU A
TC
Power wall
Límite al aumento de frecuencia

• Mayor consumo
• Mayor disipación de calor
• Mayor coste
103
Frecuencia (MHz)
102
101
100
1980 1990 2000 2010

Año A
TC
ILP wall
Límite al paralelismo de instrucciones

• Inherente a los programas
• Limitan el pipeline y la superescalabilidad
Solución
Añadir más núcleos
• Cambio de paradigma de programación
• Memory wall
• Brick wall = Power wall + ILP wall + Memory wall
A
TC
Taxonomía de Flynn
Arquitecturas categorizadas según el número de flujos concurrentes

de instrucciones y datos
1 SISD: Single Instruction, Single Data
• CPU secuenciales y segmentadas
2 SIMD: Single Instruction, Multiple Data
• GPU, instrucciones multimedia (MMX, SSE, . . . )
3 MISD: Multiple Instruction, Single Data
• sistemas tolerantes a fallos
4 MIMD: Multiple Instruction, Multiple Data
• Memoria distribuida: conjuntos CPU+memoria separados
• Memoria compartida: varias CPU comparten memoria
A
TC
Paralelismo a nivel de hilo
Hilo
Unidad mínima que un S.O. puede planificar
• un proceso puede tener varios hilos (al menos uno)
Paralelismo a nivel de hilo 6= Paralelismo a nivel de instrucción

(pipeline o arquitec-
turas superescalares)
Implicaciones
• Paralelismo a nivel de instrucción mejora la ejecución de
cualquier programa
• transparente al programador
• Programador debe implicarse para aprovechar paralelismo a
nivel de hilo (TLP)
• creación de hilos, sincronización, etc.
A
TC
Sistemas multinúcleo
Los computadores actuales son MIMD con memoria compartida
(Shared Memory Multiprocessors)
CPU 0 CPU 1 CPU 2 CPU 3
Caché Caché Caché Caché
Memoria Entrada/
principal salida
Simultaneos Multi-Threading (HyperThreading)

• Replicación de unidades funcionales
• Hilos concurrentes en un núcleo A
TC
S.O. Monotarea
Una tarea en ejecución en cada instante
• CPU ejecuta un único programa
• memoria contiene código y datos del programa + S.O.
• interfaces de E/S disponibles para el programa
Desventajas
Utilización baja de los recursos
• uso de CPU ⇒ interfaces de E/S desocupados
• E/S ⇒ CPU desocupada
Ejemplo 3 tareas
τ1 τ2 τ3
Tiempo CPU
E/S
A
TC
S.O. Multitarea
Varias tareas ejecutando simultáneamente
• ejecución paralela real o aparente ⇒ varias CPU
• conmutación entre tareas (cambio de contexto)
• memoria contiene código y datos de varios programas + S.O.
• interfaces compartidos entre las tareas
• S.O. ⇒ gestor de los recursos
4 mayor utilización de los recursos
τ3
E/S
τ2
τ1
Tiempo CPU
A
TC
Definición de SO multitarea
Proporciona interfaz común a las aplicaciones (API)
Aplicación Aplicación
API
S.O.
Software
Hardware
CPU Memoria
Periféricos
A
TC
Multitarea
Definición
Capacidad para ejecutar varias tareas “simultáneamente”
• Problema: los recursos son únicos
Solución
El S.O. gestiona los recursos y los comparte entre tareas
Tarea 1 Tarea 2 Tarea 3 Tarea 1 Tarea 3 Tarea 3 ...
Sistema operativo
Si la asignación temporal es pequeña (quantum) se consigue

concurrencia aparente
A
TC
Mecanismos de transferencia
Tarea 1 Tarea 2 Tarea 3 Tarea 1 Tarea 3 Tarea 3 ...
¿? ¿? ¿? ¿? ¿?
S.O. actúa como gestor de recursos

¿Bajo qué condiciones se transfiere el control al S.O.?
• Una tarea realiza una llamada a un servicio del S.O.
• Se produce una interrupción
• Se produce una excepción
A
TC
Mecanismos de transferencia
• Cada caso implica la ejecución de un manejador distinto (rutinas

de servicio)
• El manejador puede modificar el estado de las tareas
• Los mecanismos de transferencia pueden anidarse
• Por ejemplo una excepción dentro de una interrupción
• Nomenclatura dependiente de la arquitectura
¿Y si no se producen?
Añadir temporizador ⇒ S.O. toma el control periodicamente
A
TC
Soporte MIPS64 a los SO multitarea
Niveles de privilegio
Ejecución de instrucciones privilegiadas
• Usuario: UM=1, ERL=EXL=0
• Supervisor: UM=0, ERL=EXL=1
Memoria virtual paginada

Proteger al SO y a las tareas entre sí
• SO desde: 0x4000 0000 0000 0000
Recuperación estado ejecución

Proteger al SO y a las tareas entre sí.
• Registros EPC y cause register
• Instrucción eret
A
TC
Virtualización
Definición
Ejecutar varios SO sobre máquina física
• Diferentes SO
• Reducción de costes y energía
• Portabilidad ⇒ fácil administración
• Aislamiento ⇒ seguridad
Hipervisor
Programa más privilegiado que el SO
• Gestor de recursos físicos entre máquinas virtuales
A
TC
Hipervisor
Win Win Linux Linux

Win Win Linux Linux Win Win app app app app
app app app app app app
SO invitado SO invitado
Windows Linux Win Win
app app
SO Windows SO Linux SO Windows Máquina Máquina
virtual A virtual B
Máquina Máquina Máquina Hipervisor tipo 2

virtual A virtual B virtual C VirtualBox
Hipervisor tipo 1 SO anfitrión

VMware ESXi Windows
Hardware Hardware
A
TC
Virtualización
CPU sin soporte

Sigue siendo posible
• SO invitado se ejecuta en modo de bajo privilegio
• Trap-and-emulate
8 Instrucciones sensibles
• Traducción binaria ⇒ reduce rendimiento
• paravirtualización ⇒ SO invitado se modifica
Actualmente
CPU proporciona soporte
• No es necesaria la traducción binaria
• Paravirtualización es opcional
A
TC
Virtualización: soporte x86 (VT-x)
Modo VMX
Sistema operativo A Sistema operativo B
(VMX non-root) (VMX non-root)
VM exit VM entry
VM entry VM exit
VMXON Hipervisor VMXOFF

(VMX root)
Nuevas instrucciones
Rendimiento ≈ Máquina física
• VMLAUNCH ⇒ inicia VM
• VMRESUME ⇒ restaura VM
A
TC

02cpu Handout

Cargado por

02cpu Handout

Cargado por

Tema 2.

Área de Arquitectura y Tecnología de Computadores

1.- Mejoras del rendimiento

2.- Soporte a los sistemas operativos multitarea

3.- Soporte a la virtualización

Enteros (complemento a dos)

Acceso a varios bytes

Ubicación de los operandos

• Relativo al PC: beq r2, r9, -5

Todas el mismo tamaño: 32 bits

tipo R op rs1 rs2 rd inmediato función

• int32 a; // (en registro r10)

• int32 b; // (en direccion 1534h)

R0 0x1534 2000 ...

Instrucción Tipo Descripción

Instrucción Tipo Descripción

tipo R op rs1 rs2 rd inmediato función

dadd r2, r5, r8

tipo R op rs1 rs2 rd inmediato función

Instrucción Tipo Descripción

ld r4, 200(r2) / sd r2, 100(r4)

tipo R op rs1 rs2 rd inmediato función

Instruction [25:0] Shift 1

Instruction [25:0] Shift 1

Instruction [25:0] Shift 1

Reducción de tiempo de CPU

Aceleración definida en la ley de Amdahl

TCPU = Nº instrucciones × CPI × T

Reducción del tiempo de CPU

Microarquitectura CPI Duración del ciclo (T )

Caso ideal: colada 120 minutos

Caso real: colada 155 minutos

dadd r4, r3, r2

dsub r12, r13, r14

xor r5, r5, r5

and r13, r14, r15

dadd r4, r3, r2 IF ID EX MEM WB

dsub r12, r13, r14 IF ID EX MEM WB

xor r5, r5, r5 IF ID EX MEM WB

and r13, r14, r15 IF ID EX MEM WB

¿Cuánto tarda en ejecutarse una instrucción?

¿Cada cuánto la CPU completa una instrucción?

Instruction [25:0] Shift

Inst. [15:0] 16 64 6 MemWrite

Inst. [15:0] 16 64 6 MemWrite

Inst. [15:0] 16 64 6 MemWrite

Inst. [15:0] 16 64 6 MemWrite

Inst. [15:0] 16 64 6 MemWrite

Ejemplo asumiendo memoria única

ld r11, 120(r0) IF ID EX MEM WB

dadd r2, r3, r6 IF ID EX MEM WB

xor r15, r15, r15 IF ID EX MEM WB

dsub r4, r1, r9 IF IF ID EX MEM WB

and r12, r13, r10 IF ID EX MEM WB

dadd r2, r3, r4 IF ID EX MEM WB

dsub r1, r10, r2 IF ID ID ID EX MEM WB

or r12, r11, r14 IF IF IF ID EX MEM WB

xor r18, r18, r18 IF ID EX MEM WB

dsub r1, r10, r2 IF ID EX MEM WB

dadd r2, r3, r4 IF ID EX MEM WB

or r12, r11, r14 IF ID EX MEM WB

dsub r2, r10, r4 IF ID EX MEM WB

dadd r2, r3, r1 IF ID EX MEM WB

or r12, r11, r14 IF ID EX MEM WB

beq r0, r3, loop IF ID EX MEM WB

daddi r1, r0, 1 IF IF IF IF ID EX MEM WB

and r3, r2, r4 IF ID EX MEM WB

xor r8, r8, r8 IF ID EX MEM WB

loop: dsub r3, r1, r2 IF ID EX MEM WB

beq r0, r3, loop IF ID EX MEM WB

daddi r1, r0, 1 IF IF IF

and r3, r2, r4

xor r8, r8, r8

loop: dsub r3, r1, r2 IF ID EX MEM WB

daddi r1, r0, 1 IF

and r3, r2, r4