Qual é a motivação para usar Verilog ou VHDL sobre C?

Eu venho de um background de programação e não mexi muito com hardware ou firmware (no máximo, um pouco de eletrônica e Arduino).

Qual é a motivação para usar as linguagens de descrição de hardware (HDL), como Verilog e VHDL, sobre linguagens de programação como C ou algum Assembly?

Essa questão é uma questão de escolha?

Eu li que o hardware, cujo firmware está escrito em HDL, tem uma clara vantagem na execução de instruções em paralelo. No entanto, fiquei surpreso ao ver discussões expressando dúvidas sobre escrever firmware em C ou Assembly (como o Assembly é apropriado se você não possui necessariamente uma CPU?), Mas concluí que também é uma opção.

Portanto, tenho algumas perguntas (não hesite em explicar nada):

1. Um firmware pode realmente ser escrito em HDL ou em uma linguagem de programação de software, ou é apenas outra maneira de realizar a mesma missão? Eu adoraria exemplos do mundo real. Quais restrições resultantes de cada opção?

2. Sei que um uso comum de firmware por software está em aceleradores de hardware (como GPUs, adaptadores de rede, aceleradores SSL, etc.). Pelo que entendi, essa aceleração nem sempre é necessária, mas apenas recomendada (por exemplo, no caso de SSL e aceleração de algoritmos complexos). Pode-se escolher entre firmware e software em todos os casos? Caso contrário, ficaria feliz em casos em que o firmware é clara e inequivocamente apropriado.

3. Eu li que o firmware geralmente queimava em ROM ou flash. Como é representado lá? Em bits, como software? Em caso afirmativo, qual é a diferença profunda? É a disponibilidade de circuitos adaptados no caso de firmware?

Acho que cometi um erro aqui e ali em algumas suposições, por favor, me perdoe. Obrigado!

Qual é a motivação para usar as linguagens de descrição de hardware (HDL), como Verilog e VHDL, sobre linguagens de programação como C ou algum Assembly?

C e assembly são boas linguagens para dizer à CPU o que fazer. Eles descrevem ações a serem executadas seqüencialmente por uma única máquina de estado.

HDLs são boas linguagens para descrever ou definir uma coleção arbitrária de circuitos digitais. Eles podem expressar operações feitas em paralelo de maneiras que as linguagens de programação não podem. Eles também podem descrever limitações de tempo para as interfaces entre blocos de maneiras que as linguagens de programação não podem.

Fiquei surpreso ao ver discussões expressando dúvidas sobre escrever firmware em C ou Assembly (como o Assembly é apropriado se você não possui necessariamente uma CPU?)

Nessa pergunta, o que é perguntado é: "Se você está escrevendo código para um microcontrolador, existe uma diferença real se você escreve em assembly ou C ou em alguma outra linguagem de alto nível?".

Como ele está perguntando especificamente sobre sistemas com um microcontrolador (uma CPU com periféricos), C ou assembly são escolhas razoáveis ​​para o desenvolvimento do firwmare, e os HDLs não.

Um firmware pode realmente ser escrito em HDL ou em uma linguagem de programação de software, ou é apenas outra maneira de realizar a mesma missão?

Depende do tipo de hardware que você possui. Se você possui uma CPU, use uma linguagem de programação. Se você possui um FPGA ou está projetando um ASIC, use um HDL. Se você estiver projetando uma quantidade muito grande de lógica digital, poderá procurar um dos idiomas intermediários, como o SystemVerilog.

Eu li que o firmware geralmente queimava em ROM ou flash. Como é representado lá? Em bits, como software? Em caso afirmativo, qual é a diferença profunda? É a disponibilidade de circuitos adaptados no caso de firmware?

Eu acho que você está se desligando do termo "firmware". Essa palavra originalmente significava que o código seria executado em um sistema incorporado, que não estava acessível para o usuário final mudar. Se você vendeu um PC para alguém, há uma chance muito grande de o usuário alterar o software executado nele. Se você vendeu um osciloscópio para eles, não gostaria que eles mudassem o código executado no microprocessador interno, então o chamou de firmware.

Os usuários de FPGA apropriaram a palavra "firmware" para a saída de seus projetos, porque é mais mutável que o hardware (material que é soldado). Mas realmente o "firmware" que configura um FPGA é diferente do "firmware" que é executado em um uC. O firmware do uC direciona o uC através de uma série de estados para executar sua função. O firmware FPGA define um conjunto de interconexões entre elementos lógicos e valores a serem armazenados nas tabelas de consulta.

