1

Tema 2 ARQUITECTURAS ENCADENADAS BÁSICAS (Primera parte)

Arquitectura de Sistemas Paralelos 1

Daniel Cascado Caballero Francisco Gómez Rodríguez

Alejandro Linares Barranco Saturnino Vicente Díaz

Dpto de Arquitectura y Tecnología de Computadores

Universidad de Sevilla

2

ÍNDICE (I)

2.1. Concepto de encadenamiento, segmentación o encauzamiento

2.2. Juego de instrucciones orientados al encadenamiento

Características de un buen procesador encadenado

Características de procesadores CISC y RISC

Factores involucrados en la aceleración de un procesador encadenado

2.3. Descripción del procesador ejemplo (DLX) Características principales

Formatos de instrucciones

Juego de instrucciones

3

2.4. Implementación del encadenamiento del DLX Implementación secuencial Implementación orientada al encadenamiento

2.5. Dependencias, riesgos y bloqueos 2.6. Dependencias estructurales 2.7. Dependencias de datos

Tipos: RAW, WAR, WAW Minimización de bloqueos mediante bypass (desvíos) Bypass (desvíos) en el DLX Fase ME: Optimizaciones de caches

2.8. Dependencias de control 2.9. Predicción de saltos 2.10. Instrucciones de duración variable

ÍNDICE (II)

4

Concepto de encadenamiento o segmentación (I)

La idea es la misma que en la fabricación en cadena Se divide la ejecución de la instrucción en etapas y se

introduce un paralelismo en la ejecución

Es la técnica más popular actualmente

Ejemplo Supongamos que vamos a ejecutar una serie de

instrucciones muy simples que no acceden a memoria Buscarla (IF)

Decodificarla y leer operandos (ID)

Ejecutarla (EXE)

Escribir resultados (WB)

5

Concepto de encadenamiento o segmentación (II)

Buscar la instr.

que indica el PC

IF

Decodificar

la instrucción y

leer operandos

ID

Ejecutar la

operación

que se indique

EXE

Escribir el

resultado en el

Fichero de reg.

WB

Instrucción

Operador

+

Registros

Resultado

de la

operación

T1 T2 T3 T4 T5 T6 T7

Inst1 IF ID EX WB

Inst2 IF ID EX WB

Inst3 IF ID EX WB

Inst4 IF ID EX WB

Si construimos etapas especializadas para cada fase, podemos montar una cadena

CRONOGRAMA TEMPORAL

Tiempo (ciclos)

CPIideal=1

Instruc-ciones

6

Concepto de encadenamiento o

segmentación (III)

Características generales

Sólo existe una unidad de procesado para cada etapa

En el estacionario se ejecutan en paralelo tantas instrucciones como etapas tiene la cadena

Todas las etapas duran lo mismo. Si hemos conseguido un equilibrio perfecto entre etapas, la aceleración ideal sería:

etapas NºCPITN

CPITN

t

t A

etapas Nº

t t

segmentadosegmentadoinstr

secuencialsecuencialinstr

segmentado ejecución,

secuencial ejecución,

secuencial n,instrucciópor ejecución

segmentado n,instrucciópor ejecución

7

Concepto de encadenamiento o segmentación (IV) En general, la aceleración proviene

De la reducción del periodo de reloj

De la reducción del CPI

Pero la aceleración real nunca alcanza la ideal Por problemas en la implementación del procesador

El equilibrio entre etapas nunca es perfecto y debemos coger como periodo de reloj, la duración de la etapa más lenta

Entre las etapas existen registros temporales intermedios que consumen un tiempo adicional

Por problemas en la ejecución de programas Pueden aparecer bloqueos en la cadena por la compartición de

datos y/o recursos entre las instrucciones

8

Máquina no encadenada

Hay que terminar una instrucción antes de que pueda empezar la siguiente

La finalización de instrucciones está separada por 33ns

Tiempo

Sistema no

encadenado

Instr. 1 Instr. 2 Instr. 3

Latencia = 33ns

Ritmo de

finalización = 30MHz

Lógica

Combinacional

R

E

G

30ns 3ns

CLK

9

Sistema encadenado de 3 etapas

Estamos ejecutando 3 operaciones a la vez

La finalización de instrucciones está separada por 13ns

R

E

G

CLK

Lógica

Comb.

R

E

G

Lógica

Comb.

R

E

G

Lógica

Comb.

10ns 3ns 10ns 3ns 10ns 3ns

Latencia = 39ns

Ritmo de

finalización =

77MHz

Tiempo

Instr.1 Instr. 2 Instr. 3

Instr. 4

10

Limitación: etapas no uniformes

El ritmo de finalización está limitado por la etapa más lenta: Latencia viene determinada por: Periodo del reloj * Nº de etapas

CONCLUSIÓN: Hay que intentar balancear las etapas

CLK

R

E

G

Log.

Com.

R

E

G

Lógica

Comb.

R

E

G

Lógica

Comb.

5ns 3ns 15ns 3ns 10ns 3ns

Latencia= 18 * 3 = 54 ns

Ritmo de finalización = 55MHz

11

Limitación: muchas etapas

Los retrasos de los registros suponen un factor de limitación Incremento de la latencia Pequeña ganancia en el ritmo de finalización

Más posibilidades de conflictos entre instrucciones por dependencias

Latencia = 48ns

Ritmo de finalización = 125MHz

CLK

R

E

G

Log.

Com.

5ns 3ns

R

E

G

Log.

Com.

5ns 3ns

R

E

G

Log.

Com.

5ns 3ns

R

E

G

Log.

Com.

5ns 3ns

R

E

G

Log.

Com.

5ns 3ns

R

E

G

Log.

Com.

5ns 3ns

12

EJERCICIO

Factores involucrados en la aceleración de un procesador encadenado

El encadenamiento no ayuda a disminuir la latencia de una simple instrucción, sino que ayuda a incrementar el ritmo de finalización de las instrucciones

El ritmo de finalización está limitado por la duración de la etapa más lenta

Se ejecutan simultáneamente varias instrucciones

Aceleración potencial = Nº de etapas

Las longitudes de etapa no balanceadas producen reducción en la aceleración (se reduce T)

Más posibilidades de conflictos entre instrucciones por dependencias

El tiempo gastado en llenar y vaciar las etapas suponen otra reducción en la aceleración

13

EJERCICIO: Influencia del arranque de etapas

N=5 etapas N=10 etapas

k = número de instr. por salto k = número de instr. por salto

A A

Para un procesador con N etapas, calcular la fórmula de la aceleración

con respecto a uno ideal, cuando 1 de cada k instrucciones son saltos

que detienen la cadena y obligan a volver a arrancarla desde la primera

etapa. Como pista se dan las siguientes gráficas:

14

Unidad de Control

¿Cómo funciona la U.C. de un procesador?

Es la parte más difícil de diseñar

Es donde más errores se encuentran en la depuración de un nuevo diseño

Dado un conjunto de instrucciones y un diseño de camino de datos, la U.C. le indica al camino de datos que tiene que hacer en cada ciclo de reloj

Existen dos tipos de U.C.

U.C. cableada (máquina de estados finitos)

U.C. microprogramada

Líneas de control

(eligen un bus)

M

U

X

15

Unidad de Control Cableada

Lógica

Cableada

FSM

Reg. Instr.

Estado

Camino

de

datos

.

.

.

.

.

.

.

.

6

bits

40

bits

Condiciones

Líneas de control

6 (opcode)

+(6) 3

6

U.C. máximo como estados 6462

No es necesario enviar todos los

bits de la instrucción. Los registros

y el inmediato se envían

directamente al hardware.

!MBytes! 11.5bits 46221

Una parte pequeña de la tabla tiene

información única, por ello el tamaño

puede reducirse. PLA+ROM

16

Unidad de Control Microprogramada (I)

La idea es convertir la U.C. en un computador en miniatura

Tenemos una tabla para especificar el control del camino de datos y otra tabla para determinar el flujo de control a nivel de microprograma

Las microinstrucciones indican todas las señales de control del camino de datos, además del control del microprograma (existe un MicroPC).

El control se convierte en una tarea de programación

La microprogramación nos permite cambiar el repertorio de instrucciones cambiando el contenido de la memoria de control sin tocar el hardware

Útil para crear nuevas instrucciones (Ej. PAL de Alpha)

