Commit out of order Ciclo 1: Detecto un load que fallo en L2 en el tope del ROB Load R1(F1),@R2(F2) R3(F5)=R4(F4)+R2(F2) R2(F6)=R1(F1)+R3(F5) Branch R3(F5) R4(F7)=R3(F5) Branch R4(F7) R1(F8)=R4(F7) R4(F9)=R1(F8)+R3(F5) Map Commit F1 F2 F3 F4 Map F8 F6 F5 F9 Busy 1 Busy+Lock PC Seq Store Map Commit Lock Lock Register

Commit out of order Ciclo 1: Saco el load y lo inserto en la tabla R3(F5)=R4(F4)+R2(F2) R2(F6)=R1(F1)+R3(F5) Branch R3(F5) R4(F7)=R3(F5) Branch R4(F7) R1(F8)=R4(F7) R4(F9)=R1(F8)+R3(F5) R3(F10)=R1(F8)+R3(F5) Map Commit F1 F2 F5 F4 Map F8 F6 F10 F9 Busy 1 Busy+Lock PC Seq Store Map Commit Lock 1 F1 F2 F3 F4 Lock Register

Commit out of order Ciclo 2: La primera instrucción en el ROB esta terminada R3(F5)=R4(F4)+R2(F2) R2(F6)=R1(F1)+R3(F5) Branch R3(F5) R4(F7)=R3(F5) Branch R4(F7) R1(F8)=R4(F7) R4(F9)=R1(F8)+R3(F5) R3(F10)=R1(F8)+R3(F5) Map Commit F1 F2 F5 F4 Map F8 F6 F10 F9 Busy 1 Busy+Lock PC Seq Store Map Commit Lock 1 F1 F2 F3 F4 Lock Register

Commit out of order Ciclo 2: La instrucción que queda como primera no esta terminada, asi que la conservo. R2(F6)=R1(F1)+R3(F5) Branch R3(F5) R4(F7)=R3(F5) Branch R4(F7) R1(F8)=R4(F7) R4(F9)=R1(F8)+R3(F5) R3(F10)=R1(F8)+R3(F5) Load R1(F11),@R3(F10) Map Commit F1 F2 F5 F4 Map F11 F6 F10 F9 Busy 1 Busy+Lock PC Seq Store Map Commit Lock 1 F1 F2 F3 F4 Lock Register

Commit out of order Ciclo 3: Como la primera instrucción del ROB no esta lista, la tengo que mover a la tabla R2(F6)=R1(F1)+R3(F5) Branch R3(F5) R4(F7)=R3(F5) Branch R4(F7) R1(F8)=R4(F7) R4(F9)=R1(F8)+R3(F5) R3(F10)=R1(F8)+R3(F5) Load R1(F11),@R3(F10) Map Commit F1 F6 F5 F4 Map F8 F10 F9 Busy 1 Busy+Lock PC Seq Store Map Commit Lock 1 F1 F2 F3 F4 Lock Register

Commit out of order Ciclo 3: Tabla modificada Branch R3(F5) R4(F7)=R3(F5) Branch R4(F7) R1(F8)=R4(F7) R4(F9)=R1(F8)+R3(F5) R3(F10)=R1(F8)+R3(F5) Load R1(F11),@R3(F10) Branch R1(F11) Map Commit F1 F6 F5 F4 Map F11 F10 F9 Busy 1 Busy+Lock PC Seq Store Map Commit Lock 1 F1 F2 F3 F4 3 F6 F5 Lock Register

Commit out of order Ciclo 4: Commit de 4 Branch R3(F5) R4(F7)=R3(F5) Load R1(F11),@R3(F10) Branch R1(F11) Map Commit F1 F6 F5 F4 Map F11 F10 F9 Busy 1 Busy+Lock PC Seq Store Map Commit Lock 1 F1 F2 F3 F4 3 F6 F5 Lock Register

Commit out of order Ciclo 5: Commit de 5 R4(F7)=R3(F5) Branch R4(F7) R4(F9)=R1(F8)+R3(F5) R3(F10)=R1(F8)+R3(F5) Load R1(F11),@R3(F10) Branch R1(F11) NOP Map Commit F1 F6 F5 F4 Map F11 F10 F9 Busy 1 Busy+Lock PC Seq Store Map Commit Lock 1 F1 F2 F3 F4 3 F6 F5 Lock Register

Commit out of order Ciclo 5: Despues del commit de 5 Branch R4(F7) R1(F8)=R4(F7) R4(F9)=R1(F8)+R3(F5) R3(F10)=R1(F8)+R3(F5) Load R1(F11),@R3(F10) Branch R1(F11) NOP Map Commit F1 F6 F5 F7 Map F11 F10 F9 Busy 1 Busy+Lock PC Seq Store Map Commit Lock 1 F1 F2 F3 F4 3 F6 F5 Lock Register

Commit out of order Ciclo 6: Despues del commit de 6 R1(F8)=R4(F7) R4(F9)=R1(F8)+R3(F5) R3(F10)=R1(F8)+R3(F5) Load R1(F11),@R3(F10) Branch R1(F11) NOP Map Commit F1 F6 F5 F7 Map F11 F10 F9 Busy 1 Busy+Lock PC Seq Store Map Commit Lock 1 F1 F2 F3 F4 3 F6 F5 Lock Register

Commit out of order Ciclo 7: Despues del commit de 7 R4(F9)=R1(F8)+R3(F5) R3(F10)=R1(F8)+R3(F5) Load R1(F11),@R3(F10) Branch R1(F11) NOP Map Commit F8 F6 F5 F7 Map F11 F10 F9 Busy 1 Busy+Lock PC Seq Store Map Commit Lock 1 F1 F2 F3 F4 3 F6 F5 Lock Register

