Introduction sur les FPGAs (Field Programmable Gate Array)
1. Présentation des FPGAs:
Les FPGA sont des composants logiques reconfigurables de haute densité qui permettent
de réaliser des fonctions logiques, des calculs, et des traitements complexes. En effet, la
structure régulière des FPGAs (figure 1) intègre des éléments très performants.
Il existe plusieurs types de FPGA (les SRAM-based FPGA, les Flash-based FPGA et les
Antifuse-based FPGAs), classés en fonction de la manière dont ils sont programmés. La
majorité des FPGAs utilisent des mémoires statiques et sont appelés SRAM-based FPGA.
La configuration des FPGAs est chargée dans une mémoire statique. La cellule a besoin
d'être activée pour pouvoir charger la configuration. Ce type de mémoire peut être
configuré via une source externe comme une mémoire Flash ou via un processeur. Les
FPGAs du commerce fabriqués par Xilinx et Altera utilisent ce type de configuration. Les
Flash-based FPGAs quant à eux ne sont pas équipés de mémoire statique et gardent leur
configuration même quand ils ne sont pas alimentés. Le principal avantage de cette
technologie est qu'elle consomme moins et est aussi tolérante aux radiations, c'est pourquoi
elle est principalement utilisée dans le domaine médical. Enfin, les Antifuse-based FPGAs
sont composés d'une série de fusibles et sont principalement utilisés dans le domaine
spatial. Ces fusibles sont brûlés lors de la configuration du FPGA. Il n'est donc pas possible de
le reprogrammer. Cependant, tout comme les Flash-based FPGA, ils consomment moins que
ceux équipés d'une mémoire statique (SRAM-based).
Figure 1 : Architecture interne simplifiée d’un FPGA
Les principaux éléments composant les FPGAs sont :
- Les CLBs (Configurable Logic Block) : Les CLBs constituent le cœur des FPGAs. Ce sont
des cellules constituées d’éléments logiques programmables où l’on trouve des
bascules, des LUTs (Look-Up Table), des multiplexeurs et des portes logiques
disposées sous forme matricielle. Chaque cellule est identique aux autres et peut être
reliée à ses voisins par le biais de bus d’interconnexion. Ces cellules peuvent être
utilisées pour créer des fonctions logiques complexes mais aussi comme éléments de
stockage de variables. Au cours du temps et grâce à l’évolution de la technologie,
l’architecture de ces cellules a évolué en complexité. Par ailleurs, les FPGAs intègrent
de plus en plus de cellules sur une même surface.
- Les IOBs (Input Output Block) : Ces cellules d’entrées-sorties permettent d’interfacer
le circuit FPGA avec l’environnement extérieur.
- Les ressources d’interconnexion des cellules : Pour pouvoir réaliser des fonctions
complexes à partir des fonctions de base que représentent les CLBs, il est nécessaire
de disposer de ressources d’interconnexion entre ces différentes cellules. Ce sont des
bus qui remplissent cette fonction.
Depuis quelques décennies, les fabricants des FPGAs ont ajouté aux ressources classiques de
nombreux éléments tels que :
- Les blocs mémoire : Les FPGAs classiques peuvent se comporter comme un espace
de stockage de variables ; cet espace de stockage est réparti dans tout le circuit
FPGA. Ce mode de stockage est tout de même limité en termes d’espace disponible.
C’est pourquoi, pour pouvoir stocker une somme plus importante de variables sans
avoir à accéder à des mémoires externes, certains fabricants ont introduit des blocs
mémoire à l’intérieur des FPGAs (SRAM, FLASH, EEPROM, etc.).
- Les multiplieurs : La logique présente dans les FPGAs permet de réaliser toutes
sortes d’opérations arithmétiques (additions, multiplications, etc.). Ces opérations, et
en particulier les multiplications sont très coûteuses en termes de ressources
logiques utilisées, d’où l’intérêt de disposer dans les FPGAs de multiplieurs câblés
(plus d’une centaine sont en général disponibles sur les modèles haut de gamme). De
plus, le temps de calcul pour ces opérations est alors optimisé.
- Les blocs processeur : Il est maintenant possible d’intégrer des algorithmes
complexes sur une seule puce. Certains FPGAs disposent aujourd’hui de cœurs de
processeurs. Au début des années 2000, plusieurs fabricants proposent des cœurs de
processeurs matériels au sein des FPGA (cœur Power PC pour Xilinx, cœur ARM pour
Altera, etc.).
2. Architecture interne des LUTs (Look Up Table):
Il s'agit d'une structure de données stockée en mémoire (figure 2), employée pour
remplacer une ou plusieurs fonctions logiques (figure 3) par une opération plus simple de
consultation d’une mémoire. Le gain de vitesse peut être significatif, car rechercher une
valeur en mémoire est souvent plus rapide qu'effectuer un calcul important.
(a) (b)
Figure 2 : Architecture interne simplifiée d’un LUT à 2 entrées :
(a) architecture utilisant un seul multiplexeur 4 :1
(b) architecture utilisant plusieurs multiplexeurs 2 :1
La figure 3 montre l’équivalent de la porte logique XOR à deux entrées implémentée par
un LUT2 (LUT à 2 entrées) :
Figure 3 : configuration d’un LUT2 pour réaliser la fonction logique XOR à 2 entrées
Exercice 1 :
Soit la table de vérité de la fonction S = F (A, B, C, D) suivante :
Entrées Sortie
A B C D S
0 0 0 0 0
0 0 0 1 0
0 0 1 0 0
0 0 1 1 1
0 1 0 0 0
0 1 0 1 1
0 1 1 0 1
0 1 1 1 0
1 0 0 0 0
1 0 0 1 1
1 0 1 0 1
1 0 1 1 0
1 1 0 0 1
1 1 0 1 0
1 1 1 0 0
1 1 1 1 0
1. Utilisez un LUT à 4 entrées (LUT4) pour réaliser la fonction S dans les deux cas
suivants :
- LUT4 composé d’un seul multiplexeur 16:1 et d’une mémoire.
- LUT4 composé de plusieurs multiplexeurs 2:1 et d’une mémoire.
2. Utilisez deux LUTs à 3 entrées (LUT3) et un multiplexeur 2:1 pour réaliser la fonction
S dans les deux cas suivants :
- Chaque LUT3 est composé d’un seul multiplexeur 8:1 et d’une mémoire.
- Chaque LUT3 est composé de plusieurs multiplexeurs 2:1 et d’une mémoire.
Réponse :
0 0
1 0 D C B A
0
2
1
0
1
1
MUX 16:1
S
0
0
1 S
1
0
1
0
0
15 0
D
C
B
A
Question 1 – Cas 1 Question 1 – Cas 2
0
LUT3 N°1
0
0 D C B A
MUX 8:1
1 S0
0
1
1
0
D C B MUX 2:1 S
0
1
1
MUX 8:1
0 S1
1
0
0
0 LUT3 N°2
Question 2 – Cas 1 Question 2 – Cas 2
Exercice 2 :
Soit la fonction logique suivante : S = A.B.C.D + E.F.G.H + I.J.K.L + M.N
1. Réalisez la fonction S en utilisant des portes logiques à 2 entrées.
2. Utilisez des LUT4 et des LUT5 pour réaliser la fonction S (chaque LUT4 est composé
d’un multiplexeur 16:1 et chaque LUT5 est composé d’un multiplexeur 32:1).
Réponse :
LUT4 N°1 LUT5 N°1
A
B
F1
C
D
E
LUT4 N°2 F
G F2
H
S
I
J
LUT4 N°3 F3
K
L
M
N
LUT4 N°1 Table de vérité du LUT4 N°1
0 0
1 0
Entrées Sortie
0
2 A B C D F1
0 0 0 0 0 0
0 0 0 0 1 0
0 0 1 0 0
0 0 0 1 1 0
0 0 1 0 0 0
MUX 16:1
F1 0 1 0 1 0
0 0 1 1 0 0
0 0 1 1 1 0
1 0 0 0 0
0 1 0 0 1 0
0 1 0 1 0 0
1 0 1 1 0
0
1 1 0 0 0
0 1 1 0 1 0
1 1 1 0 0
0
1 1 1 1 1
0
15 1
D
C
B
A
LUT4 N°2 Table de vérité du LUT4 N°2
0 0
0 Entrées Sortie
1
0 E F G H F2
2
0 0 0 0 0
0
0 0 0 1 0
0 0 0 1 0 0
0 0 1 1 0
0
0 1 0 0 0
0 0 1 0 1 0
MUX 16:1
F2 0 1 1 0 0
0
0 1 1 1 0
0 1 0 0 0 0
1 0 0 1 0
0
1 0 1 0 0
0 1 0 1 1 0
0 1 1 0 0 0
1 1 0 1 0
0 1 1 1 0 0
0 1 1 1 1 1
15 1
H
G
F
E
LUT4 N°3 Table de vérité du LUT4 N°3
0 0
1 0
Entrées Sortie
0
2 I J K L F3
0 0 0 0 0 0
0 0 0 0 1 0
0 0 1 0 0
0 0 0 1 1 0
0 0 1 0 0 0
MUX 16:1
F3 0 1 0 1 0
0 0 1 1 0 0
0 0 1 1 1 0
1 0 0 0 0
0 1 0 0 1 0
0 1 0 1 0 0
1 0 1 1 0
0
1 1 0 0 0
0 1 1 0 1 0
1 1 1 0 0
0
1 1 1 1 1
0
15 1
L
K
J
I
LUT5 N°1 Table de vérité du LUT5 N°1
0 0
1 0
0 Entrées Sortie
2
1 F1 F2 F3 M N S
1
0 0 0 0 0 0
1
0 0 0 0 1 0
1
0 0 0 1 0 0
1
0 0 0 1 1 1
1
0 0 1 0 0 1
1
0 0 1 0 1 1
1
0 0 1 1 0 1
1
0 0 1 1 1 1
1
0 1 0 0 0 1
1
0 1 0 0 1 1
1 S 0 1 0 1 0 1
MUX 32:1
1
0 1 0 1 1 1
1
0 1 1 0 0 1
1
0 1 1 0 1 1
1
0 1 1 1 0 1
1
0 1 1 1 1 1
1
1 0 0 0 0 1
1
1 0 0 0 1 1
1
1 0 0 1 0 1
1
1 0 0 1 1 1
1
1 0 1 0 0 1
1
1 0 1 0 1 1
1
1 0 1 1 0 1
1
1 0 1 1 1 1
1
1 1 0 0 0 1
1
1 1 0 0 1 1
1
1 1 0 1 0 1
31 1
1 1 0 1 1 1
1 1 1 0 0 1
1 1 1 0 1 1
N 1 1 1 1 0 1
1 1 1 1 1 1
M
F3
F2
F1