17

Unidad de Control Microprogramada (II)

Memoria de

microprograma

(ROM)

PC

Camino

de

datos

.

.

.

.

.

.

.

.

Condiciones

Líneas de control U.C.

Reg. Instr.

Lógica de

selección de

dirección

+

1

dirección dest

18

Características de un buen procesador encadenado (I)

Instrucciones de tamaño fijo y escasos formatos de instrucciones Generalmente el tamaño es de 32 bits Tendremos pocos formatos de instrucciones (hasta 8) En cada formato cada bit significa lo mismo para todas las

instrucciones de ese formato Esto permite simplificar la decodificación, de forma que en la etapa ID

tendremos toda la información necesaria para ejecutar la instrucción

Sólo las instrucciones de carga/almacenamiento acceden por datos a memoria Todas las instrucciones tienen sus operandos en registros y podemos

acceder a ellos en la etapa ID Sólo los Load/Store podrán tener problemas con la jerarquía de

memoria

19

Características de un buen procesador encadenado (II)

Un conjunto amplio de registros de propósito general No es intrínseco a los RISC Es necesario, debido a que todas las instrucciones tienen sus

operandos en registros Evita un uso masivo de instrucciones load/store Facilita el uso de técnicas de coloreado de mapas para la ubicación de

variables en registros (un color por registro)

a= …

b= …

:

…= b…

c= …

…= a…

d= …

e= …

…= d…

…= c…

a b c d e

Tiempo a b

c d

e

Coloreado de registros

Igual registro

Igual registro

20

Características de un buen procesador encadenado (III)

Normalmente tenemos 32 registros de 32 bits 5 bits de opcode para direccionarlos Recordar que en el x86 hay sólo 4 registros: EAX, EBX, ECX y

EDX, más 3 registros: ESI, EDI y EBP En estos procesadores es muy difícil poner más registros puesto

que estos sirven para muy distintas y complejas cosas, de manera que ocupan mucho área de silicio

Instrucciones aritméticas/lógicas de 3 operandos Este punto no es tan seguido por los micropr. RISC Hace gastar más registros (a veces inútilmente) Por el contrario, conseguimos más flexibilidad

ADD R5,R5,R6 equivaldría a ADD R5,R6 ADD R1,R2,R3 equivaldría a MOV R1,R2 ADD R1,R3

Necesitaremos 15 bits para direccionar los 3 registros

21

Características de CISC y RISC: Posibles razones para usar CISC (I)

¿Simplifica los compiladores, por ser menor el “salto semántico”?: en realidad esto no es cierto

Los compiladores tienen difícil elegir la versión correcta de instrucciones tan complejas

A la postre, muchos compiladores acaban usando instrucciones simples

Al disponer de pocos registros es difícil generar código

22

Características de CISC y RISC: Posibles razones para usar CISC (II)

Programas más pequeños (menos instrucciones)

Todo para ahorrar memoria, un recurso caro. Pero ahora la memoria es barata

También son más rápidos

Hay que leer menos bytes de instrucciones

Si existe paginación, hay menos fallos de página

El problema es que los programas CISC son más cortos en instrucciones pero con mayor tamaño medio por instrucción (en bits) en la media no hay mucha diferencia

Las instrucciones complejas rara vez se utilizan

Como los CISC tienen más tipos de instrucciones, los campos “opcode” son más largos

Los RISC operan más con registros, que necesitan menos bits de direccionamiento que los operandos que están en memoria (muy usados en CISC)

23

Características de CISC y RISC: Posibles razones para usar CISC (III)

Tampoco los CISC son más rápidos

Las instrucciones complejas requieren una unidad de control más compleja

Es difícil usar una U.C. cableada

En caso de usar U.C. microprogramación, necesitaremos muchas microinstrucciones para decodificar y para ejecutar

mayor micromemoria

Existen muchas microinstrucciones distintas

Existen instrucciones con distinto número de microinstrucciones

Esto hace que sea difícil hacer una cadena simétrica

24

Características de CISC y RISC: Razones para usar RISC (I)

Una operación por ciclo Las operaciones típicas a realizar son

Captar dos operandos en registros

Operar sobre dos operandos

Escribir el resultado de la operación en un registro

Las operaciones RISC son equivalentes en complejidad a las microinstrucciones

No tiene sentido usar microcódigo, mejor cableado No requieren acceder a micromemoria

Son más rápidos

25

Características de CISC y RISC: Razones para usar RISC (II)

Operaciones registro-registro (salvo Load, Store)

Simplifica el conjunto de instrucciones

Tendremos pocos tipos de ADD

En VAX, tenemos 25 tipos de ADD

Menos accesos a memoria

Se utilizan los registros como variables temporales.

Ej: ab+c Con Reg: 2 cargas y 2 almacen.

c b*a Sin Reg: 4 cargas y 2 almacen.

Modos de direccionamiento sencillos

Algunos RISC sólo usan: registro+desplazamiento(con signo)

Este hecho simplifica la unidad de control

El resto de posibles direccionamientos se emulan con varias instrucciones.

26

Características de CISC y RISC: Razones para usar RISC (III)

Formato de instrucciones sencillo Longitud fija (normalmente 32 bits)

Alineadas a palabra

Posición de los campos fija Especialmente el opcode

Conseguimos un hard rápido

Podemos acceder a los operandos en los registros a la vez que se decodifica la instrucción

Consecuencias de las características vistas Facilita la aplicación de técnicas de segmentación

(encadenamiento)

Se facilita la optimización de código de los compiladores

Se utilizan instrucciones sencillas Más fácil reordenar instrucciones

Maximizar el uso de registros

Instrucción

Regis-

tros

U.C.

(decodifica)

5 6(+6)

27

Juegos de instrucciones orientados al encadenamiento

Las instrucciones podemos descomponerlas en cinco etapas IF (Instruction fetch)

Búsqueda de instrucción

ID (Instruction decode) Decodificación de la instrucción Búsqueda de registros

EXE (Execution) Cálculo de la dirección efectiva (para accesos a memoria) Ejecución de la operación indicada (instrucciones ALU)

MEM (Memory access) Completar la resolución de los saltos Acceso a la memoria

WB (Write-back) Escritura de los resultados en el fichero de registros

28

2.3. Descripción del procesador ejemplo (DLX)

Es un procesador didáctico, pero se parece a MIPS, SPARC, etc. Arq. de años 80, pero tiene varias ventajas: Es más simple que los RISC reales Podemos extender fácilmente su funcionamiento al de los

RISC Su diseño como procesador secuencial no es muy bueno.

Está diseñado para que sea óptimo como procesador encadenado

Es fácilmente extensible a (se verán en ASP2): Arquitectura vectorial Arquitectura superescalar

Existen simuladores y libros: Henn-Patt, 2ª Edición,1996 (sólo en inglés) aptdo. 2.8, cap. 3

29

Características principales del DLX(I) DLX se definió para ajustarse a las características de un buen procesador encadenado Máquina simple Load/Store

Sólo las instrucciones de carga y almacenamiento acceden a memoria

Único direccionamiento permitido es el de Registro+Desplazamiento: (Rb)despl Mem [ Rb+despl ]

Supone más del 80% de accesos (el resto se emulan con éste)

Bancos de registros Un banco de 32 registros enteros (GPR) ortogonales

Necesitamos 5 bits de opcode para direccionarlos a todos De 32 bits R0...R31 R0=0 R31 recoge las direcciones de retorno (CALL, RET)

No hay registro especial para la pila (S.O. usaría R30)

30

Características principales del DLX(II)

Un banco de 32 registros en coma flotante (FPR) Necesitamos 5 bits de opcode para direccionarlos todos 32 bits para los registros de simple precisión: F0...F31 64 bits para los registros de doble precisión: D0...D15 (F0, F2,

F4, F6, … , F30)

Existen instrucciones para convertir registros enteros a flotantes y viceversa

Existe un pequeño registro de estado que se utiliza sólo para comparaciones y excepciones en F.P.

Memoria Direccionable por bytes. BIG ENDIAN (dir. xxx00 en Mayor

final): coloca el byte cuya dirección es X...X00 en la parte más significativa de la palabra

Accesos: Byte, Half word, Word Siempre alineados

DD

CC

BB

AA

FF...F

xxx11

xxx10

xxx01

xxx00

00...0

