Como as instruções "sempre" da Verilog são implementadas no hardware?

A alwaysdeclaração Verilog , a saber

always @(/* condition */)
    /* block of code */

executa o block of codequando conditionestá satisfeito. Como esse alwaysbloco é implementado no hardware?

Primeiro, observe que nem todos os designs da Verilog são sintetizáveis. Normalmente, apenas um subconjunto muito específico de construções pode ser usado em um design que deve ser realizado em hardware.

Uma restrição importante que aparece é que todas as regvariáveis ​​podem ser atribuídas apenas em no máximo uma alwaysinstrução. Em outras palavras, regs têm afinidade com alwaysblocos.

Os seguintes tipos de alwaysblocos geralmente podem ser usados.

always @(*) begin
    // combinational
end

always @(posedge clk) begin
    // sequential
end

No primeiro caso, *indica que o bloco deve ser executado sempre que qualquer sinal usado no bloco for alterado ou, equivalentemente, que o bloco deve ser executado continuamente. Portanto, regs que têm afinidade com alwaysblocos combinacionais são implementados como sinais computados de outros sinais usando lógica combinacional, ou seja, portas.

Os registradores que têm afinidade com os alwaysblocos deste último tipo, por outro lado, são saídas de flip-flops D que são marcados com freqüência na borda ascendente de clk(borda descendente, se negedgeusada). As entradas para os flip-flops são, novamente, computadas com lógica combinacional de outros sinais.

Considere o seguinte exemplo, um tanto artificial.

reg out, out_n;
always @(*) begin
    out_n = !out;
end
always @(posedge clk) begin
    out <= !out;
end

Aqui, out_nestá associado ao primeiro alwaysbloco, outao segundo. out_nserá implementado com um único portão NOT que será acionado out_ne acionado out(observe que é uma lógica combinacional pura). Por outro lado, outserá conduzido por um flip-flop com clock de clk. A entrada para o flip-flop será novamente calculada por um gate NOT out(que é acionado pelo flip-flop acima mencionado). A otimização dos sintetizadores combinará os dois portões NOT e usará um gate NOT e um flip-flop.

Dependendo do hardware que você tem disponível, outros tipos de construções podem ser usados. Por exemplo, se os flip-flops tiverem redefinições assíncronas, a construção a seguir também será sintetizada.

always @(posedge clk or posedge rst) begin
    if (rst)
        // reset
    else
        // sequential
end

Um alwaysbloco é comumente usado para descrever um flip-flop, uma trava ou um multiplexador. O código seria implementado com um flip-flop, uma trava ou um multiplexador.

Em um FPGA, um flip-flop e uma trava geralmente são apenas duas configurações diferentes de um dispositivo de registro de uso geral. Um multiplexador seria construído a partir de um ou mais elementos lógicos de uso geral (LUTs).

Em geral, existem duas maneiras de desenvolver o design com o Verilog:

1. Visualize a lógica que você deseja em termos de portas e registros, e descubra como descrevê-la no Verilog. Os manuais de síntese dos fornecedores de FPGA ou de ferramentas de síntese fornecem informações detalhadas sobre as estruturas mais comuns com as quais você pode querer trabalhar.

2. Escreva o Verilog e não se preocupe com a aparência do hardware subjacente. No entanto, mesmo se você fizer isso, ainda precisará saber o que é e o que não é sintetizável. Então, novamente, você examinará o padrão fornecido pelo fornecedor da ferramenta e o adaptará ao seu aplicativo.

EDITAR

A resposta de Avakar é muito melhor para sua pergunta, mas isso estimulou uma discussão interessante sobre as diferenças entre Xilinx e Altera, para que não a exclua.

Como já foi dito, nem todos os blocos são sempre sintetizáveis. Existem também alguns blocos que as ferramentas de síntese aceitarão, mas que produzirão resultados diferentes do que um simulador produzirá.

Primeiro da lista de sensibilidade. A regra usual é que ele deve conter apenas construções de detecção de borda (e geralmente há uma seleção limitada de combinações possíveis) ou deve conter (possivelmente através do uso de * ou always_comb do systemverilog) todos os sinais usados ​​como entrada no bloco. Chamamos o primeiro de bloco combinatório e o último de seqüencial ou bloco. Normalmente, se você incluir apenas um subconjunto de entradas em ferramentas de síntese de blocos combinatórios, apenas o ignorará e agirá como se a lista completa tivesse sido especificada (criando incompatibilidades de simulação / síntese)

Segundo bloqueio versus tarefas noblock. Em um bloco combinatório, a diferença não importa muito, mas em um bloco seqüencial, importa muito.

Em um bloco seqüencial, as atribuições de não bloqueio modelam um registro de maneira bastante direta, enquanto as variáveis ​​do modelo de designações de bloqueio (que podem ou não implicar registros, dependendo da ordem de configuração e leitura). Como regra, um conjunto de "reg" que usa atribuições de bloqueio em um bloco seqüencial deve ser lido apenas no mesmo bloco e as declarações de bloqueio e não-bloqueio não devem ser misturadas no mesmo "reg".

A mistura de atribuições de bloqueio e não bloqueio ao mesmo item provavelmente causará falhas na síntese. Fazer uma avaliação de bloqueio em um bloco e lê-lo em outro provavelmente causará incompatibilidades de simulação / síntese (e possivelmente até incompatíveis entre diferentes execuções de simulação).

Agora temos as regras básicas fora do caminho, podemos considerar como o compilador transforma o código em lógica.

O primeiro passo é desenrolar todos os loops. Isso significa que os loops devem ter uma contagem máxima de iterações que pode ser determinada no momento da síntese ou você receberá uma falha de síntese.

Em seguida, a ferramenta pode analisar o fluxo de controle do bloco e transformá-lo em um fluxo de dados. Cada variável se torna um ou mais sinais. Cada instrução if ou construção semelhante se torna um ou mais multiplexadores, selecionando qual conjunto de resultados será realmente usado.

A ferramenta provavelmente tentará aplicar algumas otimizações.

No quartus, você pode ver os resultados desse processo após a construção do seu projeto, acessando "ferramentas-> netlist visualers-> rtl viewer".

Depois de gerar essa representação estrutural em termos de elementos lógicos abstratos, a ferramenta passará a mapear esses elementos abstratos para os recursos que o chip realmente possui.