UNIVLRSI1A` DLGLI S1UDI DI GLNOVA

lACOL1A` DI INGLGNLRIA




Corso di Laurea in Ingegneria Elettronica




Confronto di architetture digitali
basate su FPGA per lelaborazione di segnali



Luca Leomanni e Sonia Argentesi






Relatore: Prof. Davide Anguita


Correlatori: Stefano Pischiutta
Alessandro Ghio




14 marzo 2008


Anno Accademico 2007-2008

II
Comparison of digital architectures
based on FPGA for signal processing

Purpose of this thesis is realizing the modified CORDIC algorithm on a microprocessor of
an FPGA and compare the results of the implementation with those of the same algorithm
realized using structural VHDL.
The comparison between the different digital architectures concerns various facets: used
resources, timing performance, computation precision and considerations about efficiency
and flexibility.
The FPGA used for our project is the Xilinx Spartan-3 Starter Board and its
microprocessor is the MicroBlaze, while the one used for the VHDL project was Xilinx
Spartan IIE.
To implement our system we have used a professional development environment provided
by Xilinx: the EDK (Embedded Development Kit) which, through the Platform Studio
tool, allows to create a system according the user own preferences and to program the
microprocessor of a given FPGA using the C programming language.
Also considering the usage of different devices for the two realization to compare, we
found out that our project realized on the MicroBlaze, in terms of timing performance, is
far away from the realization with structural VHDL; moreover we reach a good calculation
precision only for very small values of the involved variables due to a reduced number of
bits employed.
It is possible to trade calculation precision for timing performance, that is to say that
increasing the number of bits used in the implementation we obtain a better precision to the
detriment of the time needed for the algorithm execution .



III









Alla Commissione di Laurea e di Diploma
Alla Commissione Tirocini e Tesi

Sottopongo la tesi redatta dagli studenti Luca Leomanni e Sonia Argentesi dal titolo:
Confronto di architetture digitali basate su FPGA per lelaborazione di segnali
.
Ho esaminato, nella forma e nel contenuto, la versione finale di questo elaborato scritto, e
propongo che la tesi sia valutata positivamente assegnando i corrispondenti crediti
formativi.


Il Relatore Accademico
Prof. Davide Anguita






IV
Prefazione

La tipologia della tesi si inserisce nel filone della progettazione e analisi di architetture
hardware realizzate su circuiti programmabili (FPGA) per applicazioni di calcolo. In
particolare sono stati confrontati CORDIC realizzati su diverse architetture digitali che
calcolano la funzione kernel di SVM, tecnica usata con molto successo nelle applicazioni
di pattern recognition.
La prima architettura digitale utilizza come algoritmo il CORDIC modificato che viene
compilato ed eseguito dal MicroBlaze (implementato sulla Spartan-3); la seconda
implementa il CORDIC srotolato, non srotolato sulla Spartan-II ed stata realizzata
con il tool di sviluppo Xilinx ISE 7.1 in vhdl strutturale.
Per confrontare le due architetture abbiamo cercato di scrivere il codice che realizza il
CORDIC in modo da avere caratteristiche simili al CORDIC scritto in vhdl preservando la
stessa rappresentazione dei dati (rappresentazione a virgola fissa).
Il confronto delle diverse architetture digitali riguarda diversi aspetti: risorse utilizzate,
tempo impiegato per lesecuzione dellapplicazione di calcolo, precisione di calcolo
raggiunta, tempo impiegato per la progettazione e realizzazione delle rispettive
architetture, flessibilit e risorse necessarie per sviluppi futuri.
Il risultato che ci aspettavamo stato puntualmente confermato nella fase finale di test:
infatti, il MicroBlaze per questo tipo di applicazione risulta molto lento se confrontato con
larchitettura realizzata in vhdl (il tempo impiegato per lesecuzione dello stesso algoritmo
di sei ordini di grandezza maggiore) pur utilizzando numerose risorse.
Durante lo svolgimento della tesi abbiamo avuto lopportunit di utilizzare un potente
strumento di sviluppo professionale per la progettazione di architetture digitali (Xilinx
Platform Studio), utilizzato dalle aziende del settore dellInformation and Communication
Technology (ICT).
Questa esperienza stata svolta nel laboratorio SmartLab presso il DIBE (Dipartimento
di Ingegneria Biofisica ed Elettronica) dove abbiamo incontrato delle esperte e simpatiche
persone insieme alle quali abbiamo trascorso il tempo necessario alla conclusione del
nostro lavoro.


V
Indice


Introduzione......................................................................................................................... 1

1 Teoria del CORDIC e sue applicazioni 2
1.1 Introduzione allalgoritmo COordinate Rotation Digital Computer .................... 2
1.2 Algoritmo iterativo per la rotazione di un vettore bidimensionale....................... 3
1.3 Il CORDIC per il calcolo del seno e del coseno................................................... 8
1.4 Il CORDIC per il calcolo dell arcotangente e della norma di un vettore
bidimensionale................................................................................................... 8
1.5 Il CORDIC per il calcolo delle funzioni iperboliche............................................ 8
1.6 Support Vector Machine (SVM)........................................................................... 9
1.7 La funzione Kernel utilizzata per lSVM............................................................ 10
1.8 Metodo iterativo per il calcolo dei termini u
i
senza moltiplicatori K(x, s
i
)........ 13

2 La scheda Spartan-3 14
2.1 Introduzione ....................................................................................................... 14
2.2 Configurable Logic Blocks (CLB)...................................................................... 14
2.3 Input/Output Blocks (IOB)................................................................................. 15
2.4 Block RAM......................................................................................................... 15
2.5 Multiplier Block.................................................................................................. 15
2.6 Digital Clock Manager (DCM) Block................................................................ 16
2.7 Fast Simplex Link (FSL).................................................................................... 16
2.8 Elementi della Spartan-3..................................................................................... 17

3 Il MicroBlaze 19
3.1 Introduzione........................................................................................................ 19
3.2 Architettura dei registri....................................................................................... 20
3.2.1 Registri General Purpose.......................................................................... 21
3.2.2 Registri Special Purpose........................................................................... 22
3.2.3 Convenzioni sulluso dei registri.............................................................. 23
3.3 Istruzioni............................................................................................................ 23
VI
3.4 Tipi di dati.......................................................................................................... 24
3.5 Pipeline.............................................................................................................. 24
3.5.1 Pipeline a tre stadi.................................................................................... 25
3.5.2 Pipeline a cinque stadi............................................................................. 25
3.6 Salti (Taken Branch).......................................................................................... 26
3.7 Architettura della memoria................................................................................ 26

4 Aritmetica a precisione finita 28
4.1 Introduzione........................................................................................................ 28
4.2 Rappresentazione a virgola fissa......................................................................... 29
4.3 Rappresentazione dei numeri negativi................................................................ 29
4.4 Rappresentazione di numeri negativi in complemento a due............................. 29
4.5 Errore di quantizzazione commesso sulluscita.................................................. 29
4.6 Metodi di quantizzazione dei parametri.............................................................. 30
4.6.1 Errore di troncamento e di arrotondamento.............................................. 31
4.7 Effetto della rappresentazione dei numeri negativi sullerrore........................... 32

5 Architettura del sistema che realizza il CORDIC sul MicroBlaze 33
5.1 Introduzione ...................................................................................................... 33
5.2 Ambiente di sviluppo e generazione del sistema............................................... 33
5.3 Periferica contatore dei cicli di clock................................................................. 38
5.4 Struttura della directory del progetto e principali file........................................ 41
5.5 Configurazione del MicroBlaze e del codice..................................................... 41
5.6 Algoritmo del CORDIC modificato .................................................................. 42
5.7 Considerazioni e problemi di convergenza dellalgoritmo................................ 42
5.8 Output dellalgoritmo e considerazioni sulla precisione dei risultati................ 44
5.9 Risorse impiegate per la realizzazione del sistema............................................ 45

6 Architettura hardware del CORDIC per il calcolo del kernel di SVM scritto
utilizzando il VHDL strutturale 47
6.1 Introduzione........................................................................................................ 47
6.2 Datapath.............................................................................................................. 47
6.3 Block RAM interne della Spartan-IIE................................................................. 48
VII
6.4 Blocco di calcolo della norma prima................................................................... 49
6.5 CORDIC per il calcolo del kernel di SVM......................................................... 50
6.6 CORDIC non srotolato.................................................................................... 50
6.7 CORDIC srotolato........................................................................................... 53
6.8 Risorse impiegate e prestazioni........................................................................... 55

7 Confronto del sistema con limplementazione hardware del CORDIC per il
calcolo del kernel di SVM (Support Vector Machine) 57
7.1 Considerazioni sulla precisione ottenuta con le diverse architetture.................. 57
7.2 Considerazioni sullutilizzo delle risorse tra diverse architetture....................... 58
7.3 Considerazioni sul tempo di esecuzione del CORDIC....................................... 58

8 Conclusioni
8.1 Conclusioni.......................................................................................................... 59

Appendice
A Algoritmo del CORDIC modificato in linguaggio C e commento............................... 60
B Output di una prova effettuata ..................................................................................... 65
C Codice vhdl per la generazione della periferica contatore di cicli di clock.................. 68
D Glossario........................................................................................................................ 74

Bibliografia ........................................................................................................................ 76

1
Introduzione

La nostra tesi consiste nellanalisi e nel confronto di architetture hardware realizzate su
circuiti programmabili (FPGA) per lelaborazione di segnali, in particolare abbiamo
confrontato CORDIC che calcolano la funzione kernel di SVM realizzati su diverse
architetture digitali.
Questo lavoro, che certamente servir a coloro che studiano e sviluppano architetture
digitali, vuole offrire un contributo anche in altre due direzioni: il confronto proposto,
infatti, oltre ad essere unoccasione per approfondire temi basati sullelettronica digitale,
pu servire anche come stimolo per limplementazione di nuove architetture digitali su
dispositivi programmabili.
La tesi basata su sei parti principali: nella prima (Capitolo 1) descriveremo il CORDIC e
le sue diverse applicazioni, tra cui lutilizzo per il calcolo della funzione kernel di SVM, in
questa parte verr inoltre introdotta la tecnica Support Vector Machine; nella seconda
(Capitolo 2 e Capitolo 3) sar decritto il dispositivo programmabile che abbiamo utilizzato,
la Spartan-3, e verranno esposte le caratteristiche e le funzionalit del processore
MicroBlaze; nella terza (Capitolo 4) verranno affrontati i problemi dellutilizzo di
unaritmetica a precisione finita (errore di quantizzazione, di arrotondamento, di
troncamento ecc.); nella quarta (Capitolo 5) sar descritta larchitettura del sistema che
realizza il CORDIC sul MicroBlaze, in questa parte sar, inoltre, spiegato come realizzare
e configurare il MicroBlaze utilizzando il tool Xilinx Platform Studio e ne saranno valutate
le prestazioni; nella quinta (Capitolo 6) sar descritta e commentata larchitettura hardware
del CORDIC per il calcolo del kernel di SVM scritto utilizzando il VHDL strutturale;
infine nella sesta (Capitolo 7 e Capitolo 8) verranno confrontate le due architetture e ne
saranno tratte le conclusioni.
Per confrontare le diverse architetture digitali si sono dovute considerare architetture con
caratteristiche comuni, ad esempio la rappresentazione dei dati e lalgoritmo implementato;
in questo modo stato possibile valutare diversi aspetti: dalle risorse utilizzate al tempo
impiegato per lesecuzione dellapplicazione di calcolo, dalla precisione di calcolo al
tempo impiegato per la progettazione e la realizzazione delle rispettive architetture.

2
Capitolo 1



Teoria del CORDIC e sue applicazioni


1.1 Introduzione allalgoritmo COordinate Rotation Digital Computer
(CORDIC)
Il calcolo delle funzioni trigonometriche, iperboliche, logaritmiche oggi non rappresenta
pi un ostacolo grazie alla diffusione, alla fine degli anni 50, di computer e calcolatori
scientifici che risolvono istantaneamente queste classi di funzioni per qualsiasi angolo.
Prima dellavvento di questi calcolatori venivano utilizzate tecniche di interpolazione che
si servivano di tabelle dettagliate che contenevano i valori pi significativi, generati dalla
ripetuta applicazione della somma di angoli (o met angoli) partendo da valori noti.
I moderni computer usano diverse tecniche per la risoluzione di queste funzioni: un
metodo utilizzato dai computer, che dispongono di ununit a virgola mobile (FPU),
luso combinato di tabelle e di approssimazioni polinomiali (ad esempio le
approssimazioni di Chebyshev e di Pad per approssimazioni uniformi e le serie di Laurent
e di Taylor per approssimazioni con maggiore precisione). Grazie a queste tecniche i
computer dapprima cercano langolo in una piccola tabella (LUT) e dopo, a partire da
questo valore, affinano il risultato con lapprossimazione polinomiale.
I dispositivi pi semplici, che non dispongono di moltiplicatori e di unit a virgola mobile
(FPU), possono risolvere questo tipo di funzioni grazie a particolari tecniche che utilizzano
solo addizioni (additions) e spostamenti (shifts), per questo motivo raggiungono alti livelli
di performance e risultano semplici nella realizzazione hardware.
Una classe di algoritmi che calcolano funzioni lineari, trigonometriche, iperboliche e
logaritmiche, utilizzando solamente shift e adder stata denominata da Jack Volder nel
1959 con il termine CORDIC (COordinate Rotation DIgital Computer).
Tra le soluzioni hardware esistono anche degli algoritmi iterativi per funzioni trascendenti
che si avvalgono solamente di shift e adder.
3
Le funzioni trigonometriche sono basate sulla rotazione di vettori, mentre altre funzioni
sono implementate utilizzando espressioni incrementali della funzione voluta.
Le funzioni incrementali sono realizzate con unestensione dellarchitettura hardware
molto semplice e, nonostante non facciano parte del CORDIC in senso stretto, spesso vi
sono incluse per laffinit. Lalgoritmo CORDIC in genere produce un bit di accuratezza
per ogni iterazione.
La rotazione di vettori utile non solo per calcolare qualunque funzione trigonometrica,
ma anche per le conversioni da coordinate polari a cartesiane e viceversa, per il calcolo del
modulo di vettore e per il calcolo della DFT (Discrete Fourier Transform) e della DCT
(Discrete Cosine Transform).

