Arquitectura: implementación segmentada · Arquitectura: implementación segmentada 95.57/75.03...

Arquitectura: implementación segmentada95.57/75.03 Organización del computador

Docentes: Patricio Moreno1.er cuatrimestre de 2021Última modificación: Mon May 10 14:33:30 2021 -0300

Facultad de Ingeniería (UBA)

Organización del computador Facultad de Ingeniería (UBA)

Créditos

Para armar las presentaciones del curso nos basamos en:R. E. Bryant and D. R. O’Hallaron, Computer systems: aprogrammer’s perspective, Third edition, Global edition.Boston Columbus Hoboken Indianapolis New York SanFrancisco Cape Town: Pearson, 2015.D. A. Patterson and J. L. Hennessy, Computer organiza-tion and design: the hardware/software interface, RISC-V edition. Cambridge, Massachusetts: Morgan KaufmannPublishers, an imprint of Elsevier, 2017.J. L. Hennessy and D. A. Patterson, Computer architec-ture: a quantitative approach. 2017.

1


Tabla de contenidos

1. Principios generales de la segmentación

2. Operación

3. Limitaciones

4. Riesgos del pipeline

5. Y86-64: implementación segmentada

2


Tabla de contenidos


2. Operación

3. Limitaciones



3


Segmentación: lavado de autos

Secuencial Paralelo

Segmentado

Idea:• Dividir el proceso en etapas

independientes• Mover objetos a través de las

etapas• En todo momento, múltiples

objetos se están procesando

4


Ejemplo con lógica computacional

LógicaCombinacional

REG

clock

Delay = 320 psThroughput = 3.12 GIPS

300 ps 20 ps

Sistema

• El resultado se obtiene en 300 picosegundos• Requiere 20 ps más para guardar el resultado en el registro• Necesita un ciclo de clock mínimo de 320 ps

5


Ejemplo con lógica computacional

LógicaComb.

A

REG

LógicaComb.

B

REG

LógicaComb.

C

REG

clock


100 ps 20 ps 100 ps 20 ps 100 ps 20 ps

Sistema

• Divide la lógica combinacional en 3 bloques de 100 ps cada uno• Puede comenzar una nueva operación cuando la anterior supera la

etapa A• Puede empezar una operación cada 120 ps

• Aumenta la latencia total• 360 ps desde el inicio hasta el final (vs. 320 ps)

6


Tabla de contenidos


2. Operación

3. Limitaciones



7


Diagramas de segmentación

Sin segmentar

I1I2I3

Tiempo• No puede comenzar una nueva operación hasta completar la anterior

Segmentado (3-stage pipelined)

I1I2I3

A B CA B C

A B CTiempo

• Hasta 3 operaciones procesándose en simultáneo

8


Operación a través del pipeline

Clock

I1 A B CI2 A B CI3 A B C

0 120 240Tiempo

360 480 600

230

LógicaComb.

A

100 ps

Reg

20 ps

LógicaComb.

B

100 ps

Reg

20 ps

LógicaComb.

C

100 ps

Reg

20 ps

clock9



Clock


0 120 240Tiempo

360 480 600

250

LógicaComb.

A

Reg

LógicaComb.

B

Reg

LógicaComb.

C

Reg

100 ps 100 ps 100 ps20 ps 20 ps 20 ps

clock9



Clock


0 120 240Tiempo

360 480 600

298

LógicaComb.

A

Reg

LógicaComb.

B

Reg

LógicaComb.

C

Reg

100 ps 100 ps 100 ps20 ps 20 ps 20 ps

clock9



Clock


0 120 240Tiempo

360 480 600

350

LógicaComb.

A

Reg

LógicaComb.

B

Reg

LógicaComb.

C

Reg

100 ps 100 ps 100 ps20 ps 20 ps 20 ps

clock9


Tabla de contenidos


2. Operación

3. Limitaciones



10


Limitaciones: delays no uniformes

AReg

50 ps 20 ps

BReg

150 ps 20 ps

CReg

100 ps 20 ps


clockI1 A B CI2 A B CI3 A B C

0 120 240Tiempo

360 480 600