AA BB CC DD 31 0

Memoria

31

Características principales del DLX (III) No hay “bits de estado”: el estado es PC, registros,

memoria instrucc y de datos

Todas las instrucciones son de 32 bits y deben estar alineadas (la dir. de cualquier instr. es múltiplo de 4)

4 clases de instrucciones en cuanto a lo que hacen Load/store (carga/almacenamiento)

ALU (aritmético/lógicas)

Saltos incondicionales y condicionales (bifurcaciones)

Operaciones en F.P.

Sólo 3 formatos de instrucciones (según los operandos que usan)

Tipo I (de Inmediato)

Tipo R (de Registro)

Tipo J (de “Jump”)

32

Juego de instrucciones enteras (I)

Cargas y almacenamientos Formato I

Existe una instrucción especial de carga LHI reg, #inmediato, que carga los 16 bits de la parte superior del registro con el valor del inmediato. El resto lo pone a 0.

L

S

W

B

H

D

F

U Las cargas las puedo realizar con

o sin signo extendido. +

33

Juego de instrucciones enteras (II)

Operaciones ALU Formato I si son del tipo reg-inmediato: ADDI R1, R2, #100

Formato R si son del tipo reg-reg: ADD R1, R2, R3

ADD

SUB U I

MUL

DIV U

AND

OR

XOR

I

S

LT

GT

LE

GE

EQ

NE

I + Todas las

comparaciones

son con signo

SLL

SR

I

L

A + I

EJERCICIO

34

Juego de instrucciones enteras (III)

Operaciones de control: saltos condicionales e incondicionales Formato I para los saltos condicionales y los incondicionales absolutos Formato J para el resto de saltos incondicionales relativos al PC

JAL sirve para los CALL de funciones. Pone la dirección de retorno en R31 y salta a la función. Si la subrutina llamada regresa, hará JR R31. En caso de anidamiento de subrutinas, guardará primero R31 y saltará.

Las instrucciones F.P. se verán más adelante.

B

Formato I

JR

EQZ

NEZ +

JALR

J

JAL

Formato J

Salto incondicional relativo

a una etiqueta de 26 bits

Salto incondicional

absoluto a la

dirección indicada

por un registro.

Rd no se utiliza

Salto condicional

relativo a una

etiqueta de 16 bits.

Rd no se utiliza

RFE

TRAP Llamada y retorno

de excepción

35

Formatos de instrucciones (I)

Rs (Reg “Source”). Rd (Reg. Destino). Opcode: campo fijo

Formato tipo I Load/Store

La dirección de memoria se calcula como Rs1+ inmediato

Rd es el registro destino en las cargas y el fuente en los almacenamientos

Salto condicional Rd no se usa

El desplazamiento es relativo al PC+4

Rs1 es el registro utilizado para evaluar el salto

ALU (reg-inm) entera Rd Rs1 op inmediato

El signo del inmediato se extenderá internam. a 32 bits

Código

Oper. Rs1 Rd Inmediato

6 5 5 16

0 31

36

Formatos de instrucciones (II)

Formato tipo R

ALU (reg-reg) entera o FP

Rd Rs1 op Rs2

Formato tipo J

Saltos incondicionales, Trap, vuelta de excepción, salta y enlaza (procedimientos)

Código

Oper. Rs1 Rs2 Función

6 5 5 11

Rd

5

Código

Oper. Desplazamiento

6 26

0 31

0 31

37

2.4. Implementación del encadenamiento del DLX (I)

Instrucciones enteras Una instrucción de un proc. RISC siempre debe hacer: IF, ID, INCPC. Y casi todas: RO, EXE y WB IF: Instr Fetch. ID: Instr. Decode. INCPC: Increm PC. RO: Read Oper. WB:

Write Back

Las instrucciones Load/Store acceden a memoria y añaden las fases: EA, MEM (EA: Effective Address)

Las instrucciones de salto necesitan realizar 3 operaciones a tener en cuenta: CMP: Comparación del registro con 0 PCD: Cálculo del PC (dirección) de destino WPC: Escritura del nuevo PC (Write PC)

Veamos como podemos compactar todo esto

38

Etapas del DLX (I) ALU IF ID RO(2) EXE --- WB(1)

ALU I IF ID RO(1)

d16d32 EXE --- WB(1)

LD (más

larga)

IF ID RO(1)

d16d32 EA MEM WB(1)

ST IF ID RO(2)

d16d32 EA MEM ---

BEQZ IF ID RO(1)

d16d32

CMP

PCD WPC ---

J IF ID --- PCD WPC ---

JAL IF ID --- PCD WPC WB(1)

JR IF ID RO(1) --- WPC ---

JALR IF ID RO(1) --- WPC WB(1)

INCPC se puede hacer donde se quiera (p ej con WPC)

39

Etapas del DLX (II)

Máquina síncrona (CLK): reg operación

Toda etapa acaba en registros (guardan “estado”)

Todas las instr. hacen casi lo mismo en cada fase

Fases vacías elegidas convenientemente

Todas las instrucciones son posibles con 6 fases

Las fases ID y RO son muy cortas y se pueden hacer en paralelo: podemos unirlas 5 etapas

EA, PCD lo realizamos con la ALU

Debemos añadir el hardware necesario para poder realizar CMP y PCD a la vez Añadimos un comparador para realizar CMP

Tenemos que añadir extensores de signo para las direcciones y las etiquetas

Mem /

Circ

Comb

Reg

40

Implementación secuencial: código RTL (I)

Tenemos 5 fases: IF, ID, EXE, MEM, WB

IF (Búsqueda de instrucción)

IR Mem[PC] IR: Instr. Register

NPC PC + 4 NPC: Next PC

ID (Decodificación de instrucción y lectura de operandos)

Reg U.C. decodificar IR 0..5 e IR 21..31

A Regs[IR 6..10]

B Regs[IR 11..15]

Inm ext. signo a 32 bits (IR 16..31) (complemento a 2)

IR m..n : bits de m a n del registro IR

41

Implementación secuencial : código RTL (II)

EXE (Ejecución / Dirección efectiva)

Load/Store

ALUoutput A + Inm

ALU reg-reg

ALUoutput A op. B

ALU reg-inm

ALUoutput A op. Inm

Salto condicional

ALUoutput NPC + Inm

Cond (A = 0) o (A != 0)

Entradas ALU:

1ª : A / NPC

2ª : B / Inm

42

Implementación secuencial : código RTL (III)

MEM (Acceso a memoria / Final de salto)

Load/Store

Load: LMD Mem[ALUoutput] LMD: Load Memory Data

Store: Mem[ALUoutput] B

Salto condicional

If (Cond) PC ALUoutput

else PC NPC

WB (Write-Back)

Load/Store

Load: Regs[IR 11..15] LMD

ALU reg-reg

Regs[IR 16..20] ALUoutput

ALU reg-inm

Regs[IR 11..15] ALUoutput

43

DLX Secuencial (I)

PC

Memoria

Instrucc. IR ALU

Add NPC

4

Fichero

de

registros

Ext.

signo

¿Cero?

B

A

M

U

X

M

U

X ALU Output

Cond.

Memoria

de

datos

LMD M

U

X

M

U

X

Inm

Decodificación de instrucciones /

Búsqueda de registros Búsqueda de instrucciones

Ejecución /

Cálculo de dirección efectiva Acceso a memoria /

Final Salto Write

Back

16 32

IF ID EX MEM WB

U.C.

Acción de la U.C: control del

camino de datos EJERCICIO

R/ W Tipo Oper. R/ W

44

DLX Secuencial (II)

Debido a la simplicidad de las operaciones en cada etapa, podemos usar una unidad de control cableada Mayor velocidad

CPI de este procesador sería 4 ciclos para los saltos y almacenamientos 5 ciclos para el resto Podríamos mejorar el diseño

Pasar la finalización de las instrucciones ALU a la etapa MEM Reducir el hardware redundante Definir la máquina como de 1 sólo ciclo largo de ejecución, de forma que

desaparecerían los registros temporales Etc.

Nuestro interés es diseñar fases simples sin interdependencias, para que la máquina encadenada sea lo mejor posible

EJERC

45

DLX Encadenado (I)

Problemas en la implementación: pensar en las 5 fases en paralelo (elementos que se usan en dos o más fases) Acceso a memoria para instrucciones y datos