1.2 Algoritmo iterativo per la rotazione di un vettore bidimensionale
Lalgoritmo CORDIC offre lopportunit di ruotare dei vettori di angoli arbitrari attraverso
un metodo iterativo che si serve solo di spostamenti (realizzati con shift) e somme
(realizzate con adder) .
Lalgoritmo derivato dalla trasformazione per la rotazione generale:

x = xcos ysen (1.1)
y= ycos + xsen (1.2)

che ruota un vettore in un piano cartesiano di un angolo come rappresentato nella figura
1.1.

(Fig. 1.1) Rotazione di un vettore di componenti (x, y) di un angolo


4
Le espressioni precedenti, raccogliendo cos, possono essere riscritte in questo modo:

x = cos[x ytan] (1.3)
y= cos[y + xtan] (1.4)

Per semplificare le relazioni si inizia considerando solo angoli di rotazione, per cui

tan = 2
-i

(1.5)

in modo tale che, posto i intero, la moltiplicazione per la tangente sia riconducibile ad
unoperazione di shift.
La possibilit effettiva di estendere il discorso anche alle rotazioni per angoli arbitrari
ottenibile eseguendo una serie di rotazioni di angoli di ampiezza minore.
Lalgoritmo quindi di tipo iterativo e, dato che si ruota di un angolo pi piccolo
del precedente, si pu dimostrare che garantita la convergenza.
Poich il coseno una funzione pari cosu = cos(-u) il termine cos(
i
) non dipende dal
verso di rotazione; quindi pu essere considerato semplicemente una costante.

x
i+1
= k
i
[x
i
- y
i
d
i
2
-i
] (1.6)
y
i+1
= k
i
[y
i
+ x
i
d
i
2
-i
] (1.7)

dove d
i
= 1 e stabilisce se 2
-i
positivo o negativo (tan = 2
-i
)
k
i
= cos
tale che tan = 2
-i
in quanto la tangente una funzione dispari (tan u = - tan u);

quindi si ottiene:
= arctan 2
-i
(1.8)

perci:
k
i
= tan
-1
2
-i
= 1/\(1+2
-2i
) (1.9)

5
Rimuovendo dalle equazioni iterative la scala di deformazione determinata dalla costante
k
i
, si ottiene un algoritmo che utilizza shift e adder per la rotazione di vettori; quindi il
prodotto dei k
i
(i=1,2,..) pu essere eseguito separatamente.
Se il numero di iterazioni tende a infinito, tale prodotto tende a 0,6073; di conseguenza
lalgoritmo di rotazione ha un guadagno A
j
pari a 1/H(k i), cio 1/ 0,6073 - 1,647.
Il guadagno esatto A
j
dipende dal numero di iterazioni ed stabilito dalla relazione:

A
j
= H
j
\(1+ 2
-i
) (1.10)

Langolo della rotazione composita unicamente definito dalla sequenza delle direzioni
delle rotazioni elementari; tale sequenza pu essere rappresentata da un vettore decisionale.
Linsieme di tutti i possibili vettori decisionali un sistema di misura angolare basato su
arcotangenti binarie.
La conversione di questo sistema binario in un altro si pu fare usando una LUT (Look Up
Table).
Un metodo di conversione migliore utilizza un ulteriore addizionatore che somma a
ciascuna iterazione gli angoli delle rotazioni elementari che possono essere espressi in
ununit di misura opportuna.
Questi valori di angoli sono dati da una piccola LUT (un valore per ogni iterazione).
Il problema dunque stabilire ad ogni iterazione in che verso effettuare la rotazione, quindi
se d
i
= 1 stabilendo perci se 2
-i
positivo o negativo; questo infatti un concetto chiave
in tutti gli algoritmi CORDIC. A questo punto occorre introdurre una terza variabile z che
viene aggiornata ad ogni iterazione secondo lequazione:

z
i+1
= z
i
- d
i
tan
-1
2
-i
(1.11)

Ci sono due metodi per realizzare la rotazione CORDIC: il metodo rotation e quello
vectoring.
Il primo ruota il vettore di ingresso di un angolo specifico dato come argomento; quindi il
termine d
i
viene deciso secondo la regola:

(1.12)
6
Il metodo vectoring, invece, ruota il vettore di ingresso verso lasse delle x e memorizza
langolo richiesto per fare la rotazione; in questo caso il termine d
i
viene deciso secondo
la regola:


Di conseguenza, dopo j iterazioni, applicando il metodo rotation, si ottiene:

x
j
= A
j
(x
0
cos z
0
y
0
sen z
0
) (1.14)
y
j
= A
j
(y
0
cos z
0
+ x
0
sen z
0
) (1.15)
z
j
= 0 (1.16)

Possiamo facilmente osservare che, facendo andare a zero la variabile z (nel caso rotation),
dopo j iterazioni si ha la seguente uguaglianza:

j-1
_ di arctan 2
-i
= z0 (1.17)
i=0

per cui prendendo una sequenza generica di d
i
si ottiene che z
0
langolo di rotazione del
vettore (x, y) cio proprio .

= z
0
(1.18)



Si giunge alla conclusione che possibile ruotare il vettore originario (x, y) di un angolo
con lalgoritmo sopra descritto solamente attraverso shift e somme (Fig. 1.2) .
(1.13)
7

(Fig. 1.2) Successione di rotazioni del vettore (x,y)

Altrimenti se, dopo j iterazioni, applichiamo il metodo vectoring, si ottiene:

x
j
= A
j
\(x
0
2
+y
0
2
) (1.19)
y
j
= 0 (1.20)
z
j
= z
0
+ arctan(y
0
/x
0
) (1.21)

dove i valori x
0
, y
0
e z
0
indicano i valori iniziali delle variabili x, y e z.

La realizzazione hardware dellalgoritmo necessita unicamente, come datapath, di blocchi
sommatori e di registri per effettuare gli shift aritmetici ma non occorrono strutture logiche
apposite per le moltiplicazioni, divisioni o altre operazioni complesse da realizzare in
hardware; ovviamente i valori di arctan 2
-i
vanno memorizzati in una memoria o in una
LUT per poter essere utilizzati.
Per convergere il CORDIC ha bisogna di alcuni vincoli sui valori iniziali, infatti molti di
questi algoritmi non riescono ad azzerare una delle variabili se il valore scelto inizialmente
troppo elevato in modulo; in particolare per il CORDIC precedentemente analizzato
sufficiente che le rotazioni siano limitate tra a/2 e + a/2 per avere un risultato corretto.





8
1.3 Il CORDIC per il calcolo del seno e del coseno
Per calcolare il seno e il coseno occorre inizializzare la variabile y a y
0
= 0, ottenendo
tramite il metodo rotation:

x
j =
A
j
x
0
cos z
0
(1.22)
y
j =
A
j
x
0
sen z
0
(1.23)

Per evitare lo scalamento di un fattore A
j
bisogna inizializzare la variabile x a x
0
= 1/A
j
, in
questo modo possibile ottenere sia il valore del seno sia quello del coseno.



1.4 Il CORDIC per il calcolo dell arcotangente e della norma di un
vettore bidimensionale
Per il calcolo dellarcotangente e della norma di un vettore bidimensionale occorre
utilizzare il metodo vectoring; quindi si inizializza z con il valore z
0
= 0, ottenendo:

z
j
= A
j
\(x
0
2
+y
0
2
) (1.24)
z
j
= arctan(y
0
/x
0
) (1.25)

1.5 Il CORDIC per il calcolo delle funzioni iperboliche
Il sistema trigonometrico presenta molte analogie con quello iperbolico perci le equazioni
caratteristiche del CORDIC subiscono solo delle piccole modifiche:

x
i+1
= x
i
+ y
i
d
i
2
-i
(1.26)
y
i+1
= y
i
+ y
i
d
i
2
-i
(1.27)

z
i+1
= z
i
- d
i
tanh
1
( 2
-i
) (1.28)

Allo stesso modo del caso trigonometrico, usando il metodo rotation o vectoring si ottiene
sinh, cosh , tanh
-1
, \(x
0
2
- y
0
2
).
Si deve per tener presente che, per le funzioni iperboliche, non garantita la convergenza,
infatti affinch la soluzione trovata sia corretta necessario ripetere alcune iterazioni (la 4,
13, 40, ..., k, 3k + 1, ...).

9
1.6 Support Vector Machine (SVM)
La tecnica della Support Vector Machine (SVM) serve per la regressione e la
classificazione di pattern ed stata sviluppata recentemente da Vladimir Vapnik e dal suo
team agli AT-T Bell Laboratories.
Lutilizzo della SVM consente lapprendimento di classificatori polinomiali, Radial Basis
Function (RBF) e Multi-Layer Perceptron in cui i pesi della rete si ottengono risolvendo
un problema di programmazione quadratica (QP) con vincoli di uguaglianza o di tipo box,
in cui il valore di un parametro deve essere vincolato allinterno di due estremi.
Questo uno dei vantaggi principali rispetto alle tecniche classiche di addestramento delle
reti neurali, come la Back Propagation (BP), che permettono di ottenere i pesi della rete
risolvendo un problema di ottimizzazione non convesso e non vincolato con un numero
indeterminato di minimi relativi, a differenza della tecnica di addestramento della SVM
che permette di ottenere i parametri peculiari della rete mediante la soluzione di un
problema di ottimizzazione quadratica convesso che prevede un unico minimo globale.
Ci assicura che i parametri della rete siano i migliori valori ottenibili dato il training set
attraverso cui si effettua il training.
Dato il compito di apprendere e dato un numero finito di esempi per laddestramento
(training set), la capacit di generalizzazione ottimale si ottiene bilanciando laccuratezza
acquisita nellapprendere lo specifico insieme di addestramento e labilit di apprendere un
qualunque insieme di dati, limitando il fenomeno delloverfitting.
Supponiamo di avere un vettore in ingresso x
i
(per i = 1, 2, . . . m) di dimensioni d, che
rappresenta una classe yi (indicata con il tag -1 o 1 a seconda del tipo); in pratica nel
caso di riconoscimento di facce questo significa che xi potrebbero essere i pixel del viso in
una immagine mentre yi `e unetichetta che esprime se -1 che non si tratta di un viso,
mentre se 1 allora il vettore rappresenta un viso.
Dato un insieme di vettori xi che formano un set di dati di entrambe le classi, si pu
pensare che questi siano disposti in uno spazio a d dimensioni; lo scopo della
classificazione `e quello di trovare una superficie di decisione che separa gli insiemi di
punti che rappresentano una classe da quelli che rappresentano laltra.
Alcune applicazioni, per cui le SVM sono state utilizzate con successo, sono il
riconoscimento ottico dei caratteri OCR (Optical Character Recognition, dove in breve
10
tempo le SVM divennero competitive con i migliori metodi utilizzati), lidentificazione di
facce in immagini, lidentificazione di pedoni e la classificazione di testi.

1.7 La funzione Kernel utilizzata per lSVM
Per la classificazione mediante SVM necessario calcolare il segno della sommatoria:


dove i termini nellespressione rappresentano:
x il pattern di cui lSVM deve predire la classe dappartenenza
N
s
il numero di Support Vector (SV)
s
i
li-esimo Support Vector
y
i
letichetta (-1, +1) associata ad ogni singolo SV che rappresenta la sua
classe dappartenenza.
B
i
i pesi calcolati con il Learning dellSVM.
K(x,s
i
) la funzione kernel scelta per il problema di classificazione in questione
(Tab. 1.1) Nomenclatura utilizzata per la funzione kernel di SVM

Uno dei kernel pi usati per la classificazione il kernel RBF (Radial Basis Function).
Se si definisce = 1 / (2o
2
) sostituendo nella definizione del kernel si ottiene:


Tuttavia per usare il kernel gaussiano necessario calcolare il valore della norma seconda
che dato dalla seguente espressione:


dove Ni la dimensione dei vettori che rappresentano i pattern (x) ed i Support Vector (s
i.
).
Graficamente il kernel gaussiano ha un aspetto simile a quello in figura 1.3.
(1.29)
(1.30)
(1.31)
11


(Fig. 1.3) Porzione bidimensionale del grafico della funzione kernel RBF calcolata per
Ni = 2 e Ni = 0.5

La moltiplicazione per non un problema per la simulazione hardware perch
possibile imporre il vincolo che sia una potenza di 2 durante il learning dell SVM, in
modo tale che il prodotto sia un semplice shift. Tuttavia usando questo kernel necessario
calcolare il valore della norma seconda e, di conseguenza, calcolare in hardware il
quadrato delle differenze (x - s
i
); quindi occorre moltiplicare dei numeri reali, con costi
onerosi dal punto di vista hardware. Pertanto, la norma seconda viene approssimata con la
norma prima e la funzione kernel diventa:



La definizione matematica di norma prima per le x ed i support vector s
i
:



Si pu dimostrare che questa espressione di K(x,s
i
) soddisfa le condizioni di Mercer
(la matrice quindi definita positiva) ed quindi un kernel. In questo caso la forma del
Kernel quella di figura 1.4.

(1.32)
(1.33)
12

(Fig. 1.4)Porzione bidimensionale del grafico della funzione kernel calcolata
con la norma prima per Ni = 2 e = 0.5

Unicamente a scopo qualitativo possibile vedere la differenza tra questi due tipi di kernel
nel piano bidimensionale (Figura 1.5).
Questo kernel pu essere calcolato facilmente con sommatori ed accumulatori, per cui il
problema principale calcolare i valori dei termini in seguito chiamati per chiarezza
espositiva termini elementarisenza utilizzare moltiplicatori:

B
i
e
x s
i 1
2



(Fig. 1.5) Confronto tra la funzione esponenziale con esponente
con norma seconda (blu) e con norma prima (rosso)


(1.34)
13
1.8 Metodo iterativo per il calcolo dei termini B
i
senza moltiplicatori
K(x, s
i
)

Data la funzione kernel:

si pu trasformare da esponenziale in base e in esponenziale in base 2. Se considero il
termine e
-v
, questo si pu sostituire con un termine 2
-v
in questo modo:

2
v'
e
ln2
v'
e
v ' ln2


Questa relazione implica che nella trasformazione e
-v
in 2
-v
stato introdotto il fattore di
proporzionalit ln 2, infatti:
e
-v
= 2
-v
se v = v ln2.
Di conseguenza:
v '
v
ln2
.
La funzione Kernel che si vuole calcolare la seguente:
v x s
i 1

Pertanto:
v '
x s
i 1
ln2

La funzione Kernel in base 2 diventa:

2
' x s
i 1
ln2

'

ln2


Detto E
1
lesponente di 2:
B
1
' x s
i 1

B
1
si definisce termine elementare della sommatoria.

Il CORDIC ha lo scopo di calcolare B
1
2
E
1
soltanto con operazioni di shift, somme o
sottrazioni.
con
(1.35)
(1.36)
(1.37)
(1.38)
(1.39)
(1.40)
(1.41)
(1.42)
14
Capitolo 2


La scheda Spartan-3


