Caminho de dados do processador e segmentação em pipeline

Um caminho de dados armazena e transforma os valores de que uma instrução precisa. A unidade de controle direciona esses valores e habilita escritas. Juntos, eles executam instruções como add, sub, and, or, ld, sd e beq.

Acompanhe os valores entre bordas de clock

Um elemento de estado guarda um valor: o contador de programa, o banco de registradores e a memória de dados são exemplos. Um elemento combinacional produz uma saída a partir das entradas atuais. Somadores, multiplexadores, a ULA e o gerador de imediatos realizam esse trabalho sem armazenar o resultado de uma instrução entre ciclos.

Na borda ativa do clock, os elementos de estado capturam seus próximos valores. Entre bordas, suas saídas alimentam a lógica combinacional. O PC pode, portanto, fornecer o endereço atual durante todo um ciclo e capturar o próximo endereço ao final dele. Ler um elemento de estado não o sobrescreve por si só.

Busca e acesso aos registradores

O contador de programa (PC) armazena o endereço da instrução. A memória de instruções retorna a instrução de 32 bits nesse endereço. Neste modelo, ela é somente de leitura durante a execução do programa e funciona como uma consulta que associa endereços a instruções. Um somador separado forma PC + 4 porque as instruções desse subconjunto ocupam 4 bytes.

O banco de registradores contém x0–x31. Duas portas de leitura recebem os números de origem rs1 e rs2 e retornam os valores correspondentes. Uma porta de escrita recebe o destino rd, os dados de escrita e RegWrite. As leituras são combinacionais; uma escrita habilitada é salva na borda de clock. A leitura de x0 sempre retorna zero, e escritas nesse registrador são descartadas. Registradores RV64 armazenam 64 bits. Uma versão RV32 usa registradores de 32 bits e lw/sw, com as mesmas conexões básicas.

Calcule, selecione e acesse a memória

A unidade lógica e aritmética (ULA) soma, subtrai ou realiza uma operação bit a bit. Um código de controle de 4 bits seleciona a operação. A saída Zero da ULA vale 1 quando o resultado é zero; a subtração pode, portanto, testar se dois valores são iguais.

O gerador de imediatos, ImmGen, reconstrói o imediato de uma instrução e faz a extensão de sinal até 64 bits. Copiar o bit de sinal preserva um valor negativo. O padrão de 12 bits 1111 1111 1000 representa −8; a extensão com zeros o transformaria em 4088 e enviaria uma operação de memória ao endereço errado.

Um multiplexador, ou mux, seleciona uma entrada. Multiplexadores escolhem o segundo operando da ULA, os dados de escrita do registrador e o próximo PC. Um multiplexador muda o caminho; uma habilitação de escrita decide se um valor armazenado muda.

A memória de dados tem entradas de endereço e de dados de escrita, uma saída de dados de leitura e os controles MemRead e MemWrite. Uma carga precisa buscar a instrução e acessar dados durante o mesmo ciclo único. Memórias de instruções e de dados separadas fornecem os dois acessos. Somadores separados também permitem calcular PC + 4 e o destino do desvio enquanto a ULA realiza outro trabalho.

Saídas não usadas ainda podem mudar durante um ciclo. O controle correto garante que somente as saídas selecionadas cheguem a escritas habilitadas em elementos de estado. Um valor calculado em um fio não selecionado não tem efeito no programa.

Comece pelo que cada instrução precisa ler e pelo que deve alterar. O caminho de dados compartilhado reúne essas rotas, com um multiplexador onde valores alternativos chegam a uma mesma entrada.

Busque e decodifique os campos

A busca usa o PC para ler a memória de instruções e calcula PC + 4 em paralelo. O código de operação ocupa os bits 6–0. Quando presentes, rd fica nos bits 11–7, funct3 em 14–12, rs1 em 19–15 e rs2 em 24–20; funct7 do tipo R ocupa os bits 31–25. Posições fixas dos campos de origem permitem que as leituras dos registradores comecem enquanto o controle da instrução é decodificado. Um armazenamento ou desvio não tem campo rd: os bits 11–7 compõem parte do imediato.

Compare os caminhos de execução

Para uma carga, o resultado da ULA é um endereço efetivo, o endereço dos dados a ler. A saída da memória então retorna ao banco de registradores. Um armazenamento também forma um endereço com a ULA, mas seu segundo valor de origem segue separadamente para a entrada de dados de escrita da memória. Selecionar um imediato como operando da ULA não deve descartar esse valor a ser armazenado. ImmGen reconstrói o deslocamento do formato S a partir dos dois grupos de bits.

Um desvio realiza duas operações em paralelo. A ULA subtrai os valores dos registradores comparados; Zero indica se são iguais. O somador de desvio soma o deslocamento em bytes com sinal ao próprio PC do desvio. A codificação do formato B omite o bit menos significativo, que é sempre zero. ImmGen pode reconstruir o deslocamento completo em bytes, incluindo esse zero; um diagrama que gere o deslocamento em unidades de meia palavra precisa de um deslocamento de uma posição à esquerda. Esse deslocamento deve aparecer no caminho exatamente uma vez.

Una os caminhos com multiplexadores

ALUSrc seleciona o valor de rs2 ou o imediato para a segunda entrada da ULA. MemtoReg seleciona o resultado da ULA ou a saída da memória de dados para escrita no registrador. PCSrc seleciona PC + 4 ou o destino do desvio. Dois resultados concorrentes precisam de um seletor, não de um fio que ligue diretamente suas saídas.

