Progettazione in VHDL del Vertex Shader

Transcript

1 Progettazione in VHDL del Vertex Shader Pag. 75 PARTE TERZA Progettazione in VHDL del Vertex Shader Autori: Gian Maria Ricci La presente parte è organizzata nei seguenti capitoli: Capitolo 3. Realizzare una ALU Floating Point Capitolo 4. Implementazione del Vertex Shader

2 Progettazione in VHDL del Vertex Shader Pag. 76 Capitolo 3. Realizzare una ALU Floating Point 3.1. Funzioni di conversione Uno dei punti di forza del VHDL è la possibilità di lavorare con la metodologia top-down, realizzando in un primo momento le entità con descrizioni comportamentali e scendendo nei dettagli solamente dopo che il design è stato testato e verificato. Seguendo questa metodologia è possibile progettare una FPU (Floating Point Unit), la cui realizzazione a livello circuitale è sicuramente di complessità notevole, utilizzando una descrizione comportamentale che si appoggia sulle librerie numeriche floating point del compilatore. Una volta che il design del processore è stato completato, è sufficiente sostituire la descrizione behavioural dell ALU con una descrizione comportamentale o comunque sintetizzabile dal compilatore. Per poter lavorare correttamente con ALU ed FPU a livello comportamentale è comunque necessario realizzare alcune funzioni di conversione, che consentano di trasformare la rappresentazione binaria del numero nella corrispettiva quantità reale o intera e viceversa. I segnali infatti sono definiti mediante bit_vector e non è possibile operare direttamente su di essi con gli operatori o le funzioni matematiche standard presenti nella libreria del ModelSim. Il VHDL permette infatti di definire variabili di tipo integer o real, ma non è possibile assegnare loro direttamente un valore contenuto in un segnale o in un altra variabile di tipo bit_vector. La prima cosa da fare è allora realizzare le funzioni di conversione tra i tipi interi e reali e la loro rappresentazione binaria Conversioni di quantità integer La conversione di quantità intere non presenta alcun problema: le funzioni che svolgono questo compito, oltre che molto semplici, si possono trovare in qualsiasi libro che tratti il VHDL. Per completezza è di seguito riportata la realizzazione presente nel VHDL Cookbook. function bits_to_int (bits : in bit_vector) return integer is variable temp : bit_vector(bits'range); variable result : integer := 0; if bits(bits'left) = '1' then -- negative number temp := not bits; else temp := bits; for index in bits'range loop -- sign bit of temp = '0' result := result * 2 + bit'pos(temp(index)); end loop; if bits(bits'left) = '1' then result := (-result) - 1; return result; end bits_to_int; Questa funzione effettua la conversione tra una sequenza di cifre binarie

3 Progettazione in VHDL del Vertex Shader Pag. 77 ed il numero intero da essa rappresentata, espresso naturalmente in complemento a due. La funzione è molto versatile perché non presuppone una lunghezza predeterminata della rappresentazione binaria, ma la deduce mediante l operatore di attributo 'range dal dato passatole come parametro. Viene inoltre utilizzato l attributo 'left, che permette di individuare il bit più rappresentativo che identifica il segno. Se il bit di segno è pari ad 1 (numeri negativi) è necessario negare tutte le cifre a causa del complemento a due, successivamente in un ciclo for viene calcolato il valore intero rappresentato dalla sequenza di cifre binarie. Se il numero è negativo al termine della conversione è necessario cambiare di segno e sottrarre il valore 1 come richiesto dal complemento a due. Viene inoltre realizzata la funzione che converte da binario a decimale senza segno, questa operazione si rivelerà necessaria per implementare le funzioni di conversione per i numeri in virgola mobile. Naturalmente è necessario fornire anche la funzione che effettua l operazione inversa: procedure int_to_bits (int : in integer; bits : out bit_vector) is variable temp : integer; variable result : bit_vector(bits'range); if int < 0 then temp := -(int+1); else temp := int; for index in bits'reverse_range loop result(index) := bit'val(temp rem 2); temp := temp / 2; end loop; if int < 0 then result := not result; result(bits'left) := '1'; bits := result; end int_to_bits; Questa funzione viene implementata ricorrendo ad una procedura in cui la rappresentazione binaria da calcolare viene passata come parametro per riferimento, si nota infatti che il parametro bits è definito di tipo out. Questo viene fatto principalmente per garantire la stessa versatilità della funzione precedente: quando si converte da una quantità intera alla sua rappresentazione binaria si può usare un numero qualsiasi di bit, a patto che siano sufficienti per contenere il numero. Il numero 4, ad esempio, potrebbe essere convertito a 8 bit ( ) oppure a 32 bit ( ) a seconda della rappresentazione necessaria; è quindi indispensabile che la funzione permetta di specificare il numero di bit richiesti per la conversione. Mentre per la funzione precedente il numero di bit era determinato dal bit_vector passato come parametro, in questo caso come dato di ingresso è necessario un numero intero e quindi è impossibile decidere automaticamente la grandezza della rappresentazione da utilizzare. La soluzione più conveniente è quella di accettare per riferimento un parametro bit_vector utilizzato per restituire il risultato al chiamante e per conoscere la lunghezza della rappresentazione binaria desiderata.

4 Progettazione in VHDL del Vertex Shader Pag Conversioni di quantità floating point e specifica IEEE Analogamente a quanto visto in precedenza è necessario fornire anche le funzioni di conversione da quantità in virgola mobile a rappresentazione binaria. Questa operazione non è però immediata e presenta problematiche maggiori rispetto alla semplice conversione di valori interi. Come prima cosa è chiaro che non è possibile garantire così facilmente la flessibilità della conversione; d altra parte esistono solamente 3 formati in virgola mobile che sono standard IEEE, quindi basterebbe realizzare una coppia di funzioni per ognuno di essi. La conversione non è comunque banale ed è legata alla rappresentazione utilizzata. Per non aumentare la complessità in modo eccessivo verrà utilizzato un sottoinsieme ridotto delle specifiche IEEE dettate da Intel, in particolar modo verranno fatte delle semplificazioni, che sono in parte derivate dal dover fare una descrizione behavioural evitando di scendere troppo a basso livello. Si presuppone che il lettore sia in qualche modo familiare con il formato Floating Point, in caso contrario l Intel fornisce ampia documentazione a riguardo nel suo sito internet, senza dover contattare direttamente la IEEE. La prima semplificazione è quella di limitare l utilizzo alla rappresentazione a singola precisione (32 bit), che è quella maggiormente utilizzata nella computer graphics in real-time, dove la velocità di esecuzione è il parametro fondamentale da rispettare. Questa assunzione non è in realtà una limitazione perché il Vertex Shader, come da specifiche, lavora proprio con questo tipo di dato. La seconda semplificazione è quella di considerare sempre la forma normalizzata del numero e non applicare il gradual underflow per rappresentare numeri prossimi allo zero. Anche questa assunzione non comporta grossi problemi, perché l approssimazione fatta è molto piccola. Un altro fatto che avalla questa decisione è che anche Intel, nel set di istruzioni SSE, permette di impostare un flag di round to zero per evitare la denormalizzazione, che naturalmente penalizza le prestazioni di una FPU, dato che necessita di ulteriori cicli di clock per denormalizzare il numero ed un controllo durante le operazioni sui numeri utilizzati. Come ultima semplificazione non si mantiene interamente la rappresentazione di numeri particolari come previsto dalla specifica IEEE (in questo modo si perde il significato dello zero con i due segni, delle rappresentazioni dell infinito e dei QNaN e SNaN). L implementazione di queste specifiche 33 richiederebbe di scendere ad un livello di progettazione troppo elevato. Il formato real utilizzato nel VHDL infatti non è neppure ben definito e la sua unica specifica è quella di accomodare al suo interno un numero espresso in singola precisione. L unica restrizione è quindi sull intervallo minimo rappresentabile, ma non viene neanche fornita limitazione sulla precisione richiesta. Probabilmente ogni simulatore effettua la scelta più conveniente che sicuramente risulta essere la rappresentazione del processore su cui gira il simulatore stesso. Sull architettura 80x86 viene quindi probabilmente utilizzata la rappresentazione 64 bit, ma questa è solamente una supposizione. 33 Presenti fin dall 8087.

5 Progettazione in VHDL del Vertex Shader Pag Breve descrizione del formato single precision floating point Il formato single precision floating point utilizza 24 bit per la mantissa, 8 per l esponente ed uno per il segno. Sommando queste quantità si ottiene 33 bit, ma bisogna considerare che il 24 bit della mantissa è per default considerato pari ad 1, ovvero la mantissa assume sempre la forma 1xxxxxxx xxxxxxxx xxxxxxxx dove le x rappresentano cifre binarie. La mantissa quindi codifica le prime 23 cifre dopo la virgola, assumendo che la parte intera sia pari ad 1. Con la sola mantissa quindi si possono rappresentare numeri da 1 a 2 (con 2 non compreso). Il bit più significativo della rappresentazione è il bit di segno relativo alla mantissa e vale 1 per numeri negativi e 0 per numeri positivi. Questo tipo di rappresentazione è chiamata complemento a uno ed ha la strana caratteristica di avere due rappresentazioni distinte per lo zero: +0 e 0. Questa apparente stranezza viene invece sfruttata nei processori odierni per distinguere quando si è ottenuto uno zero da un arrotondamento di una quantità negativa o da una positiva. Per rappresentare numeri minori di 1 e maggiori di 2 si utilizza l esponente, che viene memorizzato in 8 bit con il metodo excess-127, ottenuto aggiungendo 127 al vero valore dell esponente. Il range di esponenti ammesso sarebbe quindi [ 127 (rappresentato da 0), +128 (rappresentato da 255)]; questi due valori estremi vengono però utilizzati per codificare numeri particolari 34 e quindi in pratica gli esponenti ammessi sono compresi nell intervallo [-126, +127]. Il range di valori ammissibili per un numero in single precision è quindi approssimativamente compreso nell intervallo [2-126, ] che in decimale diviene [1.18E-38, 3.40E38]. L ordine in cui le tre componenti appaiono nel formato è segno-esponente-mantissa. Si supponga ora di voler calcolare la precisione in cifre decimali di questa rappresentazione. Dato che la mantissa è costituita da 24 bit, di cui 23 dopo la virgola, il più piccolo numero decimale positivo rappresentabile con essa è 2-23 ovvero 0, , quindi la precisione ottenibile è leggermente maggiore di 6 cifre decimali Funzioni di conversione: da rappresentazione binaria a reale Convertire dalla rappresentazione binaria a quella reale non presenta eccessive difficoltà, la funzione che realizza questa conversione viene qui di seguito riportata: function bits_to_float (Num : in bit_vector) return real is 0); variable Temp : real := 1.0; variable result : real; variable exponent : integer; variable T : bit_vector(7 downto 0); alias NumExp : bit_vector(7 downto 0) is Num(30 downto 23); alias Mantissa : bit_vector(22 downto 0) is Num(22 downto --0) Controllare il caso particolare dello zero if Num = X"0000_0000" then return 0.0; 34 Come: infinito, SNaN e QNaN.