O se bloquea si hay 2 accesos al mismo tiempo

o se separan los cachés (datos e instr.)

El caché de instr. debe suministrar 1 pal./ciclo

El fichero de registros es usado en 2 etapas (ID, WB) Pueden darse 2 lecturas y 1 escritura simultáneas

Necesitamos 3 puertos en el banco de registros

Existe un problema: coincidencia de registro leído y escrito No debe existir confusión, la escritura del registro debe

realizarse antes que la lectura

Surge un conflicto de acceso En principio, provocará bloqueo. Posteriormente lo resolveremos

*WB

MEM

EX

*ID

IF

*WB

MEM

EX

*ID

IF

46

DLX Encadenado (II)

El PC debe ser actualizado en cada ciclo. Cuidado: Saltos El resultado de la actualización del PC puede ser:

Incremento en 4 (NPC) Asignar la dirección de destino calculada en un salto

La condición del salto se resuelve en la etapa EXE y el PC se actualiza en MEM (WPC): O se “congela” la cadena durante tres ciclos por cada salto O se incrementa el PC y se ejecutan las siguientes al salto (se

“especula” con ellas; luego puede que haya que abortarlas si la condición es cierta)

Los registros temporales y la propia instrucción se usan varios ciclos después de su decodificación Cada instrucción debe arrastrar consigo todo lo que necesita, con

el valor que tenían en el momento de su emisión Han de transmitirse por la cadena continuamente Esto forma una cadena de registros temporales de datos (A, B,

etc) y de control (IR). P ej: IF/ID.IR, ID/EX.IR, EX/MEM.IR, etc.

WB

*WPC

EX

ID

*IF

WB

*MEM

*EX

*ID

*IF

47

DLX Encadenado (III)

4

ID IF EXE MEM WB

16 32

IR

IF / ID ID / EXE EXE / MEM MEM / WB

Rs1

Rs2

Rd

dato Faltarían las señales

de control de los

multiplexores, ALU, etc

provenientes de la U.C.

32

PC

Memoria

Instrucc. ALU

Add

Fichero

de

registros

Ext.

signo

¿Cero?

M

U

X

M

U

X

Memoria

de

datos

M

U

X

M

U

X

U.C.

48

ALUOutput

Código RTL (DLX encadenado)

49

2.5. Dependencias, riesgos y bloqueos (I)

En procesadores secuenciales no suelen existir estos problemas

Dependencia Cualquier motivo que hace que una instrucción dependa de otra

Dependencia por un dato (en registro o en memoria) Dependencia de control (salto tomado o no) Dependencia estructural (conflictos con recursos)

Riesgo Es la situación de posible mala ejecución por la existencia de

una dependencia Todo riesgo debe resolverse:

Complicando el hardware para evitar el riesgo Mediante software (típicamente reordenando las instr.) Introduciendo los bloqueos necesarios (esto requiere un hard

adicional para detectar los riesgos peligrosos)

Bloqueo Es la detención de alguna/s fase/s en la ejecución

50

Dependencias, riesgos y bloqueos (II)

Por lo general, cuando se produce un bloqueo,

Todas las instrucciones siguientes a la que lo produjo también se bloquearán. No se emite (IF) ninguna instrucción nueva

Las instrucciones previas al bloqueo deben continuar para que se resuelva el bloqueo

Cada bloqueo se puede entender como una “burbuja vacía” en la cadena que se propaga de izquierda a derecha

51

Dependencias, riesgos y bloqueos(III)

T1 T2 T3 T4 T5 T6 T7 T8 T9 T10

Inst1 IF ID EX ME WB

Inst2 IF ID EX EX*

ME WB

Inst3 IF ID ID* EX ME WB

Inst4 IF IF* ID EX ME WB

Inst5 IF ID EX ME WB

IF ID EXE MEM WB

T1

T2

T3

T4

T5

T6

T7

T8

T9

T10

1

2

3

4

4

5

1

2

3

3

4

5

1

2

2

3

4

5

1

2

3

4

5

1

2

3

4

5

V

V Burbuja Vacía

Falta una fase

Instr. Anteriores

siguen avanzando

Instr. posteriores se

bloquean

52

Dependencias, riesgos y bloqueos(IV)

Reformulamos el CPI

Memoria Bq.Control Bq.lEstructura Bq.Datos Bq.Bloqueo

BloqueoBloqueoIdealReal

CPI CPI CPI CPI CPI

CPI 1 CPI CPI CPI

¿Son aditivos? Sólo en procesadores encadenados y casos simples

En proc. avanzados, unos bloqueos se ocultan a otros

Ciclos totales = Ciclos ideales + Ciclos Bloqueo

(sup. se bloquea toda la máquina)

Divido por Ninstr :

53

2.6. Dependencias estructurales (I)

Pensar en todas las fases a la vez (en el mismo ciclo) En el DLX ya los resolvimos 2 puertos de lectura y 1 puerto de escritura al fichero de registros Caché de instrucciones y datos separados Incremento del PC en la etapa IF Registros temporales de cadena

Las fuentes de bloqueos estructurales pueden ser múltiples (se verán más adelante). Ejemplos: Si p ej se quieren ejecutar 2 instr. /ciclo necesitaremos duplicar los

recursos hard, lo cual no siempre es posible Si una U.F. no está completamente segmentada, provocará

bloqueos en 2 instrucciones cercanas del mismo tipo (típico en las divisiones)

54

Dependencias estructurales (II)

En principio, debemos intentar evitar estas fuentes de bloqueos, pero a veces puede que no sea prioritario Debemos sopesar entre:

% de ocasiones en las que se produce el riesgo

Coste que supone la solución Duplicar las U.F. ó recursos

Encadenar o segmentar las U.F.

Veamos dos ejemplos de actuación

55

Dependencias estructurales (III)

Ejemplo 1. ¿Es conveniente evitar el bloqueo estructural entre acceso a instrucciones y datos de un caché unificado

SeparadosUnif icado T 1,05 T

9% Store

26% Load

Por la mayor complejidad del caché separado

- buses separados

- hard de redireccionamiento (separar inst. de datos)

El caché unificado tendrá un ciclo de bloqueo en cada Load/Store que emita

28,105,1

35,1

1

SeparadoSeparadoinstr

Unif icadoUnif icadoinstr

Separado ejecución,

Unif icado ejecución,

SeparadoUnif icado

Separado

TCPIN

TCPIN

t

t A

1,35 0,090,26 CPI CPI

1 CPI

56

Dependencias estructurales (IV)

Ejemplo 2. Supongamos un DLX cuya duración de la etapa EXE de las multiplicaciones F.P. es de 5 ciclos ¿Qué impacto tendría de media en las prestaciones el hecho de que no esté segmentada?. Suponer que un programa F.P. tiene como máximo un 14% de instrucciones de multiplicación en F.P.

Solución

Si suponemos que las multiplicaciones están uniformemente distribuidas, tendremos 1 multiplicación cada 7 instrucciones (aprox.) no tendríamos bloqueos

El peor caso sería que todas las multiplicaciones fueran contiguas, en cuyo caso tendríamos que ejecutarlas a un ritmo de 5 ciclos/inst. CPIMáximo= (0,86 * CPINormal) + (0,14 * 5) = 1,56

En la práctica, los bloqueos de datos de las instr. largas serían mucho mayores que los estructurales.

En procesadores encadenados reales los bloqueos estructurales suponen menos del 3% de los totales

57

2.7. Dependencias de datos (I)

El solapamiento de instrucciones en los procesadores encadenados, provoca que los registros u operandos puedan ser leídos/escritos en orden distinto al del código Una dependencia de datos se produce cuando una primera instrucción lee ó escribe un registro, y este registro es usado por una instrucción posterior (en lectura ó en escritura) que empieza a ejecutarse antes de que concluya la primera

ADD R1, R2, R3 IF ID EX ME WB SUB R5, R4, R1 IF -- -- -- ID EX

Debemos estudiar los bloqueos posibles para: Diseñar la máquina y que no tenga fallos ante una dependencia,

intentando que los ciclos de bloqueo sean los mínimos posibles Generar código con el menor número de riesgos posibles, para

evitar ciclos de bloqueo

58

Dependencia de datos (II)

Para evitar los riesgos de datos (en los que habría que insertar bloqueos), debemos primero detectarlos En RISC sencillos es fácil detectarlos, ya que sólo se lee en ID y

