UFES – Mestrado em Informática
Arquiteturas Avançadas de
Computador
DTSVLIW
UFES – Mestrado em Informática
Arquiteturas Avançadas de
Computador
DTSVLIW
DTSVLIW
Sotério Ferreira de Souza
Orientador: Prof. Alberto Ferreira de Souza
23 de outubro de 2003DTSVLIW
Sotério Ferreira de Souza
Orientador: Prof. Alberto Ferreira de Souza
23 de outubro de 2003DTSVLIW
Dynamically Trace Scheduled Very
Long Instruction Word
DTSVLIW
Dynamically Trace Scheduled Very
Long Instruction Word
Long Instruction Word
Prof. Dr. Alberto Ferreira de Souza
Tese de Doutorado – UCL - Set/1999Long Instruction Word
Prof. Dr. Alberto Ferreira de Souza
Tese de Doutorado – UCL - Set/19991 – Visão geral da arquitetura DTSVLIW
2 – Como extrai paralelismo no nível de instrução 3 – Como renomeia registradores
Do que vamos falar?
4 – Como renomeia leituras/escritas na memória 5 – Como trata aliasing exceptions
6 – Como trata exceções
Background
Paralelismo no Nível de Instrução – ILP
Explorar a possibilidade de execução de instruções
independentemente da seqüência definida pelo programador Paralelismo no Nível de Instrução – ILP
Explorar a possibilidade de execução de instruções
independentemente da seqüência definida pelo programador independentemente da seqüência definida pelo programador
Temporal: processador segmenta a “execução” em vários subprocessos executados por unidades autônomas.
Espacial: processador com múltiplas unidades funcionais executando simultaneamente.
independentemente da seqüência definida pelo programador
Temporal: processador segmenta a “execução” em vários subprocessos executados por unidades autônomas.
Espacial: processador com múltiplas unidades funcionais executando simultaneamente.
Background
PIPELINE
PARALELISMO TEMPORALPIPELINE
PARALELISMO TEMPORAL Execute Memory Access Write Back Decode FetchBackground
PIPELINE
PARALELISMO TEMPORALPIPELINE
PARALELISMO TEMPORAL Execute Memory Access Write Back Decode Fetch I1 CLK 1Background
PIPELINE
PARALELISMO TEMPORALPIPELINE
PARALELISMO TEMPORAL Execute Memory Access Write Back Decode Fetch I1 CLK 1 I2 I1 CLK 2Background
PIPELINE
PARALELISMO TEMPORALPIPELINE
PARALELISMO TEMPORAL Execute Memory Access Write Back Decode Fetch I1 CLK 1 I2 I1 CLK 2 I3 I2 I1 CLK 3Background
PIPELINE
PARALELISMO TEMPORALPIPELINE
PARALELISMO TEMPORAL Execute Memory Access Write Back Decode Fetch I1 CLK 1 I2 I1 CLK 2 I3 I2 I1 CLK 3 I4 I3 I2 CLK 4 I1Background
PIPELINE
PARALELISMO TEMPORALPIPELINE
PARALELISMO TEMPORAL Execute Memory Access Write Back Decode Fetch I1 CLK 1 I2 I1 CLK 2 I3 I2 I1 CLK 3 I4 I3 I2 CLK 4 I5 I4 I3 I1I2 I1 CLK 5Background
PIPELINE
PARALELISMO TEMPORALPIPELINE
PARALELISMO TEMPORAL Execute Memory Access Write Back Decode Fetch I1 CLK 1 I2 I1 CLK 2 I3 I2 I1 CLK 3 I4 I3 I2 CLK 4 I5 I4 I3 I1I2 I1 CLK 5 I6 I5 I4 I3 I2 CLK 6Background
PIPELINE
PARALELISMO TEMPORALPIPELINE
PARALELISMO TEMPORAL Execute Memory Access Write Back Decode Fetch I1 CLK 1 I2 I1 CLK 2 I3 I2 I1 CLK 3 I4 I3 I2 CLK 4 I5 I4 I3 I1I2 I1 CLK 5 I6 I5 I4 I3 I2 CLK 6 I7 I6 I5 I4 I3 CLK 7Background
PIPELINE
PARALELISMO TEMPORALPIPELINE
PARALELISMO TEMPORAL Execute Memory Access Write Back Decode Fetch I1 CLK 1 I2 I1 CLK 2 I3 I2 I1 CLK 3 I4 I3 I2 CLK 4 I5 I4 I3 I1I2 I1 CLK 5 I6 I5 I4 I3 I2 CLK 6 I7 I6 I5 I4 I3 CLK 7 I8 I7 I6 I5 I4 CLK 8Background
PIPELINE
PARALELISMO TEMPORALPIPELINE
PARALELISMO TEMPORAL Execute Memory Access Write Back Decode Fetch I1 CLK 1 I2 I1 CLK 2 I3 I2 I1 CLK 3 I4 I3 I2 CLK 4 I5 I4 I3 I1I2 I1 CLK 5 I6 I5 I4 I3 I2 CLK 6 I7 I6 I5 I4 I3 CLK 7 I8 I7 I6 I5 I4 CLK 8 I8 I7 I6 I5 CLK 9Background
PIPELINE
PARALELISMO TEMPORALPIPELINE
PARALELISMO TEMPORAL Execute Memory Access Write Back Decode Fetch I1 CLK 1 I2 I1 CLK 2 I3 I2 I1 CLK 3 I4 I3 I2 CLK 4 I5 I4 I3 I1I2 I1 CLK 5 I6 I5 I4 I3 I2 CLK 6 I7 I6 I5 I4 I3 CLK 7 I8 I7 I6 I5 I4 CLK 8 I8 I7 I6 I5 CLK 9 I8 I7 I6 CLK 10Background
PIPELINE
PARALELISMO TEMPORALPIPELINE
PARALELISMO TEMPORAL Execute Memory Access Write Back Decode Fetch I1 CLK 1 I2 I1 CLK 2 I3 I2 I1 CLK 3 I4 I3 I2 CLK 4 I5 I4 I3 I1I2 I1 CLK 5 I6 I5 I4 I3 I2 CLK 6 I7 I6 I5 I4 I3 CLK 7 I8 I7 I6 I5 I4 CLK 8 I8 I7 I6 I5 CLK 9 I8 I7 I6 CLK 10 I8 I7 CLK 11Background
PIPELINE
PARALELISMO TEMPORALPIPELINE
PARALELISMO TEMPORAL Execute Memory Access Write Back Decode Fetch I1 CLK 1 I2 I1 CLK 2 I3 I2 I1 CLK 3 I4 I3 I2 CLK 4 I5 I4 I3 I1I2 I1 CLK 5 I6 I5 I4 I3 I2 CLK 6 I7 I6 I5 I4 I3 CLK 7 I8 I7 I6 I5 I4 CLK 8 I8 I7 I6 I5 CLK 9 I8 I7 I6 CLK 10 I8 I7 CLK 11 I8 CLK 12Background
PIPELINE
PARALELISMO TEMPORALPIPELINE
PARALELISMO TEMPORAL Execute Memory Access Write Back Decode Fetch I1 CLK 1 I2 I1 CLK 2 I3 I2 I1 CLK 3 I4 I3 I2 CLK 4 I5 I4 I3 I1I2 I1 CLK 5 I6 I5 I4 I3 I2 CLK 6 I7 I6 I5 I4 I3 CLK 7 I8 I7 I6 I5 I4 CLK 8 I8 I7 I6 I5 CLK 9 I8 I7 I6 CLK 10 I8 I7 CLK 11 I8 CLK 12 CLK 13Background
VLIW
PARALELISMO ESPACIALVLIW
PARALELISMO ESPACIAL I1 I2 I3 I4 FU-3 FU-4 FU-2 FU-1 IC DC E I5 I6 I7 I8Background
VLIW
PARALELISMO ESPACIALVLIW
PARALELISMO ESPACIAL I1 I2 I3 I4 FU-3 FU-4 FU-2 FU-1 IC DC E I5 I6 I7 I8 I5 I6 I7 I8 I3 I4 I2 I1 CLK 1Background
VLIW
PARALELISMO ESPACIALVLIW
PARALELISMO ESPACIAL I1 I2 I3 I4 FU-3 FU-4 FU-2 FU-1 IC DC E I5 I6 I7 I8 I5 I6 I7 I8 I3 I4 I2 I1 CLK 1 I1 I2 I3 I4 I7 I8 I6 I5 CLK 2Background
VLIW
PARALELISMO ESPACIALVLIW
PARALELISMO ESPACIAL I1 I2 I3 I4 FU-3 FU-4 FU-2 FU-1 IC DC E I5 I6 I7 I8 I5 I6 I7 I8 I3 I4 I2 I1 CLK 1 I1 I2 I3 I4 I7 I8 I6 I5 CLK 2 I5 I6 I7 I8 FU-3 FU-4 FU-2 FU-1 I1 I2 I3 I4 CLK 3Background
PARALELIZAÇÃO
Capacidade de paralelização que pode ser explorada é limitada pelas dependências de controle e de dados entre as instruções.
PARALELIZAÇÃO
Capacidade de paralelização que pode ser explorada é limitada pelas dependências de controle e de dados entre as instruções. pelas dependências de controle e de dados entre as instruções. PIPELINE: impedem a execução de instruções consecutivas.
VLIW: impedem a inserção de mais instruções dentro de uma instrução longa.
pelas dependências de controle e de dados entre as instruções. PIPELINE: impedem a execução de instruções consecutivas.
VLIW: impedem a inserção de mais instruções dentro de uma instrução longa.
Background
Dependências:
if r8 = 0 goto L r3 : = r1 + r4 ... ...Dependências:
if r8 = 0 goto L r3 : = r1 + r4 ... ... r2 : = r1 + 1 r1 : = r2 / r5 ... L: r1 : = r3 * r4 r1 : = 50[r6] ... ... r2 : = r1 + 1 r1 : = r3 + r4 r2 : = r1 + 1 r1 : = r2 / r5 ... L: r1 : = r3 * r4 r1 : = 50[r6] ... ... r2 : = r1 + 1 r1 : = r3 + r4Background
Dependências:
if r8 = 0 goto L r3 : = r1 + r4 ... ...Dependências:
if r8 = 0 goto L r3 : = r1 + r4 ... Controle ... r2 : = r1 + 1 r1 : = r2 / r5 ... L: r1 : = r3 * r4 r1 : = 50[r6] ... ... r2 : = r1 + 1 r1 : = r3 + r4 r2 : = r1 + 1 r1 : = r2 / r5 ... L: r1 : = r3 * r4 r1 : = 50[r6] ... ... r2 : = r1 + 1 r1 : = r3 + r4Background
Dependências:
if r8 = 0 goto L r3 : = r1 + r4 ... ...Dependências:
if r8 = 0 goto L r3 : = r1 + r4 ... Controle ... r2 : = r1 + 1 r1 : = r2 / r5 ... L: r1 : = r3 * r4 r1 : = 50[r6] ... ... r2 : = r1 + 1 r1 : = r3 + r4 r2 : = r1 + 1 r1 : = r2 / r5 ... L: r1 : = r3 * r4 r1 : = 50[r6] ... ... r2 : = r1 + 1 r1 : = r3 + r4 SaídaBackground
Dependências:
if r8 = 0 goto L r3 : = r1 + r4 ... ...Dependências:
if r8 = 0 goto L r3 : = r1 + r4 ... Controle ... Anti-dependência r2 : = r1 + 1 r1 : = r2 / r5 ... L: r1 : = r3 * r4 r1 : = 50[r6] ... ... r2 : = r1 + 1 r1 : = r3 + r4 r2 : = r1 + 1 r1 : = r2 / r5 ... L: r1 : = r3 * r4 r1 : = 50[r6] ... ... r2 : = r1 + 1 r1 : = r3 + r4 SaídaBackground
Dependências:
if r8 = 0 goto L r3 : = r1 + r4 ... ...Dependências:
if r8 = 0 goto L r3 : = r1 + r4 ... Controle ... Anti-dependência r2 : = r1 + 1 r1 : = r2 / r5 ... L: r1 : = r3 * r4 r1 : = 50[r6] ... ... r2 : = r1 + 1 r1 : = r3 + r4 r2 : = r1 + 1 r1 : = r2 / r5 ... L: r1 : = r3 * r4 r1 : = 50[r6] ... ... r2 : = r1 + 1 r1 : = r3 + r4 Saída VERDADEIRABackground
Técnicas para minimização dos problemas causados por dependências. Técnicas para minimização dos problemas causados por dependências.
Register Renaming
Register Renaming
Elimina dependências de saída e anti-dependência, também conhecidas como dependências de nome.
Exemplos: r1:=r2+r4 r1:=r2+r4 r3:=r1+r4 r3:=r1+r4
... ... ... ...
r1:=r2*r5 r3:=r2*r5 r1:=r2/r5 r6:=r2/r5 Elimina dependências de saída e anti-dependência, também conhecidas como dependências de nome.
Exemplos: r1:=r2+r4 r1:=r2+r4 r3:=r1+r4 r3:=r1+r4
... ... ... ...
Background
Técnicas para minimização dos problemas causados por dependências. Técnicas para minimização dos problemas causados por dependências.
Branch Prediction
Branch Prediction
Branch Prediction
Reduz impacto das dependências de controle.
Desvios podem ser preditos estaticamente pelo compilador ou dinamicamente pelo hardware.
Branch Prediction
Reduz impacto das dependências de controle.
Desvios podem ser preditos estaticamente pelo compilador ou dinamicamente pelo hardware.
Background
Técnicas para minimização dos problemas causados por dependências. Técnicas para minimização dos problemas causados por dependências.
Speculative Execution
Speculative Execution
Speculative Execution
As instruções são executadas sem que o resultado de um desvio
condicional seja conhecido, porém os valores de saída são confirmados apenas se o resultado do desvio for coerente com o caminho tomado na execução especulativa.
Speculative Execution
As instruções são executadas sem que o resultado de um desvio
condicional seja conhecido, porém os valores de saída são confirmados apenas se o resultado do desvio for coerente com o caminho tomado na execução especulativa.
Background
Técnicas para minimização dos problemas causados por dependências. Técnicas para minimização dos problemas causados por dependências.
Memory Disambiguation
Memory Disambiguation
É necessária quando instruções load/store são executadas fora da ordem especificada pelo programador.
Exemplo: ... st r3,a ld a,r1 ld a,r1 ... ... st r3,a
É necessária quando instruções load/store são executadas fora da ordem especificada pelo programador.
Exemplo: ... st r3,a ld a,r1 ld a,r1 ... ... st r3,a
Background
Técnicas para minimização dos problemas causados por dependências. Técnicas para minimização dos problemas causados por dependências.
Predication
Predication
Predication
Execução condicional baseada em valor booleano de um operador de entrada. Instrução com predicado true são executadas normalmente enquanto as com predicado false, embora tratadas, não tem seus resultados salvos no estado ISA.
Predication
Execução condicional baseada em valor booleano de um operador de entrada. Instrução com predicado true são executadas normalmente enquanto as com predicado false, embora tratadas, não tem seus resultados salvos no estado ISA.
Background
Técnicas para minimização dos problemas causados por dependências. Técnicas para minimização dos problemas causados por dependências.
Instruction Hoisting
Instruction Hoisting
Instruction Hoisting
Execução especulativa de instruções load, store e ponto-flutuante pode causar exceções que não devem ser sinalizadas enquanto os resultados da execução especulativa não sejam confirmados.
Instruction Hoisting
Execução especulativa de instruções load, store e ponto-flutuante pode causar exceções que não devem ser sinalizadas enquanto os resultados da execução especulativa não sejam confirmados.
Máquina
Máquina dede EscalonamentoEscalonamento:: Unidade
Unidade dede EscalonamentoEscalonamento Processador
Processador PrimárioPrimário PipelinedPipelined
Máquina
Máquina VLIWVLIW::
Cache
Cache VLIWVLIW
D
D
T
T
S
S
V
V
CacheCache VLIWVLIWEstágios
Estágios PipelinedPipelined
Fecth
Fecth UnitUnit::
Program
Program CounterCounter
Endereço
Endereço dede InstruçãoInstrução Endereço
Endereço dede InstruçãoInstrução LongaLonga
V
V
L
L
II
W
W
Instruction Cache
Scheduler
Visão Geral da Arquitetura DTSVLIW
Visão Geral da Arquitetura DTSVLIW
VLIW Cache Fecth Unit Primary Processor Scheduler Unit Scheduler Engine Scheduling List VLIW Engine Data Cache To/From Memory
A Máquina de Escalonamento
Processador Primário
Processador pipelined simples com estágios de fetch,
decode, execute e write back, capaz de executar todas as decode, execute e write back, capaz de executar todas as
instruções Sparc Version 7 ISA.
Unidade de Escalonamento
Implementação, em hardware, de versão simplificada do algoritmo FCFS (First Come First Served)
A máquina VLIW
Cache VLIW
Cache associativo com tamanho de linha igual à um bloco de instruções longas (BLOCK_SIZE), com campo nba
associado à cada linha do cache. associado à cada linha do cache.
Processamento das instruções
Unidades funcionais pipelined com estágios de fetch,
execute e write back, para processamento de instruções
A máquina DTSVLIW
A máquina DTSVLIW
Scheduler Engine Scheduler Unit I S Mu Mu Mu Mu Instruction Cache Primary Processor VLIW Engine Fecth Unit VLIW Cache F E WB F D WB E I SA Unidade de Escalonamento
O algoritmo FCFS:
• Motivos para a escolha
• Como trabalha
• A inserção na lista de escalonamento
• Instrução candidata / Move Up
• Condições para Move Up
• Envio para o Cache VLIW
Inserções na lista de Escalonamento
Instrução livre de dependências com outras presentes no último elemento da lista são inseridas em slot vago neste elemento e se tornam candidatas, podendo ser escalonadas dentro da lista (move up). Caso contrário, um novo elemento é criado para receber a instrução recebida do estágio execute do processador primário, sendo a mesma instalada nesse novo elemento.
Condições para Move Up
Se existe slot vago e não existe dependência verdadeira com outras instruções presentes no elemento imediatamente superior (i-1).
Se existe dependência de saída com instrução em (i-1); Se existe dependência de saída com instrução em (i-1); Ou existe antidependência com instrução em (i);
Ou existe dependência de controle com instrução em (i). Nestes três últimos casos, a instrução candidata é dividida.
Renomeia-se a saída e instala-se instrução cópia no slot atual da instrução longa (i).
Split de instruções
Em caso de dependência de saída, antidependência ou dependência de controle com instrução no elemento (i-1):
O registrador de saída é renomeado para um renaming register e o
move up acontece normalmente. Instrução COPY é instalada no slot atual para copiar renaming register para registrador original. slot atual para copiar renaming register para registrador original.
...
(i-k) r3: = r1 + r4 ...
Split de instruções
Em caso de dependência de saída, antidependência ou dependência de controle com instrução no elemento (i-1):
O registrador de saída é renomeado para um renaming register e o
move up acontece normalmente. Instrução COPY é instalada no slot atual para copiar renaming register para registrador original. slot atual para copiar renaming register para registrador original.
... (i-k) r3: = r1 + r4 ... (i) r1: = r2 + r5 (i) r9: = r2 + r5 ... (i-k) r3: = r1 + r4 ... (i) r1: = r9
Instruções COPY
Não provocam dependência de dados e podem ser sobrescritas. Instrução em (i) que escreve em registrador de saída de instrução cópia em (i-1) pode ser escalonada sem divisão se o tag é igual ao da instrução longa. Neste caso, pode subrescrever instrução cópia em (i-1).
em (i-1).
Se tag da instrução cópia é diferente do tag da instrução longa (i-1), a instrução em (i) tem que ser dividida para ser movida para (i-1) Instrução longa que lê registrador de saída de instrução cópia, pode ser escalonada com renomeação do registrador de entrada.
Instruções de Desvio
Instruções de desvio condicional são instaladas quando inseridas. Estabelecem tag para suas instruções longas que são propagados para instruções inseridas e/ou instaladas posteriormente.
para instruções inseridas e/ou instaladas posteriormente.
Os tags são avaliados na execução VLIW. Se válidos, as instruções tem seus resultados escritos no estado de máquina.
O algoritmo FCFS executando:
for (sum=0, i=0; i<x;i++) {
sum=a[i] + sum; }
1: or r0, 0, r9 # r9=sum 2: sethi hi(56), r8 # r8=temp 3: or r8, 8, r11 # r11=*a 4: or r0, 0, r10 # r10=4*i Loop: 5: ld [r10+r11],r8 6: add r9, r8, r9 7: add r10, 4, r9 8: subcc r10, 4*x-1,r0 9: ble loop 9: ble loop 10: or r0, 0, r0 # nop
O algoritmo FCFS executando:
for (sum=0, i=0; i<x;i++) {
sum=a[i] + sum; }
1: or r0, 0, r9 # r9=sum 2: sethi hi(56), r8 # r8=temp 3: or r8, 8, r11 # r11=*a 4: or r0, 0, r10 # r10=4*i Loop: 5: ld [r10+r11],r8 6: add r9, r8, r9 7: add r10, 4, r9 8: subcc r10, 4*x-1,r0 9: ble loop or r0,0,r9 slh-> Depois de 1 ciclo 9: ble loop 10: or r0, 0, r0 # nop
O algoritmo FCFS executando:
for (sum=0, i=0; i<x;i++) {
sum=a[i] + sum; }
1: or r0, 0, r9 # r9=sum 2: sethi hi(56), r8 # r8=temp 3: or r8, 8, r11 # r11=*a 4: or r0, 0, r10 # r10=4*i Loop: 5: ld [r10+r11],r8 6: add r9, r8, r9 7: add r10, 4, r9 8: subcc r10, 4*x-1,r0 9: ble loop or r0,0,r9 slh-> Depois de 1 ciclo Depois de 2 ciclos or r0,0,r9 slh-> sethi hi(56),r8 9: ble loop 10: or r0, 0, r0 # nop
O algoritmo FCFS executando:
for (sum=0, i=0; i<x;i++) {
sum=a[i] + sum; }
1: or r0, 0, r9 # r9=sum 2: sethi hi(56), r8 # r8=temp 3: or r8, 8, r11 # r11=*a 4: or r0, 0, r10 # r10=4*i Loop: 5: ld [r10+r11],r8 6: add r9, r8, r9 7: add r10, 4, r9 8: subcc r10, 4*x-1,r0 9: ble loop or r0,0,r9 slh-> Depois de 1 ciclo Depois de 2 ciclos or r0,0,r9 slh-> sethi hi(56),r8 Depois de 3 ciclos or r0,0,r9 slh-> sethi hi(56),r8 or r8,8,r11 slt-> 9: ble loop 10: or r0, 0, r0 # nop
O algoritmo FCFS executando:
for (sum=0, i=0; i<x;i++) {
sum=a[i] + sum; }
1: or r0, 0, r9 # r9=sum 2: sethi hi(56), r8 # r8=temp 3: or r8, 8, r11 # r11=*a 4: or r0, 0, r10 # r10=4*i Loop: 5: ld [r10+r11],r8 6: add r9, r8, r9 7: add r10, 4, r9 8: subcc r10, 4*x-1,r0 9: ble loop or r0,0,r9 slh-> Depois de 1 ciclo Depois de 2 ciclos or r0,0,r9 slh-> sethi hi(56),r8 Depois de 3 ciclos or r0,0,r9 slh-> sethi hi(56),r8 or r8,8,r11 slt-> Depois de 4 ciclos or r0,0,r9 slh-> sethi hi(56),r8 or r8,8,r11 slt-> or r0,0,r10 9: ble loop 10: or r0, 0, r0 # nop
O algoritmo FCFS executando:
for (sum=0, i=0; i<x;i++) {
sum=a[i] + sum; }
1: or r0, 0, r9 # r9=sum 2: sethi hi(56), r8 # r8=temp 3: or r8, 8, r11 # r11=*a 4: or r0, 0, r10 # r10=4*i Loop: 5: ld [r10+r11],r8 6: add r9, r8, r9 7: add r10, 4, r9 8: subcc r10, 4*x-1,r0 9: ble loop or r0,0,r9 slh-> Depois de 1 ciclo Depois de 2 ciclos or r0,0,r9 slh-> sethi hi(56),r8 Depois de 3 ciclos or r0,0,r9 slh-> sethi hi(56),r8 or r8,8,r11 slt-> Depois de 4 ciclos or r0,0,r9 slh-> sethi hi(56),r8 or r8,8,r11 slt-> or r0,0,r10 or r0,0,r10 or r0,0,r9 slh-> sethi hi(56),r8 or r8,8,r11 ld [r10+r11],r8 slt-> Depois de 5 ciclos 9: ble loop 10: or r0, 0, r0 # nop
O algoritmo FCFS executando:
for (sum=0, i=0; i<x;i++) {
sum=a[i] + sum; }
1: or r0, 0, r9 # r9=sum 2: sethi hi(56), r8 # r8=temp 3: or r8, 8, r11 # r11=*a 4: or r0, 0, r10 # r10=4*i Loop: 5: ld [r10+r11],r8 6: add r9, r8, r9 7: add r10, 4, r9 8: subcc r10, 4*x-1,r0 9: ble loop or r0,0,r9 slh-> Depois de 1 ciclo Depois de 2 ciclos or r0,0,r9 slh-> sethi hi(56),r8 Depois de 3 ciclos or r0,0,r9 slh-> sethi hi(56),r8 or r8,8,r11 slt-> Depois de 4 ciclos or r0,0,r9 slh-> sethi hi(56),r8 or r8,8,r11 slt-> or r0,0,r10 or r0,0,r10 or r0,0,r9 slh-> sethi hi(56),r8 or r8,8,r11 ld [r10+r11],r8 slt-> Depois de 5 ciclos add r9,r8,r9 slt-> or r0,0,r10 or r0,0,r9 slh-> sethi hi(56),r8 or r8,8,r11 ld [r10+r11],r8 Depois de 6 ciclos 9: ble loop 10: or r0, 0, r0 # nop
O algoritmo FCFS executando:
for (sum=0, i=0; i<x;i++) {
sum=a[i] + sum; }
1: or r0, 0, r9 # r9=sum 2: sethi hi(56), r8 # r8=temp 3: or r8, 8, r11 # r11=*a 4: or r0, 0, r10 # r10=4*i Loop: 5: ld [r10+r11],r8 6: add r9, r8, r9 7: add r10, 4, r9 8: subcc r10, 4*x-1,r0 9: ble loop or r0,0,r9 slh-> Depois de 1 ciclo Depois de 2 ciclos or r0,0,r9 slh-> sethi hi(56),r8 Depois de 3 ciclos or r0,0,r9 slh-> sethi hi(56),r8 or r8,8,r11 slt-> Depois de 4 ciclos or r0,0,r9 slh-> sethi hi(56),r8 or r8,8,r11 slt-> or r0,0,r10 or r0,0,r10 or r0,0,r9 slh-> sethi hi(56),r8 or r8,8,r11 ld [r10+r11],r8 slt-> Depois de 5 ciclos add r9,r8,r9 slt-> or r0,0,r10 or r0,0,r9 slh-> sethi hi(56),r8 or r8,8,r11 ld [r10+r11],r8 Depois de 6 ciclos Depois de 7 ciclos add r9,r8,r9 slt-> add r10,4,r10 or r0,0,r10 or r0,0,r9 slh-> sethi hi(56),r8 or r8,8,r11 ld [r10+r11],r8 9: ble loop 10: or r0, 0, r0 # nop
O algoritmo FCFS executando:
for (sum=0, i=0; i<x;i++) {
sum=a[i] + sum; }
1: or r0, 0, r9 # r9=sum 2: sethi hi(56), r8 # r8=temp 3: or r8, 8, r11 # r11=*a 4: or r0, 0, r10 # r10=4*i Loop: 5: ld [r10+r11],r8 6: add r9, r8, r9 7: add r10, 4, r9 8: subcc r10, 4*x-1,r0 9: ble loop or r0,0,r9 slh-> Depois de 1 ciclo Depois de 2 ciclos or r0,0,r9 slh-> sethi hi(56),r8 Depois de 3 ciclos or r0,0,r9 slh-> sethi hi(56),r8 or r8,8,r11 slt-> Depois de 4 ciclos or r0,0,r9 slh-> sethi hi(56),r8 or r8,8,r11 slt-> or r0,0,r10 or r0,0,r10 or r0,0,r9 slh-> sethi hi(56),r8 or r8,8,r11 ld [r10+r11],r8 slt-> Depois de 5 ciclos add r9,r8,r9 slt-> or r0,0,r10 or r0,0,r9 slh-> sethi hi(56),r8 or r8,8,r11 ld [r10+r11],r8 Depois de 6 ciclos Depois de 7 ciclos add r9,r8,r9 slt-> add r10,4,r10 or r0,0,r10 or r0,0,r9 slh-> sethi hi(56),r8 or r8,8,r11 ld [r10+r11],r8 Depois de 8 ciclos add r9,r8,r9 slt-> subcc r10,4*x-1,r0 or r0,0,r10 or r0,0,r9 slh-> sethi hi(56),r8 or r8,8,r11 ld [r10+r11],r8 add r10,4,r10 9: ble loop 10: or r0, 0, r0 # nop
O algoritmo FCFS executando:
for (sum=0, i=0; i<x;i++) {
sum=a[i] + sum; }
1: or r0, 0, r9 # r9=sum 2: sethi hi(56), r8 # r8=temp 3: or r8, 8, r11 # r11=*a 4: or r0, 0, r10 # r10=4*i Loop: 5: ld [r10+r11],r8 6: add r9, r8, r9 7: add r10, 4, r9 8: subcc r10, 4*x-1,r0 9: ble loop or r0,0,r9 slh-> Depois de 1 ciclo Depois de 2 ciclos or r0,0,r9 slh-> sethi hi(56),r8 Depois de 3 ciclos or r0,0,r9 slh-> sethi hi(56),r8 or r8,8,r11 slt-> Depois de 4 ciclos or r0,0,r9 slh-> sethi hi(56),r8 or r8,8,r11 slt-> or r0,0,r10 or r0,0,r10 or r0,0,r9 slh-> sethi hi(56),r8 or r8,8,r11 ld [r10+r11],r8 slt-> Depois de 5 ciclos add r9,r8,r9 slt-> or r0,0,r10 or r0,0,r9 slh-> sethi hi(56),r8 or r8,8,r11 ld [r10+r11],r8 Depois de 6 ciclos Depois de 7 ciclos add r9,r8,r9 slt-> add r10,4,r10 or r0,0,r10 or r0,0,r9 slh-> sethi hi(56),r8 or r8,8,r11 ld [r10+r11],r8 Depois de 8 ciclos add r9,r8,r9 slt-> subcc r10,4*x-1,r0 or r0,0,r10 or r0,0,r9 slh-> sethi hi(56),r8 or r8,8,r11 ld [r10+r11],r8 add r10,4,r10 add r9,r8,r9 slt-> ble loop or r0,0,r10 or r0,0,r9 slh-> sethi hi(56),r8 or r8,8,r11 add r10,4,r32 subcc r32,4*x-1,r0 or [r10+r11],r8 COPY r32,r10 Depois de 9 ciclos 9: ble loop 10: or r0, 0, r0 # nop
O algoritmo FCFS executando:
for (sum=0, i=0; i<x;i++) {
sum=a[i] + sum; }
1: or r0, 0, r9 # r9=sum 2: sethi hi(56), r8 # r8=temp 3: or r8, 8, r11 # r11=*a 4: or r0, 0, r10 # r10=4*i Loop: 5: ld [r10+r11],r8 6: add r9, r8, r9 7: add r10, 4, r9 8: subcc r10, 4*x-1,r0 9: ble loop or r0,0,r9 slh-> Depois de 1 ciclo Depois de 2 ciclos or r0,0,r9 slh-> sethi hi(56),r8 Depois de 3 ciclos or r0,0,r9 slh-> sethi hi(56),r8 or r8,8,r11 slt-> Depois de 4 ciclos or r0,0,r9 slh-> sethi hi(56),r8 or r8,8,r11 slt-> or r0,0,r10 or r0,0,r10 or r0,0,r9 slh-> sethi hi(56),r8 or r8,8,r11 ld [r10+r11],r8 slt-> Depois de 5 ciclos add r9,r8,r9 slt-> or r0,0,r10 or r0,0,r9 slh-> sethi hi(56),r8 or r8,8,r11 ld [r10+r11],r8 Depois de 6 ciclos Depois de 7 ciclos add r9,r8,r9 slt-> add r10,4,r10 or r0,0,r10 or r0,0,r9 slh-> sethi hi(56),r8 or r8,8,r11 ld [r10+r11],r8 Depois de 8 ciclos add r9,r8,r9 slt-> subcc r10,4*x-1,r0 or r0,0,r10 or r0,0,r9 slh-> sethi hi(56),r8 or r8,8,r11 ld [r10+r11],r8 add r10,4,r10 add r9,r8,r9 slt-> ble loop or r0,0,r10 or r0,0,r9 slh-> sethi hi(56),r8 or r8,8,r11 add r10,4,r32 subcc r32,4*x-1,r0 or [r10+r11],r8 COPY r32,r10 Depois de 9 ciclos Depois de 10 ciclos add r9,r8,r9 slt-> ble loop or r0,0,r10 or r0,0,r9 slh-> sethi hi(56),r8 or r8,8,r11 add r10,4,r32 subcc r32,4*x-1,r0 or [r10+r11],r8 COPY r32,r10 9: ble loop 10: or r0, 0, r0 # nop
O algoritmo FCFS executando:
for (sum=0, i=0; i<x;i++) {
sum=a[i] + sum; }
1: or r0, 0, r9 # r9=sum 2: sethi hi(56), r8 # r8=temp 3: or r8, 8, r11 # r11=*a 4: or r0, 0, r10 # r10=4*i Loop: 5: ld [r10+r11],r8 6: add r9, r8, r9 7: add r10, 4, r9 8: subcc r10, 4*x-1,r0 9: ble loop or r0,0,r9 slh-> Depois de 1 ciclo Depois de 2 ciclos or r0,0,r9 slh-> sethi hi(56),r8 Depois de 3 ciclos or r0,0,r9 slh-> sethi hi(56),r8 or r8,8,r11 slt-> Depois de 4 ciclos or r0,0,r9 slh-> sethi hi(56),r8 or r8,8,r11 slt-> or r0,0,r10 or r0,0,r10 or r0,0,r9 slh-> sethi hi(56),r8 or r8,8,r11 ld [r10+r11],r8 slt-> Depois de 5 ciclos add r9,r8,r9 slt-> or r0,0,r10 or r0,0,r9 slh-> sethi hi(56),r8 or r8,8,r11 ld [r10+r11],r8 Depois de 6 ciclos Depois de 7 ciclos add r9,r8,r9 slt-> add r10,4,r10 or r0,0,r10 or r0,0,r9 slh-> sethi hi(56),r8 or r8,8,r11 ld [r10+r11],r8 Depois de 8 ciclos add r9,r8,r9 slt-> subcc r10,4*x-1,r0 or r0,0,r10 or r0,0,r9 slh-> sethi hi(56),r8 or r8,8,r11 ld [r10+r11],r8 add r10,4,r10 add r9,r8,r9 slt-> ble loop or r0,0,r10 or r0,0,r9 slh-> sethi hi(56),r8 or r8,8,r11 add r10,4,r32 subcc r32,4*x-1,r0 or [r10+r11],r8 COPY r32,r10 Depois de 9 ciclos Depois de 10 ciclos add r9,r8,r9 slt-> ble loop or r0,0,r10 or r0,0,r9 slh-> sethi hi(56),r8 or r8,8,r11 add r10,4,r32 subcc r32,4*x-1,r0 or [r10+r11],r8 COPY r32,r10 ld [r10+r11],r8 add r9,r8,r9 slt-> ble loop or r0,0,r10 or r0,0,r9 slh-> sethi hi(56),r8 or r8,8,r11 add r10,4,r32 subcc r32,4*x-1,r0 or [r10+r11],r8 COPY r32,r10 Depois de 11 ciclos 9: ble loop 10: or r0, 0, r0 # nop
Envio de Instruções Longas para Cache
Não existe elemento livre, a lista de escalonamento é descarregada para o Cache VLIW, como um bloco, à taxa de 1 instrução longa por ciclo.
Três registradores slh, slt e olip são usados para descarregar. Todos os registradores são devolvidos ao pool.
Instrução que está chegando encabeça novo bloco. Operação simultânea. Não gera bolha na lista.
Instruções de Load/Store
São divididas e movidas pelo algoritmo sem restrições.
Endereços de dados são comparados com os de outras load/store. Registradores usados são comparados com os de outras instruções, incluindo load/store.
Memory Disambiguation
Instruções load/store executadas fora da seqüência original. Ocorre quando load lê de ou store escreve em posição de memória que está sendo escrita por store que deveria ser executado posteriormente.
Instruções load/store executadas fora da seqüência original. Ocorre quando load lê de ou store escreve em posição de memória que está sendo escrita por store que deveria ser executado posteriormente.
executado posteriormente.
Em máquinas VLIW é resolvido, geralmente, em tempo de compilação.
Na DTSVLIW, suporte de hardware extra foi adicionado para detecção e resolução em tempo de execução.
executado posteriormente.
Em máquinas VLIW é resolvido, geralmente, em tempo de compilação.
Na DTSVLIW, suporte de hardware extra foi adicionado para detecção e resolução em tempo de execução.
Memory Aliasing Detection
Suporte extra de hardware na máquina VLIW.
Campos extras são acrescentados nas instruções load/store Suporte extra de hardware na máquina VLIW.
Campos extras são acrescentados nas instruções load/store
order : recebe a ordem das inserções de load/store
cross bit :setado quando load/store é instalado em instrução
longa contendo store ou cópia de memória gerada por store
split.
Listas para armazenar endereços de load e de store.
order : recebe a ordem das inserções de load/store
cross bit :setado quando load/store é instalado em instrução
longa contendo store ou cópia de memória gerada por store
split.
Memory Aliasing Detection (load)
Instruções load têm seus endereços comparados com enderços de store em suas instruções longas e todos os endereços constantes na lista de store.
Instruções load têm seus endereços comparados com enderços de store em suas instruções longas e todos os endereços constantes na lista de store.
endereços constantes na lista de store.
Na coincidência, se order do load < order do store correspondente, é sinalizada exceção de aliasing. endereços constantes na lista de store.
Na coincidência, se order do load < order do store correspondente, é sinalizada exceção de aliasing.
Memory Aliasing Detection (store)
Instruções store têm seus endereços comparados com endereços de store e de load em suas instruções longas e todos os endereços de store e de load constantes na Instruções store têm seus endereços comparados com endereços de store e de load em suas instruções longas e todos os endereços de store e de load constantes na e todos os endereços de store e de load constantes na lista de store e de load.
Na coincidência, se order do store < order do load/store correspondente, é sinalizada exceção de aliasing.
e todos os endereços de store e de load constantes na lista de store e de load.
Na coincidência, se order do store < order do load/store correspondente, é sinalizada exceção de aliasing.
Instruções Multiciclo
Características adicionadas à lista de escalonamento: Instrução candidata e slot extras para cada elemento.
Duas instâncias são inseridas na lista de escalonamento, com referências cruzadas, evitando que instruções com dependências verdadeiras sejam escalonadas nos elementos delimitados pelas duas instâncias, afetados pela instrução multiciclo.
Instruções Multiciclo
Instância A
Instância B não sofre/provoca dependência de recurso e nem dependência de dados relativas às suas entradas.
Instância A não sofre/provoca dependência de dados relativas às suas saídas, sofre dependência de controle e, neste caso, a
Instância B
às suas saídas, sofre dependência de controle e, neste caso, a saída é renomeada e instância B é dividida.
Instâncias sobem juntas.
Se instância B sofre depêndência de saída ou antidependênica, ela é dividida e A é renomeada.
Exceções
Instruções split não devem sinalizar exeções até que a instrução cópia correspondente seja executada.
Para evitar, um bit de exceção é adicionado em cada registrador de Para evitar, um bit de exceção é adicionado em cada registrador de renomeação. Este bit é setado e propagado para o registrador de destino à cada leitura.
Quando instrução possui registrador de entrada com bit setado e registrador de destino é parte do estado, exceção é sinalizada.
Exceções
(mecanismo de tratamento)
CHECKPOINTING
Todos os registradores que constituem o estado da ISA são
salvos em registradores sombra no início da execução de cada bloco de instruções longas.
bloco de instruções longas.
Esquema 1: valores salvos em registradores sombra e após checkpoint, os valores são transferidos para a memória.
Esquema 2: valores sobrescritos no cache são salvos nos
registradores sombra. Em caso de exceção, os valores retornam ao cache.
Exceções
(mecanismo de tratamento)
Dados sobrescritos no cache de dados são salvos numa lista de recuperação de checkpoint de store (lrcs), que contém o
Store Instructions
endereço, o dado e o tipo do dado.
Esquema alternativo:
Dados são escritos em uma data store list que contém o endereço, o dado, o tipo do dado e campo order.
Exceções
(mecanismo de tratamento)
Detectada a exceção pela VLIW, Scheduler Engine entra no modo de recuperação da execução.
modo de recuperação da execução.
Registradores recebem valores armazenados nos registradores sombra, entradas da lista de recuperação de checkpoint de store são reescritas no cache, listas de load e de store são limpas.
Exceções
(mecanismo de tratamento)
Entrada no cache VLIW é invalidada.
Aliasing Exception
Entrada no cache VLIW é invalidada. Execução retorna no modo trace normal
Exceções
(mecanismo de tratamento)
Execução retorna no modo exceção até que a exceção se repita.
Outras Exceções
Neste modo, apenas o Processador Primário trabalha, após a exceção, sai do modo exceção.
Scheduler Engine Scheduler Unit I S Mu Mu Mu Mu
A máquina DTSVLIW
A máquina DTSVLIW
IC ProcessorPrimary EngineVLIW
Fecth Unit C A C H E F E WB F D WB E Fecth Unit PC Fecth Unit PC Fecth Unit PC [ I ] Fecth Unit PC [ I ] Fecth Unit PC [ I ] Fecth Unit PC [ I ] Fecth Unit PC [ I ] Fecth Unit PC [ I ] Fecth Unit PC [ I ] Fecth Unit PC [ I ] Fecth Unit PC [ I ] Fecth Unit PC [ I ] Fecth Unit PC [ I ] Fecth Unit PC [ I ] Fecth Unit PC [ I ] Fecth Unit PC [ I ] Fecth Unit PC [ I ] Fecth Unit PC [ I ] Fecth Unit PC [ I ] Fecth Unit PC [ I ] Fecth Unit PC [ I ]
AVALIAÇÃO
DE
DE
Maquina DTSVLIW factível
Parâmetros:
Bloco com 16 instruções longas com 8 instruções por instrução longa.
Máquina VLIW com largura de 12 unidades funcionais. Cache VLIW associativo de 192Kbyte.
compres gcc go ijpeg m88ksim perl vortex xlip H.Mean A.Mean Instruction per Cycle 2,07 1,33 1,31 2,77 2,56 2,17 1,92 1,98 1,89 2,01 Load Latency Cost 15,64% 8,16% 9,22% 20,47% 15,53% 31,67% 13,26% 27,32% 14,50% 17,66% VLIW Cache Cost 0,00% 33,27% 29,64% 0,00% 0,01% 0,00% 20,26% 1,31% - 10,56% Data Cache Cost 19,24% 3,39% 3,30% 1,38% 0,98% 0,18% 5,69% 3,58% 0,95% 4,72% Next LI Miss Cost 5,37% 2,23% 3,38% 0,03% 5,84% 5,49% 2,74% 6,72% 0,22% 3,97% Type F.U. Cost 0,00% 4,48% 4,34% 3,98% 1,96% 1,97% 1,51% 5,43% - 2,96% Instruction Cache Cost 0,01% 7,81% 4,92% 0,01% 0,23% 0,95% 5,17% 0,05% 0,02% 2,39% Aliasing Exceptions 0 4 39 0 1 0 1 0 - 5,63% VLIW Execution Cycles 96,43% 53,42% 60,47% 99,97% 98,47% 86,56% 73,58% 99,09% 79,19% 83,50% Valid Instr. per Block 25,18% 39,25% 35,15% 38,95% 36,44% 41,05% 44,96% 30,35% 35,35% 36,42%
compres gcc go ijpeg m88ksim perl vortex xlip H.Mean A.Mean Integer Ren. Reg. 33 49 44 24 38 33 39 28 34,32 36,00 Flag Ren. Reg. 17 20 17 15 18 21 18 17 17,70 17,88 Memory Ren. Reg. 14 14 8 7 11 8 15 8 9,78 10,63 Load List Size 10 15 16 7 10 11 12 10 10,72 11,38 Load List Size 10 15 16 7 10 11 12 10 10,72 11,38 Store List Size 32 15 32 5 13 12 23 14 13,24 18,25 Chckpnt Rec. St. L.S. 48 34 48 11 20 31 39 25 25,82 32,00