• El throughput es limitado por la etapa más lenta• Las demás etapas permanecen ociosas• Desafío: segmentar el sistema en etapas balanceadas

11


Limitaciones: overhead de los registros

LógicaComb.

A

REG

LógicaComb.

B

REG

LógicaComb.

C

REG

LógicaComb.

D

REG

LógicaComb.

E

REG

LógicaComb.

F

REG

clock

50 ps 20 ps 50 ps 20 ps 50 ps 20 ps 50 ps 20 ps 50 ps 20 ps 50 ps 20 ps

Delay = 420 ps, Throughput = 14.29 GIPS

• Cuanto más se segmenta, más pesa la carga de los registros• Porcentaje del ciclo de clock utilizado en cargar los registros:

• 1-stage pipeline: 6,25%• 3-stage pipeline: 16,67%• 6-stage pipeline: 28,57%

12


Ejercicio 4.28

80 ps 30 ps 60 ps 50 ps 70 ps 10 ps

A E FCB D

20 ps

Clock

Reg

• 2-stage pipeline ¿throughput? ¿latencia?• 3-stage pipeline ¿throughput? ¿latencia?• 4-stage pipeline ¿throughput? ¿latencia?• ¿cuál es la mejor segmentación? ¿throughput? ¿latencia?

13


Ejercicio 4.29

Comb.logic

Comb.logic

Comb.logic

Comb.logic

Comb.logic

Comb.logic

50 ps

Reg

50 ps20 ps 20 ps 20 ps 20 ps 20 ps 20 ps50 ps

Reg

50 ps

Delay = 420 ps, throughput = 14.29 GIPSClock

Reg

50 ps

Reg

50 ps

Reg

Reg

• k-stage pipeline ¿throughput? ¿latencia?• ¿límites?

14


Tabla de contenidos


2. Operación

3. Limitaciones



15


Riesgos de segmentación

Riesgos estructurales surgen de conflictos de los recursos, cuando elhardware no puede soportar todas las combinacionesposibles de instrucciones en ejecuciones solapadassimultáneamente.

Riesgos por dependencia de datos surgen cuando una instruccióndepende de los resultados de una instrucción anterior, deforma que, ambas, podrían llegar a ejecutarse de formasolapada.

Riesgos de control (de saltos) surgen de la segmentación de los saltosy otras instrucciones que cambian el PC.

16


Dependencia de datos

LógicaCombinacional

REG

clock

OP1OP2OP3

Tiempo

Sistema

• Cada operación depende del resultado de una operación anterior

17


Riesgos de la dependencia de datos

LógicaComb.

A

REG

LógicaComb.

B

REG

LógicaComb.

C

REG

clock

OP1OP2OP3OP4

A B CA B C

A B CA B C

Tiempo

• El resultado no se realimenta a tiempo• La segmentación cambió el comportamiento del sistema

18


Dependencias en los procesadores

1 irmovq $50, %rax2 addq %rax, %rbx3 mrmovq 100(%rbx), %rdx

• El resultado de una operación se usa como operando en la siguiente• dependencia Read-After-Write (RAW)

• Muy común (típico)• Hay que mejarlas bien

• Obtener el resultado correcto• Minimizar el impacto en el desempeño

19


Dependencias en los procesadores

1 loop:2 subq %rdx, %rbx3 jne targ4 irmovq $10, %rdx5 jmp loop6 targ:7 halt

• La siguiente instrucción a ejecutar depende del resultado de la actual

• dependencia en el control

20


Tabla de contenidos


2. Operación

3. Limitaciones



21


SEQ Hardware

Stat

PC update

Memory

Execute

Decode

Fetch

newPC

New PC

data outdmem_error

read

write

Datamemory

Addr Data

Mem.control

Cnd valE

valM

Stat

CC ALUALUfun.

ALUA

ALUB

valA valB dstE dstM srcA srcB

dstE dstM srcA srcB

Registerfile

Write back

A B

E

M

icodeinstr_valid

imem_errorifun rA rB valC valP

PCincrement

Instructionmemory

PC

• Las etapas se ejecutansecuencialmente

• Se procesa de a una operaciónpor vez

22


SEQ+ Hardware

Memory

Execute

Decode

Fetch

PC

valMdata out

read

write