6 Progettazione in VHDL del Vertex Shader Pag ) Recuperare l'esponente del numero in virgola mobile for ii in T'range loop T(ii) := Num(ii + 23); end loop; exponent := bits_to_intu(t); exponent := exponent - 127; --2) Trovare il valore della mantissa -- Il numero nella forma normale è 1,xxxxxx result := 1.0; for Index in Mantissa'range loop Temp := Temp / 2.0; --Creo le potenze di 2 negative if Mantissa(index) = '1' then result := result + Temp; end loop; --3) Moltiplicare per l'esponente e mettere il segno result := result * (2.0 ** exponent); if Num(Num'left) = '1' then Result := result * (-1.0); return result; end bits_to_float; Come prima cosa, l utilizzo degli alias in VHDL permette di identificare facilmente le varie parti del formato. La prima parte che viene elaborata è l esponente; dato che si sono trascurati i risultati denormalizzati, i QNan e le altre rappresentazioni particolari, è possibile semplicemente sottrarre 127 dal valore rappresentato per ottenere l esponente desiderato. L esponente viene convertito con una versione unsigned dalla funzione di conversione binariointero perché è appunto memorizzato senza segno. Se si fosse utilizzata la normale funzione di conversione, un esponente con valore 100 (memorizzato con il numero 227) sarebbe convertito in -29 e sottraendo ancora 127 si otterrebbe l esponente -156, palesemente non corretto. Successivamente si trova il valore della mantissa, considerando che il numero è nella forma 1.xxxxx poiché si sono trascurate le rappresentazioni denormalizzate. Il suo valore viene quindi inizializzato a 1.0 e poi vengono aggiunte le corrispondenti potenze di due se la cifra della rappresentazione è pari ad 1. Infine si applica l esponente realizzato dalla funzione Exp Conversione da real a rappresentazione binaria. Questa conversione è sostanzialmente più difficile della precedente, anche perché la conversione da decimale in binario è differente per la parte intera e per quella dopo la virgola. In più bisogna cercare la prima cifra della rappresentazione diversa da 0 e calcolare in base alla sua posizione l esponente, assicurandosi contemporaneamente di avere calcolato abbastanza cifre per completare i 23 bit assegnati alla mantissa. La funzione non viene pertanto riportata nella sua completezza, ma una sezione per volta in modo da poter commentare in modo approfondito i vari passaggi. function float_to_bits2 (Num : in real) return bit_vector is variable ParteIntera : integer; variable Numero : real := Num; 35 Si sarebbe potuto anche utilizzare l operatore **.

7 Progettazione in VHDL del Vertex Shader Pag. 81 variable result : bit_vector(31 downto 0); variable ParteIntera_Bits : bit_vector(31 downto 0); variable ExponentPart : bit_vector(7 downto 0); variable Index : integer := 22; variable ParteReale : real; variable Exponent : integer := 0; variable Position : integer; --Questo caso particolare viene trattato altrimenti viene --calcolato erratamente l esponente if Numero = 0.0 then return X"0000_0000"; --conversione float --> rappresentazione binaria --1) Determinazione del bit di segno if Numero < 0.0 then result(31) := '1'; Numero := Numero * (-1.0); else result(31) := '0'; Nell intestazione vengono dichiarate tutte le variabili necessarie alla funzione; in questo caso, a differenza della conversione con interi, è possibile evitare l utilizzo di una procedura perché si conosce a priori il numero di bit utilizzati dalla rappresentazione. Come prima cosa si controlla il segno del numero da rappresentare e si setta in modo corrispondente il 32 bit della rappresentazione. Nel caso di numeri negativi la quantità viene moltiplicata per 1 in modo da assicurarci che nelle parti successive dell algoritmo il numero da convertire sia sicuramente maggiore di zero. while Numero > real(integer'high) loop Numero := Numero / 2.0; Exponent := Exponent + 1; end loop; Per convertire correttamente il numero si ha la necessità di separare la parte intera da quella frazionaria; il VHDL purtroppo non mette a disposizione funzioni come la floor del linguaggio C, ma solamente l operazione di conversione da un tipo ad un altro. È possibile quindi eseguire la conversione da un numero reale ad uno intero, ma bisogna tenere in considerazione che una quantità intera non può superare il valore di , considerando la rappresentazione a 32 bit con segno. Per superare questa limitazione è possibile dividere per due il numero da convertire, aumentando contemporaneamente l esponente, in modo da far rientrare la parte intera del numero reale nel range ammesso da una variabile intera. In questo modo non si perde nessuna cifra significativa perché quelle che vengono scartate dallo shift a destra sono sicuramente oltre la 23 a cifra della mantissa e verrebbero comunque scartate dalla rappresentazione. Questa tecnica non funziona però se si vuole passare alla rappresentazione a doppia precisione. In realtà molti programmi, tra cui il ModelSim, possiedono delle librerie che implementano il set di funzioni standard per lavorare con quantità real; la realizzazione di questa funzione voleva però essere la più generale possibile in modo da non dipendere dalla rappresentazione. ParteIntera := integer(numero - 0.5); ParteReale := Numero - real(parteintera); if (ParteIntera /= 0) then int_to_bits(parteintera, ParteIntera_Bits); for itemp in ParteIntera_Bits'range loop

8 Progettazione in VHDL del Vertex Shader Pag. 82 if ParteIntera_Bits(iTemp) = '1' then Exponent := Exponent + itemp; Position := itemp - 1; exit; end loop; while (Position >= 0) and (index >= 0) loop result(index) := ParteIntera_Bits(Position); Position := Position - 1; index := index - 1; end loop; else --non ho nulla come parte intera. while ParteReale < 1.0 loop ParteReale := ParteReale * 2.0; Exponent := Exponent - 1; end loop; ParteReale := ParteReale - 1.0; Dopo aver separato la parte intera da quella frazionaria è necessario verificare se la parte intera è diversa da zero. In questo caso la si converte in binario con l usuale funzione, senza preoccuparsi del segno perché la quantità è sempre positiva e minore di Si cerca poi la prima cifra pari ad 1 nella rappresentazione binaria e si calcola il corrispondente esponente, considerando che la virgola va spostata dopo quella cifra. Usciti dal ciclo for si copiano semplicemente le cifre nella rappresentazione binaria. Se la parte intera è pari a zero allora bisogna iniziare a convertire la parte decimale alla ricerca della prima occorrenza della cifra 1 ; come è noto la conversione della parte decimale viene effettuata mediante moltiplicazioni successive per 2. In ogni iterazione quindi si diminuisce l esponente di uno perché si deve spostare la virgola di una ulteriore posizione a destra. Una volta trovata la cifra si può proseguire, ricordando di togliere 1 come vuole l algoritmo di conversione per la parte frazionaria di un numero da decimale a binario. if Index >= 0 then --Ho ancora bit da riempire nella mantissa while Index > 0 loop ParteReale := ParteReale * 2.0; if ParteReale > 1.0 then ParteReale := ParteReale - 1.0; result(index) := '1'; else result(index) := '0'; Index := Index - 1; end loop; --while ParteReale := ParteReale * 2.0; if ParteReale > 0.5 then result(0) := '1'; else result(0) := '0'; Sia che la parte intera esista oppure no, se la variabile index (che rappresenta la posizione corrente nella mantissa) non è minore di zero vuol dire che la mantissa non è stata ancora completata e quindi bisogna proseguire nella conversione della parte decimale. In questo caso l ultima cifra viene lasciata come caso particolare perché è necessario effettuare un arrotondamento. Si prosegue quindi con la conversione della parte frazionaria fino a che tutte le cifre della mantissa non sono state riempite correttamente.

9 Progettazione in VHDL del Vertex Shader Pag. 83 Exponent := Exponent + 127; int_to_bits(exponent, ExponentPart); for itemp in ExponentPart'range loop result(itemp + 23) := ExponentPart(iTemp); end loop; return result; end float_to_bits2; Infine si converte in binario l esponente dopo aver fatto l excess 127. In questo caso non ci si preoccupa del segno perché il valore Exponent è solamente positivo e per come è fatta la funzione int_to_bits non ci sono problemi. A questo punto si può pensare di realizzare una archittettura behavioural di una FPU utilizzando il VHDL. La realizzazione delle fuzioni base è ora particolarmente banale perché basta convertire le rappresentazioni in float, eseguire le operazioni richieste tra variabili float e convertire di nuovo il risultato Test delle funzioni di conversione e primi passi con il ModelSim Per testare in maniera appropriata le funzioni di conversione, realizzate nel precedente paragrafo, è necessario utilizzare un entità test, sempre relizzata in VHDL. La soluzione migliore è creare un entità che accetti come input la rappresentazione binaria di un numero floating point e resistuisca in output la stessa rappresentazione, dopo averla convertita prima in real e riportata in binario con le apposite funzioni. Se il risultato di uscita è lo stesso di quello di ingresso si può affermare con sufficiente certezza che le funzioni realizzate lavorano in modo corretto. Per effettuare la simulazione è necessario avere a disposizione un programma di simulazione per VHDL; la nostra scelta è caduta sul ModelSim perché supporta la sintassi standard e non altri dialetti come l AHDL dell Altera. La limitazione di questo tool è che nella sua versione base non può sintetizzare la logica all interno di una FPGA, ma questa limitazione non è troppo stringente dato che i normali tool per FPGA (ES. Quartus II dell Altera) non permettono di sintetizzare logica floating point direttamente utilizzando quantità real, perché comunque troppo complessa. Il progetto quindi non può essere simulato fino a che non verrà data una descrizione della ALU floating point che possa essere sintetizzata e che quindi lavori direttamente con le rappresentazioni binarie Lavorare con il ModelSim Per la simulazione il file di progetto, così come i sorgenti VHDL, si trovano nella cartella FloatConversion. Nel presente paragrafo però si spiegherà come creare dal nulla un progetto in modo da familiarizzare con l interfaccia del programma, che non è proprio user-friendly 36. Come prima cosa si crea un nuovo progetto con l apposito comando; questo crea una 36 L interfaccia è migliorata moltissimo nella versione 5.5. L ambiente presenta comunque seri problemi di stabilità, pertanto, per il presente lavoro, è stata utilizzata la versione 5.4SE (Ver. d).

10 Progettazione in VHDL del Vertex Shader Pag. 84 subdirectory con il nome del progetto al cui interno è possibile trovare il file principale che ha estensione.mpf (MoselSim Project File). Ora si debbono creare i due file.vhd per la simulazione; per far questo è necessario visualizzare l editor vhdl mediante il menù File->Open->Open Source. Dall editor è possibile creare nuovi file VHDL oppure aprire file già esistenti, in questo ultimo caso però i file sorgenti debbono trovarsi all interno della cartella del progetto, altrimenti non possono essere simulati. L editor messo a disposizione non è esattamente quello che si dice un tool efficiente: manca della funzionalità Undo e non permette di fare step nelle istruzioni durante il debug. Per quest ultima operazione è però disponibile un editor leggermente differente richiamabile mediante il menù view->source, che purtroppo non è collegato al compilatore per l individuazione immediata delle righe che danno errori in compilazione. Personalmente consiglio di utilizzare un editor più serio come UltraEdit32 che permette anche di definire una sintassi per fare l hilight delle keyword di un linguaggio e si rivela sicuramente più utile degli editor integrati, perlomeno nel supporto della funzione Undo. Per compilare i file, l editor presenta una voce del menù file che non fa altro che aprire la finestra di compilazione, dalla quale è possibile selezionare e compilare qualsiasi file VHDL presente nella cartella. Eventuali errori rilevati in fase di compilazione vengono riportati nella finestra principale, dalla quale, mediante doppio click, è possibile passare direttamente alla riga che ha causato l errore. Tutti i file compilati con successo aggiungono le loro entità alla libreria corrente che per default viene chiamata work. Il file con le funzioni di conversione contiene tutte le funzioni che sono state descritte precedentemente, racchiuse dentro una struttura package; in questo modo possono essere utilizzate da qualsiasi altra entità che fa parte del progetto corrente. Il file di test ha infine una struttura molto semplice e serve solamente per creare una entità che possa richiamare le funzioni da testare dal package realizzato Strutturazione di un file di test in VHDL Come prima cosa è necessario realizzare una entità che faccia uso delle funzioni da testare: use work.alu_fp.all; entity TEST is port (A : in bit_vector(31 downto 0); B : out bit_vector(31 downto 0)); end TEST; architecture only of TEST is main : process (A) variable Temp : real; Temp := bits_to_float(a); B <= float_to_bits(temp) after 10 ns; end process; end only; L entità generata accetta la DWORD A in ingresso, la trasforma in real e poi ancora in DWORD; il risultato viene poi assegnato alla porta di uscita. In questo modo il corretto funzionamento delle funzioni di conversione viene evidenziato dalla eguaglianza tra i segnali A e B.

11 Progettazione in VHDL del Vertex Shader Pag. 85 L entità testalu invece si occupa di fornire i dati in ingresso all entità TEST. entity testalu is end testalu; architecture tester of TestALU IS component TEST port( A : in bit_vector(31 downto 0); B : out bit_vector(31 downto 0) ); end component; --i segnali sono fatti perché il tester non ha nessuna porta signal A : bit_vector(31 downto 0); signal B : bit_vector(31 downto 0); signal clock : bit; --tester ALU1 : TEST port map ( A => A, B => B ); generatore_clock : process --I processi sono tutti concorrenti clock <= '0'; wait for 50 ns; clock <= '1'; wait for 50 ns; end process; test_bench : process variable state : integer := 0; wait until (clock'event and clock = '0'); case state is when 0 => A <= " "; -- 0, when 1 => A <= " "; ,5 when others => end case; state := state + 1; end process; end tester; L entità testalu ha un clock interno ed è essenzialmente una macchina a stati finiti. Lo stato viene incrementato ad ogni colpo di clock, si realizzano quindi vari stati in cui l unica operazione effettuata è quella di fornire i dati in ingresso alla nostra entità da testare. In questo caso vengono forniti in ingresso solamente due numeri float (0, e ,5). Un altro modo molto comune di procedere è includere nella entità di test i risultati corretti precalcolati. In questo modo, mediante l istruzione assert, è possibile rilevare immediatamente errori nel funzionamento dell entità sotto test. È comunque consigliabile verificare manualmente i risultati e fare un po di debug per controllare che tutte le strutture funzionino nel modo previsto. Per verificare la validità della conversione è stato anche utilizzato un piccolo tool realizzato in Visual Basic 6 che permette di risalire dalla rappresentazione binaria di un numero al suo valore floating point e viceversa.

12 Progettazione in VHDL del Vertex Shader Pag Simulazione Quando i due file compilano senza errori è possibile partire con la simulazione. Per fare questo è necessario decidere quale entità simulare tra quelle presenti nella libreria; nel caso in esame la scelta ovvia cade sul componente TestALU. Per aprire la finestra di dialogo che permette di scegliere cosa simulare è possibile utilizzare il menù Design -> Load Design, oppure il simbolo di apri file che appare accanto all icona di compilazione. Dovrebbe apparire ora la seguente finestra. Le uniche due entità nella libreria in questo caso sono solamente quelle presenti nel file di test, dato che non si sta testando una vera entità, ma solamente un set di funzioni. Si sceglie la architettura tester della entità testalu e si preme il tasto load. Ora è necessario aprire dal menù View le finestre wave e signals e trascinare i segnali di cui si vuole osservare l evoluzione dalla seconda nella prima, che appare inizialmente vuota. Per osservare tutti i segnali è possibile sezionarli tutti mediante il menu Edit -> Select all e poi trascinarli nella finestra wave. Un metodo alternativo è utilizzare il menu View -> Wave -> Signals in region. Dato che le quantità A e B sono vettori di 32 bit, non è comodo visualizzare la loro rappresentazione binaria. Per cambiare il modo in cui i valori vengono rappresentati nel visualizzatore è sufficiente selezionare un segnale, premere il tasto destro e scegliere il formato desiderato dal menù radix. Per questo esempio è conveniente visualizzare i segnali A e B in formato esadecimale, per un più facile confronto. Ora è tutto pronto per incominciare la simulazione. Il menù che consente di far partire la simulazione è rappresentato nella figura sottostante: Partendo da sinistra troviamo il tasto restart che serve a far ripartire da

13 Progettazione in VHDL del Vertex Shader Pag. 87 zero la simulazione. Successivamente c è una textbox che permette di decidere la durata di un singolo intervallo di simulazione e di seguito c è il tasto per far avanzare la simulazione di un intervallo. Per la simulazione corrente si cambi tale valore in 200 ns in modo da simulare due colpi di clock per ogni intervallo. I tasti più a destra servono per simulare ininterrottamente fino a che non si preme il tasto di stop, mentre gli ultimi due si utilizzano solamente quando si effettua il debug del codice. Se si preme due volte il tasto del run, si osserva che nella finestra wave le forme d onda dei segnali sono immediatamente aggiornate per mostrare i dati della simulazione. L output dovrebbe essere il seguente: La simulazione conferma che le funzioni sono state realizzate correttamente; naturalmente prima di affermare che il funzionamento è corretto è sicuramente necessario provare molti casi ed eseguire una sessione di debug Debug Come tutti i linguaggi di programmazione seri, il VHDL permette di eseguire il debug del codice. Per debug si intende la possibilità di interrompere l esecuzione del programma in punti ben definiti ed osservare il valore delle variabili e dei segnali presenti nella procedura, processo o funzione in esame. È altresì possibile eseguire una istruzione per volta (modalità step), in modo da controllare il corretto flusso di istruzioni, anche se in un processo le istruzioni vengono eseguite in maniera concorrente. Il primo passo da fare è mettere un BreakPoint (Punto di interruzione) nel programma; questa operazione viene effettuata semplicemente facendo click con il tasto sinistro del mouse vicino al numero di riga di codice sulla quale si vuole settare un breakpoint 37. Se il breakpoint viene settato correttamente appare un pallino rosso a fianco del numero di riga, un altro click fa apparire un cerchietto (vuoto all interno), che indica che il breakpoint in quella linea è stato disabilitato; per abilitarlo di nuovo è sufficiente fare un altro click. Per eliminare del tutto il breakpoint è necessario premere il tasto destro e scegliere la voce Remove Breakpoint dal menù a tendina che appare. Si faccia ora il reset della simulazione, si posizioni un breakpoint sulla riga del file di test e si faccia ripartire la simulazione; questa volta l elaborazione si interrompe e nella finestra principale appare la scritta: # Break at D:/.../FloatConversion/TestALU.vhd line 13 Se ora si apre la finestra denominata variables, si possono osservare le variabili interne al processo corrente, si nota inoltre che nella finestra del 37 Il ModelSim evidenzia, rappresentandole in verde, le righe sulle quali è possibile porre un breakpoint. 38 La riga contiene il codice: B <= float_to_bits(temp) after 10 ns;

14 Progettazione in VHDL del Vertex Shader Pag. 88 sorgente è apparsa una freccia azzurra, che indica l istruzione successiva. A questo punto è possibile proseguire l esecuzione istruzione per istruzione, mediante gli ultimi due comandi presenti nella barra degli strumenti relativa alla simulazione. Vale la pena ricordare che per utilizzare la funzione di step è necessario aprire l editor con il menù View->Source. Premendo di nuovo il tasto run l esecuzione riprende fino a fermarsi dopo il passaggio dei 200 ns impostati come passo base della simulazione. Facendo ripartire la simulazione, l esecuzione si arresta nuovamente nel punto di interruzione; nella finestra variables viene ora rappresentata l unica variabile interna al processo corrente, chiamata Temp. Si può verificare, come ulteriore conferma della correttezza delle funzioni di conversione implementate, che tale variabile assume proprio il valore floating point imposto alla variabile A, come rappresentato nella figura precedente La struttura ALU_FP Una volta terminata la verifica delle funzioni di conversione è possibile utilizzarle per implementare una ALU floating point mediante architettura behavioural. Nella prima simulazione si utilizzeranno le funzioni matematiche definite dallo standard IEEE, che sono racchiuse nella libreria Math_Real, analoghe a quelle contenute nella libreria math.h del linguaggio C. L utilizzo della Math_Real consente di effettuare le principali operazioni matematiche con numeri reali. La definizione della entità ALU_FP viene così effettuata: entity ALU_FP is generic (Dly : Time := Delay); port ( op1 : in DWORD; op2 : in DWORD; res : out busdword; cmd : in ALU_Command; CC : out CondCode; clk1 : in bit; clk2 : in bit; enabled : in bit; use_temp : in bit; ready : out bit ); end ALU_FP; La scelta delle porte è ovvia: si hanno due porte per gli operandi e due porte per i due segnali di clock, una porta in cui viene indicata l operazione da effettuare, chiamata cmd, ed una porta di uscita in cui viene fornito l esito delle operazioni di confronto. Per funzionare correttamente è necessario inserire anche un bit di enabled che permette di disabilitare dall esterno l ALU ed infine

15 Progettazione in VHDL del Vertex Shader Pag. 89 un bit di ready per capire quando l esecuzione dell operazione corrente è terminata. In una ALU floating point infatti il tempo di esecuzione varia molto da istruzione a istruzione. La definizione dei tipi di dato busdword, ALU_Command, CondCode sono stati preventivamente definiti all interno di un package di cui si riporta solamente la parte significativa. type ALU_Command is ( add, mul, floor, log, exp, sqrt, rcp, cmp); subtype DWORD is bit_vector (31 downto 0); subtype WORD is bit_vector (15 downto 0); subtype BYTE is bit_vector (7 downto 0); subtype CondCode is bit_vector(1 downto 0); type ADWORD is array (integer range <>) of DWORD; function resolve_dword (driver : in ADWORD) return DWORD; subtype busdword is resolve_dword DWORD; La funzione di risoluzione per il bus DWORD è semplicemente un OR perché si sta lavorando con segnali bit_vector; ben più complessa sarebbe stata la situazione se si fosse utilizzata la std_logic, ma per una prima simulazione l utilizzo di bit_vector va più che bene. Il bit use internal serve semplicemente ad utilizzare come primo operando il risultato della operazione precedente, questo viene fatto mediante un registro interno che tiene traccia del risultato dell elaborazione appena conclusa. Questa tecnica viene in aiuto per l esecuzione di operazioni composte come il reciproco della radice quadrata 39. L entità ha naturalmente un solo processo al cui interno vengono implementate tutte le operazioni che possono essere svolte: ALU_operate : process variable fop1, fop2 : real; variable Comp_factor : integer := 2; variable TempRes : real; type ALU_state is (idle, working); variable current_state : ALU_state; wait until enabled'event and enabled = '1'; Comp_factor := 2; ready <= '0' after dly; if use_temp = '1' then fop1 := TempRes; else fop1 := bits_to_float(op1); fop2 := bits_to_float(op2); La variabile Comp_factor serve a simulare la differente velocità di esecuzione delle varie operazioni: è risaputo infatti che un operazione di add è molto più veloce di un operazione di radice quadrata o trigonometrica. Naturalmente nella implementazione realizzata non esiste il concetto di pipeline e quindi le istruzioni possono essere richieste una per volta. Nei processori moderni questo non è vero e solitamente è possibile richiedere 39 In alcune situazioni (SSE di Intel) l implementazione di istruzioni molto complesse come la radice quadrata può essere effettuata semplicemente utilizzando una look-up table. Se la precisione ottenuta non è soddisfacente solitamente viene utilizzato l algoritmo di Newton-Raphson.

16 Progettazione in VHDL del Vertex Shader Pag Utilizzare file con il VHDL all ALU una operazione per ogni colpo di clock anche se l elaborazione di una istruzione necessità più di un colpo di clock per essere eseguita. La prima operazione che viene effettuata è quindi la conversione degli operandi dalla rappresentazione binaria al valore real corrispondente. Per il primo operando, come detto in precedenza, è possibile anche utilizzare il risultato della operazione precedente, memorizzato nel registro TempRes. Successivamente si esegue l operazione richiesta: case cmd is when add => --semplice addizione tra i due operandi TempRes := fop1 + fop2; --when sub => --semplice addizione tra i due operandi --TempRes := fop1 - fop2;... when exp => --elevamento a potenza 2 ^ fop1 TempRes := 2 ** fop1; Comp_factor := 20; Tutte le istruzioni vengono implementate in questo modo ed è possibile utilizzare la variabile Comp_factor per simulare una maggiore complessità della funzione. end case; if cmd /= idle then res <= float_to_bits(tempres) after Dly * Comp_factor; ready <= transport '1' after Dly * Comp_factor; end process; Quando l esecuzione è terminata, il risultato viene messo nella porta di uscita ed il bit di ready viene posto ad 1 per indicare il completamento dell istruzione. Naturalmente una ALU reale non è sintetizzabile con una rete combinatoria, ma il suo funzionamento sarà regolato da uno o più segnali di clock. Nondimeno la semplice struttura realizzata permette di avere una entità che svolge operazioni Floating Point e risponde non immediatamente, ma con un ritardo fittizio. In questo modo si è sintetizzato in maniera soddisfacente il comportamento di una ALU reale. Terminata la struttura è possibile costruire una semplice entità di test che verifica il corretto funzionamento dell ALU Simulazione mediante testbench automatici Per testare il dispositivo realizzato è possibile effettuare una simulazione e verificare che i segnali in uscita siano quelli corretti. Per semplificare questo processo è possibile scrivere un testbench automatico, il cui scopo è appunto quello di automatizzare le operazioni di test. Il compito di questo oggetto è leggere dei dati di input da file, applicarli all entità da testare e verificare i risultati ottenuti con quelli corretti, che sono stati preventivamente inseriti in un altro file. Per evidenziare le differenze tra i dati corretti e quelli effettivamente ottenuti è possibile utilizzare delle istruzioni ASSERT, oppure creare un file di testo in cui viene fatto il log di tutta la simulazione e che verrà

17 Progettazione in VHDL del Vertex Shader Pag. 91 controllato una volta terminata l esecuzione. È quindi necessario avere familiarità con le strutture di file in VHDL, che sono comunque semplici da utilizzare. Una struttura di tipo file si dichiara semplicemente nel seguente modo. type FHEX is file of integer; FILE myfile : FHEX IS OUT "values.dat"; Come prima cosa si specifica il tipo di file mediante l istruzione type e successivamente si dichiara un file di quel tipo indicando il nome dell oggetto (specificando se utilizzato in lettura o scrittura) ed infine il nome su disco. Il VHDL mette poi a disposizione le routine write e read che permettono di leggere e scrivere i valori di tipo base 40 nel file Scrivere float in un file Nel caso del Vertex Shader è necessario leggere e scrivere valori float in un file, purtroppo l unico tipo di dato floating point permesso dal VHDL è il tipo real, la cui precisione non è definita dallo standard. Se si prova infatti a fare output di valori real su di un file, ci si accorge che, come era facilmente intuibile, esso corrisponde al tipo in doppia precisione, formato standard di memorizzazione utilizzato nell architettura 80x86. Per effettuare operazioni di I/O di valori float su file è necessario allora provvedere alla conversione del numero in bit_vector (con le funzioni realizzate per l ALU) e successivamente convertire nuovamente il formato ottenuto in intero. In questo modo si ottiene la rappresentazione in float del numero cercato all interno di una variabile intera. Le funzioni che realizzano queste operazioni sono contenute nel file file_pack.vhd e la loro realizzazione è così semplice che non vale la pena riportarla in questa sede File di testo e libreria standard Durante il test automatico si ha la necessità di fare molto output in formato testo, questo perché è necessario tenere traccia di cosa accade nella simulazione e cosa molto importante, bisogna evidenziare gli eventuali errori. Ciò che serve è una funzionalità analoga a quella del printf del linguaggio C, che permetta di fare output di valori stringa e numerici e che permetta un minimo di formattazione per rendere l output leggibile. Lo standard VHDL non prevede però routine per lavorare con stringhe, ma queste funzionalità sono così richieste che sono state implementate nella libreria standard del ModelSim. Questa libreria si chiama textio e contiene funzioni utili per leggere e scrivere su file di testo. E comunque possibile fare output non in un file, ma nella finestra di output del simulatore mediante uso dell istruzione ASSERT.. SEVERITY NOTE. La libreria textio contiene un nuovo tipo di dato chiamato line, il quale non è altro che una stringa definita con l attributo access. In questo modo è possibile definire una stringa la cui lunghezza non è conosciuta a compile-time, ma decisa a run-time. Il tipo linea è quindi assimilabile ad un puntatore ad una stringa e nella libreria textio, ogni qualvolta si scrive qualche cosa nel dato 40 Integer, real, bit_vector, etc.

18 Progettazione in VHDL del Vertex Shader Pag. 92 linea, viene allocato e deallocato spazio in modo dinamico, mediante le funzioni New e Deallocate. La libreria contiene inoltre un set di funzioni in overloading che consentono di scrivere in una linea valori interi, floating point, booleani, etc. etc. Ricercando nelle librerie del ModelSim si trova nella cartella examples un file che introduce nuove funzionalità, tipo poter imporre una radice (binaria, decimale, esadecimale...) per i numeri interi che vengono stampati in una stringa. La libreria fornisce infine le funzioni readline e writeline che permettono di leggere e scrivere un dato di tipo linea su di un file di tipo text, che non è altro che un file di stringhe. Nella cartella di installazione del ModelSim è possibile reperire i sorgenti di tutte queste funzioni, che costituiscono quindi un buon esempio di come si lavori sui file e sui tipi di dato. Purtroppo non è possibile in VHDL fare liste di argomenti variabili per una funzione e questo rende impossibile realizzare una funzione analoga alla printf del C. Ci si deve allora accontentare di lavorare con le linee e realizzare la stringa di output un elemento alla volta, come mostrato nello spezzone di codice sottostante, che legge un intero da file e lo visualizza nel simulatore ad ogni ciclo del processo. USE std.textio.all; USE work.io_utils.all; entity ProvaFile is end ProvaFile; architecture Prova1 of ProvaFile is subtype DWORD is bit_vector(31 downto 0); type FHEX is file of integer; FILE myfile : FHEX IS IN "values"; try : process variable Num : integer; variable L : Line; if not endfile(myfile) then read(myfile, Num); else Num := 0; write (l, string'("il numero letto è ")); write (l, Num, base => binary); ASSERT FALSE REPORT L.all SEVERITY NOTE; wait for 110 ns; Deallocate(L); end process; end Prova1; Naturalmente bisogna aver compilato il file che contiene il package io_utils (presente nella cartella degli esempi del ModelSim) prima di compilare il programma appena presentato. L entità creata non fa altro che leggere sequenzialmente numeri interi da un file e visualizzare un messaggio nel simulatore in formato binario. Per visualizzare con ASSERT la linea creata è necessario utilizzare il suo campo all, che restituisce la stringa da visualizzare. Un esempio dell output che si ottiene da un file che contiene un solo intero è: # Loading work.io_utils(body) # Loading work.provafile(prova1) run # ** Note: Il numero letto è

19 Progettazione in VHDL del Vertex Shader Pag. 93 # Time: 0 ns Iteration: 0 Instance: /provafile run # ** Note: Il numero letto è 0 # Time: 110 ns Iteration: 0 Instance: /provafile run # ** Note: Il numero letto è 0 # Time: 220 ns Iteration: 0 Instance: /provafile VSIM 79> L intervallo di simulazione è impostato a 100 ns, mentre il processo ha una clausola wait che lo fa attendere per 110 ns. Se si preferisce è possibile inviare l output ad un file di testo, in modo da avere un log permanente dell esito della simulazione. In particolare è possibile realizzare un programma in C che genera automaticamente i file con i dati di test e alla fine della simulazione controlla nel file di output se si sono verificati degli errori. Con un poco di pratica è possibile realizzare strumenti di test veramente potenti ed automatizzati, che senza dubbio possono aiutare moltissimo durante la progettazione di un processore Differenze di versione Lo standard VHDL nel 1993 ha aggiornato la sintassi, in particolare la dichiarazione di file è cambiata notevolmente ed è bene conoscere le differenze principali per non avere problemi di compilazione. Si prenda in esame l entità presentata nel paragrafo 3.3.3; di seguito viene riportata la dichiarazione del file conforme al nuovo standard: FILE myfile : FHEX open write_mode is "values"; Al posto di IS OUT la sintassi è cambiata ed impone open write_mode, in questo modo è molto più chiaro che si sta lavorando su file e la sintassi è più coerente dato che OUT è corretto per una porta, ma non si adatta bene come attributo di un file. Una sintassi particolare rende inoltre molto semplice passare file come argomento di funzioni. Naturalmente per passare un file è necessario dichiarare il tipo di file, in modo da invocare correttamente le funzioni read e write del VHDL, che possono operare correttamente solo se in fase di compilazione si sa che tipo di dato deve essere letto/scritto. Per mostrare la sintassi viene riportata la funzione che permette la lettura di un valore floating point in singola precisione: function ReadFloat(FILE F : FloatFile) return real is Variable Temp : integer; Variable FloatNum : real := 0.0; Variable RappBin : DWORD; if not endfile(f) then read(f, Temp); int_to_bits(temp, RappBin); FloatNum := bits_to_float(rappbin); return FloatNum; end ReadFloat; Il funzionamento della routine è molto semplice e si serve di due conversioni successive per memorizzare nel file il numero in singola precisione.

20 Progettazione in VHDL del Vertex Shader Pag. 94 La doppia conversione è resa necessaria perché se si fosse chiesto al compilatore di leggere un numero di tipo real dal file, il risultato sarebbe stato un numero a doppia precisione. Per leggere correttamente un valore float è quindi necessario utilizzare questo piccolo trucco: leggere dal file il numero come se fosse un intero (32 bit), ottenere la sua rappresentazione binaria ed infine trasformarlo in un numero floating point.

21 Progettazione in VHDL del Vertex Shader Pag. 95 Capitolo 4. Implementazione del Vertex Shader 4.1. Descrizione della struttura Vertex Shader Da dove nasce il concetto di Vertex Shader (VS) Negli ultimi anni la grafica 3D ha compiuto passi da gigante e la continua innovazione dell hardware ha reso possibile la realizzazione di programmi e giochi impensabili fino a 5 anni fa. Il mondo del videogioco infatti è molto esigente dato che viene richiesta grafica 3D in real-time; al contrario, per realizzare una scena animata per un film, è possibile aspettare anche qualche giorno per calcolare il rendering di un solo minuto di animazione. Nella grafica real-time è invece necessario mantenere un frame rate dignitoso e calcolare quindi almeno 25 frame per secondo. Con questa grande limitazione il realismo della scena è limitato, poichè la complessità computazionale in molti casi è estremamente elevata per qualsiasi hardware oggi in commercio. Il primo vero esempio di gioco 3D fu Quake, che aveva un motore grafico completamente software. Le sue limitazioni erano: risoluzione non elevata, basso dettaglio delle texture, limitato numero di poligoni che potevano essere presenti contemporaneamente nel campo visivo. La prima ditta a mettere sul mercato una scheda veramente innovativa fu la 3Dfx che con la sua Voodoo1 cambiò radicalmente il modo di fare grafica. La scheda in questione infatti incorporava un chip dedicato all accelerazione 3D che permetteva di sollevare il processore da compiti gravosi come lo shading, il clipping ed il texturing. Il processore di sistema era così libero di svolgere altri compiti (calcolo collisioni, implementazione della fisica, ecc ) ed inoltre la scheda aveva hardware dedicato in grado di svolgere compiti come il Gouraud Shading in maniera estremamente più efficiente di un processore general purpose come un 80x86. Altri produttori seguirono successivamente questa strada, per prima l Intel con il suo chip i740 e poi altre case, tra cui spicca per i risultati ottenuti NVIDIA. La successiva grande innovazione si ebbe infatti con la scheda GeForce di NVIDIA, scheda che effettua in hardware anche la fase di Trasform & Lighting (T&L); in queso modo è possibile gestire un più elevato numero di poligoni e alleggerire ulteriormente il processore di sistema. La limitazione maggiore è che l hardware di tali schede utilizza solamente alcuni degli algoritmi di grafica 3D che sono stati sviluppati nel corso degli anni. Per il T&L infatti l unico algoritmo previsto è quello del Gouraud Shading (o a limite il Flat Shading) e non è possibile implementare algoritmi più sofisticati come il Phong Shading o l illuminazione BRDF (anisotropic lighting). L ultima rivoluzione in casa NVDIA è rappresentata dalla GeForce3 che contempla l implementazione in hardware del Vertex Shader e del Pixel Shader, che consentono una certa programmabilità della pipeline grafica. Con l aumento delle prestazioni infatti non è più impossibile realizzare un Phong Shading, ma è limitativo introdurre nella GPU algoritmi fissi e poco flessibili, perché in questo modo tutte le potenzialità della scheda non possono essere sfruttate al massimo. Meglio allora dare al programmatore la possibilità di un completo controllo della GPU, in questo modo chi vuole può implementare