Esses caminhos explicam por que a carga tem a cadeia mais longa: busca, leitura de registradores, cálculo de endereço, leitura da memória e escrita de registrador contribuem para ela. A operação aritmética não passa pela memória de dados; um armazenamento não passa pela escrita do resultado no registrador.

Amplie os caminhos existentes

addi x5, x6, 3 reutiliza o caminho da ULA com entrada imediata e o caminho de escrita do resultado da ULA no registrador. Ela precisa de controle adequado, mas de nenhuma nova unidade no caminho de dados. jal tem uma exigência adicional: escreve PC + 4 em rd enquanto redireciona o PC sem um teste de igualdade. Portanto, o seletor de escrita precisa de uma entrada PC + 4, e a lógica do próximo PC deve permitir um salto incondicional.

O acompanhamento de uma instrução relaciona a operação em linguagem de montagem a valores reais nos fios. Separe os valores calculados durante o ciclo dos valores salvos na borda de clock ao final dele.

Use uma ordem consistente de acompanhamento

1. Busque a partir do PC atual e identifique os campos da instrução.
2. Leia os registradores de origem e forme o imediato com sinal.
3. Selecione os operandos da ULA e calcule o resultado.
4. Realize o acesso solicitado à memória de dados.
5. Selecione os dados de escrita do registrador e o próximo PC.
6. Liste as escritas nos elementos de estado na borda de clock.

Some dois valores de registradores

No PC 400, add x5, x6, x7 tem a codificação 0x007302B3. Seus campos são opcode 0110011, rd 5, funct3 000, rs1 6, rs2 7 e funct7 0000000. Com x6 = 25 e x7 = −9, as portas de leitura fornecem 25 e −9. ALUSrc seleciona o segundo valor de registrador, e a ULA produz 16. MemtoReg seleciona 16 para escrita no registrador. Na borda, x5 passa a valer 16 e o PC passa a valer 404. MemRead e MemWrite são ambos zero.

Carregue e depois armazene uma palavra dupla

No PC 404, considere ld x5, 16(x6) com x6 = 1000 e a memória em 1016 contendo 42. ImmGen fornece 16. A ULA calcula o endereço 1016, e a memória de dados retorna 42. MemtoReg seleciona esse valor da memória, então x5 passa a valer 42 e o PC passa a valer 408 na borda. Escrever 1016 em x5 confundiria o endereço com o valor armazenado nele.

No PC 408, sd x5, 24(x6) lê x5 = 42 e x6 = 1000. A ULA calcula 1024 enquanto o caminho de rs2 fornece 42 à memória. MemWrite habilita o armazenamento; RegWrite é zero. Na borda, a palavra dupla em 1024 passa a valer 42 e o PC passa a valer 412. O endereço de memória e o valor a armazenar percorrem fios diferentes.

Os deslocamentos são medidos em bytes. Palavras duplas RV64 adjacentes começam a 8 bytes de distância: após a palavra dupla em 1016, a próxima começa em 1024. Avançar um byte não chegaria à próxima palavra dupla.

Decida um desvio

No PC 412, beq x8, x9, 12 compara x8 = 7 com x9 = 7. A ULA subtrai e obtém zero. Branch é 1, então Branch AND Zero é 1 e PCSrc seleciona o destino do desvio. O somador de desvio produz 424 ao somar 12 a 412. Somente o PC muda.

Se x9 for 8, a subtração produzirá −1 e Zero será 0. O próximo PC será então 416. O deslocamento codificado está em unidades de 2 bytes, então a quantidade com sinal armazenada para esse deslocamento de 12 bytes é 6; o deslocamento completo usado pelo somador continua sendo 12.

Leia o estado para a próxima instrução

Cada instrução de ciclo único conclui seu trabalho entre bordas de clock consecutivas. A próxima instrução lê o estado salvo na borda anterior. Assim, o armazenamento pode ler o novo valor de x5 da carga no ciclo seguinte sem encaminhamento de pipeline. Cada instrução leva um ciclo de clock, resultando em um CPI de ciclo único igual a 1, independentemente do número de unidades de hardware usadas pelo caminho.

A unidade de controle principal traduz um código de operação em sinais de seleção e permissões de escrita. Ela é uma tabela-verdade combinacional implementada com portas lógicas: controle por lógica fixa.

Atribua uma função a cada sinal

RegWrite habilita uma escrita em rd. ALUSrc seleciona a segunda entrada da ULA: 0 para rs2, 1 para um imediato. MemRead e MemWrite solicitam o acesso correspondente à memória de dados. MemtoReg seleciona os dados de escrita do registrador: 0 para o resultado da ULA, 1 para os dados da memória. Branch indica um desvio por igualdade. O ALUOp de 2 bits informa à unidade de controle da ULA, que é separada, qual classe de operação é necessária.

PCSrc é diferente: depende da instrução e dos valores comparados. O controle principal ativa Branch, e a ULA fornece Zero. A operação AND entre eles forma PCSrc, então um resultado aritmético comum igual a zero não pode, por si só, causar um desvio.

Construa a tabela a partir das ações necessárias

Para ld, a ULA precisa de um deslocamento imediato, então ALUSrc é 1. Os dados carregados vão para rd, fazendo MemtoReg e RegWrite valerem 1. A memória é lida, não escrita, resultando em MemRead = 1 e MemWrite = 0. Branch é 0, e ALUOp = 00 solicita a adição para formar o endereço.