Em qualquer um dos casos, o firmware geralmente é armazenado como bits em um eeprom (ou em disco em uma máquina host que o descarrega sempre que o sistema incorporado é reiniciado). Mas isso não os torna parecidos.

Para a primeira parte da sua pergunta, sobre as motivações do uso de uma ou de outra: há uma diferença fundamental entre C e HDLs (VHDL / Verilog) . C é uma linguagem de programação de software (como o assembly), VHDL / Verilog são linguagens de descrição de hardware . Eles não são feitos para o mesmo propósito.

C é traduzido em código de montagem (em sua forma binária, ou seja, linguagem de máquina) quando compilado . Este código é uma série de instruções que instruem a CPU a executar uma série de operações básicas (alterar um valor de registro, executar uma adição etc.).

Por outro lado, um HDL é sintetizado no hardware. Em VHDL, você poderia, por exemplo, escrever algo como:

output <= input1 + input2;

(veja também um exemplo mais completo aqui ). Isso seria sintetizado para um somador (hardware). Se o código for sintetizado para um FPGA , isso significaria um fluxo de bits que pode configurar o FPGA específico para implementar um somador (como lógica combinacional ).

Na verdade, você pode projetar uma CPU em VHDL (consulte Processadores de núcleo mole VS Processadores de núcleo duro ) e escrever o software para ele em C ...

Sobre o firmware: tudo depende de como você define a palavra. Um firmware pode ser um programa (software) executado em um microcontrolador (escrito, por exemplo, em C ou assembler), ou pode ser um fluxo de bits para configurar um dispositivo lógico programável (hardware) (CPLD ou FPGA). Às vezes, pode ser um pacote que contém os dois: se você usa o firmware de alguns modelos de FritzBox (um modem ADSL), eles realmente contêm um sistema Linux inteiro (escrito em assembler, C e muitas outras linguagens de programação) e um fluxo de bits para configure um FPGA (provavelmente sintetizado a partir de VHDL ou Verilog).

1. Depende da sua arquitetura. Se você possui uma CPU (ou, normalmente, um microcontrolador), é necessário escrever o firmware em uma linguagem de programação regular (incluindo montagem). Se você tem algo como um FPGA, seu firmware precisa ser escrito em um HDL. HDLs não podem (que eu saiba) gerar programas que possam ser executados com eficiência por uma CPU convencional, e um FPGA não executa programas convencionais imediatamente. Você pode, no entanto, configurar seu FPGA como uma CPU e, em seguida, executar um programa convencional com isso. Isso exigiria duas camadas de firmware, a camada inferior escrita em HDL para construir a CPU e a camada superior escrita em uma linguagem de programação convencional para ser executada nessa CPU.
2. Não há distinção difícil entre firmware e software. Em muitos dispositivos, o firmware seria armazenado na memória flash, por exemplo, mas em um telefone moderno quase tudo é armazenado na memória flash e a distinção entre firmware e software não é clara (a maioria das pessoas provavelmente consideraria o código para programar o firmware do processador de banda base , e a maioria das pessoas consideraria o software de programas aplicativos, mas onde está o limite exato?).
3. Como eu disse em 2, não há distinção clara, além da idéia de que o firmware é um pouco mais permanente.

A simultaneidade de hardware é uma das principais motivações.

Os elétrons podem fluir ao mesmo tempo em fios paralelos, por isso queremos levar isso em consideração ao projetar o hardware.

Em VHDL, se você escrever algo como:

x <= a or b;
y <= a and b;
z <= x xor y;

(fora de um processou function, que o marca explicitamente como seqüencial), você codificou o fato de que:

• x, y, z, aE bsão fios
• ae bsão sinais de entrada
• xestá conectado à saída de um orcircuito, que recebe ae bcomo entrada
• e assim por diante para as outras linhas

É fácil ver como isso será sintetizado no hardware real, e isso xe yavaliado ao mesmo tempo.

        +-----+
A--+----+     |  X
   |    | OR  +-----+
B----+--+     |     |  +-----+
   | |  +-----+     +--+     |
   | |                 | XOR +-- Z
   | |  +-----+     +--+     |
   | +--+     |  Y  |  +-----+
   |    | AND +-----+
   +----+     |
        +-----+

