Dans le monde du calcul, les FPGA et les SoC programmables sont une classe d'appareils distincts des unités CPU, MCU, DSP et GPU. Les FPGA fournissent aux développeurs des implantations qui offrent un débit accru, une latence réduite et un déterminisme plus important.
Dans le monde du calcul, les FPGA et les SoC programmables sont une classe d'appareils distincts des unités CPU, MCU, DSP et GPU. Les FPGA fournissent aux développeurs des implantations qui offrent un débit accru, une latence réduite et un déterminisme plus important.
Les FPGA et les SoC programmables contiennent tous les deux des cellules logiques programmables comme des tableaux de référence, des registres et de la RAM en bloc. Lorsqu'un développeur crée une solution logique programmable, il définit la configuration et les connexions de ces cellules logiques.
Comme le développeur décrit la configuration des cellules logiques plutôt que la séquence des instructions d'exécution, il en résulte un flux de développement sensiblement différent. Cette différence présente également de nouveaux défis pour les développeurs, notamment :
– Vérification — Comment le concepteur procède-t-il au contrôle et au débogage des fonctionnalités ?
– Affectation des ressources — L'appareil contient-il suffisamment de ressources logiques pour exécuter la conception ?
– Respect des contraintes temporelles — Les cellules logiques utilisées peuvent-elles être connectées en fonction des besoins tout en conservant la fréquence de fonctionnement souhaitée ?
– Dissipation de puissance — La dissipation d'énergie de la conception finale est-elle acceptable pour son alimentation électrique et son environnement thermique ?
Capture de conception
Depuis son introduction en 1984, la façon dont les conceptions logiques programmables sont capturées a considérablement changé. Ces progrès ont permis de passer de la définition d'équations logiques pour chaque cellule logique à la capture schématique des circuits logiques, à l'utilisation des langages de description du matériel et, plus récemment, à la synthèse de haut niveau.
Bien sûr, l'un des principaux facteurs à l'origine de l'augmentation du niveau d'abstraction utilisé pour programmer les appareils a été l'augmentation de leurs performances et de leurs capacités.
La plupart des conceptions modernes sont capturées à l'aide d'un langage de description de matériel (HDL) tels que Verilog ou VHDL. Les deux langages permettent au développeur de décrire la fonctionnalité souhaitée à implémenter au niveau du transfert de registre (NTR). Définir une conception NTR signifie que le développeur décrit une conception logique synchrone et le transfert d'informations entre les registres (par exemple les automates et les compteurs.)
Bien que les langages HDL contiennent les structures que l'on pourrait attendre d'un langage de programmation (par exemple travailler avec des fichiers), seul un sous-ensemble limité du langage peut être utilisé pour créer une solution logique programmable. Les autres structures sont utilisées lors de la vérification de la conception.
Cependant, de plus en plus de développeurs de solutions de logique programmable utilisent des langages de niveau plus élevé comme C, C++, OpenCL et Matlab/Simulink pour capturer la conception. Ces langages sont utilisés conjointement avec un outil de synthèse de haut niveau, par exemple Vivado HLx ou HLS Compiler d'Intel, qui est chargé de convertir le langage de haut niveau en une description VHDL ou Verilog. Cette description HDL est ensuite implémentée en utilisant le flux de développement FPGA standard.
Comme pour tous les autres développements, qu'il s'agisse d'un langage HDL ou d'un langage de haut niveau, il est judicieux d'utiliser une approche modulaire, qui permet une compréhension et une réutilisation simplifiées en fonction de vos besoins.
Banc d'essai
À mesure du développement de chaque module HDL ou HLS, il faudra procéder à des tests pour s'assurer que la fonctionnalité se comporte comme prévu. C'est là qu'intervient le banc d'essai. Le banc d'essai va appliquer un stimulus aux entrées et au moniteur du module. Dans les cas les plus complexes, il rendra compte du comportement des signaux de sortie. Comme nous simulons les transactions pour chaque registre de la conception, les simulations logiques peuvent être beaucoup plus lentes.
Bien que théoriquement similaire à un harnais de test logiciel, le banc d'essai peut nécessiter une interaction plus détaillée, car chaque signal et chaque bus doivent être correctement pilotés et synchronisés pour stimuler le module. C'est à l'intérieur du banc d'essai que les structures plus larges du langage sont utilisées, lorsque les paramètres de stimulus sont lus ou que les résultats sont enregistrés dans des fichiers texte.
L'un des éléments clés de la simulation est le test des cas pathologiques et les conditions aux limites, susceptibles de provoquer le dysfonctionnement du module.
Pour appliquer le banc d'essai sur l'unité testée, un simulateur HDL comme Vivado Simulator (fourni avec Vivado HLx) est nécessaire, car cela permet aux développeurs de simuler la conception logique.
Il est courant de simuler la conception avant sa mise en œuvre dans l'instrument. Toutefois, cela signifie que les résultats de la simulation ne tiennent pas compte des retards de synchronisation qui se produisent dans le dispositif mis en œuvre (p. ex. les temps de configuration et de maintien). En tant que tel, il simule uniquement les performances fonctionnelles. Bien que les simulations puissent être rétro-annotées avec ces informations une fois la conception mise en œuvre, le temps d'exécution des simulations s'en trouve considérablement augmenté.
Implémentation
Une fois que le développeur est satisfait de la performance fonctionnelle de la conception, l'étape finale du développement est la mise en œuvre.
La mise en œuvre peut être divisée en quatre étapes distinctes : synthèse, placement, routage et génération de fichiers de programmation. Bien que la mise en œuvre se fasse en plusieurs étapes, elles sont toutes réalisées à l'aide d'un outil propriétaire fourni par le fournisseur du périphérique sélectionné, par exemple Intel Quartus ou Xilinx Vivado.
La synthèse résume les fichiers HDL en une description des circuits logiques à implémenter. Ainsi, la synthèse détermine les paramètres des cellules logiques configurables, des registres et des blocs de RAM et d'autres ressources logiques dédiées disponibles dans l'appareil cible. C'est au cours de l'étape de synthèse que la plupart des optimisations logiques auront lieu, et que l'ajustement des signaux et des variables inutilisés sera effectué. Cela peut entraîner des optimisations ou des décisions de synthèse indésirables. Ainsi, le développeur peut contrôler les options de synthèse, les stratégies et les optimisations à l'aide de contraintes de synthèse. Les contraintes sont textuelles et guident l'outil de synthèse pendant son fonctionnement.
La synthèse produit une netlist, qui décrit le comportement logique de la conception. L'étape suivante de la mise en œuvre consiste à placer physiquement chaque fonction logique dans l'appareil. Généralement, l'outil de placement utilisera des algorithmes intégrés qui définissent la manière dont il place les cellules logiques à l'intérieur de la conception. Toutefois, l'utilisateur peut également, s'il le souhaite, examiner et déplacer l'emplacement des cellules logiques à l'aide de contraintes d'emplacement. C'est très utile lorsque nous essayons de respecter les contraintes temporelles sur la conception.
L'avant-dernière étape de la mise en œuvre est effectuée une fois que les fonctions logiques ont été mappées. Ces ressources mappées doivent être connectées comme défini par la conception en utilisant les ressources disponibles dans l'appareil. Ce processus est appelé « routage », et c'est là que les algorithmes de routage utilisent les performances de synchronisation souhaitées pour essayer d'obtenir la fréquence de fonctionnement souhaitée. L'obtention de la fréquence de fonctionnement souhaitée est appelée « respect des contraintes temporelles », ce qui signifie que chaque élément de registre et d'horloge de la conception permet d'obtenir le temps de réglage et de maintien requis.
Dans le cas où il serait impossible de respecter les contraintes temporelles, plusieurs approches peuvent être adoptées; elles vont du choix d'une stratégie de mise en œuvre différente, à la mise à jour des contraintes de placement pour rapprocher les blocs critiques de synchronisation en passant par la mise à jour du modèle HDL pour mettre en œuvre une structure logique plus optimale pendant la synthèse.
L'étape finale du processus d'implémentation est la génération d'un fichier de programmation, qui servira à configurer l'appareil cible. Une fois cette étape franchie, nous sommes prêts à la télécharger sur notre appareil et à commencer la partie la plus intéressante, à savoir l'intégration avec le système au sens large.
Bien sûr, l'intégration peut apporter ses propres défis, à la fois pour le développeur FPGA et pour l'intégrateur système.
Conclusion
Le processus de développement du FPGA est bien différent de celui qui est utilisé pour la création d'une solution informatique plus traditionnelle. La courbe d'apprentissage, cependant, en ce qui concerne les langues et les chaînes d'outils (en particulier avec le HLS) n'est pas aussi abrupte que prévu initialement. Avec suffisamment de temps consacré à l'étude de ces processus, les développeurs peuvent commencer à mettre en œuvre des solutions à base de FPGA qui offrent un débit accru, une latence réduite et un déterminisme plus important.