Datamemory

Addr Data

Mem.control

Cnd valE

CC ALUALUfun.

ALUA

ALUB

valA valB dstE dstM srcA srcB

dstE dstM srcA srcB

Registerfile

Write back

A B

E

M

icode ifun rA rB valC valP

PCincrement

Instructionmemory

PC

PC

plcode pValCpValMpCnd pValP

Statdmem_error

Stat

instr_valid

imem_error

• sigue siendo secuencial• la etapa del PC es, ahora, la

primeraEtapa del PC• Debe seleccionar el valor de PC

para la instrucción actual• Se basa en los resultados de la

instrucción anteriorEstado del procesador• El PC ya no está en un registro

• Se lo determina en base ainformación almacenada

23


Pipeline registers

24


Etapas segmentadas

Fetch• Seleccionar el PC actual• Leer instrucción• Calcular el PC incrementado

Decode• Leer registros

Execute• Usar la ALU

Memory• Leer/escribir datos de/en la

memoriaWrite-Back• Actualizar registros

25


PIPE− Hardware Stat

Stat

valA

Stat

Stat

Writeback

W icode valE valM dstE dstM

ALUA

ALUB

ALUfun.

M icode Cnd valE valA dstE dstM

E icode ifun valC valA valB dstM srcA srcBdstE

D icodestat

stat

stat

ifun valC valPrBrA

F predPC

data out

data in

M_Cnd

e_Cnd

Memory

ALU

Execute

dstE dstM srcA srcBSelectA

PredictPC

SelectPC

d_srcAd_rvalA

d_srcB

W_valM

M_valA

W_valE

M_valAf_pc

f_stat

D_stat

E_stat

M_stat

m_stat

W_stat

imem_errorinstr_valid

W_valM

CC

Decode

Fetch

readdmem_error

write

Addr

Mem.control

Registerfile

A B

E

M

PCincrement

Instructionmemory

dstE

Datamemory

stat• Los registros de segmentación(pipeline register) guardanvalores intermedios

• Las instrucciones avanzan ensentido ascendente en el dibujo

Nombres de las señalesS_field valor del campo

almacenado en elregistro desegmentación en laetapa S

s_field valor del campocalculado en la etapaS

26


Realimentación Stat

Stat

valA

Stat

Stat

Writeback


ALUA

ALUB

ALUfun.



D icodestat

stat

stat

ifun valC valPrBrA

F predPC

data out

data in

M_Cnd

e_Cnd

Memory

ALU

Execute


PredictPC

SelectPC

d_srcAd_rvalA

d_srcB

W_valM

M_valA

W_valE

M_valAf_pc

f_stat

D_stat

E_stat

M_stat

m_stat

W_stat


W_valM

CC

Decode

Fetch

readdmem_error

write

Addr

Mem.control

Registerfile

A B

E

M

PCincrement

Instructionmemory

dstE

Datamemory

stat

Predicted PC• Valor supuesto para el siguiente

PCInformación de saltos• Salto tomando o no• Fall-through o dirección destino

Punto de retorno• Leer de memoria

Actualización de registros• A los puertos de entrada del

archivo de registros

27


Predicción del PC

• Comenzar la lectura dela siguiente instrucciónuna vez que termina laetapa fetch de la actual• No se puede

determinar a cienciacierta la siguienteinstrucción

• Adivinar qué instrucciónva a seguir• Y recuperarse

correctamente si lapredicción fueincorrecta

NeedvalC

Needregids

PredictPC

SelectPC

PCincrement

Align

Bytes 1–9

f_pc

Byte 0

imem_errorInstructionmemory

Split

Instrvalid

D icodestat ifun valC valPrBrA

F predPC

M_icode

M_Cnd

M_valA

W_icodeW_valM

icode

Stat

ifun

28


Estrategia

Instrucciones que no hacen transferencia de control

• Predicción: el siguiente PC es el valor de valP• No falla

Call y saltos incondicionales

• Predicción: el siguiente PC es el valor de valC• Siempre es fiable

Saltos condicionales

• Predicción: el siguiente PC es el valor de valC• Sólo es correcto si se realiza el salto (se cambia de rama)