Então, quando é hora de simular o circuito, o simulador (que geralmente é um programa seqüencial) simula a física do circuito, algo como isto:

• tem aou bmudou? Sim? Ei, xdepende a. Vamos atualizar x.
• ytambém depende a. Atualize isso também.
• zdepende de x. Atualize-o porque xfoi atualizado.
• alguma coisa que xdepende ( aou b) foi atualizada? Não? O mesmo para ye z. OK, terminamos esta etapa.

Isso leva a resultados possíveis "interessantes" que não possuem análogo sequencial, mas que representam possíveis situações físicas:

• x <= not xlevaria a uma recursão infinita da simulação. Os simuladores podem simplesmente ser cortados após uma certa profundidade.
• x <= 0; x <= 1leva a um erro (curto-circuito). Esta é uma das razões pelas quais std_logicexiste.

Ainda assim, embora o VHDL modele o hardware mais de perto que o C, ele não é uma descrição perfeitamente detalhada dele:

• apenas um subconjunto de VHDL em sintetizável
• são feitas muitas simplificações físicas, em particular que os sinais se propagam infinitamente rápido, consulte https://en.wikipedia.org/wiki/Static_timing_analysis TODO talvez seja possível modelar atrasos no Verilog: http://www.asic-world.com /verilog/gate3.html#Gate_and_Switch_delays

No final, o VHDL fornece um bom equilíbrio entre a funcionalidade do circuito compreensível humano de nível superior e a capacidade de sintetização de nível inferior.

C, por outro lado, está mais focado em conversar com a CPU sequencialmente.

É claro que você poderia codificar um circuito com estruturas C, enumerações e matrizes e depois simulá-lo como o VHDL (isso se parece mais ou menos com o que o Sistema C faz, mas nunca tentei).

Mas você essencialmente reimplementaria um simulador de VHDL e com uma linguagem mais detalhada. A ferramenta certa para o trabalho certo, eu acho.

Também existem ferramentas que convertem C para VHDL /programming/8988629/can-you-program-fpgas-in-c-like-languages, mas esperam um desempenho mais baixo, pois essas são conversões difíceis de nível superior.

Os HDLs são usados ​​para descrever (sintetizar) o hardware, onde a linguagem de programação é usada para programar o hardware já sintetizado, ou seja, a CPU.

Você pode obter versões soft core de cpus como VHDL ou bitstream para sintetizar essa cpu em um FPGA.

Um processador usa uma quantidade modesta de circuitos para executar um grande número de operações, sequencialmente, permitindo que a maioria dos componentes seja usada para executar operações diferentes em momentos diferentes.

Um FPGA contém vários circuitos que não podem - pelo menos individualmente - executar operações particularmente sofisticadas, mas são todos capazes de agir simultaneamente e independentemente.

Suponha que se queira ter um chip que execute várias tarefas, entre as quais o monitoramento de 15 entradas e:

• Definir uma saída alta sempre que todas as entradas permanecerem estáveis ​​por pelo menos 21ms e o número de entradas altas for múltiplo de três
• Definir a saída baixa sempre que todas as entradas permanecerem estáveis ​​por pelo menos 21ms e o número de entradas altas não for múltiplo de três
• Alterando a saída de maneira arbitrária entre o momento em que qualquer entrada é alterada e o tempo em que todas as entradas permanecem estáveis ​​por pelo menos 20 ms.

Se alguém tem um microcontrolador que está fazendo outras coisas, mas pode poupar alguns microssegundos a cada 20ms para examinar essas entradas e definir a saída, a maioria dos circuitos que o microcontrolador usa para executar outras tarefas também será utilizável para executar a tarefa indicada. acima, muito pouco circuito (além de algumas ROM e talvez RAM) precisará ser dedicado a essa tarefa. Por outro lado, pode levar algum tempo entre o tempo que uma entrada muda e o tempo em que a saída reflete corretamente.

Usando Verilog ou VHDL, pode-se construir um circuito de hardware que monitore continuamente as 15 entradas e realize o cálculo indicado. Esse dispositivo provavelmente seria capaz de fazer com que a saída produzisse uma indicação correta dentro de 100ns - ordens de magnitude mais rápidas que o microcontrolador - mas a quantidade de circuitos dedicados a essa tarefa e inutilizáveis ​​para qualquer outra finalidade seria muito maior.