Commit out of order Ciclo 8: Commit de 8 R4(F9)=R1(F8)+R3(F5) Load R1(F11),@R3(F10) Branch R1(F11) NOP Map Commit F8 F6 F5 F7 Map F11 F10 F9 Busy 1 Busy+Lock PC Seq Store Map Commit Lock 1 F1 F2 F3 F4 3 F6 F5 Lock Register

Commit out of order Ciclo 8: Commit de 8. Notar que F7 queda libre. R3(F10)=R1(F8)+R3(F5) Load R1(F11),@R3(F10) Branch R1(F11) NOP Map Commit F8 F6 F5 F9 Map F11 F10 Busy 1 Busy+Lock PC Seq Store Map Commit Lock 1 F1 F2 F3 F4 3 F6 F5 Lock Register

Commit out of order Ciclo 9: Supongamos que 1 se termina de ejecutar, en este ciclo R3(F10)=R1(F8)+R3(F5) Load R1(F11),@R3(F10) Branch R1(F11) NOP Map Commit F8 F6 F5 F9 Map F11 F10 Busy 1 Busy+Lock PC Seq Store Map Commit Lock 1 F1 F2 F3 F4 3 F6 F5 Lock Register

Commit out of order Ciclo 9: Porque 1 se termino de ejecutar nos queda: R3(F10)=R1(F8)+R3(F5) Load R1(F11),@R3(F10) Branch R1(F11) NOP Map Commit F8 F6 F5 F9 Map F11 F10 Busy 1 Busy+Lock PC Seq Store Map Commit Lock 3 F1 F6 F5 F4 1 Lock Register

Commit out of order Ciclo 9: Despues del commit de 9 Load R1(F11),@R3(F10) Branch R1(F11) NOP Map Commit F8 F6 F10 F9 Map F11 Busy 1 Busy+Lock PC Seq Store Map Commit Lock 3 F1 F6 F5 F4 1 Lock Register

Commit out of order Ciclo 10: Despues de commit 10. Se libera F8 Branch R1(F11) NOP Map Commit F11 F6 F10 F9 Map Busy 1 Busy+Lock PC Seq Store Map Commit Lock 3 F1 F6 F5 F4 1 Lock Register

Commit out of order Ciclo 11: Termina 3 Branch R1(F11) NOP Map Commit Busy 1 Busy+Lock PC Seq Store Map Commit Lock Lock Register

Commit out of order Si puedo sacar las instrucciones del reorder buffer fuera de orden, es necesario el reorder buffer?

Con el esquema anterior NO, Commit out of order Con el esquema anterior NO, PERO ...

Variable lenght ROB with out of order commit Commit out of order Con unos pequeños cambios SI: Variable lenght ROB with out of order commit

Variable lenght ROB with out of order commit Agregemosle a cada entrada en la tabla de checkpoints un contador de instrucciones faltantes de commit para ese checkpoint A cada entrada en las colas de issue se le agrega una entrada que solo tiene un numero correspondiente a su checkpoint

Variable lenght ROB with out of order commit Idea y Funcionamiento: Cada instrucción siempre tiene un chequepoint. Cada checkpoint cuenta cuantas instrucciones que no hicieron commit estan bajo su “proteccion” Cuando el checkpoint no “protege” a ninguna instrucción se libera esa entrada en la tabla Cuando se hace un dispach de una instrucción se incrementa el contador del checkpoint que la “protege” Cuando una instrucción finaliza su ejecucion decrementa el contador del checkpoint que la “protege”

Variable lenght ROB with out of order commit Donde y cuando insertar un checkpoint? El donde, en realidad no importa, si bien hay lugares que son mas convenientes que otros (los branch con baja confidencia). El cuando, no conviene que los bloques protegidos sean muy chicos (ya que no se liberarian registros dentro del bloque), ni muy grandes (se desperdiciaria mucho en caso de que el bloque no se ejecute en la totalidad). Hay que buscar una funcion de optimizacion que tenga como parametros la cantidad de instrucciones protegidas y la confidencia de los branchs)

Variable lenght ROB with out of order commit Limites: Los problemas que encuentro son: La longitud del store buffer, y la longitud de la cola de load/store, principalmente. La cantidad de entradas en la tabla de checkpoints, aunque calculo que con muy pocas entradas 8 o 16 bastarian, igual cada entrada tiene menos de 100 bytes para una arquitectura con 64 registros logicos y 256 fisicos. El costo de los saltos mal predichos es mayor

Variable lenght ROB with out of order commit Ventajas: Puede llegar a “simular” ROBs de miles de instrucciones, con lo cual se puede llegar a absorber mucho mejor las instrucciones de latencia prolongada. Puede llegar a reducir mucho la presion sobre los bancos de registros, amen de que se puede adaptar perfectamente a los registros virtuales ambos son ortogonales

Combinando ambas ideas Se pueden combinar ambas ideas y obtener lo mejor de las dos formas de trabajo, haciendo inclusive un sistema mixto que cambie de forma de trabajar de acuerdo al codigo que se este ejecutando. La ventaja de mezclar ambos metodos de trabajo seria que cuando una instrucción dependiente de otra que ya se esta en la tabla de checkpoints, no haria falta enviarla tambien a la tabla, por lo tanto no me ocuparia espacio en la tabla, la podria dejar solo en las colas de issue, con lo cual con muy pocas entradas en la tabla seria suficiente. De igul forma la ROB podria ser mas pequeña dado que existe un mecanismo que me permitiria ir mas lejos.