Para sd, a ULA também soma um deslocamento, mas o destino é a memória. Defina MemWrite = 1 e RegWrite = 0. MemRead permanece zero: usar a memória não significa lê-la. Para beq, a ULA usa os dois valores de registrador e subtrai, enquanto a única atualização possível do estado arquitetural é a do PC.

Use valores indiferentes apenas onde os resultados são ignorados

X é um valor indiferente, o que significa que qualquer valor de seleção produz o mesmo comportamento. MemtoReg pode ser X para um armazenamento ou desvio porque RegWrite é zero. A entrada de dados de escrita do banco de registradores é ignorada, então quem projeta pode escolher o valor de seleção que simplifica o circuito.

Uma habilitação de escrita em elemento de estado não pode ser tratada dessa forma quando a escrita é proibida. Um MemWrite acidental durante uma operação aritmética pode corromper a memória, embora a instrução aritmética não precise da saída dessa memória para outra finalidade. Portanto, RegWrite e MemWrite devem ser explicitamente zero para instruções que não realizam essas escritas.

Acrescente uma linha para aritmética com imediato

addi x5, x6, 3 obtém o segundo operando de ImmGen e escreve a soma da ULA. Sua linha é ALUSrc 1, MemtoReg 0, RegWrite 1, MemRead 0, MemWrite 0, Branch 0, ALUOp 00. O código de operação 0010011 é diferente do código 0110011 do tipo R, então o controle principal precisa dessa linha extra. O suporte a andi e ori também exige a decodificação dos valores de funct3 dessas instruções para selecionar a operação.

Os nomes dos sinais dependem do projeto. RegWEn, BSel e WBSel, em diagramas de outros cursos, descrevem funções relacionadas de habilitação de escrita e seleção de entrada. Ao ler um novo diagrama, acompanhe a definição de cada sinal e as entradas do multiplexador correspondente.

O código de operação sozinho não distingue add de sub: ambas pertencem à classe do tipo R. O controle em dois níveis primeiro identifica a classe e depois usa os bits de função quando necessário.

De ALUOp à operação

O controle principal fornece um ALUOp de 2 bits entre suas demais saídas. O controle da ULA combina ALUOp com funct3 e o bit 30 da instrução, parte de funct7, para produzir quatro bits de controle da operação.

Esses códigos descrevem esta implementação da ULA, não codificações de instruções RISC-V. Cargas e armazenamentos usam ALUOp 00 porque somam uma base e um deslocamento. Desvios por igualdade usam ALUOp 01 porque a subtração produz Zero quando os operandos são iguais. Instruções do tipo R usam ALUOp 10 e precisam de mais decodificação.

Acompanhe uma subtração codificada

sub x5, x6, x7 tem a codificação 0x407302B3. O código de operação 0110011 identifica o tipo R e seleciona ALUOp 10. Seu funct3 é 000, o que deixa adição e subtração como possibilidades. O bit 30 é 1, de funct7 0100000, então o controle da ULA fornece 0110 para subtração.

Mudar esse bit de função para zero produz a codificação de adição correspondente 0x007302B3, com funct7 0000000 e controle da ULA 0010. A linha do controle principal permanece a mesma porque ambas as instruções usam duas entradas de registrador, escrevem um resultado da ULA e não acessam a memória de dados.

Reutilize o somador para subtração

Na ULA clássica, as linhas de controle representam Ainvert, Bnegate e um seletor de operação de 2 bits. A subtração usa o somador após inverter o segundo operando e fornecer um vai-um de entrada igual a 1:

Essa identidade de complemento de dois permite que adição e subtração compartilhem hardware. A diferença em Bnegate explica os códigos 0010 e 0110; ela não exige um caminho aritmético separado para cada instrução.

Decodifique os bits apenas no formato adequado

Para ALUOp 00 ou 01, as posições dos campos de função não selecionam a operação da ULA. O funct3 011 de uma carga descreve um acesso a uma palavra dupla. Os bits mais significativos de armazenamento e desvio incluem bits de imediato. Tratar essas posições como campos de função do tipo R confundiria a formação de endereços com a decodificação aritmética.

Para uma verificação rápida do tipo R, ALUOp 10 com funct3 110 seleciona 0001, a operação OR. Acrescentar outra operação sob o mesmo código de operação pode exigir apenas uma mudança no controle da ULA se ela já oferecer suporte à operação. Uma nova classe de instrução também pode exigir mudanças no controle principal, como ocorre com a aritmética com imediato.

Um processador de ciclo único deve terminar sua instrução mais lenta antes da próxima borda. Instruções mais rápidas ainda esperam pelo mesmo clock fixo. A segmentação em pipeline muda a quantidade de trabalho que cada período de clock deve conter.

Determine o limite do ciclo único

Use estes atrasos dos componentes, desconsiderando multiplexadores e pequenos somadores: busca 250 ps, leitura de registradores 150 ps, ULA 200 ps, memória de dados 250 ps e escrita de registrador 150 ps.

A carga determina o caminho crítico, fixando o período em 1000 ps, ou 1 ns. Isso corresponde a um clock de 1 GHz. Uma distribuição de 25% de cargas, 10% de armazenamentos, 50% de instruções do tipo R e 15% de desvios tem um atraso ponderado de caminho de 800 ps. Mesmo assim, cada instrução recebe 1000 ps, o que equivale a 1,25 vez essa média. Um atraso médio não pode definir um clock que também deve acomodar a instrução mais longa.

Sobreponha cinco estágios

