Execução concorrente de instruções: Pipelines

Execução concorrente de instruções: Pipelines
João Canas Ferreira
Outubro de 2004
Contém figuras de “Computer Architecture: A Quantitative Approach”, J. Hennessey & D. Patterson, 3 a . ed., MKP
c○JCF, 2004 — AAC (FEUP/LEIC) Execução concorrente de instruções: Pipelines 1/33
Assuntos
1 Execução concorrente de instruções
Conceito e finalidade
Dependências entre instruções
2 Fundamentos da operação de pipelines
O que são pipelines
Pipeline de 5 andares
3 Resolução de conflitos
Conflitos estruturais
Conflitos de dados
Conflitos de controlo
c○JCF, 2004 — AAC (FEUP/LEIC) Execução concorrente de instruções: Pipelines 2/33

Execução concorrente de instruções Conceito e finalidade
O modelo sequencial de computação
No modelo sequencial de computação, a execução de um programa
processa-se do seguinte modo:
1. O CPU obtém uma instrução de memória.
2. A operação é efectuada.
3. É determinado o endereço da próxima instrução. Repetir a partir de 1.
Os efeitos observáveis da execução incluem a alteração de registos ou
posições de memória, a alteração de flags, geração de excepções, etc.
Numa implementação que corresponda directamente ao modelo apenas se
pode aumentar o desempenho tornando a execução da operação mais
rápida.
Para ultrapassar esse limite é preciso executar instruções parcial ou
totalmente em simultâneo.
Notas:
c○JCF, 2004 — AAC (FEUP/LEIC) Execução concorrente de instruções: Pipelines 3/33
3.1. O modelo sequencial permite atribuir de uma forma simples um “significado
operacional” a um programa. Tem a grande vantagem e ser relativamente
próximo de uma possível implementação em hardware (com a unidade de
controlo implementada por uma máquina de estados) e do modelo formal de
máquina de Turing. Tem a desvantagem de impor uma ordem na execução
de instruções cuja necessidade não decorre logicamente do algoritmo a
implementar.
3.2. No passo 3, a determinação da próxima instrução a executar é feita
geralmente de forma implícita: trata-se da instrução que reside na posição a
seguir à da instrução executada antes. Apenas as instruções de controlo de
fluxo indicam explicitamente a origem da próxima instrução (o “alvo” do
salto).
3.3. São concebíveis conjuntos de instruções em que cada instrução especifique o
endereço da seguinte (i.e., cada instrução é uma instrução de controlo de
fluxo). Muitos esquemas de microcódigo usam uma arquitectura desse tipo.
3

Execução concorrente
Execução concorrente de instruções Conceito e finalidade
Concorrência parcial: A execução de uma instrução é dividida em fases.
Num mesmo instante, diferentes instruções podem estar em diferentes
fases da sua execução.
Problema: Dado um programa, identificar que instruções podem ser
executadas concorrentemente, sem alterar os efeitos do programa.
Efeitos do programa: Sequência de alterações visíveis do estado da
memória e do processador.
Existem muitas técnicas para detectar e aproveitar o paralelismo entre
instruções (i.e. a capacidade de executar instruções concorrentemente).
Essa técnicas caem em duas categorias gerais:
1. técnicas dinâmicas — o processador detecta o paralelismo durante a
execução do programa (Pentium III e 4, PowerPC G4);
2. técnicas estáticas — o paralelismo é detectado antes da execução
pelo compilador (IA-64, sistemas embutidos).
Não se trata de uma divisão estanque; algumas técnicas podem ser
adoptadas nos dois domínios.
Notas:
c○JCF, 2004 — AAC (FEUP/LEIC) Execução concorrente de instruções: Pipelines 4/33
4.1. As técnicas estáticas obrigam à recompilação dos programas para cada
modelo diferente do compilador, mesmo que o conjunto de instrução não
mude. Quando a compatibilidade binária é importante, apenas as técnicas
dinâmicas pode ser usadas. Excepção: Pode ser possível produzir um
“tradutor binário” que converte um programa em binário de um modelo para
o outro, refazendo as optimizações necessárias. Consultar, por exemplo,
http://www.research.compaq.com/wrl/projects/om/om.html ou http:
//www.experimentalstuff.com/Technologies/Walkabout/index.html.
4.2. A utilização de técnicas dinâmicas não exclui o emprego das outras.
Considere-se o caso dos processadores da Intel que implementam a
arquitectura IA-32. A compatibilidade binária entre modelos é garantida,
mas a recompilação de um programa pode permitir a geração de código mais
eficiente para um modelo particular (mas igualmente correcto para qualquer
modelo).
4

