Sintesi processi VHDL

[simoiamma]

Ciao a tutti!

Sto cercando di scrivere un codice in VHDL per un comparatore ad N bit generico.
Ha due ingressi ad N bit, controlla se sono uguali facendo un XOR tra ogni elemento dei due vettori: se risultano tutti zero vuol dire che sono uguali. (salvato ad esempio nel vettore Ris(N-1))

Controllare se tutti i bit sono zero sarebbe semplice se si conoscessero a priori i bit dei vettori in ingresso, mettendo in AND le uscite di ogni OR del processo precedente si otterrebbe un unica uscita Equal = 0 se sono uguali e Equal = 1 se non sono uguali

Il problema sorge nel renderlo generale, infatti non si conosce a priori il numero di bit in ingresso.

Una possibile soluzione sarebbe: ciclo for dentro un process, come lo si farebbe in qualsiasi altro linguaggio sequenziale:

Codice: Seleziona tutto


AndCode: PROCESS()
variable Equal = 0;

for i in 0 to N-1
    Equal := Equal AND Ris(i)

END PROCESS;


La mia domanda è: come viene sintetizzato un processo del genere all'interno dell'FPGA? E' qualcosa di combinatorio o sequenziale mascherato da un clock interno?

Grazie!

[deltax]

Guarda, io vorrei aiutarti, ma ho dato una materia di VHDL 1 anno fa, sono un po' arrugginito, però avevo fatto una cosa molto molto simile (un contatore completo a N bit, con N arbitrario). Allora le cose sono 3: o io non ho capito la domanda, o io non ho capito come funzionano gli FPGA e la programmazione VHDL, oppure tu stai facendo un po' di confusione sul paradigma di programmazione degli FPGA.
Quando tu scrivi in codice VHDL, che appunto è l'acronimo di Hardware description, tu non stai andando a scrivere cosa l'FPGA eseguirà (in tal caso il for; come hai scritto nell'ultima riga del tuo messaggio). Con il codice verrà creato un hardware relativo (una porta logica, per esempio) che farà delle operazioni; con un for, verrà creato un certo numero di quelle strutture, che dipende dall'indicizzazione del for. Per questo un codice con un generico N non dovrebbe funzionare se tu non specifichi un N all'inizio del codice (per dire, tu puoi scrivere tutto il codice con un generico N, ma per poter essere compilato il codice all'inizio devi dare un valore ad N!).
Quindi non è che l'FPGA "fa" (in senso di processa) il for, ma il VHDL interpreta il for come la costruzione di N strutture logiche che tu hai scritto nel codice (con N specificato!); in un secondo momento tutta la struttura generale dell'hardware descritto sarà mappata sul'FPGA, programmando le celle di memoria che controllano le "strutture elementari" (che tipicamente sono delle strutture che hanno varie funzioni di latch e porte logiche complesse adattabili)

Spero di non aver sparato castronerie

[DanteCpp]

Non conosco il VHDL, pero se puoi usare delle ALU come primitive, potresti comparare per differenza virtuale...

EDIT
No, il tuo problema è di più basso livello. Comunque sono d'accordo con deltax devi fissare un N.

[boiler]

Il generic devi sempre dichiararlo quando instanzi un'entità. Poi il compiler nel tuo caso genererà il numero necessario di confronti (non una struttura di controllo).

Perché sia sintetizzabile ricordati che il range del loop deve essere statico (quindi, appunto, devi dichiarare il generic al momento dell'intanziazione) e non può contenere comandi di wait. In caso contrario è simulabile ma non sintetizzabile.

Se ti interessa sapere cosa ha prodotto il compiler (ed è spesso una buona idea) puoi sempre dare un'occhiata alla netlist generata. Come si fa dipende dalla toolchain che utilizzi.

Ciao Boiler

[gb88]

Per vedere cosa viene generato sull'FPGA devi controllare la netlist, per esperienza dovrebbe crearti una rete di porte combinatorie, i flip-flop di solito sono inseriti per ottenere la chiusura temporale per evitare percorsi logici combinatori troppo lunghi o catene chiuse.

[boiler]

i flip-flop di solito sono inseriti per ottenere la chiusura temporale per evitare percorsi logici combinatori troppo lunghi o catene chiuse.

Cosa intendi per "sono inseriti". Se il VHDL che scrivi è buono e non in stile Arduino i flip-flop vengono istanziati se e soltanto se (a) tu generi un costrutto che lo richieda (vedi sotto) (b) li istanzi esplicitamente.

Visto che rinfrescare i concetti male non fa, questo è l'unico costrutto (togliendo eventualmente quello che non serve se non si vogliono le funzioni enable e load) che chi tiene alla propria salute mentale usa per generare flip-flops:

Codice: Seleziona tutto

register : process (CLK ,RST)
begin
   if RST=’0’ then
      STATEVECTOR <= (others => ’0’)
   elsif CLK ’event and CLK=’1’ then
      if LOD=’1’ then
         STATEVECTOR <= (others => ’1’)
      elsif ENA=’1’ then
         STATEVECTOR <= NEXTSTATEVECTOR;
      end if;
   end if;
end process register;

In particolare: null'altro nella sensitivity list e nessun'altra condizione if.

Boiler

[Gionatan]

Ho letto qualcosa di programmazione VHDL per cui chiedo scusa a priori se dico qualche stupidaggine.
Stante che non si sa quanti bit si devono verificare e supponendo che i bit si presentano al pin d'ingresso in modalità seriale, si suppone che ci sia qualche segnale che indica che non ci sono più bit da paragonare per cui è possibile fare lo xor di un bit per volta man mano arrivano e mettere il risultato nel RESET di un Latch che indicherà quando anche uno solo dei confronti avrà dato esito negativo.

[boiler]

Il tuo ragionamento è corretto, ma non fai altro che spostare il problema all'esterno dell'entità: ci vuole una struttura di controllo che genera questo segnale.

Inoltre il concetto che ci sta dietro è completamente diverso: uno fa il confronto in un ciclo singolo, l'altro ne ha bisogno di n (usando però un solo comparatore). In inglese si chiama iterative decomposition. La scelta di cosa utilizzare dipende spesso dalla velocità di clock che si vuole/deve ottenere in confronto al tempo necessario per fare una singola operazione del loop.

Boiler

[simoiamma]

Grazie a tutti delle risposte. Mi rendo conto solo ora che non avevo capito molto bene la differenza tra un codice che viene eseguito sequenzialmente e un codice che viene prima interpretato dal compilatore e poi sintetizzato come una rete hardware.