• Típicamente es correcto el 60 % de las veces (hay mejoresestrategias)

Instrucción de retorno (ret)

• No intentar predecir29


Fallas en la predicción

• Salto incorrecto• El flag que indica si se debía realizar el salto se obtiene cuando la

instrucción llega a la etapa de memoria• Se puede obtener el valor correcto del PC (la dirección correcta

donde saltar) del valor de valA (M_valA en la versión segmentada)

• Instrucción de retorno (ret)• No hubo predicción• El valor de retorno del PC se obtiene cuando la instrucción ret llega

a la etapa de memoria

30


Resumen de PIPE−

Concepto

• Separar la ejecución de la instrucción en etapas (5 en este caso)• Ejecutar las instrucciones en pipeline

Limitaciones

• No opera correctamente cuando hay dependencia entre instruccionesque se hallan muy cercanas

• Dependencia de datos• Una instrucción escribe en un registro, luego otra instrucción lo lee

(Read-After-Write, RAW)

• Dependencia en el control• Una instrucción establece el PC de forma que la pipeline no predice

correctamente• Predicción incorrecta de una rama y retorno de la instrucción

31


Implementación PIPE

Riesgos de datos

• Una instrucción que tiene al registro R como destino es seguida poruna instrucción que tiene al registro R como origen.

• Es una condición común• No queremos reducir el throughput de instrucciones

Riesgos de control (de saltos)

• Predicción incorrecta de un salto condicional• Predice que siempre se salta• Siempre se ejecutan 2 instrucciones de más

• Obtención de la dirección de retorno para la instrucción ret• Siempre se ejecutan 3 instrucciones de más

32


Pipeline stages

Fetch• Seleccionar el PC actual• Leer instrucción• Calcular el PC incrementado

Decode• Leer registros

Execute• Usar la ALU

Memory• Leer/escribir datos de/en la

memoriaWrite-Back• Actualizar registros

33


PIPE− Hardware Stat

Stat

valA

Stat

Stat

Writeback


ALUA

ALUB

ALUfun.



D icodestat

stat

stat

ifun valC valPrBrA

F predPC

data out

data in

M_Cnd

e_Cnd

Memory

ALU

Execute


PredictPC

SelectPC

d_srcAd_rvalA

d_srcB

W_valM

M_valA

W_valE

M_valAf_pc

f_stat

D_stat

E_stat

M_stat

m_stat

W_stat


W_valM

CC

Decode

Fetch

readdmem_error

write

Addr

Mem.control

Registerfile

A B

E

M

PCincrement

Instructionmemory

dstE

Datamemory

stat• Los registros de segmentación(pipeline register) guardanvalores intermedios

• Las instrucciones avanzan ensentido ascendente en el dibujo

• Los valores se pasan de unaetapa a la siguiente

• No se pueden saltear etapas• Por ejemplo, valC no se

necesita en la etapa decodepero dicho valor se almacenaen el registro, no pasadirectamente a la etapaexecute

34


Dependencia de datos: 3 nops

F D E M WF D E M W

F D E M WF D E M W

F D E M WF D E M W

F D E M W

Cycle 6

Cycle 7

1 2 3 4 5 6 7 8 9 10 11

W

D

R[%rax] 3

valA R[%rdx] = 10valB R[%rax] = 3

0x000: irmovq $10, %rdx0x00a: irmovq $3, %rax0x014: nop0x015: nop0x016: nop0x017: addq %rdx, %rax0x019: halt

#prog1

35



D

D E M WF D E M W

F D E M WF D E M W

F D E M WF D E M W

Cycle 6

1 2 3 4 5 6 7 8 9 10

W

Error

. . .

0x000: irmovq $10, %rdx0x00a: irmovq $3, %rax0x014: nop0x015: nop0x016: addq %rdx, %rax0x018: halt

#prog2

R[%rax] 3


F

36



M

D

F D E M WF D E M W

F D E M WF D E M W

F D E M W

Cycle 5

1 2 3 4 5 6 7 8 9

W

Error

. . .

0x000: irmovq $10, %rdx0x00a: irmovq $3, %rax0x014: nop0x015: addq %rdx, %rax0x017: halt

#prog3

R[%rdx] 10