O pipeline divide a execução em IF (busca), ID (decodificação e leitura de registradores), EX (execução ou cálculo de endereço), MEM (acesso à memória de dados) e WB (escrita em um registrador). Instruções diferentes ocupam estágios diferentes simultaneamente.

A vazão conta as instruções concluídas por unidade de tempo. A latência mede o tempo que uma instrução leva da entrada até a conclusão. Uma linha de montagem pode concluir um item por intervalo mesmo que cada item precise de vários intervalos para percorrê-la. A mesma distinção se aplica aqui.

O estágio mais lento leva 250 ps. Com 20 ps de sobrecarga dos registradores de pipeline, o período de clock é de 270 ps, cerca de 3,70 GHz. Uma instrução percorre cinco períodos, levando 1350 ps. Isso supera sua latência no ciclo único, mas um pipeline cheio pode concluir uma instrução a cada 270 ps.

Inclua o tempo de enchimento e conclusão

Sem paradas, um pipeline de k estágios executa n instruções em k + n − 1 ciclos. Para cinco estágios, são n + 4. Quatro instruções precisam de oito ciclos, levando 2160 ps, em comparação com 4000 ps no processador de ciclo único. A aceleração é de cerca de 1,85.

Para 1.000.000 de instruções, o pipeline precisa de 1.000.004 ciclos, aproximadamente 270,0 μs. O projeto de ciclo único precisa de 1000 μs. A aceleração se aproxima da razão 1000/270, cerca de 3,70, à medida que o custo fixo de enchimento e esvaziamento se torna pequeno.

Uma aceleração perfeita de cinco vezes exigiria cinco estágios igualmente lentos de 200 ps, sem sobrecarga de registradores ou atrasos por conflitos. Estágios desiguais fazem os mais rápidos esperar pelo mais lento. Mais estágios também acrescentam sobrecarga e podem aumentar os custos dos conflitos.

Instruções fixas de 32 bits nesse subconjunto simplificam a busca. Campos de registrador em posições fixas ajudam ID, e a restrição do acesso à memória de dados a cargas e armazenamentos se ajusta ao cálculo de endereço em EX seguido por MEM. Essas propriedades da ISA tornam práticos os limites entre estágios.

Várias instruções compartilham o caminho de dados ao mesmo tempo, então cada estágio precisa dos valores da instrução que está nele. Registradores de pipeline preservam esses valores e seus sinais de controle em cada borda de clock.

Relacione o conteúdo ao trabalho posterior

Cada registrador recebe o nome dos estágios adjacentes. Ele captura as saídas do primeiro estágio para uso no segundo. Não há registrador de pipeline extra após WB; WB escreve no estado arquitetural. O PC fornece o estado na entrada da busca.

O conteúdo de EX/MEM apresentado acima atende a um projeto que usa as informações de desvio em MEM. Um projeto que resolve desvios em EX retorna essas informações à busca mais cedo. O estágio de resolução determina a penalidade por conflito de controle.

Mantenha o destino e os dados juntos

Uma carga é decodificada em ID, mas escreve em rd três ciclos depois, em WB. Nesse momento, IF/ID contém uma instrução mais recente. Se a porta de escrita usasse o rd dessa instrução mais recente, o valor carregado iria para o registrador errado. Portanto, o número do destino da carga deve passar por ID/EX, EX/MEM e MEM/WB junto com o resultado.

Um armazenamento também transporta seu valor de rs2 por ID/EX e EX/MEM. O endereço e os dados devem corresponder ao mesmo armazenamento quando chegam à memória de dados. Os registradores de pipeline preservam a identidade de uma instrução por meio desses valores associados, embora várias outras instruções estejam ativas ao mesmo tempo.

Mova o controle com a instrução

O controle é gerado em ID. EX usa ALUSrc e ALUOp; MEM usa Branch, MemRead e MemWrite; WB usa MemtoReg e RegWrite. Cada estágio passa os controles necessários posteriormente junto com os dados.

Se o controle da ULA for decodificado em EX, ID/EX deverá transportar o bit 30 e funct3, além de ALUOp. As operações do tipo R compartilham ALUOp 10, então esse valor sozinho não distingue add, sub, AND e OR. Outro projeto válido decodifica a operação completa de 4 bits em ID e transporta esse código.

Mantenha regular a passagem pelos estágios

Uma instrução do tipo R passa por MEM sem usar a memória de dados. Um armazenamento passa por WB sem escrever em um registrador. Manter todas as instruções na mesma sequência de cinco estágios preserva a ordem das escritas nos registradores. Se uma instrução do tipo R pulasse MEM, ela poderia chegar à única porta de escrita de registrador no mesmo ciclo que a carga imediatamente anterior.

O banco de registradores atende a WB e ID em um ciclo escrevendo na primeira metade e lendo na segunda. ID pode então ver um valor escrito por uma instrução anterior naquele ciclo. Memórias de instruções e de dados separadas permitem que IF e MEM operem simultaneamente.

A maior parte das informações avança pelo pipeline. A escrita do resultado retorna um valor ao banco de registradores, e o controle de desvio retorna à busca uma decisão sobre o próximo PC. Esses caminhos longos de retorno explicam por que instruções posteriores podem precisar de ajuda antes que uma instrução anterior termine.

Um diagrama de pipeline mostra explicitamente a sobreposição. As linhas mostram as instruções em ordem de programa, e as colunas mostram os ciclos de clock. Cada célula indica o estágio ocupado pela instrução naquele ciclo.

Construa uma escada

