Qual è la motivazione nell'uso di Verilog o VHDL su C?

Vengo da un background di programmazione e non ho troppi problemi con hardware o firmware (al massimo un po 'di elettronica e Arduino).

Qual è la motivazione nell'uso dei linguaggi di descrizione hardware (HDL) come Verilog e VHDL rispetto ai linguaggi di programmazione come C o alcuni Assembly?

Questo problema è assolutamente una questione di scelta?

Ho letto che l'hardware, il cui firmware è scritto in un HDL, ha un chiaro vantaggio nell'eseguire le istruzioni in parallelo. Tuttavia, sono rimasto sorpreso nel vedere discussioni che esprimono dubbi sulla scrittura del firmware in C o Assembly (come è appropriato Assembly se non si dispone necessariamente di una CPU?) Ma ho concluso che è anche un'opzione.

Pertanto, ho alcune domande (non esitate a spiegare qualcosa):

1. Un firmware può davvero essere scritto in HDL o in un linguaggio di programmazione software, oppure è solo un altro modo per eseguire la stessa missione? Mi piacerebbe esempi del mondo reale. Quali vincoli derivano da ciascuna opzione?

2. So che un uso comune del firmware rispetto al software è negli acceleratori hardware (come GPU, adattatori di rete, acceleratori SSL, ecc.). A quanto ho capito, questa accelerazione non è sempre necessaria, ma solo raccomandata (ad esempio, nel caso di SSL e accelerazione di algoritmi complessi). Si può scegliere tra firmware e software in tutti i casi? In caso contrario, sarei felice dei casi in cui il firmware è chiaramente e inequivocabilmente appropriato.

3. Ho letto che il firmware è stato masterizzato principalmente su ROM o flash. Come viene rappresentato lì? A pezzi, come il software? Se è così, qual è la differenza profonda? È la disponibilità di circuiti adattati nel caso del firmware?

Immagino di aver fatto un errore qua e là in alcune ipotesi, ti prego di perdonarmi. Grazie!

Qual è la motivazione nell'uso dei linguaggi di descrizione hardware (HDL) come Verilog e VHDL rispetto ai linguaggi di programmazione come C o alcuni Assembly?

C e assembly sono buoni linguaggi per dire a una CPU cosa fare. Descrivono le azioni che devono essere eseguite in sequenza da una singola macchina a stati.

Gli HDL sono buoni linguaggi per descrivere o definire una raccolta arbitraria di circuiti digitali. Possono esprimere le operazioni fatte in parallelo in modi che i linguaggi di programmazione non possono. Possono anche descrivere i limiti di temporizzazione per le interfacce tra i blocchi in modi che i linguaggi di programmazione non possono.

Sono stato sorpreso di vedere discussioni che esprimono dubbi sulla scrittura del firmware in C o Assembly (come è appropriato Assembly se non si dispone necessariamente di una CPU?)

In quella domanda, ci si chiede: "Se stai scrivendo un codice per un microcontrollore, c'è una vera differenza se scrivi in ​​assembly o in C o in qualche altro linguaggio di alto livello?".

Dal momento che sta chiedendo in particolare i sistemi con un microcontrollore (una CPU con periferiche), C o assembly sono entrambe scelte ragionevoli per lo sviluppo di firwmare, e HDL non lo sono.

Un firmware può davvero essere scritto in HDL o in un linguaggio di programmazione software, oppure è solo un altro modo per eseguire la stessa missione?

Dipende dal tipo di hardware che hai. Se hai una CPU, usa un linguaggio di programmazione. Se hai un FPGA o stai progettando un ASIC, usa un HDL. Se stai progettando una grande quantità di logica digitale, puoi guardare a una delle lingue intermedie come SystemVerilog.

Ho letto che il firmware è stato masterizzato principalmente su ROM o flash. Come viene rappresentato lì? A pezzi, come il software? Se è così, qual è la differenza profonda? È la disponibilità di circuiti adattati nel caso del firmware?

Penso che ti stiano bloccando il termine "firmware". Questa parola originariamente significava che il codice doveva essere eseguito su un sistema incorporato, che non era accessibile per l'utente finale. Se hai venduto qualcuno a un PC, c'è un'alta probabilità che l'utente cambi il software su cui è in esecuzione. Se hai venduto loro un oscilloscopio, non vorrai che cambiassero il codice che viene eseguito sul microprocessore interno, quindi lo hai chiamato firmware.

Gli utenti FPGA si sono appropriati della parola "firmware" per l'output dei loro progetti, perché è più modificabile dell'hardware (elementi saldati insieme). Ma davvero il "firmware" che configura un FPGA è diverso dal "firmware" che gira su un uC. Il firmware UC dirige l'UC attraverso una serie di stati per svolgere la sua funzione. Il firmware FPGA definisce una serie di interconnessioni tra elementi logici e valori da memorizzare nelle tabelle di consultazione.

In entrambi i casi, il firmware viene in genere archiviato come bit su una eeprom (o su disco su una macchina host che lo scaricherà ogni volta che si riavvia il sistema incorporato). Ma ciò non li rende simili tra loro.

Per la prima parte della tua domanda, sulle motivazioni dell'uso dell'una o dell'altra: esiste una differenza fondamentale tra C e HDL (VHDL / Verilog) . C è un linguaggio di programmazione software (così come lo è assembly), VHDL / Verilog sono linguaggi di descrizione hardware . Non sono pensati per lo stesso scopo.

C viene tradotto in codice assembly (nella sua forma binaria, cioè in linguaggio macchina) quando compilato . Questo codice è una serie di istruzioni che indicano alla CPU di eseguire una serie di operazioni di base (modificare un valore di registro, eseguire un'aggiunta, ecc.).

D'altra parte, un HDL è sintetizzato all'hardware. In VHDL potresti ad esempio scrivere qualcosa del tipo:

output <= input1 + input2;

(vedi anche un esempio più completo qui ). Questo sarebbe sintetizzato in un sommatore (hardware). Se il codice è sintetizzato per un FPGA , ciò significherebbe un bitstream che può configurare l'FPGA specifico per implementare un sommatore (come logica combinatoria ).

In realtà, è possibile progettare una CPU in VHDL (vedere Processori soft core VS Processori core core ) e scrivere il software per esso in C ...

Informazioni sul firmware: in realtà tutto dipende da come si definisce la parola. Un firmware può essere un programma (software) che viene eseguito in un microcontrollore (così scritto ad esempio in C o assemblatore), oppure può essere un bitstream per configurare un dispositivo logico programmabile (hardware) (CPLD o FPGA). A volte può essere un pacchetto contenente entrambi: se prendi il firmware per alcuni modelli di FritzBox (un modem ADSL), in realtà contengono un intero sistema Linux (scritto in assemblatore, C e molti altri linguaggi di programmazione) e un bitstream per configurare un FPGA (probabilmente sintetizzato da VHDL o Verilog).

1. Dipende dalla tua architettura. Se si dispone di una CPU (o, in genere, di un microcontrollore), è necessario scrivere il firmware in un linguaggio di programmazione regolare (incluso assembly). Se hai qualcosa come un FPGA, il tuo firmware deve essere scritto in un HDL. Le HDL non possono (per quanto ne sappia) generare programmi che possono essere eseguiti in modo efficiente da una CPU convenzionale e un FPGA non esegue programmi convenzionali. Tuttavia, è possibile configurare l'FPGA come CPU e quindi eseguire un programma convenzionale con quello. Ciò richiederebbe due livelli di firmware, il livello inferiore scritto in un HDL per costruire la CPU e il livello superiore scritto in un linguaggio di programmazione convenzionale per essere eseguito su quella CPU.
2. Non esiste una forte distinzione tra firmware e software. Su molti dispositivi, il firmware verrebbe archiviato ad esempio nella memoria flash, ma su un telefono moderno, quasi tutto viene archiviato nella memoria flash e la distinzione tra firmware e software non è chiara (la maggior parte delle persone probabilmente considererebbe il codice per programmare il firmware del processore in banda base e la maggior parte delle persone considererebbe il software dei programmi applicativi, ma dov'è il confine esatto?).
3. Come ho detto in 2, non esiste una chiara distinzione, a parte l'idea che il firmware sia un po 'più permanente.

La concorrenza hardware è una delle principali motivazioni.

Gli elettroni possono fluire contemporaneamente in fili paralleli, quindi vogliamo tenerne conto durante la progettazione dell'hardware.

In VHDL, se scrivi qualcosa del tipo:

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

(al di fuori di un processo function, che lo contrassegna esplicitamente come sequenziale), hai codificato il fatto che:

• x, y, z, aE bsono fili
• ae bsono segnali in ingresso
• xè collegato all'uscita di un orcircuito, che accetta ae bcome input
• e così via per le altre linee

È facile vedere come questo sarà sintetizzato nell'hardware reale e che xe ysarà valutato allo stesso tempo.

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

Quindi, quando è il momento di simulare il circuito, il simulatore (che di solito è un programma sequenziale) ha simulato così la fisica del circuito in questo modo:

• è cambiato ao è bcambiato? Sì? Ehi, xdipende a. Aggiorniamo x.
• ydipende anche da a. Aggiorna anche quello.
• zdipende da x. Aggiornalo perché è xstato aggiornato.
• è stato aggiornato qualcosa che xdipende ( ao b)? No? Lo stesso per ye z. OK, abbiamo finito con questo passaggio.

Ciò porta a risultati "interessanti" che non hanno un analogo sequenziale, ma che rappresentano possibili situazioni fisiche:

• x <= not xporterebbe a una ricorsione infinita della simulazione. I simulatori possono essere tagliati dopo una certa profondità.
• x <= 0; x <= 1porta ad un errore (corto circuito). Questo è uno dei motivi per cui std_logicesiste.

Tuttavia, anche se VHDL modella l'hardware più da vicino di C, non è esso stesso una descrizione perfettamente dettagliata di esso:

• solo un sottoinsieme di VHDL sintetizzabile
• vengono fatte molte semplificazioni fisiche, in particolare che i segnali si propagano all'infinito velocemente, vedere https://en.wikipedia.org/wiki/Static_timing_analysis TODO forse è possibile modellare i ritardi in Verilog: http://www.asic-world.com /verilog/gate3.html#Gate_and_Switch_delays

Alla fine VHDL fornisce un buon equilibrio tra funzionalità di circuito comprensibile per l'uomo di livello superiore e sintetizzabilità di livello inferiore.

C d'altra parte, è più concentrato sul parlare in sequenza con la CPU.

Ovviamente potresti codificare un circuito con strutture C, enumerazioni e array, e quindi simularlo proprio come fa VHDL (questo assomiglia più o meno a ciò che fa il Sistema C , ma non l'ho mai provato).

Ma essenzialmente si reimplementerebbe un simulatore VHDL e con un linguaggio più dettagliato. Immagino lo strumento giusto per il lavoro giusto.

Ci sono anche strumenti che convertono C in VHDL /programming/8988629/can-you-program-fpgas-in-c-like-languages ma si aspettano prestazioni inferiori poiché si tratta di conversioni di livello più elevato.

Gli HDL sono usati per descrivere (sintetizzare) l'hardware in cui viene usato come linguaggio di programmazione per programmare l'hardware già sintetizzato, ad esempio CPU.

Puoi ottenere versioni soft core di cpus come VHDL o bitstream per sintetizzare quella cpu su un FPGA.

Un processore utilizza una modesta quantità di circuiti per eseguire un gran numero di operazioni, in sequenza, consentendo alla maggior parte dei componenti di essere utilizzati per eseguire diverse operazioni in momenti diversi.

Un FPGA contiene una serie di circuiti che non possono - almeno individualmente - eseguire operazioni particolarmente sofisticate, ma sono tutti in grado di agire simultaneamente e indipendentemente.

Supponiamo che si desideri avere un chip che esegua una serie di compiti, tra cui il monitoraggio di 15 input e:

• Impostando un'uscita alta ogni volta che tutti gli ingressi sono rimasti stabili per almeno 21 ms e il numero di ingressi che è alto è un multiplo di tre
• Impostando l'uscita in basso ogni volta che tutti gli ingressi sono rimasti stabili per almeno 21 ms e il numero di ingressi che è alto non è un multiplo di tre
• La modifica dell'output in modo arbitrario tra il tempo in cui cambia qualsiasi input e il tempo in cui tutti gli input sono stati stabili per almeno 20 ms.

Se uno ha un microcontrollore che sta facendo altre cose, ma può risparmiare qualche microsecondo ogni 20 ms per esaminare quegli ingressi e impostare l'uscita, allora la maggior parte dei circuiti che il microcontrollore utilizza per eseguire altre attività sarà anche utilizzabile per eseguire l'attività indicata sopra, così pochi circuiti (oltre a qualche ROM e forse RAM) dovranno essere dedicati a questo compito. D'altra parte, potrebbe volerci un po 'di tempo tra il momento in cui un input cambia e il momento in cui l'output lo riflette correttamente.

Utilizzando Verilog o VHDL, si potrebbe costruire un circuito hardware in grado di monitorare continuamente i 15 ingressi ed eseguire il calcolo indicato. Un tale dispositivo sarebbe probabilmente in grado di far sì che l'uscita produca un'indicazione corretta entro 100 ns - ordini di grandezza più veloci del microcontrollore - ma la quantità di circuiti dedicati a tale compito e inutilizzabili per qualsiasi altro scopo sarebbe molto maggiore.