M_valE = 3M_dstE = %rax

37



D

F D E M WF D E M W

F D E M WF D E M W

Cycle 4

1 2 3 4 5 6 7 8

M

E

Error

0x000: irmovq $10, %rdx0x00a: irmovq $3, %rax0x014: addq %rdx, %rax0x016: halt

#prog4

e_valE 0 + 3 = 3E_dstE = %rax


M_valE = 10M_dstE = %rdx

38


Dependencia de datos: inserción de burbujas

F D E M WF D E M W

E M WE M W

E M WDDFFF

D D E WMF F D E WM

1 2 3 4 5 6 7 8 9 10 11

0x000: irmovq $10, %rdx#prog4

0x00a: irmovq $3, %rax

0x014: addq %rdx, %rax0x016: halt

bubble bubble

bubble

• Si una instrucción genera un riesgo de datos, se la demora un poco• Al frenarla, se la mantiene en la etapa decode

• Dinámicamente se insertan instrucciones nop a la etapa de ejecución

39


Condiciones de demora (stall) Stat

Stat

valA

Stat

Stat

Writeback


ALUA

ALUB

ALUfun.



D icodestat

stat

stat

ifun valC valPrBrA

F predPC

data out

data in

M_Cnd

e_Cnd

Memory

ALU

Execute


PredictPC

SelectPC

d_srcAd_rvalA

d_srcB

W_valM

M_valA

W_valE

M_valAf_pc

f_stat

D_stat

E_stat

M_stat

m_stat

W_stat


W_valM

CC

Decode

Fetch

readdmem_error

write

Addr

Mem.control

Registerfile

A B

E

M

PCincrement

Instructionmemory

dstE

Datamemory

stat dstE dstM

dstE dstM

dstE

dstM

• Registro de origen• srcA y srcB de la instrucción

en la etapa decode

• Registro de destino• Campos dstE y dstM• Instrucciones en las etapas

execute, memory, ywrite-back

• Caso especial• No realizar ninguna demora

para el registro 15 (0xF)

40


Detección de la condición de demora

F D E M WF D E M W

F D E M WF D E M W

E M WF D D E WM

F F D E WM

1 2 3 4 5 6 7 8 9 10 11#prog20x000: irmovq $10, %rdx0x00a: irmovq $3, %rax0x014: nop0x015: nop


bubble

W

. . .

W_dstE =W_valE = 3

%rax

D

%raxsrcA = %rdxsrcB =

41


Detección de la condición de demora

F D E M WF D E M W

E M WE M W

E M WDDFFF

D D E WMF F D E WM

1 2 3 4 5 6 7 8 9 10 11

0x000: irmovq $10, %rdx#prog4

0x00a: irmovq $3, %rax


bubble bubble

bubble

W

W_dstE =

Ciclo 6

%rax

M

M_dstE =

Ciclo 5

%rax

E

e_dstE =

Ciclo 4

%rax

D


···D


D


···

42


¿Qué ocurre al retener las instrucciones?

# prog4.ys0x000: irmovq $10, %rdx0x00a: irmovq $3, %rax0x014: addq %rdx, %rax0x016: halt

Ciclo 4Write-Back

Memory 0x000: irmovq $10, %rdxExecute 0x00a: irmovq $3, %raxDecode 0x014: addq %rdx, %rax

Fetch 0x016: halt

• La instrucción demorada se retiene en la etapa decode• La siguiente instrucción se mantiene en la etapa fetch• Se inyectan burbujas en la etapa execute

• Como nops generados dinámicamente• Los nop se propagan a través de las siguientes etapas

43




Ciclo 5Write-Back 0x000: irmovq $10, %rdx

Memory 0x00a: irmovq $3, %raxExecute burbujaDecode 0x014: addq %rdx, %rax

Fetch 0x016: halt



44




Ciclo 6Write-Back 0x00a: irmovq $3, %rax

Memory burbujaExecute burbujaDecode 0x014: addq %rdx, %rax

Fetch 0x016: halt



45




Ciclo 7Write-Back burbuja

Memory burbujaExecute burbujaDecode 0x014: addq %rdx, %rax

Fetch 0x016: halt



46