Para cinco instruções independentes, registre IF para I1 no ciclo 1, depois ID, EX, MEM e WB nos ciclos 2–5. Inicie I2 um ciclo depois e repita. Os nomes dos estágios formam uma escada diagonal.

No ciclo 5, I1 está em WB, I2 em MEM, I3 em EX, I4 em ID e I5 em IF. Ler uma coluna de cima a baixo fornece um retrato de um único ciclo. Acompanhar uma linha fornece o histórico de uma instrução.

Numere os estágios de IF = 1 a WB = 5. Sem paradas, a instrução i chega ao estágio s no ciclo i + s − 1. Portanto, I3 chega a MEM no ciclo 6. A última célula WB indica o ciclo de conclusão: cinco instruções terminam no ciclo 9.

Insira valores em um retrato

Considere I1 como ld x5, 16(x6), com x6 = 1000 e a memória em 1016 contendo 42. Considere I2 uma adição independente, I3 uma subtração independente e I4 uma operação OR independente. No ciclo 4, a carga lê a memória em 1016, I2 usa a ULA, I3 lê registradores e I4 é buscada. No ciclo 5, a carga escreve 42 em x5. Uma coluna contém trabalho de várias instruções, não vários estágios da carga.

Mostre uma parada sem interromper o trabalho anterior

Agora use ld x10, 0(x20) seguida por add x11, x10, x12 e depois por uma instrução independente. Com encaminhamento, a consumidora imediata ainda precisa de uma parada:

• A carga ocupa IF 1, ID 2, EX 3, MEM 4, WB 5.
• A add ocupa IF 2, ID 3, novamente ID 4, EX 5, MEM 6, WB 7.
• A terceira instrução ocupa IF 3, novamente IF 4, ID 5, EX 6, MEM 7, WB 8.

A add espera em ID enquanto uma bolha passa por EX. A carga continua normalmente; congelá-la adiaria justamente o valor de que a add precisa. Toda instrução posterior é atrasada junto com a add.

Conte a sequência uma única vez

Um pipeline de cinco estágios precisa de n + 4 ciclos sem paradas. Cada parada inserida acrescenta um ciclo, resultando em n + 4 + paradas quando não há outras perdas. O exemplo de três instruções termina no ciclo 8: três instruções, quatro intervalos extras de estágio e uma parada.

Os primeiros quatro ciclos enchem o pipeline, e os últimos quatro o esvaziam. São maneiras de observar a mesma sequência de n + 4 ciclos, não duas cobranças separadas de quatro ciclos. Em uma sequência longa, a contribuição fixa é pequena; em uma sequência curta, ela pode dominar a aceleração.

Um conflito impede que a próxima instrução seja executada no ciclo planejado. Para identificá-lo, determine o recurso ou valor necessário, o ciclo em que ele é necessário e o ciclo em que fica disponível.

Distinga três tipos de conflito

Memórias de instruções e de dados separadas eliminam o conflito estrutural entre IF e MEM. Escrever no banco de registradores na primeira metade de um ciclo e lê-lo na segunda também permite que WB e ID o compartilhem. Com essas disposições, não há conflito estrutural neste modelo de cinco estágios.

Identifique a produtora real

Uma dependência de leitura após escrita (RAW) existe quando uma instrução posterior lê um valor escrito por uma anterior. Em add x1, x2, x3 seguida por sub x4, x1, x5, a add produz x1 e a subtração o consome. Sem ajuda, a subtração lê x1 em ID durante o ciclo 3, antes que a add o escreva em WB durante o ciclo 5.

Uma dependência de escrita após leitura (WAR) reutiliza um registrador depois que uma instrução anterior o leu. Uma dependência de escrita após escrita (WAW) dá a duas instruções o mesmo destino. Essas dependências de nome não causam conflitos no projeto de cinco estágios com execução em ordem: as leituras ocorrem em ID e as escritas ocorrem em WB, em ordem de programa. Elas importam ao decidir se o software pode reordenar instruções.

Acompanhe uma sequência com destinos repetidos

Considere:

ld  x5, 0(x10)
add x6, x5, x7
sub x5, x8, x9
or  x9, x6, x5

As ligações RAW são carga → adição por x5, adição → OR por x6 e subtração → OR por x5. A OR precisa do novo x5 da subtração, não do valor carregado anteriormente. Procurar apenas nomes de registrador iguais pode deixar passar essa mudança de produtora.

A subtração escreve x5 após a adição ler x5, uma dependência WAR. A carga e a subtração também têm uma dependência WAW em x5. A OR escreve x9 após a subtração lê-lo, outra dependência WAR. Nenhuma delas cria um conflito de hardware WAR ou WAW nesse pipeline com execução em ordem.

Conte as esperas sem encaminhamento

Com apenas o banco de registradores que escreve antes de ler, uma consumidora imediata precisa de dois ciclos de parada. Ela deve adiar sua leitura em ID do ciclo 3 para o ciclo 5. Uma instrução independente entre a produtora e a consumidora reduz isso a uma parada. Duas instruções independentes permitem que a consumidora chegue a ID no ciclo WB da produtora, sem precisar de parada.

Uma dependência é uma propriedade do programa; se ela cria uma parada depende da temporização e dos caminhos disponíveis. Uma dependência RAW distante pode não exigir nenhuma ação. O registrador x0 nunca fornece um resultado pendente porque sua leitura sempre retorna zero e ele ignora escritas.

O software pode inserir instruções nop ou mover trabalho independente para os intervalos de espera. O hardware pode encaminhar resultados ou inserir paradas automaticamente. Ambas as abordagens devem manter cada consumidora ligada ao valor escrito por sua produtora na ordem do programa.

