Segmentación de instrucciones

(1)

1 1 7HPD6HJPHQWDFLyQGH,QVWUXFFLRQHV •2EMHWLYRV •5HIHUHQFLDV •(WDSDVGHXQFDXFH •3DURQHV •HVWUXFWXUDOHV •SRUGHSHQGHQFLDGHGDWRV •SRUGHSHQGHQFLDGHFRQWURO •0RGLILFDFLyQGHXQFDXFHSDUDRSHUDFLRQHVPXOWLFLFOR •(MHPSORHO0,365 2

Segmentación de instrucciones Objetivos

2EMHWLYRV •&RQRFHUODVFDUDFWHUtVWLFDV\HOIXQFLRQDPLHQWRGHXQFDXFH GHLQVWUXFFLRQHVVLPSOH •&RPSUHQGHUODVGLILFXOWDGHVTXHVXUJHQDODKRUDGH VHJPHQWDUODHMHFXFLyQGHLQVWUXFFLRQHV •&RQRFHUDOJXQDVGHODVVROXFLRQHVTXHVHDSOLFDQSDUDUHVROYHU HVDVGLILFXOWDGHV

(2)

3

Segmentación de instrucciones Referencias

5HIHUHQFLDV

•Este tema está sacado de forma prácticamente íntegra del Hennessy-Patterson (la 2ª edición) (casi todas las figuras son de él)

•Para algunas transparencias se han usado como modelo las de Al Davis

•Como complemento se puede mirar el Kai Hwang

Segmentación de instrucciones Descripción de las etapas

(WDSDVGHOFDXFH •%~VTXHGD,)

se accede a memoria a por la instrucción se incrementa el CP

•'HFRGLILFDFLyQ%~VTXHGDGHRSHUDQGRV,'

se decodifica la instrucción

se accede al banco de registros a por los registros operandos se calcula el valor del operando inmediato con el signo extendido (por si hace falta más adelante)

•(MHFXFLyQ'LUHFFLyQHIHFWLYD(;

si es una instrucción de proceso, se ejecuta en la ALU si es un acceso a memoria, se calcula la dirección efectiva si es un salto, se calcula el destino, y si se toma o no

(3)

3

5

(WDSDVGHOFDXFHFRQW

•$FFHVRDPHPRULDWHUPLQDFLyQGHOVDOWR0(0

si es un acceso a memoria, se accede si es un salto, se almacena el nuevo CP •$OPDFHQDPLHQWR:%

se almacena el resultado (si lo hay) en el banco de registros

6

Segmentación de instrucciones Descripción de las etapas 0iTXLQDEiVLFD

(4)

7

(MHPSORGHHMHFXFLyQGHLQVWUXFFLRQHV &LFOR ,QVWL IF ID EX MM WB ,QVWL IF ID EX MM WB ,QVWL IF ID EX MM WB ,QVWL IF ID EX MM WB ,QVWL IF ID EX MM WB

(5)

5

9

9HQWDMDVGHODVHJPHQWDFLyQ •3ULQFLSDOPHQWHHOPHMRUUHQGLPLHQWR –JDQDQFLDHQUHQGLPLHQWR 1HWDSDVGHOFDXFH DUHORMFRQVWDQWH –SHUR£FXLGDGRVyORHVHOPi[LPRWHyULFR •(VFRPSOHWDPHQWH+DUGZDUH !PHMRUTXH6RIWZDUH •(OPRGHORGHSURJUDPDFLyQQRFDPELD –SHURYHUHPRVTXHDIHFWDDOSURJUDPDGRUVREUHWRGR DOFRPSLODGRU •3(52KD\TXHWHQHUHQFXHQWDTXHHOFRQWUROWDPELpQVH YXHOYHPiVFRPSOHMR 10

Segmentación de instrucciones Parones

3DURQHVVLWXDFLRQHVTXHLPSLGHQDODVLJXLHQWHLQVWUXFFLyQ TXHVHHMHFXWHHQHOFLFORTXHOHFRUUHVSRQGH

+D\WLSRV

(VWUXFWXUDOHV

provocados por conflictos por los recursos

3RUGHSHQGHQFLDGHGDWRVSDURQHV SRUGDWRV

ocurren cuando dos instrucciones se comunican por medio de un dato (ej.: una lo produce, y la otra lo usa)

3RUGHSHQGHQFLDGHFRQWUROSDURQHV SRUFRQWURO

ocurren cuando la ejecución de una instrucción depende de cómo se ejecute otra (ej.: un salto, y los dos posibles caminos)

(6)

11 &LFOR ,QVWL IF ID EX MM WB ,QVWL IF ID EX MM WB ,QVWL (parón) IF ID EX MM WB ,QVWL IF ID EX MM WB ,QVWL IF ID EX MM WB

6XSRQJDPRVXQSDUyQHQODLQVWUXFFLyQL

(IHFWRHOUHQGLPLHQWRGLVPLQX\HGHOPi[LPRWHyULFR

0i[LPRWHyULFR número de etapas del cauce &RQSDURQHV (CPI no seg / CPI seg) =

= (CPI no seg / (CPI ideal + Nº parones por instrucción)) = = (CPI no seg / (1 + Nº parones por instrucción)) =

= ( Nº etapas del cauce / (1 +Nº parones por instrucción)) (ganancia de rendimiento, a reloj constante)

(7)

7

13

Segmentación de instrucciones Parones Estructurales

(MHPSORXQDLQVWUXFFLyQGHFDUJDVHJXLGDGHRWUDV YDULDV/DPiTXLQDWLHQHXQ~QLFRSXHUWRGHPHPRULD

14

(IHFWRHOORDG_{\ODLQVWUXFFLyQWLHQHQXQFRQIOLFWRFRPSLWHQSRU} HOSXHUWRGHPHPRULD(OSDUyQHQHOFDXFH

(8)

15

3RVLEOHVOLPLWDFLRQHVHQORVUHFXUVRV !SDURQHVHVWUXFWXUDOHV •SXHUWRGHPHPRULDHQOXJDUGH !IHWFK DFFHVRPHP •$/8HQOXJDUGH !LQFUHPHQWR3& LQVWUXFFLyQGHSURFHVR •EDQFRGHUHJLVWURVFRQSRFRVSXHUWRV !OHFWXUD HVFULWXUD 6ROXFLyQDORVSDURQHVHVWUXFWXUDOHV DxDGLUPiVUHFXUVRV 3(52£ORGHVLHPSUHKD\TXHHQFRQWUDUXQHTXLOLEULR HQWUHUHQGLPLHQWR\FRVWH

Segmentación de instrucciones Parones por Datos

(9)

9

17

6ROXFLyQDGHODQWDPLHQWRGHUHVXOWDGRV E\SDVVLQJIRUZDUGLQJ •/DLQVWUXFFLyQTXHFDOFXODHOQXHYRYDORUGH5ORWLHQH OLVWRDOILQDOGHOFLFOR •/DLQVWUXFFLyQTXHOROHHHQUHDOLGDGQHFHVLWDTXHHVWp OLVWRDOSULQFLSLRGHOFLFOR •6HSXHGHPRGLILFDUOD$/8FRQXQDUHDOLPHQWDFLyQSDUDTXH HOQXHYRYDORUGH5YD\DGHODVDOLGDDODHQWUDGDDGHPiV VLJXHVLHQGRHQYLDGRDOEDQFRGHUHJLVWURVHQODIDVH:% 18

(10)

19

0iTXLQDPiVUHDOLVWD,,

2EVHUYDFLRQHVDODGHODQWDPLHQWRGHUHVXOWDGRV •6HGHEHQKDELOLWDUFDPLQRVGHUHDOLPHQWDFLyQGHWRGDVDWRGDV ODVXQLGDGHVSHMGHOD$/8DPHPRULDGHOD$/8DOD$/8HWF ODVGHSHQGHQFLDVVHGDQHQWUHLQVWUXFFLRQHVGHWRGRVORVWLSRV •+D\TXHWHQHUHQFXHQWDTXHHOFRQWUROVHFRPSOLFDD~QPiV KD\TXHGHFLGLUFXiQGRVHUHDOLPHQWDXQUHVXOWDGRFRQWURODU ODUHDOLPHQWDFLyQHWF •$~QDVtSXHGHQRVHUVXILFLHQWH SRUHMHPSORVLXQDLQVWUXFFLyQGHPHPRULDJHQHUDXQ GDWRSDUDXQDGH$/8 OZUU VXEUUU

(11)

11

21

22

&ODVLILFDFLyQGHODVGHSHQGHQFLDVGHGDWRV •/HFWXUDGHVSXpVGH(VFULWXUD/'(5$:

–la que hemos visto hasta ahora: una instrucción genera un dato que lee otra posterior

•(VFULWXUDGHVSXpVGH(VFULWXUD('(:$:

–una instrucción escribe un dato después que otra posterior –en una máquina segmentada simple sólo se da si se deja que las instrucciones se adelanten unas a otras

•(VFULWXUDGHVSXpVGH/HFWXUD('/:$5

–una instrucción modifica un valor antes de que otra anterior que lo tiene que leer, lo lea

(12)

23

(MHPSORV

/'( addU,r2,r3

add r4,U,4

('( lw U,0(r2)

add U,r2,r3

(si modificamos el cauce: un acceso a memoria son dos ciclos, y las instrucciones se pueden adelantar)

('/ sw U,0(r2)

addU,r3,r4

(también hacen falta modificaciones: r1 se lee al ir a escribir (2 ciclos), y las instrucciones se pueden adelantar)

$SURYHFKDPLHQWRGHOFDXFH UHRUGHQDFLyQGHLQVWUXFFLRQHV Se trata de calcular: a = b + c d = e - f g = a + d

(13)

13 25 lw rb,b lw UF,c add ra,rb,UF lw re,e lw UI,f sub rd,re,UI add rg,ra,rd sw rg,g lw rb,b lw rc,c OZUHH OZUGI add ra,rb,rc sub rd,re,rf add rg,ra,rd sw rg,g

&yGLJRLQLFLDO &yGLJRUHRUGHQDGR

26

(ILFDFLDGHODUHRUGHQDFLyQ 7H; 6SLFH JFF &RQ 6LQ 3RUFHQWDMHGHODVFDUJDVTXHSURYRFDQXQSDUyQ

(14)

27

Segmentación de instrucciones Parones por Control

+DVWDDKRUDHO&3VHDFWXDOL]DHQODIDVHGHE~VTXHGD

3HURVLHQHOFDXFHHQWUDXQVDOWRKD\GRVLQVWUXFFLRQHVTXH SXHGHQVHUODVLJXLHQWHTXHKD\TXHEXVFDU

la que está a continuación del salto la que es el destino del salto

352%/(0$QHFHVLWDPRVVDEHU\DFXiOHVODVLJXLHQWH LQVWUXFFLyQTXHYDPRVDPHWHUHQHOFDXFHSHUR

si es un salto condicional, aún no se sabe cuál de las dos es (se sabe en la fase EX)

en cualquier caso, el contador de programa incrementado se almacena en la fase (WB)

(VWRVyORVHUtDLPSRUWDQWHVLHOSRUFHQWDMHGHVDOWRVWRPDGRV RQRTXHDSDUHFHQHQHOFyGLJRHVVLJQLILFDWLYR co m p eq nt es pr _gcc li do du c ea r hy dr o m dl j 2c or FRQG KDFLD GHODQWH FRQG KDFLDDWUiV LQFRQG 3RUFHQWDMHGHLQVWUXFFLRQHVTXHVRQVDOWRV

(15)

15

29

(QSURPHGLRSDUDHQWHURV

GHLQVWUXFFLRQHVVRQVDOWRVFRQGLFLRQDOHVKDFLDGHODQWH GHLQVWUXFFLRQHVVRQVDOWRVFRQGLFLRQDOHVKDFLDDWUiV VRQVDOWRVLQFRQGLFLRQDOHV

Todo esto depende de las optimizaciones que use el compilador, pero como orientación sirve.

5HVXPLHQGRGHFDGDLQVWUXFFLRQHVHVXQVDOWR

&RQFOXVLyQVtKD\TXHWHQHUORVHQFXHQWD

30

¢4XpVHSXHGHKDFHU"

3ODQ$HQFXDQWRYHDPRVTXHXQDLQVWUXFFLyQHVXQ VDOWRSDUDPRVHOFDXFHKDVWDTXHVHSDPRVDGyQGHVDOWD

Sabemos si es un salto en la fase ID;

Conocemos el destino en MEM (usando realimentación) Total: 3 ciclos de parón

Si el porcentaje de saltos es del 30%, y el CPI ideal es 1, la máquina tiene una ganancia de aprox. el 50% del máximo teórico

(16)

31

3ODQ% LQWHQWDPRVDYHULJXDUVLHOVDOWRVHWRPDRQRHQ XQDIDVHDQWHULRU YDPRVFDOFXODQGRHOGHVWLQRORDQWHVSRVLEOHSRU VLDFDVRKDFHIDOWD ,PSOLFDFLRQHV HOSDUyQHVPHQRUFLFOR HOFRVWHHVPD\RUVXPDGRU 3RUHMHPSORHQODIDVHGHGHFRGLILFDFLyQDPEDV

(17)

17

33

)RUPDVGHWUDWDUODSUHVHQFLDGHXQVDOWRHQHOIOXMRGH LQVWUXFFLRQHV

QRKDFHUQDGD

es el esquema más sencillo (y barato) también es el que peor rendimiento da

VXSRQHUTXHHOVDOWRQRVHYDDWRPDU

se siguen buscando instrucciones a continuación del salto en caso de que se tome, se invalidan

VXSRQHUTXHHOVDOWRVHYDDWRPDU

se calcula el destino, y se empieza a buscar por él

en nuestra máquina no es viable: se conocen el sentido y el destino a la vez => no es suposición, es certeza

UHWDUGDUODHMHFXFLyQGHOVDOWR

ejecutar la instrucción siguiente, tanto si el salto se toma, como si no

34

i (salto) IF ID EX MM WB i+1 IF ID EX MM WB i+2 IF ID EX MM WB i+3 IF ID EX MM WB i (salto) IF ID EX MM WB i+1 IF QDGD QDGD QDGD QDGD destino IF ID EX MM WB d+1 IF ID EX MM WB 6XSRQLHQGRTXHHOVDOWRQRVHWRPD VLHQUHDOLGDGQRVHWRPD VLHQUHDOLGDGVtVHWRPD

(18)

35

5HQGLPLHQWR

Si el salto en realidad no se toma: penalización 0 Si el salto sí se toma: penalización 1 ciclo

&RQUHVSHFWRDODRSFLyQGHQRKDFHUQDGDHQHOFDVRSHRU HOUHQGLPLHQWRHVHOPLVPR 6HUtDLQWHUHVDQWHVDEHUTXpSRUFHQWDMHGHVDOWRVQRVHWRPD •6LHOVDOWRQRVHWRPDHOFDXFHQRVHWRFD •6LVHWRPDVHDQXODODHMHFXFLyQGHODLQVWUXFFLyQVLJXLHQWH DOVDOWRHVGHFLUVHERUUDQORVODWFKHVHQWUHIDVHV

co m p es p r _li ea r m d lj KDFLD GHODQWH KDFLDDWUiV 3RUFHQWDMHGHVDOWRVWRPDGRVVREUH HOWRWDOGHHMHFXWDGRV

(19)

19

37

(QSURPHGLR

•el 62% de los saltos ejecutados en programas de enteros se toman

•en programas de coma flotante, el porcentaje sube al 70%

3RUORWDQWR

•sería más interesante la opción de suponer que el salto se va a tomar (es más probable)

3(52

•para buscar la instrucción destino del salto, es necesario calcularla

•en nuestra máquina, este valor se obtiene en la fase ID

•para entonces, también sabemos si el salto se toma o no =>ya no es necesario suponer

•en otras máquinas puede ser útil

38

&XDUWDRSFLyQHMHFXFLyQUHWDUGDGDGHOVDOWR

&XDQGRVHOOHJDDXQVDOWRODVLJXLHQWHLQVWUXFFLyQVHHMHFXWD WDQWRVLHOVDOWRVHWRPDFRPRVLQR³GHOD\VORW´

,PSOLFDFLRQHV

•a la hora de generar código es necesario tener esto en cuenta => cambio en la compilación / programación •el número de instrucciones situadas a continuación de un salto que se ejecutan puede variar con la arquitectura •a veces no es posible utilizar el “GHOD\VORW´para hacer

(20)

39

3RVLELOLGDGHVSDUDUHOOHQDUHO³GHOD\VORW´

5HTXLVLVWRVSDUDDSURYHFKDUHO³GHOD\ VORW´

6LODVLQVWUXFFLRQHVVHWRPDQGHDQWHVGHOVDOWR

•no debe haber dependencia entre ellas y el salto •siempre mejora el rendimiento

6LODVLQVWUXFFLRQHVVHWRPDQGHOGHVWLQRGHOVDOWR

•no debe afectar al programa el que se ejecuten si el salto no se toma

•puede haber ocasiones en las que el código no se copie, sino que se duplique (al destino se llega desde varios puntos) •mejora el rendimiento si el salto se toma

6LODVLQVWUXFFLRQHVVHWRPDQDFRQWLQXDFLyQGHOVDOWR

•no debe afectar al programa el que se ejecuten si el salto se toma •mejora el rendimiento si el salto no se toma

(21)

21

41

3XHGHVHUGLItFLOHQFRQWUDULQVWUXFFLRQHVDFRQWLQXDFLyQ GHOVDOWRRGHOGHVWLQRTXHQRDIHFWHQDOSURJUDPDVLVH HMHFXWDQFXDQGRHOVDOWRVHWRPDRQRUHVSHFWLYDPHQWH 352%/(0$ 62/8&,Ï1 6DOWRVFRQDQXODFLyQRFDQFHODFLyQ

se predice si se van a tomar o no (por el compilador) se rellenan sus “delay-slots” con instrucciones según corresponda

si el salto se comporta como se espera => todo bien si no => se anula la ejecución de los “delay-slots”

&RQHVWRVHUHODMDQORVUHTXLVLWRVVREUHODVLQVWUXFFLRQHV TXHYDQHQORV³GHOD\VORWV´

42

co m p eq n t es p r g cc li d o d u c ea r h yd ro m d lj su 2 co r DQXODGR YDFtR (MHFXFLyQGHORV³GHOD\VORWV´HQSRUFHQWDMHVREUH HOWRWDOGHORVVDOWRVFRQGLFLRQDOHV

(22)

43

2EVHUYDFLRQHVVREUHHOXVRGH³GHOD\VORWV´

•en promedio, el 30% se desperdician (35% en enteros, 25% en coma flotante)

•o lo que es igual, hasta un 70% se aprovechan

•sin embargo, en nuestra máquina, los saltos sólo tienen 1 “delay-slot”; en otras, con cauces más largos, pueden tener más

•esto puede hacer difícil el rellenarlos con trabajo útil •lo mismo ocurre con procesadores superescalares

(ya los veremos en detalle: ejecutan varias instrucciones a la vez)

5HVXPLHQGRORV³GHOD\VORWV´WLHQHQEDVWDQWHXWLOLGDGHQFDXFHV VHQFLOORVSHURHQFDXFHVPiVFRPSOHMRVVXHIHFWLYLGDGHVSRFD

(QRWUDVSDODEUDV\DQRVHXVDQ

Segmentación de instrucciones Operaciones multiciclo

352%/(0$8QDVLQVWUXFFLRQHVWDUGDQPiVHQHMHFXWDUVH TXHRWUDV

Ejemplo: una multiplicación y un desplazamiento lógico

6LHOFLFORGHUHORMVHDMXVWDDODPiVOHQWDFRQODVUiSLGDV \FRQODVGHPiVHWDSDVGHOFDXFHVHHVWiSHUGLHQGRWLHPSR

6LHOFLFORGHUHORMVHDMXVWDDODPiVUiSLGDDODVOHQWDVQR OHVGDFRQXQFLFOR

(23)

23

45

6HJ~QHVWRQXHVWUDPiTXLQDFRQVWDGH

•hardware para ejecutar las fases que son iguales en todas las instrucciones (IF, ID, MEM y WB)

•además, una serie de unidades funcionales para ejecutar cada tipo de instrucción

–operaciones comunes de enteros

–multiplicación de enteros / coma flotante –suma de coma flotante

–división enteros / coma flotante

•estas unidades de ejecución van a estar a su vez segmentadas

46

(OIOXMRGHLQVWUXFFLRQHVDWUDYpVGHOFDXFHHVDKRUD

•las instrucciones pasan por las fases IF e ID

•a continuación, cada instrucción pasa a la unidad funcional que la ejecute

•las instrucciones terminan en su unidad funcional , y recorren las fases MEM y WB

(VQHFHVDULRPRGLILFDUODPiTXLQD

•añadiendo latches entre las fases de las unidades funcionales •posibilitando el flujo desde ID hasta cualquier unidad

funcional

(24)

47

(OQXHYRFDXFH

MULTD IF ID 0 M2 M3 M4 M5 M6 0 MM WB

ADDD IF ID $ A2 A3 $ MM WB

LD IF ID (; 00 WB

SD IF ID (; 00 WB

(MHPSORGHRFXSDFLyQGHOQXHYRFDXFH

•Se supone que las instrucciones no tienen dependencias entre sí •Las fases en FXUVLYDindican cuándo se necesitan los datos

(25)

25

49

&RPSOLFDFLRQHVTXHDSDUHFHQHQHOQXHYRPRGHOR •ODVSRVLELOLGDGHVGHGHSHQGHQFLD !SDURQHVDXPHQWDQ

–algunas unidades funcionales están segementadas y pueden tener varias instrucciones en ejecución

–además, varias unidades funcionales pueden estar activas simultáneamente

•\ORVSDURQHVDGHPiVVHUiQPiVODUJRVSXHVWRTXH

HOFDXFHHVPiVODUJRGHSHQGLHQGRGHODXQLGDGIXQFLRQDO

•ODVLQVWUXFFLRQHVQRWLHQHQSRUTXpWHUPLQDUHQRUGHQ

–cuidado con las dependencias EDE

–puede haber varias instrucciones en la fase WB a la vez (conflicto estructural)

•VLQHPEDUJRODVGHSHQGHQFLDV('/VLJXHQVLQSRGHUVHGDU

50

ld f4,0(r2) IF ID EX MM WB multd f0,f4,f6 IF ID M1 M2 M3 MR M5 M6 M7 MM WB add f2,f0,f8 IF ID A1 A2 A3 A4 MM sd f2,0(r2) IF ID EX (MHPSOR •+D\GHSHQGHQFLDV/'(GHFDGDLQVWUXFFLyQFRQODDQWHULRU !SDURQHV •/DLQVWUXFFLyQQHFHVLWDHOUHVXOWDGRGHODSHURSDUDVX IDVH0(0SRUORTXHSXHGHSDVDUDODIDVH(;HQHOFLFOR •+D\GHSHQGHQFLDVHVWUXFWXUDOHVHQHOFLFORODLQVWUXFFLyQ QRSXHGHSDVDUDODIDVH,'SRUTXHODLQVWUXFFLyQHVWi UHWHQLGDDKt

(26)

51

Segmentación de instrucciones Ejemplo: el MIPS R4000

(O0,365 •5HSUHVHQWDWLYRGHDUTXLWHFWXUDVTXHDSDUHFLHURQ DSDUWLUGHORV •(VXQDPiTXLQDGHELWV •,PSOHPHQWDHOUHSHUWRULR0,36 •7LHQHXQFDXFHFRQJUDQQ~PHURGHHWDSDV VXSHUVHJPHQWDFLyQ •(VWROHSHUPLWtDXWLOL]DUXQDIUHFXHQFLDDOWD 0+] •8WLOL]DGRSRU1(&1LQWHQGR6LOLFRQ*UDSKLFV6RQ\

(OFDXFHGHO5 ,) fetch, fase 1 ,6 fetch, fase 2 5)Decod, búsqueda de operandos, comprobación de dependencias

(;ejecución, cálculo de dir. efectiva,

cálculo/comprobación de salto

')acceso a mem, fase 1 '6acceso a mem, fase 2

(27)

27

53

(MHFXFLyQGHXQµORDG¶HQHO5

(OUHWDUGRGHXQDFDUJDVRQGRVFLFORVHOSRVLEOHSDUyQVL ODVLJXLHQWHLQVWUXFFLyQQHFHVLWDHOGDWR

54

(MHFXFLyQGHXQVDOWRHQHO5

&XiOHVHOGHVWLQRGHOVDOWR\VLVHWRPDVHVDEHDOILQGHOD IDVH(; SRUORWDQWRODSHQDOL]DFLyQVRQFLFORV

(28)

55

/RVVDOWRVHQHO5

•(O5SHUPLWHHODSURYHFKDPLHQWRGHXQµGHOD\VORW¶ DXQTXHKD\D

•3DUDORVRWURVGRVVHSUHGLFHTXHHOVDOWRQRVHYDDWRPDU

–ejecuta 2 instrucciones de la continuación del salto –si el salto se toma, se anula su ejecución

•'LVSRQHGHLQVWUXFFLRQHVGHµVDOWRSUREDEOHPHQWHWRPDGR¶

–equivalente a nuestro salto con anulación

/DVRSHUDFLRQHVGHFRPDIORWDQWH •7LHQHXQLGDGHVIXQFLRQDOHV GLYLVLyQ PXOWLSOLFDFLyQ VXPD •/DXQLGDGGHVXPDVHXVDWDPELpQDOILQDOGHOD PXOWLSOLFDFLyQ\ODGLYLVLyQ •/DGXUDFLyQGHODVRSHUDFLRQHVYDGHFLFORVSDUD XQDQHJDFLyQDFLFORVSDUDXQDUDt]FXDGUDGD

(29)

29

57