Memory burbujaExecute 0x014: addq %rdx, %raxDecode 0x016: halt

Fetch



47





Memory 0x014: addq %rdx, %raxExecute 0x016: haltDecode

Fetch



48




Ciclo 10Write-Back 0x014: addq %rdx, %rax

Memory 0x016: haltExecuteDecode

Fetch



49




Ciclo 11Write-Back 0x016: halt

MemoryExecuteDecode

Fetch



50


Implementación de la rentención

F

CC

W icode valE valM dstEstat

stat

stat

stat

dstM



D icode ifun valC valPrBrA

F predPC

srcAsrcB

Stat

Pipelinecontrollogic

M_icode

W_stat

e_Cnd

m_stat

E_dstM

d_srcBd_srcA

D_icode

E_icode

E_bubble

set_cc

W_stall

M_bubble

D_bubbleD_stall

F_stall

Lógica de Control

• La lógica de control detecta la condición de demora• Estable las señales indicando a los registros cómo se deben actualizar

51


Modos de actualización de los registros de pipeline

x y

x

xnop

x

State = x State = y

Input = y

stall= 0

bubble= 0

Output = x Output = yRisingclock

State = x State = x

Input = y

stall= 1

bubble= 0

Output = x Output = xRisingclock

State = x State = nop

Input = y

stall= 0

bubble= 1

Output = x Output = nopRisingclockBurbuja

Retención

Normal

52


Envío de datos

Pipeline Naïve

• Los registros no se actualizan hasta el final de la etapa write-back• Los operandos origen leen del banco de registros en la etapa decode

• Es necesario que el valor esté guardado al comienzo de la etapa

Observación

• El valor es generado en la etapa execute o en la etapa memory

Solución

• Pasar el valor de la etapa de generación directamente a la etapadecode

• Es necesario que esté disponible al final de la etapa decode

53


Ejemplo de envío de datos

• irmovq en la etapa write-back• El valor de destino en el

registro W del pipeline• Enviar como valB hacia la

etapa decode

54


Caminos de envío

• Etapa decode• La lógica de reenvío

selecciona valA y valB• Típicamente del banco de

registros• Reenvío: obtiene valA o

valB de una etapa posteriordel pipeline

• Fuentes de reenvío• Execute: valE• Memory: valE, valM• Write back: valE, valM

55


Ejemplo 2 de envío de datos

Registro %rdx• La ALU genera el valor en el

ciclo anterior• Enviado desde la etapa memory

como valA

Registro %rax• Su valor fue recién generado

por la ALU• Se envía desde la etapa execute

como valB

56


Prioridad de envío

Opciones al tener múltiplesorígenes• ¿Cuál debería tener prioridad

sobre las demás?• Usar el valor de la etapa más

cercana

57


Implementación del reenvío de operandos

• Agrega circuitos derealimentación desde losregistros de pipeline E, M, y Wa la etapa decode

• Agrega lógica de control paraseleccionar entre múltiplesopciones los valores para valAy valB

58


Implementación del reenvío de operandos

1 ## ¿Cuál debebería ser el valor de A?2 int d_valA = [3 # Use incremented PC4 D_icode in { ICALL, IJXX } : D_valP;5 # Forward valE from execute6 d_srcA == e_dstE : e_valE;7 # Forward valM from memory8 d_srcA == M_dstM : m_valM;9 # Forward valE from memory

10 d_srcA == M_dstE : M_valE;11 # Forward valM from write back12 d_srcA == W_dstM : W_valM;13 # Forward valE from write back14 d_srcA == W_dstE : W_valE;15 # Use value read from register file16 1 : d_rvalA;17 ];

59


Limitaciones de la realimentación

Dependencia Load/Use(Carga/Uso)• Requiere un valor al final de la

etapa decode en el ciclo 7• El valor es leído de la memoria

en la etapa memory en el ciclo 8

60


¿Cómo se evita el riesgo de carga/uso?

• Frena la instrucción en uso porun ciclo

• Luego puede tomar el valorcargado realimentando de laetapa memory

61


Detección del riesgo de carga/uso

Evento CondiciónRiesgo Load/Use E_icode in {IMRMOVQ, IPOPQ } && E_dstM