Um resultado da ULA existe antes de chegar à escrita no registrador. O encaminhamento, também chamado de bypass, envia esse resultado diretamente à entrada de uma instrução posterior, evitando a espera pelo banco de registradores.

Selecione a origem de cada operando

Dois multiplexadores alimentam os caminhos de execução. ForwardA atende a rs1 e ForwardB atende a rs2. Cada operando é verificado independentemente.

O caminho EX/MEM alcança a instrução imediatamente seguinte. O caminho MEM/WB alcança uma instrução duas posições atrás e pode transportar um resultado da ULA ou dados carregados. ForwardB também alimenta o caminho de dados de armazenamento antes que ALUSrc escolha entre esse valor e um imediato.

Verifique permissão, destino e correspondência

Para ForwardA = 10, a instrução em EX/MEM deve ter RegWrite = 1, rd diferente de zero e rd igual a ID/EX.rs1. Substitua rs1 por rs2 no teste de ForwardB. Um armazenamento ou desvio não deve ser tratado como produtor apenas porque seus bits de instrução se parecem com um número de destino. Escritas em x0 também não devem se tornar valores encaminhados.

Para ForwardA = 01, faça em MEM/WB as verificações correspondentes de RegWrite, rd diferente de zero e correspondência de registrador. Use esse resultado mais antigo somente quando EX/MEM ainda não fornecer o operando necessário. ForwardB segue a mesma regra de prioridade independentemente.

Acompanhe um resultado em consumidoras posteriores

Comece com add x1, x2, x3, em que x2 = 10 e x3 = 5. Ela produz 15 ao final de EX no ciclo 3.

• A próxima instrução, sub x4, x1, x5, chega a EX no ciclo 4. Com x5 = 3, ForwardA = 10 fornece 15 e a subtração resulta em 12.
• and x6, x7, x1 chega a EX no ciclo 5. ForwardB = 01 obtém x1 de MEM/WB.
• or x8, x1, x9 lê registradores em ID durante o ciclo 5, após a escrita da add na primeira metade. Ela não precisa de encaminhamento em EX.

Nenhuma parada é necessária para essas dependências de resultados da ULA. A consumidora recebe o valor quando usa a ULA, mesmo que sua leitura anterior em ID tenha obtido um valor antigo.

Resolva duas escritas correspondentes

Em três instruções consecutivas add x1, x1, x2, add x1, x1, x3 e add x1, x1, x4, tanto EX/MEM quanto MEM/WB correspondem ao rs1 da terceira instrução. EX/MEM contém o resultado da segunda add, o x1 mais recente. MEM/WB contém o resultado da primeira add e deve perder a prioridade.

Os mesmos caminhos permitem que add x5, x6, x7 forneça dados a sd x5, 0(x8) sem parada. O x5 encaminhado chega ao caminho de dados de escrita da memória enquanto a ULA do armazenamento usa o deslocamento imediato.

O encaminhamento não pode fornecer dados antes que existam. EX/MEM para uma carga contém o endereço dela, não o valor carregado. A consumidora imediata deve esperar até que a carga termine MEM; encaminhar o endereço faria o cálculo usar a quantidade errada sem aviso.

Uma carga produz dados ao final de MEM. A instrução imediatamente seguinte precisaria desses dados no início de EX no mesmo ciclo. Uma parada move o estágio EX da consumidora para o ciclo seguinte, quando MEM/WB pode fornecer o valor.

Detecte o valor indisponível em ID

A unidade de detecção de conflitos examina a instrução em EX e a instrução que está sendo decodificada. O teste básico é ID/EX.MemRead = 1 e uma correspondência entre ID/EX.rd e qualquer um dos campos de número de origem em IF/ID. Um teste refinado exclui rd = x0 e verifica quais campos de origem a instrução decodificada realmente lê.

Essa última verificação evita uma parada desnecessária em uma instrução do tipo I cujos bits imediatos ocupam a posição usual de rs2. Comparar as posições dos campos sem interpretá-los é seguro, mas pode atrasar uma instrução que não lê o registrador.

Retenha o trabalho posterior e avance a carga

A parada realiza três ações coordenadas:

1. Defina como zero os controles que entram em ID/EX, inserindo uma bolha.
2. Defina PCWrite = 0 para manter inalterado o endereço de busca.
3. Defina IF/IDWrite = 0 para manter a instrução que espera em ID.

A carga e as instruções anteriores continuam avançando. A bolha passa pelos estágios posteriores sem escrever em registradores ou na memória. Congelar ID/EX com a carga ainda nele repetiria a carga em vez de inserir uma operação vazia.

Para ld x10, 0(x20) seguida por add x11, x10, x12, a carga está em EX e a add em ID durante o ciclo 3. No ciclo 4, a carga está em MEM, a bolha em EX e a add ainda em ID. No ciclo 5, a carga está em WB e a add chega a EX com ForwardA = 01.

Escalone instruções independentes

Considere:

ld  x10, 0(x20)
ld  x11, 8(x20)
add x12, x10, x11
sd  x12, 24(x20)
ld  x13, 16(x20)
add x14, x10, x13
sd  x14, 32(x20)

Os usos de x11 e x13 vêm imediatamente após suas cargas. Com encaminhamento, eles causam duas paradas, resultando em 7 + 4 + 2 = 13 ciclos. Mova ld x13, 16(x20) para a terceira posição, antes da primeira add. Isso separa a carga de x11 da consumidora e coloca x13 suficientemente antes da instrução que o consome. A sequência passa a levar 7 + 4 = 11 ciclos.