2.1 Introduzione
Le FPGA (Field Programmable Gate Array) sono dispositivi programmabili costituiti da
una matrice di componenti logici collegabili tra loro. Le FPGA mettono a disposizione
dellutente diversi componenti logici (CLB - Slice), costituiti da logica, piccole memorie,
flip-flop, buffer, multiplexer, linee di connessione sia locali (corte) che distribuite (lunghe),
matrici di inter-connessione per collegare varie linee tra loro e da queste ai blocchi logici,
blocchi di I/O, particolari blocchi logici dedicati allI/O provvedono buffer, protezioni,
Fan-out, resistenze di pull-up e pull-down, adattatori dimpedenza, blocchi particolari
memorie, moltiplicatori, PLL, decodificatori.
La Spartan-3 una FPGA che dispone di un gran numero di logica programmabile,
Intellectual Property (IP) core, e di strutture logiche veloci e versatili.
E` possibile usare il processore MicroBlaze 32-bit per integrare un intero sistema con tutte
le funzioni di controllo e leventuale logica di supporto avendo tutto su ununica
piattaforma a costi molto bassi.
Larchitettura della famiglia delle Spartan-3 composta da cinque elementi funzionali
programmabili fondamentali: Configurable Logic Blocks (CLBs), Input / Output Blocks
(IOBs), Block RAM, Multiplier Blocks, Digital Clock Manager (DCM) Blocks.

2.2 Configurable Logic Blocks (CLB)
I Configurable Logic Blocks (CLB) contengono LUT (Look Up Tables) flessibili che
implementano elementi logici usati come flip flop o latches. I CLB realizzano una grande
variet di funzioni logiche nonch larchiviazione dei dati.
Nella Spartan 3 XC3S200A sono presenti fino a 448 CLB (32 righe x 16 colonne) per un
totale di 1920 slice. Ciascun CLB contiene 4 slice, ognuna con la propria coordinata di
locazione. Le slice possono essere di due tipi: SLICEM e SLICEL: l`M` finale indica che
15
la slice supporta le funzioni in relazione con la memoria, mentre la `L` che la slice
supporta soltanto la logica.
Il CLB comprende inoltre una catena di carry ed una logica dedicata a combinare una LUT
per realizzare funzioni logiche a 5 o 6 ingressi.


(Fig. 2.1) Configurable Logic Block (CLB)

2.3 Input/Output Blocks (IOB)
Gli Input/Output Block (IOB) controllano il flusso di dati tra i pin di ingresso e uscita e la
logica interna del dispositivo. Gli IOB supportano un flusso di dati bidirezionale.

2.4 Block RAM
La Block RAM consente larchiviazione dei dati sotto forma di blocchi dual-port a 18Kbit.
Ogni Block RAM contiene 18432 bit di RAM statica, 16000 bit dei quali sono impiegati
per larchiviazione dei dati. Fisicamente la Block RAM ha due porte di accesso
completamente indipendenti, Port A e Port B. La struttura totalmente simmetrica; infatti,
possibile utilizzare le porte A e B in maniera intercambiabile sia per operazioni di lettura
e di scrittura.
I Block RAM sono organizzati in colonne, a ciascuna di esse corrispondono pi blocchi di
Ram a 18Kbit e ad ogni blocco associato a un moltiplicatore dedicato.
Per ottenere una pi complessa organizzazione della memoria senza compromettere i
vincoli temporali, necessario impiegare risorse specifiche per il routing.
16
FSL_M_Clk
FSL_M_Data
FSL_M_Writ
FSL_M_Full
FSL_S_Control
FSL_S_Clk
FSL_S_Data
FSL_S_Read
FSL_S_Exist










Gestione FIFO FSL_M_Control
2.5 Multiplier Block
I Multiplier Block accettano due numeri binari a 18-bit come ingressi e ne calcolano il
prodotto, inoltre ogni moltiplicatore pu essere usato in modo indipendente.

2.6 Digital Clock Manager (DCM) Block
I Digital Clock Manager (DCM) Block forniscono calibrazione autonoma, soluzioni
interamente digitali per distribuzione, ritardo, moltiplicazione, divisione e spostamento di
fase dei segnali di clock.
I DCM sono posizionati due in cima e due in fondo al dispositivo e, per i dispositivi pi
grandi, ve ne possono essere ulteriori sui lati.
La generazione di Spartan-3 caratterizzata da una ricca rete che interconnette tutti e
cinque gli elementi funzionali e trasmette segnali tra di essi.

2.7 Fast Simplex Link (FSL)
Il bus FSL un canale di comunicazione unidirezionale punto-punto tra master e slave
gestito come una coda FIFO (sia sincrona che non) pi veloce rispetto all`OPB (On chip
Peripheral Bus). In un MicroBlaze possibile utilizzarne fino ad 8 (ciascuno comprende
ovviamente un master e uno slave). Inoltre, fornisce un tipo di comunicazione non
condivisa e non arbitrata. E` possibile usare un ulteriore bit di controllo per il canale slave,
utile ad esempio per segnalare linizio e la fine della trasmissione di un pacchetto dati.
Per trasferire i dati contenuti in registro del MicroBlaze su un bus FSL e viceversa si
possono utilizzare le istruzioni putfsl (dato, link) e getfsl (dato, link).
Il bus FSL (Fast Simplex Link) pu raggiungere una velocit di trasferimento dati pari a
300MB\s, cio 2400Mb\s.

(Fig. 2.2) Schema del Bus Fast Simplex Link
17

2.8 Elementi della Spartan-3
La Spartan-3 dispone di una porta JTAG alla quale possibile collegare un cavo apposito
che permette la connessione della scheda alla porta parallela di un PC e il trasferimento del
progetto; inoltre, dotata di una porta seriale con la quale si possono visualizzare le
comunicazioni che avvengono tra lutente e il programma attraverso lHyper Terminal.
La scheda alimentata con una tensione di 5 Volt ed costituita dai seguenti elementi (Tab
2.1) :

1. Xilinx XC3S200 Spartan-3 FPGA 16. Jumpers
2. XCF025 2Mbit Configuration PROM 17. Program Push Button
3. Platform Flash Jumpers 18. Configuration DONE led
4. 2 x 256K x 16 10ns SRAM 19. B1 Expansion Header
5. 8 color VGA Port 20. A1 Expansion Header
6. RS- 232 Port Serial Port 21. A2 Expansion Header
7. RS-232 Driver 22. Jtag Download Cable Connector
8. Jumper 1
23. Digilent Low cost Parallel Port to Jtag
Cable
9. PS/2 Port
24. Parallel cable IV Multipro desktop
Tool Jtag Connector
10. 4 Character 7-Segment LED
25. 5 VDC 2 Supply 100 240 V AC Input
50 -60 Hz
11. 8 Slide Switches 26. Power On LED
12. 8 Leds 27. 3.3V Regulator
13. 4 Push Buttons 28. 2.5V Regulator
14. 50 Mhz Oscillator 29. 1.2V Regulator
15.Auxiliary Oscillator Socket
Configuration Mode selector

(Tab 2.1) Elementi della Spartan-3
18


(Fig. 2.3) Illustrazioni e fotografie del dispositivo utilizzato


Abbiamo utilizzato il modello di Spartan-3 XC3S200A che dispone di 200000 porte
logiche con tecnologia di 90nm e di 448 CLB, ciascuno dei quali costituito da quattro
slice. Pu avere fino a 16 moltiplicatori dedicati e dispone di 288Kb di Block RAM e di
28Kb di Distributed RAM.


(Fig. 2.4) Caratteristiche della Spartan-3





19
Capitolo 3


Il MicroBlaze


3.1 Introduzione
Il MicroBlaze un processore di tipo RISC (Reduced Instruction Set Computer) a 32 bit
implementato con architettura Harward realizzato da Xilinx e reso disponibile dalla
Spartan-3; infatti il MicroBlaze embedded processor soft core stato pensato per le
implementazioni con FPGA della Xilinx.
Larchitettura di tipo Harvard supporta indirizzi a 32 bit e permette di separare gli spazi in
cui avvengono gli accessi in memoria dei dati da quelli delle istruzioni.
Il processore supporta fino a tre interfacce per gli accessi alla memoria: Local Memory Bus
(LMB), On-Chip Peripheral Bus (OPB) e Xilinx Cache Link (XCL).
Per la memoria possono essere utilizzate sia quella on-chip, BRAM (Block Ram), sia
quella offchip.
Laccesso alla BRAM avviene rapidamente grazie alle risorse di instradamento dedicate.
Il processore pu lavorare fino ad una frequenza di clock pari a 150 MHz.
Il soft core processor del MicroBlaze pu essere personalizzato per ogni tipo di
applicazione.
Il barrel shifter, la cache dei dati e il bus di sistema FSL (Fast Simplex Link) sono
opzionali.
La dimensione della cache si pu impostare da 2KB fino a 64KB. Sono disponibili
periferiche standard compatibili con il Core Connect e quindi possono essere integrate
molto facilmente in un progetto di un sistema embedded.
20

(Fig. 3.1) Struttura a blocchi del MicroBlaze

E un processore altamente configurabile e consente di selezionare linsieme di
caratteristiche pi adatte al proprio progetto. Linsieme di elementi di base del processore
comprende trentadue registri a 32 bit general purpose, istruzioni a 32 bit con tre operandi e
due modi di indirizzamento, un bus a 32 bit e una pipeline.
Oltre a questi elementi possibile selezionarne altri, opzionali, come la cache, la Floating
Point Unit, lon chip peripheral bus, il local memory bus, il Fast Simplex Link, ecc.
Per rappresentare i dati il MicroBlaze usa il big endian, formato in cui la memorizzazione
avviene a partire dal byte pi significativo per finire con il meno significativo e supporta i
tipi word, half word e byte.

3.2 Architettura dei registri
Il MicroBlaze ha unarchitettura del set di istruzioni ortogonale: infatti, i diversi metodi di
indirizzamento e i diversi registri possono essere usati indifferentemente per tutte le
istruzioni. Inoltre, ha trentadue registri general purpose a 32 bit e fino a diciotto registri,
sempre a 32 bit, special purpose che dipendono dalle scelte di configurazione.
21
3.2.1 Registri General Purpose
I trentadue registri a 32-bit di tipo general purpose sono numerati con R0 fino a R31.
Nella seguente tabella (Tab 3.1) sono descritte le funzionalit dei singoli registri.

Bit Nome Descrizione
0:31 R0
registro che contiene sempre il valore 0 anche quando vi si scrive
un dato
0:31 R1 a R13 registri di tipo general purpose a 32 bit.
0:31 R14
registro a 32 bit utilizzato per memorizzare lindirizzo di ritorno
in caso di interrupt.
0:31 R15
registro utilizzato per la memorizzazione di indirizzi di ritorno
per vettori utilizzati dallutente.
0:31 R16 registro usato per memorizzare gli indirizzi di ritorno per i break.
0:31 R17
se il MicroBlaze configurato per supportare le eccezioni
hardware, su questo registro viene copiato lindirizzo
dellistruzione successiva a quella che causa leccezione
hardware.
0:31 R18 a R31 registri di tipo general purpose a 32 bit.
(Tab. 3.1) Registri di tipo General Purpose











22
3.2.2 Registri Special Purpose
Nella seguente tabella (Tab. 3.2) sono descritte le funzionalit dei registri di tipo special
purpose.
Program Counter (PC)
contiene lindirizzo a 32 bit
dellistruzione in esecuzione.
Machine Status Register (MSR)
contiene il bit di controllo di stato per il
processore.
Exception Address Register (EAR)
memorizza lindirizzo che ha causato
leccezione
Exception Status Register (ESR) contiene i bit di stato per il processore.
Branch Target Register (BTR)
esiste solo se il MicroBlaze configurato
per usare le eccezioni.
Floating Point Status Register (FSR)
contiene il bit di stato per lunit a
virgola mobile.
Exception Data Register (EDR)
memorizza i dati letti sull FSL che causa
una eccezione solo di tipo FSL.
Process Identifier Register (PID)
usato per identificare un processo
software durante la traduzione
dellindirizzo MMU
Zone Protection Register (ZPR)
usato per sovrascrivere la protezione
della memoria MMU definita nella TLB
Translation Look-Aside Buffer High Register
(TLBHI)
usato per accedere ai dati della MMU
Translation Look-Aside Buffer Index
Register (TLBX)
usato come indice per accedere
allUnified Translation Look-Aside
Buffer (UTLB)
Translation Look-Aside Buffer Search Index
Register (TLBSX)
serve per la ricerca di un numero di
pagina virtuale allinterno dellUnified
Translation Look-Aside Buffer (UTLB)
Processor Version Register (PVR)
controllato dallopzione di
configurazione C_PVR del MicroBlaze
(Tab. 3.2)Registri di tipo Special Purpose
23
3.2.3 Convenzioni sulluso dei registri
I registri volatili sono usati temporaneamente e non mantengono i valori tra le varie
chiamate a funzioni.
Alcuni registri sono usati come registri dedicati e i programmatori non possono usarli per
altri scopi.
I registri special purpose non sono codificati direttamente nel register file e quindi il loro
utilizzo diverso da quelli general purpose.
Il registro R1 memorizza il valore dello stack pointer ed aggiornato allinizio e alla fine
dell'esecuzione delle funzioni.
Il registro R2 di sola lettura per le piccole aree di dati SDA (Small Data Area) ed usato
per laccesso alle costanti esplicite.
I registri da R3 a R12 sono volatili; tra questi i registri R3 ed R4 sono usati per ritornare i
valori alle funzioni chiamanti, mentre i registri da R5 a R10 per passare i parametri tra le
sub-routine.
Il registro R13 di scrittura e lettura delle SDA ed usato per laccesso ai valori nelle
sezioni SDA Read-Write .
I registri da R14 a R17 sono usati per memorizzare rispettivamente gli indirizzi di ritorno
dagli interrupt, sub-routine, trap ed eccezioni.
Il registro R18 usato come registro temporaneo per operazioni di tipo assembler.
I registri da R19 a R31 non sono volatili e quindi mantengono i loro contenuti tra le
chiamate alle funzioni.

3.3 Istruzioni
Tutte le istruzioni del MicroBlaze sono a 32 bit e sono suddivise in istruzioni di tipo A o di
tipo B.
Le istruzioni di tipo A hanno fino a due registri sorgenti a 8 bit ed uno di destinazione,
quelle di tipo B hanno solo un registro sorgente a 8 bit ed un registro di destinazione e un
valore immediato di 16 bit. Le istruzioni sono organizzate secondo le categorie funzionali:
aritmetiche, logiche, salto, memorizzazione e speciali.
Il MicroBlaze dispone di istruzioni privilegiate come GET, PUT, NGET, NPUT, CGET,
CPUT, ecc. il cui suo in modalit user causa una eccezione di istruzione privilegiata.

24
3.4 Tipi di dati
I tipi di dati usati dal MicroBlaze sono indicati nella seguente tabella (Tab. 3.3):

Tipi di dati in C
Dimensione
in byte
char 1
short 2
int 4
long int 4
float 4
enum 4
pointer 2/4
(Tab. 3.3) Tipi di dati e dimensione in byte

3.5 Pipeline
Lesecuzione delle istruzioni organizzata mediante la pipeline. Per la maggior parte delle
istruzioni, ciascuno stadio impiega un ciclo di clock per terminare. Di conseguenza il
numero di cicli di clock necessari per completare lesecuzione di una determinata
istruzione pari al numero di stadi di pipeline; perci ad ogni ciclo di clock viene
completata unistruzione. Solo una minima parte di istruzioni richiede pi cicli di clock per
lesecuzione degli stadi; ci viene gestito con situazioni di stallo nella pipeline.
Nel caso in cui lesecuzione sia su memoria lenta, listruzione di fetch pu richiedere pi
cicli di clock.
Lulteriore latenza danneggia lefficienza della pipeline. Il MicroBlaze implementa un
buffer di prefetch dellistruzione che riduce limpatto di questa latenza. Mentre la
pipeline in stallo, il buffer di prefetch continua a caricare istruzioni sequenziali. Quando
la pipeline riprende lesecuzione, lo stadio di fetch pu caricare la nuova istruzione
25
direttamente dal buffer di prefetch, invece di aspettare che laccesso alla memoria
dellistruzione sia terminato.
3.5.1 Pipeline a tre stadi
Quando abilitata lopzione di ottimizzazione dellarea, la pipeline viene divisa in tre stadi
per ridurre il costo hardware; gli stadi sono tre: Fetch, Decode, ed Execute.
ciclo 1 ciclo 2 ciclo 3 ciclo 4 ciclo 5 ciclo 6 ciclo 7
Istruzione 1 Fetch Decode Execute
Istruzione 2 Fetch Decode Execute Execute Execute
Istruzione 3 Fetch Decode Stall Stall Execute
(Tab 3.4) Esempio di pipeline a tre stadi

3.5.2 Pipeline a cinque stadi
Quando disabilitata lopzione di ottimizzazione dellarea la pipeline divisa in cinque
stadi per aumentare le prestazioni: Fetch (IF), Decode (OF), Execute (EX), Access
Memory (MEM), e Writeback (WB).

ciclo 1 ciclo 2 ciclo 3 ciclo 4 ciclo 5 ciclo 6 ciclo 7 ciclo 8 ciclo 9
Istruzione 1 Fetch Decode Execute
Access
Memory
Writeback
Istruzione 2 Fetch Decode Execute
Access
Memory
Access
Memory
Access
Memory
Writeback
Istruzione 3 Fetch Decode Execute Stall Stall
Access
Memory
Writeback
(Tab 3.5) Esempio di pipeline a cinque stadi

26
3.6 Salti (Taken Branch)
Normalmente le istruzioni negli stadi fetch e decodifica (nonch nel prefetch buffer) sono
scaricate quando nellesecuzione si presenta un salto. Lo stadio di fetch riempito con la
nuova istruzione dellindirizzo calcolato per il salto. Un salto impiega 3 cicli di clock per
essere eseguito, due dei quali sono richiesti per riempire la pipeline con le nuove istruzioni.
Per ridurre laumento di latenza, il MicroBlaze gestisce i salti con blocchi di ritardo.
I blocchi di ritardo, quando si arriva allesecuzione di un salto, permettono lo svuotamento
dello stadio di fetch; di conseguenza listruzione nello stadio di decodifica potr terminare.
Questa tecnica riduce effettivamente la penalizzazione dei salti da due cicli a uno.

3.7 Architettura della memoria
Il MicroBlaze implementato, come gi accennato nellIntroduzione, con una architettura
di memoria di tipo Harward; quindi gli accessi alle istruzioni e ai dati sono effettuati in
spazi di indirizzo separati. Ogni spazio di indirizzo dispone di 32-bit range ( possibile
indirizzare fino a 4-Gb di memoria rispettivamente per le istruzioni e per i dati).
Sia le interfacce per le istruzini che per i dati del MicroBlaze sono a 32 bit e utilizzano il
formato big endian, bit-reversed.
Il MicroBlaze supporta accessi alla memoria dati di tipo word, halfword, e byte. Gli
accessi dei dati devono essere allineati (gli accessi alle word devono essere entro i limiti
della word, halfword ), a meno che il processore non sia configurato per supportare accessi
dei dati disallineati. Tutti gli accessi alle istruzioni, invece, devono essere con word
allineate.Il MicroBlaze non separa gli accessi dei dati dall I/O e dalla memoria.
Il processore dispone fino a tre interfacce per gli accessi alla memoria: Local Memory Bus
(LMB), Processor Local Bus (PLB) o On-Chip Peripheral Bus (OPB) e Xilinx CacheLink
(XCL). Il range di indirizzamento della memoria LMB non deve sovrapporsi con gli spazi
destinati al PLB, allOPB o al XCL.
Il MicroBlaze ha una latenza di un singolo ciclo di clock per gli accessi alla memoria
locale (LMB) e per la lettura dei cache hits, tranne quando abilitata lottimizzazione
dellarea in cui gli accessi ai dati e alla cache richiedono due cicli di clock.
Le cache del MicroBlaze delle istruzioni e dei dati possono essere configurate per usare
fino a 4 o 8 word di linee di cache. Quando viene usata una pi lunga linea di cache, pi
byte sono in fase di prefetch, generalmente migliorando le performance del software con
27
una combinazione di accessi sequenziali. Comunque, se si utilizza del software
caratterizzato da una maggiore casualit di combinazione di accesso le performance
possono, invece, diminuire per una data dimensione della cache. Questo peggioramento
delle prestazioni causato da un ridotto cache hit rate dovuto alla minore disponibilit di
linee della cache.


(fig. 3.2) Architettura della memoria







28
Capitolo 4


Aritmetica a precisione finita


4.1 Introduzione
Lelaborazione dei segnali basata su teorie matematiche che operano con i numeri reali.
Tali numeri, per, non possono essere rappresentati esattamente su un calcolatore poich i
registri, allinterno dei quali sono memorizzati i valori delle variabili utilizzate, hanno una
lunghezza finita di bit. Pertanto se si vuole rappresentare in hardware un numero reale
occorre approssimarlo con un opportuno numero razionale, cio si quantizza il numero
reale.
Questa operazione introduce un errore che dipende dal numero di bit dei registri e dalla
rappresentazione che si scelta.
Le principali rappresentazioni utilizzate sono quella a virgola mobile (floating point) e a
virgola fissa (fixed point). Per la realizzazione del progetto con cui programmare la
Spartan3 si scelta la rappresentazione a virgola fissa affinch la realizzazione fosse
confrontabile con una implementata senza lutilizzo di un microprocessore. Infatti, nella
maggioranza dei casi, per la realizzazione hardware su FPGA risulta pi conveniente la
scelta della rappresentazione a virgola fissa per la maggiore semplicit dei blocchi di
calcolo.
Su un processore general pourpose, invece, si possono avere una o pi unit a virgola
mobile per poter ottenere una maggiore precisione di calcolo non viziati dagli errori tipici
della rappresentazione a virgola fissa. Questo perch il datapath per i calcoli a virgola
mobile viene realizzato direttamente sul chip di silicio e non con blocchi programmabili
come i CLB delle FPGA.




29
4.2 Rappresentazione a virgola fissa
La rappresentazione a virgola fissa il modo pi semplice per rappresentare un numero in
hardware; infatti avendo a disposizione un registro a n bit e volendo memorizzare un
numero intero minore di 2n, immediato adottare un sistema di numerazione in base 2
analogo al pi diffuso sistema decimale.

4.3 Rappresentazione dei numeri negativi
Per rappresentare il segno di un numero necessario utilizzare uno dei bit a disposizione a
discapito di quelli per la rappresentazione del modulo.
Utilizzando la rappresentazione dei numeri con il segno si ha il problema che le operazioni
elementari di addizione e sottrazione tra numeri con segni discordi non sono pi valide.
Per aggirare questo problema si utilizza una rappresentazione apposita per i numeri con
segno in modo che la somma o la differenza tra numeri positivi e negativi dia risultati
corretti. Tale rappresentazione il complemento a 2.

4.4 Rappresentazione di numeri negativi in complemento a due
Il complemento a uno di un numero binario definito come il numero che si ottiene
invertendo tutti i bit, ossia sostituendo ai bit a 1 lo 0 e viceversa. Il complemento a due si
ottiene sommando +1 al complemento a uno di un numero. Si dimostra che, se si
rappresentano i numeri negativi con il complemento a due del loro modulo, si ottiene un
numero binario (il cui bit di segno sicuramente posto a 1) per cui valgono le operazioni
come laddizione e la sottrazione. Questa caratteristica del complemento a due utile per il
CORDIC nel calcolo della funzione kernel di SVM perch, per decidere se porre d = 0 o
d = 1, bisogna verificare se alliterazione corrente si ottiene un numero positivo o negativo
e, per non commettere errori critici in questa fase di decisione, si utilizza la
rappresentazione in complemento a due per i numeri impiegati nel calcolo di d.

4.5 Errore di quantizzazione commesso sulluscita
I CORDIC sono una classe di algoritmi che si prestano particolarmente bene per la
realizzazione di circuiti logici in hardware. E necessario tener presente che la precisione
dei numeri che si possono rappresentare vincolata dalla lunghezza finita dei registri e,
pertanto, i risultati che si ottengono sono gravati da un errore. Uno dei difetti pi
30
significativi degli algoritmi che sono organizzati in iterazioni sequenziali lerrore
presente allinizio del processo di calcolo che si propaga e in alcuni casi pu diventare
considerevole.
Detti n
o
il numero di bit con cui sono rappresentati gli operandi in ingresso allalgoritmo e
n
r
il numero di bit con cui vengono rappresentati i registri interni per i calcoli, lerrore di
quantizzazione che si ritrova sulluscita pu essere diviso in due componenti : lerrore
dovuto alla quantizzazione dellingresso (EQI) e lerrore dovuto alla precisione interna
(EQP). Il primo ha un errore massimo pari a 2
(no - 1)
; pertanto, se il numero di bit con cui
rappresentato lingresso piccolo, lerrore sulluscita rilevante. Il secondo, invece,
dovuto alla precisione interna dei registri e dai calcoli da effettuare.
Si pu fare in modo che, allinterno del dispositivo che realizza il CORDIC, lEQP sia pari
a met dellEQI fissando il numero di registri interni con cui si effettuano i calcoli .
Lerrore sulluscita perci dipende principalmente dal termine EQI e si pu ridurlo solo
aumentando il numero di bit con cui sono rappresentati i bit di ingresso.

4.6 Metodi di quantizzazione dei parametri
Ci sono tre metodi principali per la quantizzazione dei parametri: troncamento,
arrotondamento round to nearest e arrotondamento convergent rounding.
Per il troncamento si scartano le cifre oltre lultima cifra significativa considerata, per
larrotondamento round to nearest si sceglie il numero immediatamente pi vicino
approssimando lultima cifra per difetto se compresa nellintervallo [0, 0.5) o per eccesso
se compresa nellintervallo [0.5, 1].
Larrotondamento convergent rounding migliora lerrore statistico introdotto
dallapprossimazione per eccesso (dovuto al fatto che 0.5 incluso nellintervallo di
arrotondamento), scegliendo, nel caso in cui si abbia 0.5, se approssimare per difetto o per
eccesso in modo casuale (questa tecnica diffusa nellambito dei DSP).
Nel MicroBlaze viene utilizzato il metodo di arrotondamento round to nearest.





31
4.6.1 Errore di troncamento e di arrotondamento
Un numero A viene rappresentato come un numero Q(a) che non sempre corrisponde
esattamente allo stesso valore originario; di conseguenza viene introdotto un errore E.
Quando si approssima un numero avente n1 bit in un registro avente n bit con (n < n1) si
commette un errore pari a:
E = Q(a) A
Nel caso del troncamento:

(2
-n
2
-n
1
) < E _ 0

mentre nel caso dellarrotondamento:

(2
-n
2
-n
1
) /2< E _ (2
-n
2
-n
1
) /2

In pratica si usano espressioni semplificate: (2
-n
) < E _ 0 per il troncamento e
(2
-n
) /2 < E _ (2
-n
) /2 per larrotondamento dove si considera 2
-n
1
<< 2
-n
.

Il livello di dettaglio del gradino di quantizzazione dato dal bit meno significativo; perci
fissando la lunghezza dei registri a (n + 1) bit (cio con il bit di segno), il gradino di
quantizzazione 2
-n
.
Si pu notare che lerrore commesso dal troncamento di un numero maggiore di quello
commesso dallarrotondamento; tuttavia in hardware pi semplice effettuare loperazione
di troncamento anzich quella di arrotondamento.








(4.1)
(4.2)
(4.3)
32
4.7 Effetto della rappresentazione dei numeri negativi sullerrore
Nel caso dellarrotondamento non ha alcuna influenza la rappresentazione dei numeri
negativi.

(Fig. 4.1) Differenza tra il numero reale ed il valore ottenuto con larrotondamento

Nel caso del troncamento, invece, il tipo di rappresentazione dei numeri negativi ha un
ruolo importante sullerrore commesso durante i calcoli, in particolare varia a seconda che
si utilizzi il complemento a uno o il complemento a due.


(Fig. 4.2) Differenza tra il numero reale ed il valore ottenuto con il troncamento
rispettivamente per il complemento a uno (a sinistra) ed il complemento a due (a destra)

Quindi lerrore commesso E `e dato da:
- (2
-n
) /2 < E _ (2
-n
) /2 per larrotondamento
- (2
-n
) < E _ 0 per il troncamento di numeri in complemento a uno positivi
- 0 _ E < (2
-n
) per il troncamento di numeri in complemento a uno negativi
- (2
-n
) < E _ 0 per il troncamento di numeri in complemento a due
33
Capitolo 5


