FPGA - LUT, slice e risorse della famiglia 7

Una FPGA (Dispositivi logici programmabili - PROM, PLA, PAL e CPLDUn componente logico programmabile (PLD) è un circuito integrato a catalogo la cui funzione logica viene fissata da una programmazione che altera la struttura del circuito (non va confusa con la programmazione software di un microprocessore). I meccanismi sono fusibili, antifusibili (una volta), EPROM/EEPROM/Flash (reversibili e non volatili) e celle SRAM (reversibili ma volatili). Le architetture semplici (SPLD) sono due piani AND-OR: PROM (AND fisso, cioè un decoder di tutti i mintermini, OR programmabile), PLA (entrambi programmabili, dimensione indipendente dal numero di ingressi, più lenta) e PAL (AND programmabile, OR fisso, più veloce). I CPLD sono matrici di blocchi SPLD con interconnessioni programmabili, le FPGA hanno molti blocchi logici piccoli (LUT + registro) in una griglia di interconnessioni complessa, configurata da SRAM.Dispositivi logici programmabili - PROM, PLA, PAL e CPLD →) è un circuito integrato programmabile "sul campo" formato da una matrice di blocchi logici configurabili collegati da una rete di interconnessioni anch'essa programmabile. Si realizza in CMOS (oggi processi a $16$ nm) con memoria di configurazione SRAM, e arriva a decine di milioni di porte equivalenti e frequenze fino a circa $800\ \mathrm{MHz}$. Gli strumenti di sviluppo integrano sintesi, simulazione, piazzamento e instradamento (Simulazione, testbench, vincoli di temporizzazione e flusso su FPGAUn progetto VHDL si verifica per simulazione con un testbench: una entity senza porte che istanzia il circuito sotto test (UUT), genera il clock (process con wait for e inversione), applica gli stimoli e controlla le uscite con assert/report/severity (note, warning, error, failure) o leggendo vettori da file (textio). Il flusso su FPGA è: descrizione VHDL, simulazione funzionale, sintesi (rete di LUT e flip-flop), implementazione (piazzamento e instradamento), analisi di temporizzazione, generazione del bitstream e programmazione della scheda. I vincoli (file XDC) assegnano i pin e definiscono il clock (periodo); l'analisi di temporizzazione verifica per ogni cammino registro-registro lo slack di setup, T − (t_c-q + t_logica + t_routing + t_su), e di hold; con slack negativo la frequenza è troppo alta: f_max = 1/(T − WNS).Simulazione, testbench, vincoli di temporizzazione e flusso su FPGA →). La famiglia usata in laboratorio (scheda con un dispositivo Xilinx Artix-7) appartiene alla serie 7.

Gli elementi principali

1. Celle logiche configurabili: logica combinatoria (LUT), funzioni di registro (latch, flip-flop D, ...) e logica aritmetica con catena di riporto dedicata.
2. Blocchi di ingresso/uscita (SelectIO): supportano molti standard, con SERDES, ritardi regolabili e registri DDR.
3. Block RAM (e FIFO) integrate.
4. Gestione del clock: buffer di clock a bassa skew e blocchi MMCM/PLL.
5. Blocchi DSP (moltiplicatori e accumulatori) e, in alcuni dispositivi, transceiver seriali (da $3{,}75$ a oltre $13\ \mathrm{Gb/s}$), interfacce PCI Express e un convertitore A/D a $12$ bit (XADC). Le FPGA includono in genere moduli specifici (sommatori, moltiplicatori, unità MAC, RAM, anche microprocessori e interfacce veloci) perché implementarli in logica generale è meno efficiente.

La LUT

La look-up table (LUT) a $k$ ingressi è una piccola memoria di $2^k$ celle SRAM da $1$ bit, indirizzata dai $k$ ingressi, con un multiplexer $2^k\to1$ in uscita: gli ingressi della funzione sono i segnali di selezione del multiplexer, e il contenuto delle celle è la tabella di verità della funzione. Qualsiasi funzione combinatoria di $k$ variabili si realizza riscrivendo le celle, con ritardo costante attraverso la LUT: il tempo dipende solo dal numero di ingressi, non dalla complessità della funzione. Il numero di funzioni diverse è $2^{2^k}$: $256$ per $k=3$, $2^{64}$ per $k=6$.

Esempio: $y=(a\cdot b)+\overline c$ con LUT a $3$ ingressi. Tabella per $abc=000,001,\ldots,111$: $y=1,0,1,0,1,0,1,1$; i bit programmati sono quindi $10101011$ (indirizzo $abc$). Se la funzione ha più ingressi di quelli della LUT si combinano più LUT attraverso multiplexer dedicati.

Una LUT può essere anche una ROM (con contenuto fisso, $64\times1$ per la LUT a $6$ ingressi) o, se si abilita la scrittura, una RAM.

Lo slice nella serie 7

Il CLB (configurable logic block) è la risorsa principale per la logica combinatoria e sequenziale: contiene due slice, collegati a una matrice di commutazione per l'instradamento. Ogni slice contiene:

• quattro LUT a 6 ingressi: ciascuna può essere usata come una LUT a 6 ingressi con un'uscita (qualsiasi funzione di $6$ variabili) oppure come due LUT a 5 ingressi indipendenti (con ingressi comuni e due uscite); impatto sulla velocità minimo;
• multiplexer larghi F7MUX (combina due LUT: funzione arbitraria a $7$ ingressi o mux $8\to1$) e F8MUX (combina due F7MUX: funzione a $8$ ingressi o mux $16\to1$): sono dedicati, quindi il ritardo è piccolo;
• catena di riporto (carry chain): realizza somme e sottrazioni veloci; il riporto si propaga verticalmente attraverso le quattro LUT dello slice e poi allo slice nella stessa colonna del CLB sopra (con carry look-ahead sulle quattro LUT);
• quattro flip-flop/latch (FF/L) più altri quattro flip-flop: tutti di tipo D, con un solo ingresso di clock (invertibile al confine dello slice), un enable e un reset/set (sincrono o asincrono secondo il bitstream); il dato $D$ può venire dalla LUT, dalla carry chain, dai multiplexer larghi o dall'ingresso dello slice.

Esistono due tipi di slice:

• SLICEM: slice completo; le LUT si possono usare anche come RAM distribuita e come registri a scorrimento;
• SLICEL: solo logica e aritmetica (le LUT non sono memorie). Gli strumenti di implementazione assegnano la logica agli slice (packing).

Dispositivo della scheda di laboratorio (Artix-7 100T): circa $15\,850$ slice, quindi $63\,400$ LUT a $6$ ingressi e $126\,800$ flip-flop ($8$ per slice), $135$ block RAM da $36\ \mathrm{kb}$ e $240$ blocchi DSP (valori del dispositivo, non delle dispense; coerenti con $4$ LUT e $8$ flip-flop per slice).

RAM distribuita e registro a scorrimento (SRL)

Nello SLICEM la memoria della LUT può essere usata come dato:

• RAM distribuita: una LUT a $6$ ingressi è una RAM $64\times1$ (o $32\times2$); scrittura sincrona, lettura asincrona (si può rendere sincrona con i flip-flop dello slice); porte: singola, doppia (una di lettura/scrittura più una di sola lettura), quadrupla; fino a $256\times1$ componendo più LUT.
• Registro a scorrimento a 32 bit (SRL32): la LUT è un registro a scorrimento in cui la lunghezza effettiva è scelta dall'indirizzo: dato in ingresso ritardato di $(\text{indirizzo}+1)$ cicli; più LUT in cascata arrivano a $128$ bit per slice. Servono per linee di ritardo, FIFO sincrone, memorie associative, generatori di sequenze e compensazione di latenza. Esempio: una pipeline di $17$ stadi da $64$ bit richiederebbe $17\cdot64=1088$ flip-flop, cioè $136$ slice, oppure $64$ SRL (uno per bit, lunghezza $17$ regolata dall'indirizzo): solo $16$ slice.

Block RAM, DSP, clock e I/O

• Block RAM: blocchi di memoria dedicati, integrati nel chip (non fatti con LUT, né esterni al package): $36\ \mathrm{kb}$ (o due da $18\ \mathrm{kb}$) configurabili da $32\mathrm{k}\times1$ a $512\times72$, a doppia porta (simple dual-port o true dual-port), con logica FIFO integrata e correzione d'errore a $64$ bit. Blocchi adiacenti si combinano fino a $64\mathrm{k}\times1$ senza logica aggiuntiva.
• Slice DSP: moltiplicatore $25\times18$ bit con pre-sommatore a $25$ bit, ALU a $48$ bit, accumulatore (MAC) a $96$ bit, rilevatore di pattern e shifter, con pipeline flessibile e cascata: i moltiplicatori e i filtri (Traslatori, comparatori e moltiplicatoriOltre ai sommatori, la ALU contiene traslatori (shifter), comparatori e moltiplicatori. Lo shift a sinistra di k posizioni moltiplica per 2^k; lo shift a destra aritmetico (con replica del bit di segno) divide per 2^k nel complemento a due; il barrel shifter realizza qualsiasi traslazione fino a N − 1 posizioni con log₂N livelli di multiplexer 2→1. Il comparatore di uguaglianza è l'AND delle XNOR bit a bit; quello di grandezza confronta partendo dal bit più significativo (GT = g_{N−1} + e_{N−1}(g_{N−2} + e_{N−2}(…))) oppure usa la sottrazione e le flag. Il moltiplicatore a matrice (array) forma N² prodotti parziali con porte AND e li somma con N(N−1) full adder; il ritardo cresce come 2N t_carry; moltiplicatori ad albero (Wallace) e sequenziali (shift-and-add) sono alternative; le FPGA hanno blocchi DSP dedicati.Traslatori, comparatori e moltiplicatori →) li usano.
• Clock: struttura di distribuzione a bassa skew, regioni di clock e CMT (clock management tile, con un MMCM e una PLL).
• I/O: banchi high range (fino a $3{,}3\ \mathrm V$) e high performance (fino a $1{,}8\ \mathrm V$), con registri DDR e ritardi regolabili.

Instradamento

I collegamenti tra CLB e altre risorse usano le risorse di routing: segmenti di diversa lunghezza (orizzontali singoli, doppi, quad; verticali singoli, doppi, hex; diagonali) che si collegano a matrici di commutazione adiacenti alle risorse. Nelle FPGA il ritardo delle interconnessioni domina quello della logica e dipende dal piazzamento.

Errori comuni

• Dire che le block RAM sono costruite con LUT o sono esterne: sono blocchi dedicati integrati.
• Contare il ritardo di una LUT dipendente dalla funzione: è costante.
• Dimenticare che la configurazione SRAM è volatile e va ricaricata.
• Confondere SLICEM e SLICEL: solo il primo può essere RAM o SRL.