sólo se escribe en WB. Los compiladores los pueden detectar sin excesivos problemas

En procesadores CISC es más difícil detectarlos. Los compiladores lo tienen muy difícil Pueden existir registros de estado (banderas o “flags”) Modos de direccionamiento con autoincremento, etc. Ej x86: MOVSB

Otro problema que nos puede surgir es cuando la dependencia se produce por un dato de memoria (coincidencia de direcc.) En DLX no se da este problema (de momento) ya que sólo

accedemos a memoria en una etapa (fase MEM en orden)

En DLX sólo tendremos dependencias de datos entre registros. Estas dependencias pueden ser detectadas y sus riesgos solucionados:

Por el compilador (técnicas estáticas) Mediante hard (técnicas dinámicas)

59

Tipos de dependencias de datos (I)

Read Read Cuatro

Write Write combin.

RAW (read after write) o dependencia real

Cuando el operando destino de una instrucción va a ser usado como fuente por alguna/s instrucciones posteriores

ADD R1,R2,R3 IF ID EXE MEM WB

SUB R4, R5,R1 IF --- --- --- ID EXE MEM WB 3 c.bq.

Es la más común

Es inevitable e inherente al algoritmo

After

60

Tipos de dependencias de datos (II)

WAR (write after read) o antidependencia

Una instrucción escribe su resultado en un registro destino que es el mismo que un registro fuente de una instrucción anterior.

En el DLX estas dependencias no producen riesgos, ya que siempre se lee al principio de la cadena (ID) y se escribe al final (WB) (fase WB en orden)

Estas dependencias se producen en procesadores que: Leen sus registros fuentes en etapas finales

Ejemplo (raro): Lee R1

SW 8(R2), R1 IF ID EX ME ME ME WB

ADD R1, R5,R4 IF ID EX -- -- WB Se pueden eliminar mediante renombrado de registros. Son ficticias,

debidas a: mal coloreado de registros pocos registros (se agotan al compilar). Común en CISC

61

Tipos de dependencias de datos (III)

WAW (write after write) o dependencia de salida Dos instrucciones que usan el mismo registro destino, y el riesgo

se produce cuando la instrucción posterior quiere escribir antes que la anterior

En el DLX básico (sin instrucciones de larga duración) no se producen riesgos de este tipo, ya que sólo se escribe en la etapa WB

Estas dependencias se producen en procesadores que: Permiten escribir en varias etapas Utilizan instrucciones con duración variable

MUL R1, R2, R3 IF ID EXE EXE EXE EXE EXE MEM WB ADD R1, R5, R4 IF ID EXE MEM --- --- --- --- WB

– Se pueden eliminar mediante renombrado de registros (idem que WAR)

62

Tipos de dependencias de datos (IV)

RAR (read after read) No serían un problema, puesto que la lectura no modifica

valores

Las dependencias reales son muy frecuentes. Aproximadamente el 25% de las instrucciones ALU contiguas la tienen. Las instrucciones ALU suponen el 40% del total de instrucciones. CPI = CPIIdeal + (0,4 * 0,25 * 3) = 1,3 (en el peor de los

casos) un 30% de perdida de prestaciones

Las dependencias de datos son un problema y deben evitarse al máximo los bloqueos que inducen.

Para proc. avanzados, aún es más importante evitar bloqueos (ej. CPIIdeal =1/2)

EJERCICIO

63

Minimización de bloqueos mediante “bypass” (I)

Las técnicas de “bypass” o “forwarding” (cortocircuito, camino de desvío o de realimentación) consisten en capturar el operando destino de la instrucción anterior, directamente de la salida de los registros temporales e inyectarlo en la fase donde se van a usar (en lugar de que ID espere a la WB de la instr anterior). Deberán realimentarse los registros temporales de cadena hacia la entrada de donde se necesite. Deberemos incluir multiplexores en las entradas donde se establezca un bypass, para que la U.C. pueda seleccionar el canal adecuado en función del bypass La U.C. analizará los registros temporales de instrucción (IR) de las instrucciones que se están ejecutando Por ej, para detectar una dependencia, la U.C. debe comparar:

Si opcode [ID/EXE.IR0..5]=ALU y opcode [IF/ID.IR0..5]=ALU reg-reg

y (ID/EXE.IR11..15= IF/ID.IR6..10 ó ID/EXE.IR11..15= IF/ID.IR11..15)

64

ADD

SUB

AND

OR

Minimización de bloqueos mediante “bypass” (II)

ALU – ALU

ADD R1,R2,R3

SUB R4,R1,R5

AND R6,R1,R4

OR R8,R1,R9

Para el último bypass hay 2 posibilidades

El bypass en rojo, lo cual implica otro registro temporal

Escritura en el primer semiciclo y leer en el segundo (usaremos este por defecto)

CUIDADO: Los registros temp. con aspa se leen pero no se usan

ALU

output

AL

U * ALU

output

Fichero

registros

AL

U

ALU

output

AL

U * ALU

output

Bypass

AL

U

Doble Bypass Bypass

rojo

A

B

A

B

B

A

Reg Tmp

NOTA: Para simplificar la figura no se han

dibujado los MUX de las entradas de ALU

Registro

copia

65

Minimización de bloqueos mediante “bypass” (III)

ALU – Store

ADD R1,R2,R3

SW 20(R1),R1

AL

U Fichero

registros

AL

U

Memoria

Bypass

No válido

ALU

output

* ALU

output

ALU

output

A

B B

Inm

• NOTA: Para simplificar la figura no se han

dibujado los MUX de las entradas de ALU y

de memoria

66

Minimización de bloqueos mediante “bypass” (IV)

Load – ALU

LW R1,0(R2)

SUB R4,R1,R5

En este caso no podemos eliminar todos los

riesgos hay que insertar 1 ciclo de bloqueo.

Para evitar estos c. bq. debemos de usar otros métodos (p ej insertando una instr independiente entre ambas)

AL

U

Bypass

Ciclo de bloqueo

inevitable

Memoria

ALU

output

A

B B

Reg.

Temp.

A

• NOTA: Para simplificar la figura no se

han dibujado los MUX de las entradas

de ALU

67

DLX con bypass (I)

ALU Fichero

de

registros

Ext.

signo

M

U

X

Memoria

de

datos

M

U

X

IF ID EXE MEM WB

16 32

IF / ID ID / EXE EXE / MEM MEM / WB

Rs1

Rs2

Rd

dato

M

U

X

M

U

X

Reg Tmp

WB-MEM

MEM-MEM MEM-EXE

(EXE) MEM-EXE

EXE-EXE

MEM-EXE

(EXE) MEM-EXE EXE-EXE

M

U

X

¿Cero?

EJERCICIO

68

DLX con bypass (II)

EXE-EXE

ALU R1, ..., ...

ALU ..., R1, ...

MEM-EXE

(1 cbq) LW R1, ..., ...

ALU ..., R1, ...

(EXE) MEM-EXE

ALU R1, ..., ...

Instr. indp.

ALU ..., R1, ...

MEM-MEM

LW R1, ...

SW ..., R1

(EXE) MEM-MEM

ALU R1, ..., ...

SW ..., R1, ...

(MEM)WB-MEM

LW R1, ...

Instr. indp.

SW ..., R1

(EXE) WB-MEM ADD R1, ..., ...

Instr. indp.

SW ..., R1

Faltan los saltos (se verán en aptdo 2.8)

EJERC: dibujar

los crono-grama

s

69

Bypass en otros procesadores

Modelo de DLX que usaremos: todos los bypasses; escribe en 1º semiciclo de WB; lee en 2º semiciclo de ID (y resolución de saltos se adelantará a ID, aptdo 2.8). Similar a empotrados de 32 bits actuales

Introducir todos los bypasses ocupa mucho silicio y consumo potencia: Otras soluciones (usuales en proc. bajo consumo) son: Reducir el número de fases (evita combinaciones menos bypasses)

Sólo existen bypasses para un operando (compilador debe saberlo para ordenar registros: técnica estática posible pérdida de prestaciones)

No existen bypasses (compilador debe reordenar instrucciones al máximo: técnica estática posible pérdida de prestaciones)

El procesador no detecta dependencias (compilador debe insertar NOPs: técnica estática posible incompatibilidad futura)