Architettura del sistema che realizza il CORDIC sul
MicroBlaze


5.1 Introduzione
Il nostro obiettivo il confronto delle prestazioni e dei costi (tempo di esecuzione, risorse
utilizzate, quantit di memoria, ecc.) tra diverse architetture digitali basate su FPGA.
Si scelto di utilizzare come algoritmo il CORDIC modificato che verr compilato,
eseguito dal MicroBlaze (implementato sulla Spartan-3) e confrontato con
limplementazione hardware del CORDIC srotolato, non srotolato per il calcolo del
kernel di SVM (Support Vector Machine) realizzato con il tool di sviluppo Xilinx ISE 7.1.

5.2 Ambiente di sviluppo e generazione del sistema
Per realizzare il progetto stato utilizzato il programma Xilinx Embedded Development
Kit (EDK) che consente di programmare il processore e alcune parti di logica su diversi
tipi di FPGA (Spartan3, Virtex, ecc.).
Abbiamo utilizzato lambiente di sviluppo Xilinx Platform Studio, attraverso il quale
stato possibile configurare numerosi parametri del progetto prima di programmare
effettivamente il dispositivo.
Innanzitutto, si sceglie di creare un nuovo progetto e si seleziona il tipo di dispositivo con
cui si intende lavorare (in questo caso la Spartan-3); verranno visualizzate quindi le
caratteristiche principali come illustrato in figura 5.1:

34

(Fig. 5.1) Caratteristiche del dispositivo Spartan-3

Successivamente il tool Base System Builder consente di impostare alcune caratteristiche
del sistema: lutilizzo e la tipologia del debug, labilitazione della cache, la frequenza di
clock del bus del processore (12,5MHz 75MHz), labilitazione della Floating Point Unit
e la dimensione della memoria su cui verranno memorizzati dati e istruzioni come
illustrato in figura 5.2.

35

(Fig. 5.2) Configurazione del MicroBlaze

Nel caso in cui venga abilitata la Floating Point Unit, si deve tenere presente che, per
programmare il MicroBlaze, alcune istruzioni sono differenti da quelle del linguaggio
standard C: ad esempio, per le funzioni di stampa, viene messa a disposizione la funzione
xil_printf () che pi piccola rispetto a quella classica printf() e, proprio per questo,
supporta tipi di stampa solo di interi e non quindi possibile stampare un numero float
scrivendo %f.
Inoltre, importante ricordare che leffettiva scelta per la dimensione della Local Memory
dipende dal progetto; nel nostro caso possibile scegliere solo tra 8KB e 16KB poich le
dimensioni 32KB e 64KB, al momento della generazione del file .bit da trasferire sulla
scheda, provocano un errore dovuto alleccessiva quantit di memoria Block Ram per il
dispositivo utilizzato.
36
Quindi, occorre avere fin dallinizio una certa stima dello spazio della FPGA che si intende
utilizzare per il proprio progetto per evitare che si presentino messaggi di errore in fase di
generazione del file .bit.
Nella fase successiva alla creazione del progetto si ha lopportunit di scegliere quali
interfacce di input/output includere e se disporre di una memoria esterna di tipo statico. Le
interfacce di uscita sono i LED a 8 bit e i LED a 7 segmenti, mentre quelle di ingresso sono
i Push Buttons a 3 bit e i Dip Switches a 8 bit. Fra i Push Buttons a 3 bit uno il reset della
FPGA e resta sempre attivo, anche se lintero gruppo di bottoni non viene incluso.
Per questo progetto occorre solo la porta seriale RS232 in modo da visualizzare le stampe a
monitor del codice che saranno generate dal MicroBlaze.
Scelte le interfacce da utilizzare, possibile impostare alcuni parametri tra i quali
labilitazione degli interrupt.
Nella seguente figura (Fig. 5.3) e nella successiva (Fig. 5.4) vengono illustrati i dispositivi
disponibili e la possibilit di abilitarli mediante la check-box.


(Fig. 5.3) Configurazione dellinterfaccia di I/O
37



(Fig. 5.4) Configurazione dellinterfaccia di I/O


Nella pagina di configurazione successiva si ha la possibilit di aggiungere una periferica;
in questo progetto occorre un contatore di cicli di clock che si interfacci al MicroBlaze
servendosi di un bus tra quelli a disposizione, ad esempio il bus FSL (Fast Simplex Link).
Questa periferica sar realizzata in un secondo momento, dopo la generazione del sistema.
Dunque occorre impostare come standard di input e di output la porta seriale e, prima della
conferma per generare il sistema, viene visualizzato un riassunto generale delle specifiche
impostate (Fig. 5.5).

38

(Fig. 5.5) Riassunto complessivo del sistema creato

5.3 Periferica per contare i cicli di clock
Dal momento che il MicroBlaze non dispone di un timer, per vedere il tempo in cui viene
eseguita lelaborazione, stata realizzata una periferica esterna, un contatore che conta i
cicli di clock. Abbiamo collegato questa periferica esterna al MicroBlaze attraverso due
bus FSL, il primo impostato come master per il processore e come slave per la periferica,
laltro impostato in maniera duale.
Inoltre, i clock dei bus e della periferica sono stati configurati in modo da essere sincroni
con il clock di sistema.
Utilizzando la Platform Studio si pu scegliere di creare o importare una periferica
iniziando cos un wizard per la sua configurazione. Per creare la periferica innanzitutto
abbiamo scelto di salvarla nella cartella del progetto con il nome contatore.
Successivamente si passati alla configurazione di parametri pi importanti; infatti si
scelto di collegare la periferica al microprocessore attraverso il bus Fast Simplex Link
39
(FSL) configurato con un ingresso a 32 bit ed unuscita, infine si ha un riepilogo delle
impostazioni scelte prima di generare la periferica.
Terminato il wizard, si devono aggiungere al sistema attraverso la finestra IP Catalog la
periferica e due bus FSL e impostare le connessioni dei due bus master e slave sia della
periferica sia del MicroBlaze (Fig. 5.6).


(Fig. 5.6) Configurazione dei bus del Fast Simplex Link

A questo punto nella tabella Ports si possono collegare i clock della periferica e dei due
bus in modo da renderli sincroni con quello di sistema. Aprendo il file dalla cartella del
progetto che contiene un codice vhdl desempio della periferica creata, (percorso della
cartella del progetto\pcores\contatore_v1_00_a\hdl\vhdl\contatore.vhd), si possono
modificare le funzionalit della periferica; nel nostro caso, modificando il codice vhdl,
abbiamo creato un contatore a 32bit che conta i cicli di clock a partire dallarrivo di un
segnale sul bus FSL.
Infine, come sar spiegato nel paragrafo 5.5, occorre modificare il codice C che
programma il MicroBlaze.
Per permettere la comunicazione tra il MicroBlaze e la periferica a livello software,
innanzitutto bisogna includere nel codice C la libreria fsl.h che mette a disposizione due
istruzioni: putfsl(A,canale) e getfsl(B,canale). Queste istruzioni permettono rispettivamente
40
di inviare un dato A alla periferica e di ricevere un dato B da questultima dopo averne
subito unelaborazione.
Inoltre, il secondo campo delle due istruzioni richiede la specifica del canale scelto per la
trasmissione.
Nel codice C del MicroBlaze utilizziamo listruzione putfsl che manda un segnale alla
periferica affinch inizi a contare i cicli di clock, mentre alla fine del codice, appena prima
del termine dellapplicazione, utilizziamo listruzione getfsl per ottenere il numero di cicli
di clock trascorsi.
Dal momento che la frequenza del sistema di 50MHz, dividendo i colpi di clock contati
per la frequenza di sistema, si ottiene il tempo impiegato per lesecuzione del programma.



(Fig. 5.7) Schema a blocchi della struttura del sistema