Aspectos básicos
Execução concorrente de instruções Conceito e finalidade
➛ O quantidade de paralelismo existente num bloco básico é reduzida:
Blocos básicos têm tipicamente entre 5 e 7 instruções em média (MIPS).
➛ Paralelismo simples de identificar: loop-level parallelism
Paralelismo entre iterações de um ciclo.
for (i=1; i

Execução concorrente de instruções Dependências entre instruções
O conceito de dependência entre instruções
Duas instruções independentes podem ser executadas em simultâneo
sem conflitos, desde que existam recursos suficientes.
Quando existe uma relação de dependência entre duas instruções,
estes devem ser executadas em série (embora talvez com sobreposição
parcial).
dependências de dados:
dependências verdadeiras e dependências de nomes.
dependências de controlo
Um conflito ocorre sempre que existe uma dependência entre
instruções suficientemente próximas para que a sobreposição ou
re-ordenação modifique a ordem de acesso ao operando envolvido na
dependência.
A satisfação das dependências garante a manutenção da ordem do
programa , i.e., garante que as alterações de estado (observáveis) são as
especificadas pelo modelo sequencial de execução.
Notas:
c○JCF, 2004 — AAC (FEUP/LEIC) Execução concorrente de instruções: Pipelines 6/33
6.1. O conceito de dependência depende expressar formalmente a relação de
precedência entre duas instruções.
6.2. Instruções dependentes não podem executar de forma totalmente concorrente
com as instruções de que dependem. Isto não implica que uma execução
parcialmente concorrente seja impossível, como no caso de pipelines.
6.3. Um conflito ocorre sempre que a execução (parcialmente) concorrente de
instruções leva à violação de uma dependência. Se um conflito ocorre ou não
(para uma dada dependência) depende da organização interna do CPU. De
um modo geral, pretende-se minimizar a ocorrência de conflitos.
6.4. Um conflito pode ser sempre evitado se a execução de instruções retomar o
modo de funcionamento completamente sequencial. Ou seja, quando ocorre
um conflito é sempre possível resolvê-lo atrasando a execução das instruções
dependentes. Assim garante-se para cada instrução que aquelas de que
depende já foram certamente executadas.
6

Dependências de dados
Execução concorrente de instruções Dependências entre instruções
A instrução j depende da instrução i (i is data-dependent on j) se ocorrer
uma das duas situações seguintes:
1. a instrução i produz um resultado que pode ser usado pela instrução j;
2. a instrução j depende da instrução k, que, por sua vez, depende da
instrução i.
A cadeia de dependências pode englobar o programa completo.
Exemplo com 3 dependências:
Loop: L.D F0 , 0(R1) ; F0

Execução concorrente de instruções Dependências entre instruções
Características das dependências de dados
A presença de uma dependência de dados numa sequência de
instruções reflecte uma dependência no programa original:
dependências são propriedades dos programas.
O facto de uma dependência resultar na detecção de um conflito e/ou
de causar um protelamento são propriedades da organização da
pipeline.
Uma dependência:
1. indica a possibilidade de existência de um conflito;
2. determina a ordem de cálculo;
3. estabelece um limite superior para a quantidade de paralelismo que
pode ser aproveitado.
Fluxo de dados: (i) por registos [e flags]; (ii) por memória.
Soluções:
1. manter a dependência, mas evitar o conflito;
2. eliminar a dependência por transformação do código.
Notas:
c○JCF, 2004 — AAC (FEUP/LEIC) Execução concorrente de instruções: Pipelines 8/33
8.1. Dependências causadas por transferências de informação via memória podem
ser difíceis de detectar. Por exemplo, as instruções L.D R1, 100(R4) e
L.D R1, 64(R6) podem designar a mesma posição de memória (por
exemplo, se R4=0 e R6=36). Neste caso, diz-se que os endereços efectivos
são iguais.
8.2. O endereço efectivo de uma instrução também pode variar durante a
execução do programa: basta que o conteúdo do registo associado mude.
Portanto, para efeitos de detecção de conflitos, não basta analisar os códigos
das instruções, é necessário ter em conta também o estado dos registos.
8.3. Quando não é possível garantir a ausência de conflitos, é necessário assumir
que eles podem existir, caso contrário, não seria possível garantir a execução
correcta do programa.
8

Dependências de nome
Execução concorrente de instruções Dependências entre instruções
Uma dependência de nome ocorre quando duas instruções usam o mesmo
registo ou posição de memória (um «nome»), mas sem que haja um fluxo
de dados associado com esse nome. Existem dois tipos de dependências de
nome envolvendo uma instrução i que precede a instrução j num programa:
Uma antidependência entre i e j ocorre quando a instrução j escreve
num registo ou posição de memória lido pela instrução i.
Uma dependência de saída ocorre quando ambas as instruções
escrevem no mesmo registo ou posição de memória. A ordem das
instruções deve ser preservada para garantir que o valor final
corresponde a j.
Como não se trata de verdadeiras dependências, as instruções i e j podem
ser executadas simultaneamente (ou por ordem diferente) desde que o
«nome» usado seja mudado. Esta operação é mais fácil de executar (pelo
compilador ou processador) para registos: register renaming.
Notas:
c○JCF, 2004 — AAC (FEUP/LEIC) Execução concorrente de instruções: Pipelines 9/33
9.1. Dependências de nome ocorrem, por exemplo, quando um registo (associado
a uma variável) é reutilizado para guardar o valor de outra variável.
9.2. Em geral, dependências de nome envolvendo registos podem ser evitadas se
existirem registos temporários que permitam guardar todos os valores. Todas
as instruções que referem o «nome» original devem ser modificadas
dinamicamente para usarem os dados dos registos temporários apropriados.
9

Conflitos de dados
Execução concorrente de instruções Dependências entre instruções
Conflitos de dados possíveis entre duas instruções i e j (que ocorrem no
programa por esta ordem):
RAW (read after write) — j tenta ler uma fonte antes que i aí coloque
um valor. Corresponde a uma verdadeira dependência de dados.
WAW (write after write) — j tenta escrever num local antes de i.
Corresponde a uma dependência de saída. Ocorre em pipelines que
efectuam escritas em mais que um andar ou que permitem que
instruções continuem mesmo quando uma instrução anterior é
protelada.
WAR (write after read) — j tenta escrever num local antes de este
ser lido por i. Corresponde a uma antidependência. Não ocorre na
maioria das pipelines com emissão estática de instruções.
RAR (read after read) não constitui um conflito.
Notas:
c○JCF, 2004 — AAC (FEUP/LEIC) Execução concorrente de instruções: Pipelines 10/33
10.1. O nome dos conflitos é dado de acordo com a ordem do programa que deve
ser preservada.
10.2. Conflitos do tipo war tendem a surgir apenas em processadores que emitem
instruções fora de ordem (emitir uma instrução = iniciar a sua execução) ou
que suportam conjuntos heterogéneos de instruções em que algumas
instruções alteram dados no início da execução e outras lêem dados nas fases
finais da execução. Muitos processadores nunca podem ter conflitos deste
tipo.
10.3. Conflitos do tipo waw também não correm nas organizações concorrentes
mais simples. Por exemplo, a pipeline básica analisada mais à frente não tem
destes conflitos.
10

Execução concorrente de instruções Dependências entre instruções
Dependências de controlo
Uma dependência de controlo determina a ordem de uma instrução i face
a uma instrução de salto condicional. Todas as instruções de um
programa, excepto as do primeiro bloco básico, dependem de algum
conjunto de saltos condicionais.
Dependências de controlo impõem duas restrições:
Uma instrução dependente de um salto não pode ser colocada antes do
salto, porque já não seria controlada pelo instrução de salto condicional.
Uma instrução que não está dependente de um salto não pode ser movida
para depois de um salto, porque passaria a ser controlada por esse salto.
No caso mais simples, dependências de controlo são preservadas porque
1. as instruções são executadas pela ordem em que surgem no programa;
2. o controlo de conflitos garante que uma instrução não é executada antes de se
conhecer o destino do salto.
Respeitar as dependências de controlo não é um fim em si; o que se quer
garantir é o fluxo de dados e o comportamento face a excepções.
Notas:
c○JCF, 2004 — AAC (FEUP/LEIC) Execução concorrente de instruções: Pipelines 11/33
11.1. Exemplo de uma dependência de controlo simples:
if cond1 instr1;
if cond2 instr2;
A instrução instr1 apresenta uma dependência de controlo em relação a
cond1 e instr2 tem uma dependência de controlo de cond2, mas não de
cond1.
11

Execução concorrente de instruções Dependências entre instruções
Comportamento correcto na presença de excepções
➛ Comportamento correcto na presença de excepções significa que
qualquer alteração da ordem de execução das instruções não modifica a
forma como as excepção são levantadas no programa.
➛ Frequentemente usa-se uma condição mais relaxada: a nova ordem não
deve causar a ocorrência de novas excepções no programa.
DADDU R2 , R3, R4
BEQZ R2 , L1 ; saltar para L1 se R2=0
LW R1, 0( R2 )
L1: . . .
Existe uma dependência de dados envolvendo R2.
É possível trocar as duas últimas instruções? Não existe nenhuma de
dependência de dados entre elas. Mas a instrução LW pode causar uma
excepção no acesso a memória.
Uma técnica designada por especulação permite ultrapassar este problema.
Notas:
c○JCF, 2004 — AAC (FEUP/LEIC) Execução concorrente de instruções: Pipelines 12/33
12.1. A dependência de dados envolvendo R2 impõe que a primeira instrução seja
executada em primeiro lugar, mas não impõe uma ordem relativa entre as
outras duas; essa ordem é imposta pela dependência de controlo de LW em
relação a BEQZ. Não existe uma dependência de dados entre estas duas
instruções.
12.2. Como é que a instrução LW pode causar uma excepção? Por exemplo,
acedendo a uma zona de memória que não pertença ao seu processo. Assim,
poderia ocorrer uma excepção que não surgiria se a ordem do programa fosse
alterada.
12.3. As técnicas de especulação devem ser capazes de anular o lançamento da
excepção caso o salto condicional seja efectivamente tomado.
12

Execução concorrente de instruções Dependências entre instruções
Preservação do fluxo de dados
Fluxo de dados: fluxo de valores entre as instruções que os produzem e as
que os consomem. As instruções de salto condicional fazem com que o
fluxo seja dinâmico, i.e., o valor de um dado registo/posição de memória
pode provir de diferentes origens.
DADDU R1, R2, R3
BEQZ R4, L
DSUBU R1, R5, R6
L: . . .
OR R7, R1, R8
DSUBU não pode ser colocada antes do salto por alterar o fluxo de dados
de OR. O valor de R1 depende do salto BEQZ.
Por vezes, é possível determinar que o desrespeito de uma dependência de
controlo não afecta o fluxo ou a geração de excepções. Esta tarefa é
geralmente efectuada pelos compiladores.
Notas:
c○JCF, 2004 — AAC (FEUP/LEIC) Execução concorrente de instruções: Pipelines 13/33
13.1. Exemplo de uma situação DADDU em R1, que R2, umaR3dependência de controlo pode ser
BEQZ R12, skipnext
desrespeitada:
DSUBU R4, R5, R6 ; pode ser "adiantada"
DADDU R5, R4, R9
skipnext: OR R7, R8, R9 ; R4 não é usado mais
Suponhamos que o registo R4não era usado no bloco de código colocado após
a etiqueta skipnext. Então passar a instrução DSUBU para antes do salto
não alteraria os efeitos do programa (o item de dados em R4 está “morto”).
13.2. Determinar se os dados guardados num registo estão “vivos” (vão ser ainda
usados) ou “mortos” (não são mais usados) é uma das tarefas que
geralmente incumbe ao compilador (para saber quando pode reutilizar
registos).
13

Pipelines
Fundamentos da operação de pipelines O que são pipelines
Pipelining é uma técnica de implementação em que a execução de
múltiplas instruções é feita concorrentemente.
Analogia: Linha de montagem.
A B C D
andar 1 andar 2 andar 3 andar 4
ciclo 1 2 3 4 5 6 · · ·
inst 1 A B C D
inst 2 A B C D
inst 3 A B C D
inst 4 A B C · · ·
inst 5 A B · · ·
inst 6 A · · ·
Notas:
Cada andar trabalha concorrentemente
com os outros, embora sobre
uma “parte” diferente da instrução.
débito: n o de instruções que são completadas
(i.e. abandonam a pipeline) por unidade
de tempo.
ciclo do processador: tempo necessário
para “mover” a instrução através de 1 andar.
O ciclo do processador é determinado pelo
andar mais lento.
Ideal: Equilibrar o tempo de todos os andares.
c○JCF, 2004 — AAC (FEUP/LEIC) Execução concorrente de instruções: Pipelines 14/33
14.1. Em cada instante podem estar até 4 instruções em execução (neste
exemplo); em cada ciclo (a partir do 4) é terminada uma instrução.
14.2. Como os andares estão interligados, é necessário que todos estejam prontos
ao mesmo tempo: esse tempo constitui o período do ciclo de relógio do
processador.
14.3. Porque os andares devem prosseguir todos ao mesmo tempo, a duração do
ciclo é determinado pelo tempo necessário para que o andar mais lento
execute a sua tarefa.
14.4. Se o tempo de processamento de todos os andares for idêntico, então o
tempo médio por operação é (em condições ideais)
tempo por instrução do CPU sem pipeline
número de andares
14.5. Pipelining é tipicamente invisível para o programador (em CPUS com
interlocks).
14

Fundamentos da operação de pipelines Pipeline de 5 andares
Um conjunto de instruções RISC básico
Para efeitos de análise das questões que surgem em pipelines, usaremos
um subconjunto do MIPS64 (ver tb. a página www da disciplina).
➛ Todas as operações sobre dados aplicam-se a registos de 64 bits e
modificam todo o registo;
➛ Apenas instruções load/store afectam a memória; podem operar sobre
parte de um registo (por exemplo, afectando 32 bits de 64);
➛ As instruções têm todas o mesmo comprimento e os formatos
diferentes são poucos.
➛ Instruções da ALU: Tomam dois registos, ou um registo e um valor
imediato de 16 bits, como operandos e guardam o resultado num
terceiro registo.
➛ Instruções load/store: Tomam um registo (a base) e um
deslocamento (de 16 bits) como operandos. Um segundo registo é o
destino/origem da transferência.
➛ Saltos condicionais e incondicionais: Os saltos condicionais
baseiam-se no resultado da comparação entre dois registos.
Notas:
c○JCF, 2004 — AAC (FEUP/LEIC) Execução concorrente de instruções: Pipelines 15/33
15.1. As instruções indicadas constituem um subconjunto de MIPS64. Esta
arquitectura de conjunto de instruções será analisada com mais pormenor
numa aula teórico-prática.
15.2. Os saltos condicionais são relativos e têm um deslocamento de 16 bits (são
interpretados como números com sinal).
15.3. Todas as instruções têm todas o mesmo tamanho: 32 bits.
15

Fundamentos da operação de pipelines Pipeline de 5 andares
Implementação multi-ciclo sem pipelining
1. IF (instruction fetch): Usa o endereço contido no contador de
programa (PC) para ir buscar a instrução actual a memória. Actualiza
PC: PC ← PC+4.
2. ID (instruction decode/register fetch): Descodifica a instrução e lê
os registos fonte. Compara registos. Efectua extensão do
deslocamento. Calcula endereço de destino e actualiza PC (se saltar).
3. EX (execution/effective address): Uma de 3 operações: (i) calcula
endereço efectivo para acesso a memória; (ii) a ALU executa a
operação sobre os registos; (iii) a ALU executa operação sobre registo e
valor imediato.
4. MEM (memory access): Para instruções load/store: transferir dados.
5. WB (write-back): Instrução de ALU ou load: guardar dados em
registo.
Saltos: 2 ciclos, store: 4 ciclos, outras: 5 ciclos. Globalmente, CPI=4.54 se
assumirmos frequências de 12%, 10%, e 78%, respectivamente.
Notas:
c○JCF, 2004 — AAC (FEUP/LEIC) Execução concorrente de instruções: Pipelines 16/33
16.1. Este esquema apresenta uma divisão possível das etapas pelas quais passa a
execução de cada instrução. Trata-se de um passo preliminar, com vista a
simplificar a descrição do funcionamento da pipeline básica.
16.2. Nem todas as instruções necessitam de todas as etapas. As instruções de
salto terminam na 2 a etapa. As instruções de escrita em memória terminam
na 4 a etapa.
16.3. As instruções de ALU não fazem nada na etapa 4, terminando na etapa 5.
Seria possível antecipar a última tarefa da etapa 5 para a etapa 5. Contudo,
isso já não será possível na implementação em pipeline, pelo que também
não é feito aqui.
16

Fundamentos da operação de pipelines Pipeline de 5 andares
Pipeline de cinco andares
O processamento pode ser implementado com pipeline de 5 andares (aliás
a divisão de tarefas da transparência anterior já foi feita a pensar nisso).
Ciclo de processador
Instrução 1 2 3 4 5 6 7 8 9
i IF ID EX MEM WB
i + 1 IF ID EX MEM WB
i + 2 IF ID EX MEM WB
i + 3 IF ID EX MEM WB
i + 4 IF ID EX MEM WB
Restrição: Não é possível usar os mesmos recursos em duas tarefas
diferentes no mesmo ciclo! Memórias cache separadas para dados e
instruções evitam conflitos entre IF e MEM.
Notas:
c○JCF, 2004 — AAC (FEUP/LEIC) Execução concorrente de instruções: Pipelines 17/33
17.1. A fase IF tem um acesso implícito a memória, pelo que poderia interferir
com instruções na fase MEM. Para evitar um conflito, vamos assumir que
memória de instruções e memória de dados são diferentes. Embora tal não
corresponda estritamente à realidade, a utilização de caches separadas para
dados e instruções faz com que seja uma aproximação razoável.
17.2. Para já assumimos que o acesso a memória pode ser feito apenas num ciclo
de relógio do processador. Trata-se de uma suposição menos realista que a
anterior. Veremos mais tarde como remover esta restrição e de que maneira
é afectado o desempenho global.
17.3. As instruções de salto só usam dois andares: IF e ID.
17.4. As instruções de escrita em memória (store) não têm WB.
17.5. Estamos a assumir que as operações executadas em EX apenas necessitam
de um ciclo de relógio. Isso não se aplica a operações como a divisão nem a
operações com vírgula flutuante.
17

Fundamentos da operação de pipelines Pipeline de 5 andares
Múltiplos percursos de dados desfasados no tempo
O banco de registos tem de suportar 2 leituras e 1 escrita por ciclo.
Problema: Salto condicional só modifica PC no andar ID.
Notas:
c○JCF, 2004 — AAC (FEUP/LEIC) Execução concorrente de instruções: Pipelines 18/33
18.1. Implicitamente estamos a assumir que existem recursos para executar
concorrentemente as várias operações. Por exemplo, o cálculo do novo valor
de PC no caso de um salto não pode ser feito pela ALU (que estará ocupada
com o processamento de outra instrução).
18.2. O banco de registos pode tornar-se facilmente num factor de contenção.
Vamos assumir que todas as leituras são feitas no fim do ciclo de relógio (por
instruções na fase ID) e que a escrita é feita no início do ciclo de relógio
(pela instrução que passar para WB).
período de relógio
escrita
18.3. Como estamos assumir uma implementação relativamente agressiva dos
saltos condicionais, supomos que o PC é modificado no segundo ciclo da
instrução (ID). Mesmo assim, os saltos (condicionais ou incondicionais) vão
introduzir um conflito de controlo.
18
leitura

Fundamentos da operação de pipelines Pipeline de 5 andares
Inserção de registos entre andares
Evitam a interferência entre andares e preservam valores intermédios.
Notas:
c○JCF, 2004 — AAC (FEUP/LEIC) Execução concorrente de instruções: Pipelines 19/33
19.1. Sem cuidados especiais, a actividade “lógica” não pode ser limitada a um
certo andar (i.e., os efeitos de qualquer mudança propagar-se-iam mais ou
menos rapidamente por todo o circuito). Para evitar essa interferência, todos
os os sinais que saem de um andar são “registados”, ou seja, os seus valores
são guardados num elemento de memória (registo) cujo conteúdo apenas é
alterado no flanco ascendente do relógio.
19.2. Muitos dos registo já seriam necessários numa implementação multi-ciclo
para preservar valores entre os diferentes ciclos.
19.3. Os registos também serão aproveitados para evitar alguns conflitos
provocados por dependências de dados (cf. forwarding).
19

Fundamentos da operação de pipelines Pipeline de 5 andares
Desempenho de pipelines (1 a abordagem)
Pipeline idealmente equilibrada: tinst_p = tinst
Nandares
Na prática, o tempo de execução de cada instrução aumenta
ligeiramente devido a overhead de controlo.
O programa é mais rápido embora nenhuma instrução seja mais
rápida!
Speedup: Sp = tinst/tinst_p
Na prática, certa instruções podem necessitar de ciclos de
protelamento em algumas circunstâncias. Seja nprot o número médio
de ciclos de protelamento por instrução. Então:
CPIp = CPIideal + nprot = 1 + nprot
Assumindo igual frequência de relógio:
Notas:
Sp = CPI
1 + nprot
c○JCF, 2004 — AAC (FEUP/LEIC) Execução concorrente de instruções: Pipelines 20/33
20.1. A melhoria de desempenho proporcionada por pipelining é directamente
dependente do número médio de ciclos de protelamento. Torna-se, portanto,
imperioso reduzir nprot ao mínimo. Como os saltos são, em muitas
organizações de CPU, a principal fonte de ciclos de protelamento, torna-se
vital reduzir a sua frequência ou o seu impacto.
20.2. A expressão final para Sp assume que a frequência de relógio de uma
implementação pipelined é igual à de uma implementação multi-ciclo. Na
prática, será ligeiramente maior (≈ 10%). O número de instruções
executadas é naturalmente o mesmo.
20

Resolução de conflitos
Alguns problemas na utilização de pipelines
Existem situações (hazards) em que uma instrução não pode ser executada
durante o ciclo apropriado. Existem três tipos de conflitos:
estruturais É um conflito de recursos: o hardware não suporta a
execução concorrente de todas as combinações possíveis de
tarefas;
de dados Este conflito surge quando uma instrução depende dos
resultados de uma instrução anterior de uma forma que é
“exposta” pela linha de processamento.
de controlo este conflito resulta de saltos condicionais ou de outras
instruções que alteram o PC.
Conflitos reduzem o desempenho ideal da pipeline.
Notas:
c○JCF, 2004 — AAC (FEUP/LEIC) Execução concorrente de instruções: Pipelines 21/33
21.1. Conflitos de dados e de controlo são devidos, respectivamente, a
dependências de dados e de controlo. Conflitos estruturais resultam da
inexistência de recursos suficientes para executar algumas operações
concorrentemente.
21

Resolução de conflitos
Protelamento de operações
Conflitos podem obrigar a protelar (stall) o processamento de instruções.
Habitualmente quando uma instrução é protelada:
1. todas as instruções emitidas posteriormente também são proteladas;
2. todas as instruções emitidas anteriormente devem prosseguir (para
“limpar” a situação de conflito).
Consequência: durante o protelamento não são processadas novas
instruções.
Pode não ser economicamente proveitoso eliminar conflitos que ocorram
raramente, porque os protelamentos associados são raros (número médio
de ciclos de protelamento causados por esses conflitos é baixo).
Nota: Existem esquemas em que as instruções emitidas posteriormente
podem “passar à frente” da instrução protelada (se não violarem nenhuma
dependência).
Notas:
c○JCF, 2004 — AAC (FEUP/LEIC) Execução concorrente de instruções: Pipelines 22/33
22.1. O protelamento de operação é a solução “universal”. Contudo, é sempre
preciso implementar circuitos de detecção de conflitos (pipeline interlocks).
22

Conflitos estruturais
Resolução de conflitos Conflitos estruturais
A execução concorrente de instruções em pipeline pode requerer que as
unidades funcionais sejam também pipelined e que outros recursos sejam
duplicados para acomodar todas as combinações possíveis de instruções. O
processamento pode exibir conflitos estruturais quando tal não acontece.
Exemplo: processador com uma memória cache partilhada para
dados/instruções (memória comum de dados e instruções).
Ciclo de processador
Instrução 1 2 3 4 5 6 7 8 9 10
load IF ID EX MEM WB
i + 1 IF ID EX MEM WB
i + 2 IF ID EX MEM WB
i + 3 stall IF ID EX MEM WB
i + 4 IF ID EX MEM WB
i + 5 IF ID EX MEM
i + 6 IF ID EX
Notas:
c○JCF, 2004 — AAC (FEUP/LEIC) Execução concorrente de instruções: Pipelines 23/33
23.1. Esta situação não ocorre na organização de base que estamos a analisar,
porqie assumimos a existência de caches separadas de dados e instruções.
23

Resolução de conflitos Conflitos estruturais
Ilustração de um conflito estrutural
Notas:
c○JCF, 2004 — AAC (FEUP/LEIC) Execução concorrente de instruções: Pipelines 24/33
24.1. Notar que não existe nenhum conflito estrutural associado ao banco de
registos.Por exemplo, no ciclo 5, ocorrem uma escrita no banco de registos
(associado à instrução load) e duas leituras (associadas à instrução 3). Estas
operações ocorrem em partes diferentes do ciclo, conforme indicado
graficamente pelo tracejado: a escrita acontece no início do ciclo, as leituras
no fim.
24

Conflitos de dados
Resolução de conflitos Conflitos de dados
Um grande efeito de pipelining é modificar a temporização relativa das
operações, o que pode introduzir conflitos.
Conflitos de dados ocorrem quando a ordem de leitura/escrita de
operandos é modificada (por referência à versão sem pipelining).
Exemplo:
DADD R1, R2, R3
DSUB R4, R1, R5 ;ADD altera R1 em WB, mas DSUB requer valor em ID
AND R6, R1, R7 ;R1 correcto fim do ciclo 5; AND lê registos no 4
OR R8, R1, R9 ;OR não tem conflitos; leituras na 2 a parte do ciclo
XOR R10, R1, R11 ;não tem conflitos
Notas:
c○JCF, 2004 — AAC (FEUP/LEIC) Execução concorrente de instruções: Pipelines 25/33
25.1. O registos R1 é alterado pela primeira instrução. Como o resultado da
instrução só atinge os registos no quinto ciclo, a instrução DSUB produz um
conflito ao querer usar o novo valor de R1 no quarto ciclo (a sua etapa EX),
já que isso implica a leitura dos registos no fim do ciclo anterior (o ciclo 3).
25.2. A instrução AND também produz um conflito: precisa do novo valor logo no
início do quinto ciclo (a sua etapa EX), e portanto, a leitura dos registos foi
feita no ciclo anterior, quando o banco de registos ainda tinha o valor antigo
de R1.
25.3. A instrução OR já não provoca conflito.
25.4. Este tipo de conflito entre instruções da ALU é muito frequente e introduz 2
ciclos de protelamento, o que é muito. Consequentemente, este tipo de
conflito deve necessariamente ser resolvido.
25.5. Notar que o conflito surge porque a alteração do banco de registos é
efectuada 2 ciclos depois do cálculo do resultado. O resultado propriamente
dito já foi calculado (no fim do ciclo 3).
25

Resolução de conflitos Conflitos de dados
Forwarding pode resolver conflitos de dados
O resultado da ALU é realimentado para a sua entrada. O banco de
registos (leitura e escrita em partes diferentes do ciclo) também serve para
fazer forwarding. A sequência analisada executa sem protelamento.
Notas:
c○JCF, 2004 — AAC (FEUP/LEIC) Execução concorrente de instruções: Pipelines 26/33
26.1. O novo valor de R1 é calculado antes de ser necessário para as operações
seguintes. Apenas o banco de registos não é actualizado suficientemente
depressa.
26.2. Para resolver o conflito, basta “agulhar” o futuro valor de R1 do registo
temporário onde se encontra para a entrada do andar que necessita do seu
valor. Locais de origem e destino dos dados estão indicados a tracejado na
figura.Sempre que o destino estiver à frente da origem, deve proceder-se ao
agulhamento necessário.
26.3. Para além dos circuitos de agulhamento (basicamente multiplexadores), o
CPU deve dispor também de circuitos de detecção dos conflitos.
26.4. A utilização de forwarding é indispensável para um bom desempenho.
26

Resolução de conflitos Conflitos de dados
Protelamento pode ser inevitável
LD R1, 0(R2) ; dados prontos apenas no fim do ciclo 4
DSUB R4, R1, R5 ; necessita de dados no início de 4
AND R6, R1, R7
OR R8, R1, R9
Notas:
c○JCF, 2004 — AAC (FEUP/LEIC) Execução concorrente de instruções: Pipelines 27/33
27.1. O esquema de forwarding não resolve todos os problemas. Por exemplo, o
conflito que ocorre quando uma instrução usa um valor lido de memória pela
instrução imediatamente precedente não pode ser resolvido desta maneira.
27.2. De facto, o valor ainda não está no CPU no instante em que se pretenderia
utilizá-lo. Isso é indicado pelo segmento a tracejado em que o destino (o
“lugar” onde o valor é necessário para o restante processamento) está
“atrás” da origem.
27

Resolução de conflitos Conflitos de dados
Protelar resolve o problema. . .
Ciclo de processador
Instrução 1 2 3 4 5 6 7 8 9
LD R1,0(R2) IF ID EX MEM WB
DSUB R4, R1, R5 IF ID EX MEM WB
AND R6, R1, R7 IF ID EX MEM WB
OR R8, R1, R9 IF ID EX MEM WB
LD R1,0(R2) IF ID EX MEM WB
DSUB R4, R1, R5 IF ID stall EX MEM WB
AND R6, R1, R7 IF stall ID EX MEM WB
OR R8, R1, R9 stall IF ID EX MEM WB
A sequência de etapas de processamento da tabela inferior mostra como o
protelamento resolve o problema de ter os dados correctos em R1.
Notas:
c○JCF, 2004 — AAC (FEUP/LEIC) Execução concorrente de instruções: Pipelines 28/33
28.1. Notar que o processamento de todas as instruções subsequentes à que
provoca o conflito também são proteladas.
28.2. A obtenção de instruções (etapa IF) também é protelada.
28

Conflitos de controlo
Resolução de conflitos Conflitos de controlo
Saltos condicionais causam conflitos de controlo porque podem alterar ou
não o PC (quando o fazem é no fim de ID).
O que fazer enquanto não é possível determinar se o salto é realmente
feito (ou tomado) ? Nada. . . e repetir quando já existir a informação.
Ciclo de processador
Instrução 1 2 3 4 5 6 7 8 9
salto relativo IF ID EX MEM WB
sucessor IF IF ID EX MEM WB
sucessor + 1 IF ID EX MEM WB
sucessor + 2 IF ID EX MEM WB
Dada a frequência de saltos relativos, estes conflitos podem levar a perdas
de desempenho na ordem dos 10%–30% !
Notas:
c○JCF, 2004 — AAC (FEUP/LEIC) Execução concorrente de instruções: Pipelines 29/33
29.1. Nesta arquitectura um salto condicional demora tanto como um salto
incondicional. Em ambos os caso, o PC tem o novo valor do endereço no fim
da etapa ID.
29.2. Em muitas organizações de pipeline, o salto condicional necessita de mais
ciclos que o incondicional.
29.3. A instrução “sucessor” não pode entrar imediatamente na fase de
descodificação. O primeiro IF (da 2 a linha) obtém a instrução do valor
“regular” do PC (a instrução residente em memória a seguir ao salto
relativo). Este valor pode não ser o correcto. O segundo IF já usa o valor de
PC definido no ciclo 2 (o valor correcto).
29.4. Quando o salto não é tomado, o segundo IF é desnecessário. Esse facto pode
ser aproveitado para reduzir o impacto do conflito de controlo.
29

Resolução de conflitos Conflitos de controlo
Alternativa: Optar por uma das alternativas
O CPU assume que o salto não é tomado e corrige a sua decisão quando
determinar o valor da condição (se necessário).
Ciclo de processador
Instrução 1 2 3 4 5 6 7 8 9
salto não tomado IF ID EX MEM WB
i + 1 IF ID EX MEM WB
i + 2 IF ID EX MEM WB
i + 3 IF ID EX MEM WB
i + 4 IF ID EX MEM WB
salto tomado IF ID EX MEM WB
i + 1 IF inact. inact. inact. inact.
alvo IF ID EX MEM WB
alvo + 1 IF ID EX MEM WB
alvo + 2 IF ID EX MEM WB
Também se pode partir do princípio que o salto é tomado. No caso
presente, isso não tem interesse. (Porquê?)
Notas:
c○JCF, 2004 — AAC (FEUP/LEIC) Execução concorrente de instruções: Pipelines 30/33
30.1. Assumir que o salto é tomado obriga ainda assim a calcular a posição da
instrução seguinte (“alvo” do salto).
30.2. Quando o salto é tomado, a instrução subsequente em processamento é
errada: internamente é transformado numa instrução NOP (no operation).
No nosso caso, isso é simples, porque a instrução ainda não alterou o estado
interno do CPU.
30

Resolução de conflitos Conflitos de controlo
Execução incondicional da instrução seguinte
Outra opção: Executar sempre a instrução colocada a seguir ao salto!
Ciclo de processador
Instrução 1 2 3 4 5 6 7 8 9
salto não tomado IF ID EX MEM WB
(delay slot) i + 1 IF ID EX MEM WB
i + 2 IF ID EX MEM WB
i + 3 IF ID EX MEM WB
i + 4 IF ID EX MEM WB
salto tomado IF ID EX MEM WB
(delay slot) i + 1 IF ID EX MEM WB
alvo IF ID EX MEM WB
alvo + 1 IF ID EX MEM WB
alvo + 2 IF ID EX MEM WB
Notas:
c○JCF, 2004 — AAC (FEUP/LEIC) Execução concorrente de instruções: Pipelines 31/33
31.1. A este tipo de salto chama-se delayed btanch e a posição da instrução
executada incondicionalmente designa-se por delay slot. Algumas
arquitecturas têm dois delay slots.
31.2. Neste caso, o trabalho de encontrar uma instrução para o delay slot é
deixado ao compilador ou programador em assembly.
31.3. Caso não seja possível encontrar uma instrução apropriada, coloca-se uma
instrução NOP no delay slot.
31

Resolução de conflitos Conflitos de controlo
Branch delay slot: estratégias de sequenciamento
Notas:
c○JCF, 2004 — AAC (FEUP/LEIC) Execução concorrente de instruções: Pipelines 32/33
32.1. A situação (a) é a melhor. As estratégias (b) e (c) são usadas quando a
estratégia (a) não é possível.
32.2. A estratégia (b) requer geralmente a duplicação da instrução colocada no
delay slot. Esta estratégia é boa para casos em que o salto é tomado com
elevada probabilidade (como no caso dos ciclos).
32.3. Para que (b) e (c) sejam legais, é necessário que a execução da instrução não
altere o resultado do programa. Quando muito, o trabalho executado por
essa instrução é desperdiçado.
32.4. No caso do exemplo (c), o registo R7 poderia conter um valor temporário
que simplesmente não é usado quando o salto é tomado. Note-se que o caso
(b) o valor final de R4 não é o mesmo; se isso for importante, a duplicação
da instrução não pode ser feita.
32

Resolução de conflitos Conflitos de controlo
Impacto da arquitectura do conjunto de instruções
A arquitectura do conjunto de instruções pode introduzir factores de
ineficiência e dificuldades de implementação.
Instruções que que alteram o estado a “meio” da execução dificultam
o tratamento de excepções. Exemplos: auto-incremento em IA-32. O
processador necessita de ter a capacidade para reverter o estado.
Instruções de cópia de strings também pertencem a esta categoria
(solução: usar registos como memória de trabalho).
Alguns elementos de estado (p. ex. códigos de condição) podem
dificultar o funcionamento da pipeline (p. ex. instruções que alterem
os c.c. não podem ser colocadas no delay slot). Pode ser difícil
determinar quando é que o código de condição é válido.
Instruções multi-ciclo introduzem grandes desequilíbrios (instruções
podem demorar de 1 a >100 ciclos). Solução: pipeline de
microcódigo (VAX8800, IA-32 depois de 1995).
Notas:
c○JCF, 2004 — AAC (FEUP/LEIC) Execução concorrente de instruções: Pipelines 33/33
33.1. Na arquitectura IA-32, a utilização modos de endereçamento com
auto-incremento implica a actualização de registos a meio da execução do
programa.
33.2. Durante muito tempo, partiu-se do princípio que a interacção entre a
arquitectura do conjunto de instruções e a implementação era reduzida, pelo
que s questões de implementação não tinham peso na concepção dos
conjuntos de instruções. A partir dos anos 80 tornou-se claro que a
dificuldade de implementar pipelines e a sua ineficiência podem ser
aumentadas por más escolhas a nível da ACI.
33