Quel type de codage dois-je utiliser ? Exemples d'applications FPGA

Suivez trois expériences qui montrent le processus de détermination du type de codage adapté à un FPGA donné.

Quel type d'encodage dois-je utiliser pour mon FPGA ? Comme je l'ai expliqué dans l'article précédent, un compilateur décidera généralement cela pour vous et je vous recommande de suivre ce que le compilateur décide.

Il est cependant important de comprendre les différences entre les types d'encodage et pourquoi un compilateur peut arriver à une certaine conclusion. Dans cet esprit, cet article vous guidera à travers une expérience qui montre un exemple d'application FPGA et explique, étape par étape, quel type d'encodage est le meilleur.

Jusqu'à présent dans cette série, nous avons expliqué comment créer une machine à états finis (FSM) avec Verilog, l'état initial et comment la mémoire affecte l'encodage FPGA, et une vue d'ensemble de haut niveau comparant l'encodage binaire vs one-hot vs Gray .

Le système en cours de test

Pour cette expérience, j'ai voulu instancier une machine à états un grand nombre de fois pour amplifier les différences dans le matériel résultant lorsque des encodages binaires, Gray et one-hot sont utilisés.

Le système que j'ai finalement choisi est le jeu de la vie de Conway, un automate cellulaire qui simule le comportement des cellules vivantes dans leur environnement, qui est un réseau 2D rectangulaire de cellules. Le jeu de la vie de Conway est une simulation de la naissance, de la reproduction et de la mort de ces cellules, selon un ensemble simple de règles que chaque cellule suit pour déterminer ce qui se passe au cycle suivant. Chaque cellule vivante peut survivre ou mourir, et chaque cellule morte peut rester morte ou devenir vivante. Voici les règles pour chaque cycle :

1. Les cellules vivantes avec deux ou trois voisins vivants survivent.
2. Les cellules mortes avec trois voisins vivants prennent vie.
3. Toutes les autres cellules meurent ou restent mortes.

Ces règles créent de nombreux comportements et modèles intéressants qui ont été largement étudiés en informatique.

Voici à quoi ressemble le jeu de la vie de Conway lors de l'utilisation de ce qu'on appelle le pistolet planeur d'un seul Gosper.

Une variante du jeu de la vie de Conway, connue sous le nom de Glider Gun de Bill Gosper. Gif créé par Lucas Vieira [CC BY-SA 3.0]

Code Verilog

Pour en revenir à notre système de test, chaque cellule a été conçue comme une machine à états à huit états. Certes, la logique d'une cellule dans Game of Life de Conway peut être résolue en un cycle, mais j'ai décidé de créer une machine à 8 états pour avoir une différence notable lors de l'utilisation de différents encodages. Les états sont utilisés pour compter les voisins vivants d'une cellule.

Le morceau de code Verilog suivant montre la structure du module de cellule pour ces machines, y compris l'encodage binaire d'origine des états.

`define STATE_0 3'b000

`define STATE_1 3'b001

`define STATE_2 3'b010

`define STATE_3 3'b011

`define STATE_4 3'b100

`define STATE_5 3'b101

`define STATE_6 3'b110

`define STATE_7 3'b111

module LifeCell(

clé d'entrée,

entrée en premier,

valeur d'entrée,

saisissez [7:0] voisins,

sortie reg en vie);

reg [2:0] état ;

toujours @ (posedge clk)

si (nrst ==0)

état <=`STATE_0;

autre

cas(état)

`STATE_0 : commencer

// ...

état <=`STATE_1;

fin

`STATE_1 : commencer

// ...

état <=`STATE_2;

fin

// ...

`STATE_7 : commencer

// ...