O movimento é válido porque a carga lê x20, que as instruções ultrapassadas não alteram. Seu destino x13 não afeta essas instruções. Seu endereço x20 + 16 é diferente de x20 + 24, endereço do armazenamento ultrapassado. Uma carga não pode passar por um armazenamento que possa escrever nos bytes que ela lê. A reordenação deve preservar as dependências RAW, WAR, WAW e de memória.

Combine paradas e encaminhamento

Para ld x5, 0(x10), add x6, x5, x7, sub x5, x8, x9 e or x9, x6, x5, somente o par imediato de carga e uso sofre uma parada. Quando OR chega a EX, ForwardA = 01 fornece o x6 da add e ForwardB = 10 fornece o x5 da subtração. O total é 4 + 4 + 1 = 9 ciclos.

A busca precisa de um novo endereço a cada ciclo. Um desvio condicional fornece a escolha correta somente após a comparação e o cálculo do destino. Essa lacuna cria um conflito de controle.

Relacione o estágio de resolução à penalidade

Em um pipeline de cinco estágios com redirecionamento após o estágio de resolução, um resultado conhecido ao final de ID perde uma posição de busca em caso de previsão errada. A resolução ao final de EX perde duas; ao final de MEM, perde três. Instruções posteriores já entraram durante essas posições.

Uma estratégia interrompe a busca até que cada desvio seja decidido. É simples, mas desvios tomados e não tomados pagam a espera completa. A estratégia de prever que o desvio não será tomado continua em PC + 4. Uma previsão correta não precisa de recuperação. Um desvio tomado redireciona a busca e descarta as instruções posteriores do caminho sequencial.

Acompanhe um desvio tomado

Busque beq x1, x2, 16 no endereço 100 no ciclo 1 e resolva o desvio ao final de EX no ciclo 3. A predição de desvio não tomado busca os endereços 104 e 108 nos ciclos 2 e 3. Se o desvio for tomado, ambas são instruções do caminho errado. A busca começa em 116 no ciclo 4, após uma penalidade de dois ciclos.

Um descarte de instruções do pipeline impede que essas entradas posteriores alterem o estado arquitetural ou gerem exceções. A implementação pode invalidar entradas ou suprimir seus controles e efeitos de exceção. Um armazenamento do caminho errado nunca deve resultar em uma escrita efetiva na memória.

Uma bolha não é igual a uma instrução RISC-V composta apenas por zeros. A codificação composta apenas por zeros é ilegal. Se uma codificação de instrução real for inserida, a nop canônica será addi x0, x0, 0, codificada como 0x00000013. Uma entrada de pipeline descartada, por sua vez, não representa nenhuma instrução executada.

Resolva mais cedo, mas obtenha operandos mais cedo

Mover o comparador e o somador do destino do desvio para ID reduz a penalidade de redirecionamento a um ciclo. A comparação passa a precisar dos valores de origem em ID, então o encaminhamento usual apenas para EX é insuficiente. Com encaminhamento adequado para ID, um desvio imediatamente após a instrução da ULA que produz seu operando espera um ciclo. Imediatamente após uma carga produtora, ele espera dois. A resolução antecipada troca menos posições de busca perdidas por uma entrega de operandos mais exigente.

A predição estática fixa uma regra antecipadamente. Regras comuns são sempre não tomado, sempre tomado e tomado para trás/não tomado para a frente. Um desvio para trás no fim de um laço frequentemente repete o laço, o que torna essa direção uma pista útil.

RISC-V não tem posição de atraso de desvio. Se um desvio for tomado, sua sucessora sequencial não será executada apenas por ter sido buscada. Alguns projetos MIPS mais antigos faziam essa sucessora executar como uma instrução definida na posição de atraso; essa é uma regra diferente da ISA.

Preserve um limite de exceção precisa

Uma instrução ilegal ou ecall transfere o controle para uma rotina de tratamento. As instruções anteriores terminam; a instrução que causou a exceção e as posteriores não efetivam seus efeitos normais. O processador registra o PC da instrução causadora e a causa, usando registradores como sepc/scause no modo supervisor ou mepc/mcause no modo de máquina, e depois busca a partir da rotina de tratamento. Essa exceção precisa apresenta o estado como um limite entre instruções anteriores concluídas e trabalho posterior não concluído.

A predição dinâmica aprende com os resultados observados durante a execução de um programa. Uma tabela de histórico de desvios (BHT) armazena pequenas entradas de estado selecionadas por bits de um endereço de desvio. Primeiro faça a previsão, depois compare-a com o resultado real e então atualize a entrada.

Veja por que um bit erra duas vezes em um laço

Um preditor de 1 bit armazena o resultado anterior. Se o último desvio foi tomado, ele prevê tomado na próxima vez; caso contrário, prevê não tomado. Em um laço executado repetidamente cujo desvio é tomado nove vezes e depois não é tomado uma vez, a saída deixa o bit em não tomado.

Na próxima execução, o primeiro desvio tomado é previsto incorretamente. Os desvios tomados intermediários ajustam o bit para tomado, então a saída final não tomada também é prevista incorretamente. Em regime permanente, são dois erros em dez resultados, ou precisão de 80%.

Acrescente um segundo bit para persistência

Um contador de saturação de 2 bits tem estados de 0 a 3. Os estados 0 e 1 preveem não tomado; 2 e 3 preveem tomado. Um resultado tomado incrementa o contador, e um resultado não tomado o decrementa. Os valores param em 0 e 3.