in {d_srcA, d_srcB}

62


Control del riesgo de carga/uso

• Frenar las instrucciones en las etapas fetch y decode

• Inyectar una burbuja en la etapa execute

Evento F D E M WRiesgo Load/Use stall stall burbuja normal normal

63


Ejemplo: error en la predicción

# prog70x000: xorq %rax,%rax0x002: jne target # No debería saltar0x00b: irmovq $1, %rax # Fall through0x015: halt0x016: target:0x016: irmovq $2, %rdx # No debe ejecutarse0x020: irmovq $3, %rbx # No debe ejecutarse0x02a: halt

• Sólo debe ejecutar las primeras 4 instrucciones (¿por qué?)• Con predictor “salta siempre” ¿qué hace?

64


Procesamiento de errores de predicción

# prog70x000: xorq %rax, %rax0x002: jne target0x016: irmovq $2, %rdx # target

burbuja0x020: irmovq $3, %rbx # target + 1

burbuja0x00b: irmovq $1, %rax # fall through0x015: halt

1 2 3 4 5 6 7 8 9 10F D E M W

F D E M WF D

E M WF

D E M WF D E M W

F D E M W

Se predice que la rama se toma (o no)

• La unidad de generación de instrucciones tomará 2 instrucciones.

Cancelar al fallar en la predicción

• Se detecta el error en la etapa de ejecución• Reemplazar las instrucciones de las etapas execute y decode por burbujas• Las instrucciones reemplazadas no generaron cambios en el estado del pipeline

65


Control de errores de predicción

# prog70x000: xorq %rax, %rax0x002: jne target0x016: irmovq $2, %rdx # target

burbuja0x020: irmovq $3, %rbx # target + 1

burbuja0x00b: irmovq $1, %rax # fall through0x015: halt

1 2 3 4 5 6 7 8 9 10F D E M W

F D E M WF D

E M WF

D E M WF D E M W

F D E M W

Evento F D E M WError de predicción normal burbuja burbuja normal normal

66


Ejemplo: return

0x000: irmovq stack,%rsp # Inicializar SP0x00a: call proc # Call0x013: irmovq $10,%rdx # Punto de retorno0x01d: halt0x020: .pos 0x200x020: proc: # proc:0x020: ret # Retorno imediato0x021: rrmovq %rdx,%rbx # No ejecutar0x030: .pos 0x300x030: stack: # stack: Stack pointer

67


Procesamiento del return

# prog60x000: irmovq stack, %rsp0x00a: call proc0x020: ret0x021: rrmovq %rdx, %rbx

burbuja0x021: rrmovq %rdx, %rbx


burbuja0x00b: irmovq $10, %rdx

1 2 3 4 5 6 7 8 9 10 11F D E M W

F D E M WF D E M W

FD E M WF

D E M WF

D E M WF D E M W

• Mientras ret pasa por el pipeline, la etapa fetch se mantiene parada

• Se insertan burbujas en la etapa decode

• Se continúa con la ejecución cuando ret llega a la etapa de escritura

68


Control del return

# prog60x000: irmovq stack, %rsp0x00a: call proc0x020: ret0x021: rrmovq %rdx, %rbx



burbuja0x00b: irmovq $10, %rdx

1 2 3 4 5 6 7 8 9 10 11F D E M W

F D E M WF D E M W

FD E M WF

D E M WF

D E M WF D E M W

Evento F D E M WDetección del return stall burbuja normal normal normal

69


Licencia del estilo de beamer

Obtén el código de este estilo y la presentación demo en

github.com/pamoreno/mtheme

El estilo en sí está licenciado bajo la Creative CommonsAttribution-ShareAlike 4.0 International License. El estilo es unamodificación del creado por Matthias Vogelgesang, disponible en

github.com/matze/mtheme

cba

70

github.com/pamoreno/mtheme

http://creativecommons.org/licenses/by-sa/4.0/

http://creativecommons.org/licenses/by-sa/4.0/

github.com/matze/mtheme

Arquitectura: implementación segmentada · Arquitectura: implementación segmentada 95.57/75.03...

Documents

Transcript of Arquitectura: implementación segmentada · Arquitectura: implementación segmentada 95.57/75.03...