• En algunos procesadores sin todos los registros temp. de cadena, los bypasses se dibujan partiendo de un conjunto de registros de desplazamiento (H&P 1ª Edición)

Bypasses

Reg1 Reg2 Reg3

AL

U

M

U

X

2.10. Instrucciones de Duración Variable

Hay operaciones que requieren mayor tiempo de ejecución EX que otras.

Operaciones como multiplicación y división de enteros, u operaciones de punto flotante necesitan un tratamiento especial en su etapa de ejecución.

Mantener 5 etapas en la cadena pipeline implicaría alargar el periodo de reloj, para amoldarse a las operaciones de larga duración. Por otra parte, si añadimos más fases para las instrucciones largas, sería poco eficiente que todas las instrucciones tuvieran todas esas fases, puesto que las instrucciones largas son poco frecuentes.

Luego se aumenta el número de etapas en la cadena sólo donde se necesita: en las etapas de ejecución EX de operaciones largas.

Instrucciones de Duración Variable

•Solución: Se tiene más de una unidad funcional para soportar estas nuevas instrucciones. Estas nuevas unidades funcionales pueden trabajar en paralelo con las demás. La cadena pipeline será la misma, pero la etapa EX se repite tantas veces como la operación lo requiera.

•DLX: Se define con una unidad funcional (U.F.) para operaciones enteras simples, otra para multiplicaciones de enteros/FP, otra para divisiones de enteros/FP y otra para suma/resta FP, las cuales necesitan más de un ciclo para concluir su etapa EX.

Actualmente se disponen de muchas U.F. diferentes para enteros y para FP.

Típicamente el DLX (1990) tiene una duracion de 1 ciclo para las operaciones de enteros simples, 5 ciclos para las multiplicaciones, 2 ciclos para sumas FP y 20 ciclos para divisiones FP.

Las unidades funcionales pueden estar segmentadas. Es decir, si la suma FP tiene 2 ciclos A1 y A2 como etapas de ejecución, las cuales pueden estar ejecutando instrucciones diferentes. Para permitir esto es necesario añadir latches entre ambas subetapas para almacenar los valores intermedios. Las no segmentadas pueden producir bloqueos estructurales.

IF ID MEM WB

EX Enteros

EX FP/Ent *

EX FP +/-

EX FP/Ent /

Instrucciones de Duración Variable

Instrucciones de Duración Variable

Duración de una U.F.: número de ciclos desde que empieza la fase EX hasta que se produce un dato (como suponemos todos los bypasses en el DLX, entonces el nº c.bq. por RAW coincide con la Duración-1).

Intervalo de repetición/iniciación: número de ciclos entre el lanzamiento de 2 instrucciones del mismo tipo. Ej: si está segmentada vale 1.

Para SPEC-INT el % de instr MUL es 0.02% y de DIV es prácticamente 0%

• Aparecen los riesgos WAW. Ej: MULTU R1, R2, R3 BEQZ... ADD R1, R4, R5

• Los ciclos bloqueo por RAW crecen. Tip. CPIdatos(prog FP) >> CPIdatos(prog INT)

• Aparecen bloqueos estructurales al no haber una duración fija de la cadena pipeline. En el DLX sin planif dinámica los consideraremos todos (así lo hace WINDLX). Es decir, los recursos (reg temp) de una fase no pueden estar replicados para 2 instr.

Unidad Funcional Fase Duración % SPEC-FP Intervalo de iniciación

ALU entera simple EX 1 1

Carga de memoria(Ent/FP) EX,MEM 2 1

Suma / Resta FP A1, A2 2 7.0 / 3.0 1

Multiplicación (Ent/FP) M1,…,M5 5 1.0/ 8.0 1

División (Ent/FP) D1,…,D20 20 0.0/ 0.4 20 (no segmentada)

Instrucciones Punto Flotante en el DLX

ADDD Dd,Da,Db Add double-precision numbers

ADDF Fd,Fa,Fb Add single-precision numbers

SUBD Dd,Da,Db Subtract double-precision numbers

SUBF Fd,Fa,Fb Subtract single-precision numbers.

MULTD Dd,Da,Db Multiply double-precision Floating point numbers

MULTF Fd,Fa,Fb Multiply single-precision Floating point numbers

DIVD Dd,Da,Db Divide double-precision Floating point numbers

DIVF Fd,Fa,Fb Divide single-precision Floating point numbers

CVTF2D Dd,Fs Converts from type single-precision to type double-precision

CVTD2F Fd,Ds Converts from type double-precision to type single-precision

CVTF2I Fd,Fs Converts from type single-precision to type integer

CVTI2F Fd,Fs Converts from type integer to type single-precision

CVTD2I Fd,Ds Converts from type double-precision to type integer

CVTI2D Dd,Fs Converts from type integer to type double-precision

__D Da,Db Double-precision compares: "__" may be EQ, NE, LT, GT, LE or GE; sets comparison bit in FP status register

__F Fa,Fb Single-precision compares: "__" may be EQ, NE, LT, GT, LE or GE; sets comparison bit in FP status register

BFPT Dest Test comparison bit in the FP status register (true) and branch; 16-bit offset from PC

BFPF Dest Test comparison bit in the FP status register(false) and branch;16-bit offset from PC

Instrucciones Punto Flotante en el DLX

• Registros de punto flotante en el DLX.

o Hay 32 registros de simple precisión flotante: de F0 a F31. Tamaño 32 bit según IEEE754 (float de lenguaje C).

o Estos 32 registros se agrupan de 2 en 2 para formar 16 registros de doble precisión flotante con índice par: F0, F2, … F30. F0(double)=[F0,F1]. Tamaño 64 bit según IEEE754 (double de lenguaje C). NOTA: el tamaño de 64 bits provoca algunas dificultades en la implementación DLX, que no vamos a considerar.

• Directivas .double y .float para declaración de variables FP en memoria.

Ejemplo: Cronograma del código siguiente:

LD F4, 0(R2)

MULTD F0, F4, F6

ADDD F2, F0, F8

SD 0(R2), F2

Nota: Cálculo aproximado y rápido de c.bq. de datos: 1 + 4 + (1-1) = 5. (Duración-1 por cada RAW. El -1 último por Store). Es aprox. porque algunos c.bq. pueden enmascararse. Además pueden aparecer bloqueos estructurales.

76

Jerarquía de memoria (I)

Es una parte importante de la AC

Gran diferencia en el incremento de prestaciones de la memoria con respecto a la CPU

1

10

100

1000

10000

100000

1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005

Años

Pre

sta

cio

ne

s

La memoria crece un 7% anual

CPU: Crece un 35% anual hasta 1986

CPU: Crece un 55% anual desde 1986

77

Jerarquía de memoria (II)

Debemos esforzarnos en el diseño de la jerarquía de memoria Obtener mayor ancho de banda Obtener menor tiempo de acceso

Surgen ideas para optimizar el acceso a la memoria Separar el reloj de la CPU del reloj del bus de memoria

Se ralentiza la ejecución cuando se accede a ella Debemos acelerar estos accesos actuando sobre 2 parámetros

Tecnológico. Las memorias cada vez son más rápidas Organizativo. Para desarrollar este punto nos basaremos en 2

premisas Hardware más pequeño es más rápido Principio de localidad (temporal y espacial). Regla empírica,

90% del tiempo de ejecución en el 10% del código y datos De estas dos premisas surge la idea de jerarquizar la memoria

78

Memorias caché

Un caché es una memoria rápida (y generalmente pequeña) donde se guardan los datos (instrucciones y/o datos de un programa) que se descubre de alguna forma que son los más usados (atendiendo al principio de localidad temporal). Cuando se arranca una máquina, el caché está “vacío” (contiene datos no válidos), y se va rellenando con los datos que se consideran que tienen más probabilidad de ser accedidos Necesita un bit Válido/Inválido. Cada vez que se trae de la memoria un dato pedido por la CPU, se carga también una serie de bytes de alrededor (principio de localidad espacial). Bloque, es la mínima cantidad de información que se intercambian

dos niveles de memoria. Una línea de caché está compuesta por un bloque mas toda la

información adicional para gestionar el bloque (etiqueta, bit de válido, bits de LRU, bits de permisos ...). Una línea de caché sólo puede tener un bloque asociado.

79

Estructura de caché.

OBJETIVO: Ver un tacc como el del caché, y un tamaño como el de la memoria.