Lhardware necessario al nostro progetto dunque configurato; ora bisogna procedere con
limpostazione del software.
Il tool Base System Builder offre la possibilit di scegliere se generare automaticamente
unapplicazione in linguaggio C. Si pu scegliere, ad esempio, lapplicazione di default
test della memoria in modo da verificare il corretto funzionamento della memoria della
nostra FPGA.
41
5.4 Struttura della directory del progetto e principali file
Lambiente di sviluppo Xilinx Platform Studio mediante il Base System Builder (BSB)
crea i file che contengono specifiche hardware e software che definiscono il
processore. Le specifiche hardware del processore (nella tabella System) sono nei file
system.mhs e system.pbd che il BSB crea immediatamente per l`utente.
Il system.mhs un file di testo che descrive la struttura del sistema, mentre il system.pbd
ne mostra una sintesi grafica. Nella directory principale compaiono le seguenti
sottocartelle:
data, contenente il file system.ucf che mostra l`assegnazione dei pin dell`FPGA per i
dispositivi utilizzati.
etc, contenente le impostazioni del sistema per la configurazione JTAG della scheda
utilizzata quando si scarica il file.bit e vengono passati i parametri di default agli strumenti
dell`ISE.
pcores, che in un primo momento vuota, ma in seguito viene utilizzata per le
periferiche dell`utente.
TestApp_Memory, contenente l`applicazione dell`utente in codice C che testa la memoria
del sistema.

5.5 Configurazione del MicroBlaze e del codice
Una volta che il sistema stato generato, nella System Assembly View ci sono tre finestre
a disposizione: Bus Interface , Ports e Addresses. Nella prima possibile osservare e
configurare i bus OPB, On Chip Peripheral Bus, e LMB, Local Memory Bus, che si
interfacciano con le risorse del sistema. Nella seconda si possono impostare ed
eventualmente aggiungere diversi segnali per ciascun elemento presente nel progetto.
Nella terza si possono generare gli indirizzi di memoria per ciascun componente del
sistema.
Nella Project Information Area possibile selezionare tre finestre: Project, IP Catalog e
Applications. Nelle finestra Project sono contenuti i file del progetto, le opzioni di
configurazione per limplementazione e la simulazione, e i reference file.
La finestra IP Catalog consente di aggiungere nuovi elementi al sistema come bus,
periferiche, timer, watchdog, etc.
42
La finestra Applications contiene il file eseguibile, il sorgente ed eventuali file header del
progetto. Il file sorgente contenuto un file di esempio (TestApp_ Memory.c) che pu
essere sostituito con il file del progetto che si intende realizzare.
In questa finestra anche possibile associare il tipo di processore allapplicazione, nel
nostro caso il MicroBlaze.

5.6 Algoritmo del CORDIC modificato
Lalgoritmo del CORDIC modificato utilizzato per il calcolo della SVM su dispositivi
con risorse molto limitate; infatti non occorrono moltiplicatori.
Definiti B
1
=
i
ed E
1
= - || x
i
- x ||
1
si realizzano le seguenti iterazioni:

B
i+1
= B
i
(1 + d
i
2
-i
)
E
i+1
= E
i
log
2
(1 + d
i
2
-i
)

dove la sequenza d
i
= {-1,0} scelta per far convergere E
i
a 0 e se ci avviene B
i
tende a
B
1
2
E1
.
Questo significa che lespressione pu essere calcolata utilizzando solo shift e adder, dal
momento che i valori del logaritmo log
2
(1 + d
i
2
-i
) possono essere calcolati
precedentemente e memorizzati in una Look Up Table.
Per prima cosa viene calcolata E
i+1
e, se risulta negativa, si considera d
i
= -1; quindi B
i+1
varr B
i
- 2
-i
.
Se, invece, E
i+1
positiva, allora d
i
= 0; pertanto, il valore di B
i+1
sar uguale a quello
calcolato nelliterazione precedente : B
i+1
= B
i
.
Affinch sia garantita la convergenza dellalgoritmo al passo i-esimo, necessario ripetere
alcune iterazioni due volte. Le i-esime iterazioni da ripetere sono quelle con i pari al
valore delle potenze di due (cio la seconda, la quarta, lottava). Considerazioni pi
dettagliate sui problemi di convergenza dellalgoritmo verranno trattate nel paragrafo
successivo Considerazioni e problemi di convergenza dellalgoritmo.

5.7 Considerazioni e problemi di convergenza dellalgoritmo
Le condizioni che garantiscono la convergenza dellalgoritmo dopo k passi si verificano se
per E
k+1
che tende a 0, B
k+1
tende a B
1
2
E1
.
(5.1)
(5.2)
43
Inoltre, il raggio di convergenza dellalgoritmo compreso tra 0 e
con k che tende a infinito, il cui valore deve essere di circa 1.79.

I valori del logaritmo che abbiamo calcolato per 15 iterazioni con i che varia da 2 a 17
sono:

Iterazione Valori logaritmo Valori logaritmo
scalati per 2
14
i=2 -0.415037 6800
i=3 -0.192645 3156
i=4 -0.0931094 1525
i=5 -0.0458036 750
i=6 -0.0227200 372
i=7 -0.0113153 185
i=8 -0.00564656 92
i=9 -0.00282051 46
i=10 -0.00140957 23
i=11 -0.000704612 11
i=12 -0.000352263 6
i=13 -0.000176120 3
i=14 -0.000088057 1
i=15 -0.000044028 0
i=16 -0.000011007 0
(Tab. 5.1 ) Valori di |log
2
(1 2
-i
)|

Affinch lalgoritmo converga occorre che i valori iniziali B
1
ed E
1
appartengano
allintervallo [0;1).
Lalgoritmo inizia le iterazioni a partire dallindice i pari a 2 anzich a 1; infatti, E
2
viene
calcolata come differenza tra E
1
e |log
2
(1 2
-1
)|, la quale, dal momento che E
1

costantemente minore di 1, risulter sempre negativa, anche nelle iterazioni successive.
Inoltre, se E
2
negativa, la B
2
viene calcolata come B
1
(1- 2
-1
); quindi B
2
sarebbe pari a
B
1
/2, e questo calcolo comprometterebbe il valore a cui tende la B finale.
44
Per garantire la convergenza necessario che al k-esimo passo si abbia:

dove (j) una serie di k interi appartenenti a [0;1] che determina se un passo verr
ripetuto una seconda volta oppure no.

In ogni caso possibile garantire la convergenza ripetendo le iterazioni con indice pari ad
una potenza di 2.
Per il nostro progetto si visto che sufficiente ripetere le iterazioni 8, 16 e 17 .


5.8 Output dellalgoritmo e considerazioni sulla precisione dei risultati
A questo punto, avendo compilato e trasferito il progetto sulla nostra Spartan-3, attraverso
la porta seriale (utilizzando lHyper Terminal) abbiamo potuto vedere loutput del
programma. Per valutare la precisione dellalgoritmo sul MicroBlaze abbiamo effettuato
delle prove utilizzando diverse basi ed esponenti, ottenendo i seguenti risultati (Tab. 5.2):

Valori
normalizzati
Risultato
Floating Point

Risultato
CORDIC MicroBlaze
con registri a 16 bit 2
14
Confronto tra il
CORDIC MicroBlaze e
risultato Floating Point
0.25 2
- 0.75
0.149 7050 (0.43) 0.28
0.5 2
-0.5
0.354 6265 (0.38) 0.03
0.75 2
-0.75
0.446 11822 (0.72) 0.27
0.7 2
-0.5
0.495 8769 (0.53) 0.03
(Tab. 5.3) Risultati ottenuti realizzando il CORDIC sul MicroBlaze

Dai risultati ottenuti si osserva che, mentre la base iniziale scelta (B
1
) non molto influente
per quanto riguarda la precisione sul dato finale, lesponente iniziale (E
1
) ha un notevole
peso sulla precisione delluscita. In particolare si ha che per E
1
=0.75 lerrore rispetto ad un
45
risultato floating point circa 0.27, mentre per E
1
= 0.5 lerrore di circa 0.03; quindi si
ottengono precisioni migliori per esponenti iniziali pi piccoli.

5.9 Risorse impiegate per la realizzazione del sistema
Per avere delle informazioni sulle risorse impiegate dal sistema occorre nella sezione
Project (Project Options) cambiare il tipo di implementazione da Implement Design in
XPS in Implement Design in ISE; in questo modo nella cartella del progetto verr
creata la cartella projnav che, una volta eseguita limplementazione (Cliccando prima su
Project e dopo su Export to Project Navigator), conterr il file system.ise del progetto.
A questo punto utilizzando il Project Navigator, possibile aprire il nostro progetto
system.ise ed effettuare la sintesi e limplementazione del progetto che comprende le fasi
di Mapping e di Place &Route, in questo modo si ottengono le informazioni sulle risorse
impiegate dal sistema (Design Summary).


(Fig. 5.8) Risorse del sistema impiegate utilizzando una memoria di 8KB

46

(Fig. 5.9) Risorse del sistema impiegate utilizzando una memoria di 16KB

Impiegando una memoria di 32KB il progetto non pu essere generato, in quanto viene a
mancare lo spazio per la rimanente logica del sistema.















47
Capitolo 6


Architettura hardware del CORDIC per il calcolo del
kernel di SVM scritto utilizzando il VHDL strutturale


6.1 Introduzione
Questa architettura hardware (CODIC), che ci apprestiamo ad illustrare, stata scritta
utilizzando il Vhdl strutturale ed stata realizzata da Luca Carlino ed Enrico Musciacchio
per il calcolo del kernel di SVM.
Il sistema, implementato sulla Spartan-IIE, impiega registri a 16 bit usando il formato Qn;
ovvero il primo bit esprime il segno ed i restanti 15 esprimono il valore normalizzato tra 0
e 1 escluso.

6.2 Datapath
Il sistema costituito da vari blocchi principali al cui interno sono presenti moduli pi
semplici. Il progetto del datapath stato scritto utilizzando il VHDL strutturale, il quale
consente la realizzazione di un sistema in modo che il tool di sintesi riesca a mappare
facilmente nellFPGA rispetto ad un analogo sistema scritto in VHDL comportamentale.
La struttura semplificata del sistema senza i blocchi di controllo delle operazioni
rappresentata in figura 6.1.
48

(Fig. 6.1) Architettura semplificata (senza i blocchi di controllo) del sistema

I blocchi di calcolo sono principalmente due: il primo calcola la norma prima, il secondo
(CORDIC) calcola, invece, il prodotto tra il valore della funzione kernel ed i coefficienti
B
i
; questi sono indipendenti e si possono eseguire contemporaneamente.
Per questo motivo sono state usate delle Block RAM interne alla Spartan-IIE in grado di
memorizzare i valori della norma prima e dei coefficienti B
i
ottenuti dal processo di
training SVM.

6.3 Block RAM interne della Spartan-IIE
La Spartan-IIE ha delle memorie interne, configurabili come bus degli indirizzi, e locazioni
dei dati che possono essere di tipo dual port RAM o single port RAM; queste memorie
interne sono comprese nel chip perch, rispetto ad FPGA di fascia pi elevata (come
Spartan-IIIE, Virtex II o Virtex IV), i CLB della Spartan-IIE sono pi semplici ed
elementari e inadatti per le memorie complesse come le dual port RAM con locazioni da
16 o 32 bit.



49
6.4 Blocco di calcolo della norma prima
Per effettuare il calcolo dellequazione tramite il CORDIC, necessario mandare in
ingresso al sistema i valori della norma prima del dato di test calcolata rispetto a tutti i
Support Vector.
Le operazioni sono state semplificate calcolando sia (x y) sia (y x) e utilizzando il
segno dei due risultati per scegliere il risultato giusto di |xy| ad esempio con un
multiplexer.
Per effettuare il calcolo della norma prima:

si pu usare un accumulatore che sommi i risultati dei moduli.
Le prove effettuate con il tool di sviluppo ISE 7.1 della Xilinx, e con il tool di sintesi Xst
ad esso associato hanno evidenziato che, per un numero di bit oltre i 16, le prestazioni di
timing dellaccumulatore degradano considerevolmente limitando la frequenza massima di
clock consentita.
Per ovviare a questo problema laccumulatore stato costruito in modo tale da avere un
unico bit in pi, su cui viene rilevato loverflow sul risultato normalizzato, che viene dato
come operando ad un altro accumulatore con un numero di bit pari a log2 (numero di bit
registri degli operandi-1) .
Ogni volta che si presenta un overflow sul risultato del primo accumulatore (bit di
overflow a 1 ), il secondo accumulatore conta il numero di overflow che si sono
verficati, mentre il risultato del primo accumulatore viene mantenuto normalizzato per il
CORDIC. In questo modo si ottiene il valore normalizzato della norma prima ed un valore
intero che equivale ad una variabile v (numero di shift) moltiplicativa ed aggiuntiva sul
risultato del CORDIC.
Di fatto non si tratta di una moltiplicazione, ma di un semplice shift a destra di v posizioni
del risultato del CORDIC; inoltre se si usano registri a 16 bit non possibile shiftare il
risultato per pi di 15 posizioni (perch un bit il segno) e perci laccumulatore degli
overflow ha solo log
2
(numero di bit registri degli operandi - 1) = log
2
(15) bit in pi.
Lo schema del blocco di calcolo della norma prima rappresentato in figura 6.2.

(6.1)
50

(Tab. 6.2) Blocco di calcolo della norma prima


6.5 Il CORDIC per il calcolo del kernel di SVM
Laspetto principale del sistema il CORDIC che calcola il prodotto tra i termini B
i
ed il
valore del kernel per ogni Support Vector.
Il blocco hardware che implementa il CORDIC in questione pu essere realizzato in vari
modi a seconda di ci che si vuole privilegiare dal punto di vista delle prestazioni, ovvero:
dimensione (CORDIC non srotolato) o velocit (CORDIC srotolato).

6.6 CORDIC non srotolato
Il modo pi semplice per realizzare il CORDIC consiste nel creare un blocco logico che
svolga le operazioni necessarie per la variabile E ed un altro blocco per la variabile B,
rimandando i risultati in ingresso per literazione successiva.
Per la variabile E bisogna eseguire una sottrazione con il valore del logaritmo; quindi
occorre sommare il modulo del logaritmo con un addizionatore.
51
Per svolgere questa operazione sono sufficienti i valori di log
2
(1 2
i
) per i = 2, . . . , 15
dato che la prima iterazione pu essere eliminata, essendo la differenza di log
2
(12
1
) =
log
2
( 1/2 ) uguale a 1.
Tutti i valori dei logaritmi in base 2 sono memorizzati allinterno di una Look-Up-Table
(LUT) avente 14 locazioni.
In figura 6.3. viene illustrato il blocco che calcola la variabile E.
Per calcolare la variabile B bisogna effettuare ad ogni iterazione la seguente operazione:
B
i+1
= B
i
c
i
= B
i
c
i
= B
i
(1 - d
i
2
i
) . Perci si deve sottrarre il valore attuale di B con
questo valore shiftato di un numero pari allindice delliterazione corrente.
Poich occorre shiftare in modo diverso a seconda delliterazione corrente, si usa un
Barrel Shifter, un componente che permette di shiftare lingresso di un certo numero di
bit.
Bisogna sottolineare che, usando un componente di questo tipo, le prestazioni in termini di
timing del sistema diminuiranno in modo considerevole.
In figura 6.4. viene rappresentato lo schema del blocco logico per la variabile B.
In figura 6.5 viene, invece, evidenziata la presenza di un multiplexer; in questo caso il
blocco delle E deve comunicare con il blocco della B se effettuare la sottrazione o meno.


(Fig. 6.3) Blocco per la variabile E
52

(Fig. 6.4) Blocco per la variabile B

Lunione dei due blocchi con laggiunta dei segnali di controllo e dei percorsi di
retroazione costituisce il primo modo in cui stato realizzato il CORDIC (figura 6.5).
Bisogna ricordare che necessaria la presenza di una macchina a stati che mandi in uscita
il risultato corretto dopo le 15 iterazioni e azzeri i valori dei registri interni per le
successive elaborazioni, anche se la retroazione delluscita alliterazione i-esima viene
realizzata con un normale bus, quando viene riportata in ingresso per literazione
(i+1)- esima (vedi lo schema in figura 6.5).


(Fig. 6.5) CORDIC non srotolato per calcolare i termini B
1
2
E1

53
Il CORDIC cos costituito ha il vantaggio di occupare poche slices (la cui grande
maggioranza serve per il Barrel Shifter); tuttavia bisogna aspettare 15 iterazioni per ogni
termine che si vuole calcolare.

6.7 CORDIC srotolato
E possibile modificare il progetto in modo tale che si eviti il percorso di retroazione e ci
sia uno stadio per ogni iterazione (comprese quelle ripetute) in cascata; il CORDIC cos
organizzato si dice srotolato ed ha il vantaggio di eliminare il Barrel Shifter e, se si mette
in ingresso un dato nuovo E e B ad ogni colpo di clock, la pipeline consente di avere, dopo
una latenza iniziale di 18 colpi di clock, un risultato valido ad ogni fronte di salita del
segnale di clock.
Lo schema per il CORDIC srotolato visibile in figura 6.6.
Tuttavia bisogna considerare che il sistema in questione estremamente efficiente ma
occupa un numero molto elevato di slices; si optato comunque per questa
implementazione perch consente di incrementare le prestazioni dellarchitettura in modo
considerevole.
54

(Fig. 6.6) CORDIC srotolato per calcolare i termini B
1
2
E1

55
6.8 Risorse impiegate e prestazioni
I valori di occupazione di slices e LUT, ottenuti con il tool di sintesi Xst della Xilinx, sono
rappresentati nelle tabelle 6.8, 6.9 e 6.10.


(Fig. 6.8) Dati di occupazione dellFPGA per il blocco di calcolo della
norma prima



(Tab. 6.9) Dati di occupazione dellFPGA per il CORDIC non srotolato


56

(Tab. 6.10) Dati di occupazione dellFPGA per il CORDIC srotolato


Le performance di timing ottenute per il CORDIC srotolato sono state:
Minimum period: 8.843ns (Maximum Frequency: 113.084MHz)
Minimum input arrival time before clock: 8.382ns
Maximum output required time after clock: 6.514ns















57
Capitolo 7


Confronto del sistema con limplementazione hardware
del CORDIC per il calcolo del kernel di SVM (Support
Vector Machine)

7.1 Considerazioni sulla precisione ottenuta con le diverse architetture
(Tab. 7.1) Confronto dei valori ottenuti con larchitettura che realizza il CORDIC
impiegando il MicroBlaze e quella realizzata in vhdl strutturale.
Sono stati calcolati gli errori assoluti per ciascuna prova tra i risultati ottenuti con il
CORDIC realizzato sul MicroBlaze e quello realizzato in vhdl strutturale. Da questi
risultati si pu osservare che per una E
1
(esponente iniziale) pari a 0.75 si ha un errore che
va da 0.24 a 0.28, mentre per una E
1
pari a 0.5 si ha un errore sensibilmente inferiore pari a
0.03. Questi errori sono principalmente causati dallutilizzo di dati con il segno nel
progetto con il MicroBlaze; pertanto i valori sono stati scalati per 2
14
anzich 2
15
come nel
progetto con il vhdl strutturale.
Inoltre, si pu notare che, diminuendo il valore dellesponente iniziale, la differenza tra i
due metodi di realizzazione diminuisce notevolmente. Il MicroBlaze quantizza i dati
secondo il metodo di arrotondamento round to nearest se si utilizza lunit floating point,
altrimenti utilizza il metodo di troncamento, lo stesso utilizzato dallarchitettura scritta in
Valori
normalizzati
Risultato
Floating
Point

Risultato CORDIC
MicroBlaze
con registri a 16 bit
2
14
Risultato
CORDIC in
vhdl strutturale
2
15
Confronto tra il
CORDIC
MicroBlaze e
vhdl strutturale
0.25 2
- 0.75
0.149 7050 (0.43) 4873 (0.148) 0.28
0.5 2
- 0.75
0.297 8769 (0.53) 9743 (0.29) 0.24
0.5 2
-0.5
0.354 6265 (0.38) 11588 (0.35) 0.03
0.75 2
-0.75
0.446 11822 (0.72) 14616 (0.45) 0.27
58
vhdl, che senzaltro un metodo meno preciso; tuttavia, come discusso nel paragrafo
dedicato allerrore di quantizzazione, il numero di bit a disposizione per unelaborazione
sono determinanti in termini di precisione sul risultato finale.

7.2 Considerazioni sullutilizzo delle risorse per le diverse architetture
Limplementazione hardware del CORDIC per il calcolo del kernel di SVM realizzata
sulla Spartan-II e le risorse impiegate per il CORDIC sul MicroBlaze sono le seguenti:

CORDIC in vhdl su
Spartan-II
CORDIC (MicroBlaze)
su Spartan-3
Tipologia di logica utilizzata: Risorse usate: Utilizzo: Risorse usate: Utilizzo:
Number of Slice Flip Flops 616 su 6144 10% 844 su 3840 21%
Number of 4 input LUTs 682 su 6144 11% 1142 su 3840 29%
Numbers of occupied Slices 495 su 3072 16% 1056 su 1920 55%
Number of Slices containing
related logic
495 su 495 100% 1056 su 1056 100%
Number of Slices containing
unrelated logic
0 su 37 0% 0 su 1056 0%
Number of bounded IOBs 49 su 142 34% 4 su 173 2%
Number of GCLKs 1 su 4 25% 2 su 8 25%
(Tab. 7.2) Confronto risorse impiegate per le due architetture

7.3 Considerazioni sul tempo di esecuzione del CORDIC
Il numero di cicli di clock necessari per lesecuzione del programma sul MicroBlaze sono
259782, quindi il tempo impiegato 259782 / 50 MHz - 0.0052s = 5.2 ms.
Nel progetto del CORDIC realizzato in vhdl per ottenere loutput occorrono 6.51ns, con
una frequenza di 135.391MHz.




59
Capitolo 8



Conclusioni

Analizzando i risultati ottenuti si pu facilmente notare che il tempo di elaborazione per il
progetto realizzato con il processore MicroBlaze di sei ordini di grandezza maggiore
rispetto a quello realizzato in vhdl; pertanto come gi ci aspettavamo questo sistema risulta
complessivamente svantaggioso nel calcolo della funzione kernel di SVM. Inoltre, si
osserva che la precisione dei risultati ottenuti dipende molto dal valore dellesponente
iniziale che si sceglie per lelaborazione, in particolare pi lesponente piccolo,
migliore la precisione rispetto ad un risultato floating point.
Questa sensibilit al valore dellesponente iniziale dipende principalmente dal numero di
bit utilizzati per la realizzazione.
Per aumentare la precisione si potrebbe aumentare il numero di bit utilizzati per la
rappresentazione dei dati, tuttavia questo andrebbe a discapito della timing performance
poich sarebbe necessario un maggior tempo per lelaborazione.
Larchitettura con il processore ha comunque diversi vantaggi: la semplicit nella
realizzazione, il minor tempo impiegato per la progettazione e limplementazione
dellintera architettura (un minore time-to-market), la possibilit di aumentare la precisione
cambiando semplicemente il tipo di rappresentazione dei dati, la flessibilit per possibili
sviluppi futuri.
Quindi, la scelta di una architettura digitale dipende principalmente dal tipo di applicazione
che si vuole implementare, perci occorre avere una buona conoscenza dellalgoritmo
dellapplicazione per poi decidere se sar adatta ad essere eseguita da un processore o da
unarchitettura digitale scritta appositamente in vhdl.






60
Appendice A

Algoritmo del CORDIC modificato in linguaggio C

1 #include "xparameters.h"
2 #include "stdio.h"
3 #include "xutil.h"
4 #include "fsl.h"
5 //====================================================
6
7 int main (void)
8 {
9 print("-- Inizio main() --\r\n");
10 Xuint32 CE = 1 ;
11 Xuint32 cont;
12 short i, k;
13 short val_log[15] = { 6800,3156, 1525, 750, 372, 185, 92, 46,23,11,6,3,1,0,0};
14 short x=0;
15 short y=0;
16 short x_precedente=8192; //x_precedente = 0.5
17 short y_precedente=11469; //y_precedente = 0.7
18 putfsl(CE,0);
19 for(i=2; i<18; i++)
20 {
21 switch(i)
22 {
23 case 8:
24 for(k=0; k<2; k++)
25 {
26 print("Iterazione per i= 8 o 16 o 17\r\n\n");
27 x=x_precedente - valori_logaritmo[i-2];
61
28 xil_printf("x = %d\r\n\n",x);
29 if(x<0)
30 {
31 y=y_precedente - (y_precedente>>i);
32 xil_printf("y = %d\r\n\n",y);
33 }
34 else
35 {
36 print("Ciclo di iterazioni doppie per i= 8 o 16 o 17 se x>0\r\n\n");
37 y=y_precedente;
38 xil_printf("y = %d\r\n\n",y);
39 }
40 x_precedente=x;
41 y_precedente=y;
42 }
43 break;
44
45 case 16:
46 for(k=0; k<2; k++)
47 {
48 print("Iterazione per i= 8 o 16 o 17\r\n\n");
49 x=x_precedente - valori_logaritmo[i-2];
50 xil_printf("x = %d\r\n\n",x);
51 if(x<0)
52 {
53 y=y_precedente - (y_precedente>>i);
54 xil_printf("y = %d\r\n\n",y);
55 }
55 else
56 {
57 print("Ciclo di iterazioni doppie per i= 8 o 16 o 17 se x>0\r\n\n");
58 y=y_precedente;
62
59 xil_printf("y = %d\r\n\n",y);
60 {
61 x_precedente=x;
62 y_precedente=y;
63 }
64 break;
65 case 17:
66 for(k=0; k<2; k++)
67 {
68 print("Iterazione per i= 8 o 16 o 17\r\n\n");
69 x=x_precedente - valori_logaritmo[i-2];
70 xil_printf("x = %d\r\n\n",x);
71 if(x<0)
72 {
73 y=y_precedente - (y_precedente>>i);
74 xil_printf("y = %d\r\n\n",y);
75 }
76 else
77 {
78 print("Ciclo di iterazioni doppie per i= 8 o 16 o 17 se x>0\r\n\n");
79 y=y_precedente;
80 xil_printf("y = %d\r\n\n",y);
81 }
82 x_precedente=x;
83 y_precedente=y;
84 }
85 break;
86 {
87 print("Ciclo di iterazioni singole per i diverso da 8 o 16 o 17 \r\n\n");
88 x=x_precedente - valori_logaritmo[i-2];
89 xil_printf("x = %d\r\n\n",x);
90 if(x<0)
63
91 {
92 print("Ciclo per i diverso da 8 o 16 o 17 se x<0\r\n\n");
93 y=y_precedente - (y_precedente>>i);
94 xil_printf("y = %d\r\n\n",y);
95 }
96 else
97 {
98 print("Ciclo per i diverso da 8 o 16 o 17 se x>0\r\n\n");
99 y=y_precedente;
100 xil_printf("y = %d\r\n\n",y);
101 }
102 x_precedente=x;
103 y_precedente=y;
104 }
105 getfsl(cont,0);
106 xil_printf ("I cicli di clock trascorsi sono %d\r\n\n",cont);
107 print("-- Fine main() --\r\n\n");
108 return 0;
109 }












64
Commento del codice:
Righe 1-4 : inclusione delle librerie "xparameters.h (libreria per la configurazione del
dispositivo) , "stdio.h"(libreria standard), "xutil.h"(per funzioni di base), "fsl.h" (per le
funzionalit del Fast Simplex Link).
Righe 10-11: dichiarazione di variabili a 32 bit intere:la variabile CE (Abilita il clock della
periferica esterna che conta i cicli di clock impiegati per lesecuzione del codice), la
variabile cont contiene il risultato dellelaborazione della periferica (il numero cicli di
clock trascorsi).
Riga 12: dichiarazione di variabili di tipo short usate per le iterazioni
Riga 13: dichiarazione e inizializzazione di un vettore di 15 elementi di tipo short
contenente i valori calcolati di |log
2
(1 2
-i
)|.
Righe 14-17: inizializzazione delle variabili x e y , x_precedente e y_precedente
Riga 18: listruzione putfsl(CE,0) invia sul bus FSL attraverso il canale 0 il segnale di CE
(Clock Enable della periferica counter) attivando in questo modo il contatore dei cicli si
clock.
Righe 19-104: questo ciclo for parte da i uguale a 2 e termina per i uguale a 17, in questo
modo la struttura switch(i) , allinterno del ciclo for, permette literazione doppia (nei casi
in cui i sia uguale a 8,16 o 17) dei cicli che permettono il calcolo di B 2
-E
.
Righe 26-86: porzione di codice in cui vengono realizzate le iterazioni doppie a seconda
del valore della variabile i.
Righe 87-103: In queste righe di codice vengono realizzati i passi dellalgoritmo
B
i+1
= B
i
(1 + d
i
2
-i
) ed E
i+1
= E
i
log
2
(1 + d
i
2
-i
) allinterno di un ciclo for impostato
in modo tale che le iterazioni dellalgoritmo siano calcolate a partire dalla seconda.
Righe 105-106: Viene ottenuto e stampato il valore dei cicli di clock necessari per
lelaborazione, calcolato con lutilizzo della periferica esterna.






65
Appendice B

Output di una prova effettuata
Caso in cui E
1
= 0.5 e B
1
= 0.5 ovvero 0.5 2
-0.5
.
Il risultato finale ottenuto : y = 6265

-- Inizio main() --
Ciclo di iterazioni singole per i diverso da 8 o 16 o 17
x = 1392
Ciclo per i diverso da 8 o 16 o 17 se x>0
y = 8192
Ciclo di iterazioni singole per i diverso da 8 o 16 o 17
x = -1764
Ciclo per i diverso da 8 o 16 o 17 se x<0
y = 7168
Ciclo di iterazioni singole per i diverso da 8 o 16 o 17
x = -3289
Ciclo per i diverso da 8 o 16 o 17 se x<0
y = 6720
Ciclo di iterazioni singole per i diverso da 8 o 16 o 17
x = -4039
Ciclo per i diverso da 8 o 16 o 17 se x<0
y = 6510
Ciclo di iterazioni singole per i diverso da 8 o 16 o 17
x = -4411
Ciclo per i diverso da 8 o 16 o 17 se x<0
y = 6409
Ciclo di iterazioni singole per i diverso da 8 o 16 o 17
x = -4596
Ciclo per i diverso da 8 o 16 o 17 se x<0
y = 6359
66
Iterazione per i = 8 o 16 o 17
x = -4688
y = 6335
Iterazione per i = 8 o 16 o 17
x = -4780
y = 6311
Ciclo di iterazioni singole per i diverso da 8 o 16 o 17
x = -4872
Ciclo per i diverso da 8 o 16 o 17 se x<0
y = 6287
Ciclo di iterazioni singole per i diverso da 8 o 16 o 17
x = -4918
Ciclo per i diverso da 8 o 16 o 17 se x<0
y = 6275
Ciclo di iterazioni singole per i diverso da 8 o 16 o 17
x = -4941
Ciclo per i diverso da 8 o 16 o 17 se x<0
y = 6269
Ciclo di iterazioni singole per i diverso da 8 o 16 o 17
x = -4952
Ciclo per i diverso da 8 o 16 o 17 se x<0
y = 6266
Ciclo di iterazioni singole per i diverso da 8 o 16 o 17
x = -4958
Ciclo per i diverso da 8 o 16 o 17 se x<0
y = 6265
Ciclo di iterazioni singole per i diverso da 8 o 16 o 17
x = -4961
Ciclo per i diverso da 8 o 16
y = 6265
Ciclo di iterazioni singole per i diverso da 8 o 16 o 17
x = -4962
67
Ciclo per i diverso da 8 o 16 o 17 se x<0
y = 6265
Ciclo di iterazioni singole per i diverso da 8 o 16 o 17
x = -4962
Ciclo per i diverso da 8 o 16 o 17 se x<0
y = 6265
Iterazione per i = 8 o 16 o 17
x = -4962
y = 6265
Iterazione per i = 8 o 16 o 17
x = -4962
y = 6265
Ciclo di iterazioni singole per i diverso da 8 o 16 o 17
x = -4962
Ciclo per i diverso da 8 o 16 o 17 se x<0
y = 6265
Iterazione per i = 8 o 16 o 17
x = -4962
y = 6265
Iterazione per i = 8 o 16 o 17
x = -4962
y = 6265
Ciclo di iterazioni singole per i diverso da 8 o 16 o 17
x = -4962
Ciclo per i diverso da 8 o 16 o 17 se x<0
y = 6265
------------------------------------------------
I cicli di clock trascorsi sono 259782
Fine main()



68
Appendice C

Codice vhdl per la periferica contatore dei cicli di clock

------------------------------------------------------------------------------
-- contatore - entity/architecture pair
------------------------------------------------------------------------------
------------------------------------------------------------------------------
-- Filename: contatore
-- Version: 1.00.a
-- Description: Example FSL core (VHDL).
-- Date: Fri Feb 29 10:52:19 2008 (by Create and Import Peripheral Wizard)
-- VHDL Standard: VHDL'93
------------------------------------------------------------------------------
------------------------------------------------------------------------------
-- Naming Conventions:
-- active low signals: "*_n"
-- clock signals: "clk", "clk_div#", "clk_#x"
-- reset signals: "rst", "rst_n"
-- generics: "C_*"
-- user defined types: "*_TYPE"
-- state machine next state: "*_ns"
-- state machine current state : "*_cs"
-- combinatorial signals: "*_com"
-- pipelined or register delay signals: "*_d#"
-- counter signals: "*cnt*"
-- clock enable signals: "*_ce"
-- internal version of output port: "*_i"
-- device pins: "*_pin"
-- ports: "- Names begin with Uppercase"
-- processes: "*_PROCESS"
-- component instantiations: "<ENTITY_>I_<#|FUNC>"
------------------------------------------------------------------------------
69
------------------------------------------------------------------------------
library ieee;
use ieee.std_logic_1164.all;
use ieee.numeric_std.all;
-------------------------------------------------------------------------------------
-- Definition of Ports
-- FSL_Clk : Synchronous clock
-- FSL_Rst : System reset, should always come from FSL bus
-- FSL_S_Clk : Slave asynchronous clock
-- FSL_S_Read : Read signal, requiring next available input to be read
-- FSL_S_Data : Input data
-- FSL_S_CONTROL : Control Bit, indicating the input data are control word
-- FSL_S_Exists : Data Exist Bit, indicating data exist in the input FSL bus
-- FSL_M_Clk : Master asynchronous clock
-- FSL_M_Write : Write signal, enabling writing to output FSL bus
-- FSL_M_Data : Output data
-- FSL_M_Control : Control Bit, indicating the output data are contol word
-- FSL_M_Full : Full Bit, indicating output FSL bus is full
--
------------------------------------------------------------------------------
-- Entity Section
------------------------------------------------------------------------------

entity contatore is
port
(

-- Bus protocol ports, do not add or delete.
FSL_Clk : in std_logic;
FSL_Rst : in std_logic;
FSL_S_Clk : out std_logic;
FSL_S_Read : out std_logic;
70
FSL_S_Data : in std_logic_vector(0 to 31);
FSL_S_Control: in std_logic;
FSL_S_Exists : in std_logic;
FSL_M_Clk : out std_logic;
FSL_M_Write : out std_logic;
FSL_M_Data : out std_logic_vector(0 to 31);
FSL_M_Control: out std_logic;
FSL_M_Full : in std_logic

);

attribute SIGIS : string;
attribute SIGIS of FSL_Clk : signal is "Clk";
attribute SIGIS of FSL_S_Clk : signal is "Clk";
attribute SIGIS of FSL_M_Clk : signal is "Clk";

end contatore;

------------------------------------------------------------------------------
-- Architecture Section
------------------------------------------------------------------------------

architecture EXAMPLE of contatore is

-- Total number of input data.
constant NUMBER_OF_INPUT_WORDS : natural := 1;

-- Total number of output data
constant NUMBER_OF_OUTPUT_WORDS : natural := 1;

type STATE_TYPE is (Idle, Read_Inputs, Write_Outputs);

71
signal state : STATE_TYPE;

-- Counters to store the number inputs read & outputs written
signal nr_of_reads : natural range 0 to NUMBER_OF_INPUT_WORDS - 1;
signal nr_of_writes : natural range 0 to NUMBER_OF_OUTPUT_WORDS - 1;

-- Segnali per il contatore
signal cont : std_logic_vector(31 downto 0) ;
signal CE : std_logic := '0';


begin
FSL_S_Read <= FSL_S_Exists when state = Read_Inputs else '0';
FSL_M_Write <= not FSL_M_Full when state = Write_Outputs else '0';
FSL_M_Data <= cont;


The_SW_accelerator : process (FSL_Clk) is
begin -- process The_SW_accelerator
if FSL_Clk'event and FSL_Clk = '1' then -- Rising clock edge
if FSL_Rst = '1' then -- Synchronous reset (active high)
-- CAUTION: make sure your reset polarity is consistent with the
-- system reset polarity
state <= Idle;
nr_of_reads <= 0;
nr_of_writes <= 0;

else
case state is
when Idle =>
if (FSL_S_Exists = '1') then
state <= Read_Inputs;
72
nr_of_reads <= NUMBER_OF_INPUT_WORDS - 1;

end if;
when Read_Inputs =>
if (FSL_S_Exists = '1') then
CE <= '1';
if (nr_of_reads = 0) then
state <= Write_Outputs;
nr_of_writes <= NUMBER_OF_OUTPUT_WORDS - 1;
else
nr_of_reads <= nr_of_reads - 1;
end if;
end if;

when Write_Outputs =>
if (nr_of_writes = 0) then
state <= Idle;

else
if (FSL_M_Full = '0') then
nr_of_writes <= nr_of_writes - 1;
end if;
end if;
end case;
end if;
end if;
end process The_SW_accelerator;





73
-- Processo contatore di cicli di clock di sistema

process (FSL_Clk)
begin
if (FSL_Clk='1' and FSL_Clk'event) then
cont <= std_logic_vector(unsigned(cont) + 1);
end if;
end process;

end architecture EXAMPLE;






















74
Appendice D

Glossario

ALU Arithmetic Logic Unit
BP Back Propagation
BRAM Block Ram
BSB Base System Builder
BTR Branch Target Register
CLB Configurable Logic Block
CORDIC COordinate Rotation Digital Computer
DCM Digital Clock Manager Block
DCT Discrete Cosine Transform
DFT Discrete Fourier Transform
EAR Exception Status Register
EDK Embedded Development Kit
EDR Exception Data Register
EX Execute
FIFO First In First Out
FPGA Field Programmable Gate Array
FPU Floating Point Unit
FSL Fast Simplex Link
FSR Floating Point Status Register
IF Instruction Fetch
IOB Input/Output Block
IP Intellectual Property
JTAG Joint Test Acton Group
LMB Local Memory Bus
LUT Look Up Table
MEM Memory
MMU Memory Management Unit
MSR Machine Status Register
75
OCR Optical Character Recognition
OF Operand Fetch
OPB On chip Peripheral Bus
PC Program Counter
PID Process Identifier Register
PLB Processor Local Bus
PVR Process Version Register
QP Quadratic Programming
RAM Random Access Memory
RBF Radial Basis Function
RISC Reduced Instruction Set Computer
SDA Small Data Area
SV Support Vector
SVM Support Vector Machine
TLBHI Translation Look-Aside Buffer High Register
TLBX Translation Look-Aside Buffer Index Register
UART Universal Asynchronous Receiver-Transmitter
UTLB Unified Translation Look-Aside Buffer
VHDL VHSIC (Very High Speed Integrated Circuit Hardware Description
Language)
WB Write Back
XCL Xilinx Cache Link
XPS Xilinx Platform Studio
ZPR Zone Protection Register






76
Bibliografia

[1] Ray Andraka. A survey of CORDIC algorithms for FPGA based computers. Andraka
Consulting Group.

[2] Xilinx Corporation. MicroBlaze Processor Reference Guide Embedded Development
Kit EDK 9.1i http://www.xilinx.com.

[3] Xilinx Corporation. MicroBlaze Tutorial Creating a Simple Embedded System and
Adding Custom Peripherals Using Xilinx EDK Software http://www.xilinx.com.

[4] Product Specification Fast Simplex Link (FSL) Bus (v2.00a) http://www.xilinx.com

[5] Xilinx Corporation. Application note (May 12,2004): Connecting Customized IP to the
MicroBlaze Soft Processor Using the Fast Simplex Link (FSL) Channel Author: Hans-
Peter Rosinger http://www.xilinx.com

[6] Faisal M. Khan, Mark G. Arnold and William M. Pottenger: Finite Precision Analysis
of Support Vector Machine Classification in Logarithmic Number Systems.

[7] Luca Carlino, Enrico Musciacchio: Progetto e realizzazione su dispositivi
programmabili (FPGA) di architetture digitali per lelaborazione di segnali

[8] Xilinx Corporation. Using Block SelectRAM e Memory in Spartan-II FPGAs. Xilinx
Application Notes, Dicembre 2000.