état <=`STATE_1;

fin

extrémité

endmodule

Si vous souhaitez examiner le code de plus près, n'hésitez pas à consulter le projet sur GitHub.

Implémentations d'encodage FPGA

Le système a été synthétisé et implémenté comme un monde de 23x23 cellules, dans un total de 27 variantes :trois FSM différents ont été utilisés, tous avec les trois encodages mentionnés ci-dessus, le tout sur trois FPGA cibles différents.

FSM #1 :Modèle d'origine

Cette machine a un état initial qui s'exécute une fois, puis s'exécute dans un cycle à travers les sept états restants. Il s'agit d'une séquence presque complète, donc l'encodage Gray m'a semblé prometteur au début.

FSM #2 :Une séquence

Cette machine se comporte comme un compteur 3 bits, donc je m'attendais également à ce que l'encodage Gray écrase la concurrence.

FSM #3 :Un enchevêtrement arbitraire

Cette machine a le même chemin critique que FSM #1, mais elle passe par un chemin arbitraire lorsque le nombre de voisins vivants est connu pour dépasser 3.

Pour ce comportement de transition d'état arbitraire, je m'attendais à ce que l'encodage one-hot soit le meilleur choix.

Architecture cible

Le système a été mis en œuvre pour trois FPGA cibles, à l'aide de l'outil de développement de leur fournisseur :

• Suite Xilinx Vivado, pour un FPGA Artix 7
• Intel Quartus Prime, pour un FPGA Cyclone V
• Lattice Diamond, pour un FPGA LatticeXP2

Comparaison des résultats

Comparer les performances de deux systèmes ou plus est difficile, principalement parce que le verdict dépend des métriques que nous utilisons et des aspects que nous considérons comme plus importants que d'autres. Pour cette expérience, j'ai rassemblé les données suivantes pour produire un score pour chaque implémentation :

• Nombre d'unités logiques. Ce sont des LUT (look up tables) pour les FPGA Xilinx et Lattice, ou des ALM pour les FPGA Intel. Note :1 point.
• Nombre de registres. Note :1 point.
• Fréquence maximale estimée. Note :2 points.
• Puissance estimée sur puce. Note :2 points.

Pour chaque implémentation, ces quatre aspects ont été comparés entre les trois encodages, donc parmi les encodages, j'ai obtenu un meilleur, un pire et un résultat moyen :le meilleur obtient son score positif, le pire obtient son score négatif et celui du milieu obtient 0.

Après avoir additionné tous les scores pour chaque modèle, j'ai obtenu les résultats suivants :

Tableau des résultats pour les 27 implémentations. Dans chaque ligne, le meilleur encodage est indiqué en vert, le pire en rouge et le milieu en jaune s'il n'y a pas d'égalité.

Cela semble suggérer de rester à l'écart de l'encodage à chaud, avec seulement deux cas où il gagne, dont l'un est une égalité. De plus, alors que je m'attendais à l'origine à ce que one-hot soit le meilleur encodage pour le modèle FSM n°3, il s'est avéré être son pire encodage, aucun outil de développement ne le recommandant. Cela dit, il y a des cas où one-hot bat les autres, principalement dans les métriques de fréquence et de puissance.

Dans l'ensemble, l'encodage Gray semble être le meilleur choix pour ce système particulier.

En extrayant les gagnants de ce tableau, nous obtenons ce qui suit :

Le verdict

Même si cette comparaison semble favoriser l'encodage Gray par rapport au binaire et au one-hot, les résultats dépendent fortement des métriques que nous utilisons, et ces métriques reflètent ce qui est important pour nous. Par exemple, dans cette comparaison, j'ai considéré la fréquence et la puissance plus importantes que l'utilisation (le nombre d'éléments logiques et de registres dans la conception.) Si j'avais évalué l'utilisation sur la fréquence et la fréquence sur la puissance, un classement différent aurait certainement eu lieu. /P>

Cette comparaison n'était pas destinée à être un travail définitif sur les performances obtenues en utilisant ces encodages. Au lieu de cela, il montre le classement produit par mes préférences personnelles dans les architectures que j'ai utilisées.

Encore une fois, si vous souhaitez jeter un œil au code, découvrir les 27 implémentations ou voir ma simulation de Game of Life de Conway en action, consultez le projet sur GitHub.