Se organiza por bloques debido al principio de localidad espacial

Trabajemos con ejemplo típico de L1: 8KB con líneas de 32 bytes: tendrá 8KB/32=213/25 =28 = 256 líneas.

Un caché es todo hardware: fácil de implementar en digital: seleccionar los últimos (13) bits de dirección. Para una dirección de 32 bits:

31 ... 0

63 ... 32

95 ... 64

... 96

...

8191 ... 8191-31

CACHÉ Mem >> caché ==>

Conflicto entre líneas: 8192+31 ... 8192

8192+63 ... 8192+32

8192+95 ... 8192+64

HAY CONFLICTO

SI: dos direcciones

separadas por múltiplo

de 8KB:

d, d+n*8KB, n Z

19 13

ETIQUETA Dir. dentro de caché

80

Estructura de caché (II)

Las etiquetas se almacenan en la caché (“tag memory”) para distinguir entre dos bloques que entren en conflicto

Acierto (Hit). Pocos ciclos CPU: thit. Porcentaje de aciertos: HR (Hit Rate)

Fallo (Miss). traer dato de L2: tiempo de penalidad Pmiss (Penalty miss), del orden de 10 ciclos para L2, 100 para memoria. Porcentaje de fallos: MR (Miss Rate)

HR + MR =1

Acierto/Fallo

Hit/Miss BUS DE DIRECC

8191 ... 8191-31

CACHÉ

ZONA DE ETIQUETAS

(19 bits por línea)

31 ... 0

ZONA DE

DATOS

00 ... 0000

MEMORIA

31 ... 0

8191 ... 8191-31 00 ... 0000

CPU

=? 32

13

19

8192+31 ... 8192

81

Estructura de un caché (III)

Tiempo de acceso medio (para todo acceso, siempre hay que gastar el thit):

Tacc= HR * thit + MR (thit +Pmiss) = thit + MR Pmiss.

Ejemplo: caché con 95% de aciertos y thit=1 ciclos, Acceso a L2: 12 ciclos:

Tacc= 1 +0.05 * 12 = 1.6 ciclos.

82

Estructura de un caché: asociatividad

¿Y si muchas direcciones de un programa se diferencian en un múltiplo de 8KB?:

char a[8192], b[8192], c[8192];

for (i=0; i<8192 ; i++) a[i]= b[i] + c[i];

Caché dividido en “vías”, y cada línea puede ubicarse en cualquiera de ellas.

Conjunto: grupo de líneas que se ubican en la misma dirección de las diferentes vías (el mismo dato puede estar en cualquier vía, dentro de un conjunto).

Si sólo tiene una vía: caché de mapeado (correspondencia) directo.

Si tiene varias, el caché es asociativo por conjuntos.

Si una vía solo contiene una línea: totalmente asociativo (una nueva línea se puede ubicar en cualquier sitio)

CACHÉ DE CUATRO VÍAS

2 KB por vía x 4 = 8 KB

c[i]

VÍA 0:

b[i]

VÍA 1:

a[i]

VÍA 2:

VÍA 3:

Conjunto 64 conjuntos

83

Estructura de un caché: asociatividad (II)

Los cachés de datos suelen tener 2, 4 e incluso 8 vías. Los de instrucciones 1 ó 2.

Más asociatividad MR menor. Regla empírica 2:1, “un caché de una vía tiene tanto MR, como una caché de dos vías de la mitad de tamaño”.

Pero hay que buscar el dato en todas las vías (más comparaciones de etiq; más hw. más thit) COMPROMISO.

Ejemplo: memoria virtual es completamente asociativa, es decir, tiene tantas vías como páginas (bloques) hay en memoria física.

¿Qué línea de un conjunto expulsar? Algoritmos fáciles de implementar en hardware:

Aleatorio

LRU (Least Recently Used). Implementación con contadores de pocos bits.

Menos veces accedido. Implementación con contadores de pocos bits.

84

Políticas de escritura

Actualización: dos posibilidades: Caché de actualización permanente. Write Through (WT, “escritura

directa”). VENTAJA: Toda línea expulsada está coherente.

INCONV: Hacer un acceso mucho más lento (consume AB).

Caché de actualización retrasada (Copy Back , CB o Write Back) Marcar la línea de caché como sucia o modificada (bit Limpia/Sucia, L/S).

VENTAJA: Sólo se accede a memoria, cuando la línea es expulsada.

Alojamiento: dos posibilidades: Carga ante fallo de escritura (Write Allocate, WA).

Si el bloque (línea) va a ser accedido más veces, esto conviene.

No carga ante fallo de escritura (No Write Allocate, NoWA). A veces un porcentaje elevado de las escrituras de los prog. son aisladas.

Cada política tiene sus pros y contras, los cachés de datos L1 suelen ser CB, WA

Ejemplo claro: páginas de memoria virtual son siempre Copy Back Write Allocate,

85

COMPORTAMIENTO DE CACHÉS

Porcentaje típico de instrucciones de lectura (Load) es 25% (progr. para RISC) Porcentaje de escrituras (Store) es del 9%. (progr. para RISC). El propio acceso a una instrucción (fase IF, caché de instrucciones) es en sí una lectura de memoria. Luego las instrucciones Ld/St acceden dos veces y el resto sólo 1. Nº de Accesos por Instrucción (NAI)= (100+25+9) / 100 =1.34

Si = thit + MR*Pmiss ; Nºcbq/acc= MR*Pmiss ; CPIMEM= NAI*MR*Pmiss

Porcentaje de accesos al caché de datos: (25+9) / (100+25+9) = 25.4% Porcentaje de accesos al caché de instrucciones: 100/ (100+25+9) = 74.6% Porcentaje total de accesos de lectura: (100+25) / (100+25+9) = 93.28% Porcentaje total de accesos de escritura: 9 / (100+25+9) = 6.72% Porcentaje de accesos de lectura al caché de datos: 25 / (25+9) = 73.5% Porcentaje de accesos de escritura al caché de datos: 9 / (25+9) = 26.5% Porcentaje de fallos de acceso al caché instr: MR,instr típicam. de 0.5% a 3% Porcentaje de fallos de acceso al caché datos: MR,datos típicam. mayor, de 2% a 10% Porcentaje de fallos de lectura (al caché datos) es típicamente bastante menor que el de escritura: MR,lect,datos < MR,escrit,datos

acct

86

Ejercicio

Calcular el MR de acceso a L1datos si se ejecuta el siguiente bucle (sí deben considerarse los fallos forzosos, es decir, la caché está vacía, y cualquier acceso inicial es un fallo) para un caché de datos de 16 KB, con bloque = 4 palabras (la palabra tiene 4 bytes). Estudiar los siguientes casos: R1 inicialmente múltiplo de 16, frente a R1 múltiplo de 16 + 12 (R1 mod 16=12). CB, No WA, frente a CB, WA. ¿Y si sustituyo el último SW por LW R5, 1024 (R1)? ; R1 apunta inicialmente al primer elemento de un array. ; El Fin del array está 16 Kbytes después del valor inicial de R1.

Bucle: LW R4, 0(R1) ADD R4, R4, R5 SW 0(R1), R4 SW 4(R1), R4 SW 1024(R1), R4 ADDI R1, R1, 1024 SLTI R2, R1, Finarray BNEZ R2, bucle

1ª ITER Fallo forzoso

Acierto

Acierto

Fallo

RESTO ITER Acierto si WA.

Fallo si No WA

Acierto

Acierto

Fallo

// PARA R1 MÚLTIPLO DE 16

EJERCICIOS:

- Calcular CPIMEM

- ¿Influye nº vías?

SOLUCIÓN: MR,WA=17/(16*4), 17 fallos, 2 en la primera iter. y 1 en

el resto. MR,NoWA=32/(16*4), 2 fallos en todas las iter. El NAI=1.5

accesos/instr. EJERCICIO: pensar en valor inicial de R1: si no es

múltiplo de 16, el 2º SW falla.

87

Minimizar ciclos acceso ME: Optimización de cachés

Tiempo de acceso medio: Tacc= thit + MR Pmiss

Se pueden clasificar las técnicas para reducir el tiempo de acceso medio según el parámetro que reducen:

Reducción de Pmiss

Varios niveles de caché

Caché víctima

Buffer de escritura