A partir do estado 3, uma saída não tomada move o estado para 2, que ainda prevê tomado. Portanto, a próxima entrada no laço é prevista corretamente. O mesmo laço de dez resultados tem um erro por execução em regime permanente, ou precisão de 90%. São necessários dois resultados contrários consecutivos para inverter uma previsão a partir de um estado forte.

Acompanhe antes de atualizar

Comece no estado 1 e observe tomado, tomado, não tomado, tomado:

1. O estado 1 prevê não tomado: errado. Incremente para 2.
2. O estado 2 prevê tomado: correto. Incremente para 3.
3. O estado 3 prevê tomado: errado. Decremente para 2.
4. O estado 2 prevê tomado: correto. Incremente para 3.

Há dois erros e o estado final é 3. Atualizar antes de prever daria incorretamente ao preditor acesso ao resultado que ele deve prever.

Distinga direção, destino e interferência

Dois endereços de desvio podem indexar a mesma entrada da BHT. Essa colisão de entradas permite que seus resultados interfiram entre si. Uma previsão errada custa ciclos, mas a recuperação verifica o resultado real e preserva a correção.

Um buffer de destinos de desvios (BTB) fornece um endereço, não apenas um bit de direção. Consultado pelo PC durante IF, ele pode fornecer o destino previsto para um desvio tomado no próximo ciclo de busca, antes da decodificação. A predição de direção decide se esse destino será usado.

Um histórico simples tem limites. Em um padrão que alterna estritamente entre tomado e não tomado, um preditor de 1 bit continua errando depois que passa a acompanhar o padrão. Um contador de 2 bits acerta no máximo metade das vezes; começar no estado 1 antes de um resultado tomado faz com que erre todas as vezes. Preditores por correlação acrescentam o histórico recente de desvios, preditores por torneio selecionam entre preditores e uma pilha de endereços de retorno prevê destinos de retorno de procedimentos. Pipelines mais profundos tornam a recuperação mais cara porque mais trabalho posterior se acumula antes da resolução.

A velocidade do pipeline depende tanto do período de clock quanto dos ciclos gastos em espera ou recuperação. O CPI efetivo mede a média desses ciclos extras ao longo da sequência de instruções.

Pondere cada custo pelas instruções afetadas

Para uma longa sequência de emissão única, comece com CPI ideal 1. Acrescente cada fonte distinta e não sobreposta de ciclos perdidos como a fração de instruções afetadas multiplicada pelos ciclos perdidos por ocorrência. Uma taxa condicional também precisa da fração à qual ela se refere.

Suponha que 25% das instruções sejam cargas e que 40% dessas cargas tenham uma consumidora imediata. Cada par desse tipo sofre uma parada, então a contribuição de carga e uso é 0,25 × 0,40 × 1 = 0,10 ciclos por instrução. Suponha que 15% sejam desvios, que 10% deles sejam previstos incorretamente e que a recuperação custe dois ciclos. A contribuição dos desvios é 0,15 × 0,10 × 2 = 0,03.

Somar os custos independentes resulta em CPI = 1 + 0,10 + 0,03 = 1,13. Atribuir uma parada a toda carga produziria 0,25 em vez de 0,10. Aplicar a taxa de erro de desvio de 10% a toda instrução também resultaria em uma contagem excessiva.

Inclua o período de clock e a contagem de instruções

Tempo de execução é igual a contagem de instruções × CPI × período de clock. Um clock de 4 GHz tem período de 0,25 ns. Para 10⁹ instruções com CPI de 1,13, a execução leva 10⁹ × 1,13 × 0,25 ns = 0,2825 s. O tempo médio por instrução é de 0,2825 ns.

Para uma sequência curta, conte explicitamente os ciclos de enchimento, esvaziamento e conflito. O CPI básico ideal de 1 descreve a vazão em regime permanente; um pipeline de cinco estágios que executa apenas algumas instruções também tem sua contribuição de quatro ciclos para enchimento e conclusão.

Compare estratégias de desvio em condições iguais

Mantenha o custo de carga e uso de 0,10, a fração de desvios de 0,15 e a penalidade de dois ciclos:

Com o mesmo período de clock e a mesma contagem de instruções, a predição dinâmica é cerca de 1,24 vez mais rápida que a espera, pois 1,40/1,13 ≈ 1,24.

Entre processadores diferentes, compare CPI × período. Um projeto de ciclo único com período de 1000 ps leva 1000 ps por instrução. Um pipeline com período de 270 ps e CPI de 1,13 leva 305,1 ps por instrução, uma aceleração de cerca de 3,28. Comparar apenas o CPI favoreceria o CPI 1 do ciclo único e levaria à conclusão errada.

Entenda o próximo compromisso de projeto

Mais estágios de pipeline podem reduzir o trabalho combinacional por ciclo. Eles também introduzem sobrecarga de registradores e podem aumentar as penalidades por carga e uso e por previsões erradas. A frequência de clock sozinha não determina se o projeto mais profundo é melhor.

A emissão múltipla inicia várias instruções por ciclo, permitindo CPI abaixo de 1 e instruções por ciclo (IPC) acima de 1. Grupos de emissão estática são escolhidos pelo compilador; a emissão dinâmica, ou execução superescalar, é escolhida pelo hardware e frequentemente usa especulação e execução fora de ordem. Dependências de dados e predição de desvios ainda limitam a sobreposição útil.