Caché no bloqueable

Reducción de MR

Aumento del tamaño de línea

Precarga

Optimizaciones del compilador

Reducción de THIT

Caché pequeño y simple

Acceso encadenado.

88

Reducción Pmiss: varios niveles de caché

La memoria DRAM es lentísima hoy respecto a CPU: tendría Pmiss altísimo.

Interesa thit chico: L1 rápida y pequeña (thit es proporcional al tamaño de caché).

Interesa MR chico: L1 no tan pequeña (MR es invers. proporcional al tamaño de caché).

Solución: otros L2, L3 cuyo tamaño crece progresivamente + ponderar tam L1

L2, L3 son caros (SRAM)

Pmiss,L1 = thit,L2 crece con tamaño.

Tiempo de acceso medio complicado:

Tacc= thit,L1 + MR,L1 Pmiss,L1= thit,L1 + MR,L1 (thit,L2 + MR,L2 Pmiss,L2)

MR,L2 es MR “local”: suele ser alto (L1 se lleva la “crema” de los accesos locales)

Interesa mayor asociatividad de L2 y otras complejidades (sólo afecta a Pmiss,L1 y no a thit,L1)

Ley empírica: tam (Lj) >= 4*tam(Lj-1)

Suele implementarse inclusión de L1 en L2.

Por simplicidad interesa tam_línea (L1)= tam_línea (L2)

Si L1 es WT L2 es CB.

89

Reducción Pmiss: buffer de escritura

Lecturas pueden bloquear la CPU; escrituras, no.

Almacenar escrituras en buffer (de WT o CB), que bajan al siguiente nivel cuando bus está libre.

Necesito: comparador de direcciones del buffer con la dirección de cualquier lectura.

Interesa generalmente que el buffer se pueda organizar por bloques: si p ej 3 escrituras caen en la misma línea, se hace un acceso de bloque completo (mejor que 3 accesos)

90

Reducción Pmiss: uso de caché víctima

Unas pocas de líneas totalmente asociativas por si existen muchos conflictos en un conjunto.

Interesante: caché mapeado directo con caché víctimas de más de 4 líneas: absorbe más del 25% de los fallos.

91

thit

thit+PMiss

Caché normal

Tiempo total

thit

thit

thit

Accesos

thit

thit+PMiss

Caché no bloqueable

Tiempo total

thit

thit

thit

Accesos

Reducción Pmiss: uso de caché no bloqueable

Procesadores simples se bloquean completamente ante fallo.

Procesador moderno intenta seguir ejecutando otras instrucciones (se verá en tema 3): interesa que caché siga sirviendo otros datos mientras se trae la línea del fallo.

En paralelo hace ambas cosas. Pmiss se “oculta”. Tiempos no son aditivos.

La fórmula Tacc = thit + MR Pmiss no sirve aquí, pues el verdadero tiempo que se pierde en un fallo, depende de los accesos que se hayan podido paralelizar

En general Pmiss,L1 se puede ocultar bastante (del 30-50%) si se acierta en L2, pero los fallos de L2 no son fáciles de ocultar (muchos ciclos sin que llegue el dato necesario).

92

Técnicas de reducción del MR

Modelo regla de las 3 C (4 C para multiprocesadores)

Forzoso (“Compulsory”): fallos forzosos o inaugurales. Supongo caché infinito.

Sólo se reducen aumentando tamaño línea. Pero aumenta Pmiss.

Capacidad. Supongo completamente asociativo.

Sólo se reducen aumentando tamaño caché: da idea del tamaño (L2).

Conflicto. Fallos de colisión.

Se reducen aumentando asociatividad. Pero aumenta thit.

93

Técnicas de reducción del MR (II)

94

Reducción del MR: aumento del tamaño de línea

Reduce fallos forzosos (aprovecha más la loc. espacial).

Pero aumenta PMiss. Cuidado: producto MR * PMiss

Además pocas líneas: mucho MR

Ejemplo: páginas de 4KB o más porque latencia disco es alta y Ancho de Banda (AB) también.

PMiss

Latencia

16 32 64 128 256 Tam línea

95

Reducción del MR: precarga hard. de instrucciones y datos

Instrucciones: además de traerse una línea se guarda la siguiente en un buffer (traza bastante secuencial). Si el buffer tiene varias líneas guardadas, éste captura en torno a la mitad de los fallos.

Datos: accesos más dispersos: buffer mayor tamaño. Se calcula la zancada (distancia entre dos fallos) y se busca la línea distanciada tal zancada. “Patrón de accesos”. “Smart caché” en Pentium 4, L2.

Funciona bien si el patrón de accesos es simple.

96

Reducción del MR: precarga soft del compilador

Añadir una instrucción que sólo sirve para cargar un dato antes de usarlo.

for (j=0; j<1000 ; j++) a[i][j]= b[i][j] + c[j][i];

//c[][] se accede por columnas: mala localidad

//a[][] y b[][] se accede por filas: buena localidad

Se podría escribir así, sup. que un acceso a L2 dura 10 iteraciones (estimarlo):

for (j=0; j<1000 ; j++) {

prefetch(c[j+10][i]);

a[i][j]= b[i][j] + c[j][i];

} //no se contempla los fallos de primeras iteraciones

// ni las precargas inútiles de las últimas iter.

//Peligro: muchas instr. Prefecth añadidas más tiempo.

//EJERCICIO: escribir código para evitar los 3 comentarios //

anteriores

Punteros: más difícil calcular los prefetch, pero también se evitan muchos fallos.

Prefetch usual: se prohíbe que provoque un fallo de página.

97

Reducción del MR: optimizaciones del compilador

Aumentar la localidad de los accesos a instrucciones: Reordenar/reubicar código para evitar conflicto entre procedimientos que se

usan a la vez.

Alinear para que las instrucciones de arranque (tras un salto) sean las primeras de una línea.

Resultados: se puede conseguir que un caché de instrucciones de mapeado directo tenga menos MR que uno de 8 vías

Aumentar la localidad de los accesos a datos. Ordenación de: Recorrido por filas / columnas de matrices

Estructura de vectores (SOA) suele ser mejor que vectores de estructuras (AOS)

Normalmente solo se usa un campo, pero… CONTRAEJEMPLO: struct {char a[8192]; char b[8192] char c[8192]; } s;

for (i=0; i<8192 ; i++) s.a[i]= s.b[i] + s.c[i];

struct {char a; char b; char c; } s[8192];

for (i=0; i<8192 ; i++) s[i].a= s[i].b+ s[i].c

98

Reducción del MR: optimizaciones del compilador

Para matrices grandes trabajar por bloques de tamaño menor o igual que caché: ejemplos: filtros de imágenes, producto de matrices (el código de más abajo...)

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

for (jj=0; jj<N; jj+=bb)

for (kk=0; kk<N; kk+=bb)

for (i=0; i<N; i++)

for (j=jj; j<jj+bb; j++)

for (k=kk; k<kk+bb; k++)

D[i][j] = D[i][j] + A[i][k] * B[k][j];

// bb*bb es el tamaño del bloque. Sup. N es múltiplo de bb

= *

99

Técnicas que reducen THIT

Caché de primer nivel pequeño y simple:

Electrónica: cuanto más pequeño: más rápido.

Crítico: la frecuencia del procesador suele venir determinada por thit. Un aumento de thit puede afectar a toda la CPU.

Aunque tenga más MR, un caché L1 menor y más simple (mapeado directo) posibilita más frecuencia de la CPU: simulación SPICE 20-50% más rápidos que el de dos vías.

El tamaño de L1 no ha crecido en los últimos 10 años (en Pentium 4 ha disminuido): caché 8KB puede ser (simulación SPICE) 30% más rápido que uno de 16 KB y 60% más que de 32KB.

Para L2 no es tan crítico, pero interesa L2 dentro del chip.

Acceso al caché segmentado o encadenado:

Barrera del acceso a memoria: acceso a cachés cada vez más ciclos CPU.

Permitir ejecutar accesos en cadena. Varios accesos simultáneos

T3 T2 T1

Resto de la instrucción (varios ciclos)

Acceso al caché de instrucciones (tb. se hace para datos)

T3 T2 T1

Resto de la instrucción (varios ciclos)

T3 T2 T1

Resto de la instrucción (varios ciclos)

La latencia es la misma o mayor (se incrementa el AB)