Synthèse de blocs IP vidéo Vivado HLS : 12 étapes

2024 Auteur: John Day | [email protected]. Dernière modifié: 2024-01-30 09:09

Avez-vous déjà eu envie de traiter en temps réel sur vidéo sans ajouter beaucoup de latence ou dans un système embarqué ? Des FPGA (Field Programmable Gate Arrays) sont parfois utilisés pour cela; cependant, écrire des algorithmes de traitement vidéo dans des langages de spécification matérielle comme VHDL ou Verilog est au mieux frustrant. Entrez Vivado HLS, l'outil Xilinx qui vous permet de programmer dans un environnement C++ et de générer du code de langage de spécification matérielle à partir de celui-ci.

Logiciels requis:

• Vivado HLS
• Vivado
• (Si vous utilisez les registres AXI) Vivado SDK

(Facultatif) Téléchargez les exemples créés par Xilinx ici:

Exemples de vidéos Xilinx HLS

Étape 1: Qu'est-ce que Vivado HLS ?

Vivado HLS est un outil utilisé pour transformer du code de type c++ en structures matérielles pouvant être implémentées sur un FPGA. Il comprend un IDE pour effectuer ce développement. Une fois que vous avez terminé le développement du code pour HLS, vous pouvez exporter votre IP générée dans un format à utiliser avec Vivado.

Téléchargez les fichiers joints et placez-les près de l'endroit où vous allez créer votre projet. (renommez-les en "top.cpp" et "top.h" s'ils ont un nom aléatoire)

Étape 2: Bibliothèque de vidéos HLS

La bibliothèque vidéo HLS contient de la documentation avec des conceptions de référence dans cet article: XAPP1167 Une autre bonne ressource est la page Wiki de Xilinx à ce sujet.

Démarrez Vivado HLS.

Créer un nouveau projet.

Prenez les fichiers que vous avez téléchargés à l'étape précédente et ajoutez-les en tant que fichiers source. (Remarque: les fichiers ne sont pas copiés dans le projet, mais restent là où ils se trouvent)

Utilisez ensuite le bouton Parcourir pour sélectionner la fonction supérieure.

Sur la page suivante, sélectionnez la pièce Xilinx que vous utilisez.

Étape 3: Synthétiser

Solution => Exécuter la synthèse C => Solution active

Après ~227,218 secondes, cela devrait être fait. (Remarque: votre temps de synthèse réel variera en fonction de nombreux facteurs)

Étape 4: Gestion des versions et autres informations pour l'exportation

Les numéros de version interagissent avec Vivado pour vous permettre de mettre à jour l'IP dans une conception. S'il s'agit d'un changement de version mineur, il peut être effectué sur place tandis que les changements de version majeurs nécessitent que vous ajoutiez manuellement le nouveau bloc et supprimez l'ancien. Si vos interfaces n'ont pas changé et que la mise à jour de version est mineure, la mise à jour peut être fait complètement automatiquement en appuyant sur le bouton de mise à jour IP. Vous pouvez exécuter "report_ip_status" dans la console Vivado tcl pour voir l'état de votre IP.

Définissez les numéros de version et autres informations dans Solution => Paramètres de la solution…

Alternativement, ces paramètres peuvent être définis pendant l'exportation.

Étape 5: Exportation vers une bibliothèque IP Vivado

Solution => Exporter RTL

Si vous n'avez pas défini les détails de la bibliothèque IP à l'étape précédente, vous pouvez le faire maintenant.

Étape 6: Synthèse et analyse d'exportation

Sur cet écran, nous pouvons voir les statistiques de notre module exporté, montrant qu'il respecte notre période d'horloge de 10 ns (100 MHz) et la quantité de chaque ressource qu'il utilise.

Avec une combinaison de cela, de notre rapport de synthèse et de notre analyse de flux de données, nous pouvons voir qu'il faut 317338 cycles d'horloge * période d'horloge de 10 ns * 14 étapes de pipeline = 0,04442732 secondes. Cela signifie que la latence totale ajoutée par notre traitement d'image est inférieure à un vingtième de seconde (lorsqu'elle est cadencée à la fréquence cible de 100 MHz).

Étape 7: Ajout de la bibliothèque IP dans Vivado

Pour utiliser votre bloc IP synthétisé, vous devrez l'ajouter à Vivado.

Dans Vivado, ajoutez un référentiel IP à votre projet en accédant au catalogue IP et faites un clic droit en sélectionnant "Ajouter un référentiel…"

Accédez à votre répertoire de projet Vivado HLS et sélectionnez votre répertoire de solution.

Il doit signaler l'adresse IP qu'il a trouvée.

Étape 8: Faire une mise à niveau

Parfois, vous devez apporter des modifications à votre bloc HLS après l'avoir inclus dans une conception Vivado.

Pour ce faire, vous pouvez apporter les modifications et resynthétiser et exporter l'IP avec un numéro de version plus élevé (voir les détails à l'étape précédente sur les changements de numéro de version majeur/mineur).

Après avoir modifié l'exportation de la nouvelle version, actualisez vos référentiels IP dans Vivado. Cela peut être fait lorsque Vivado remarque que l'IP a changé dans le référentiel, ou activé manuellement. (Remarque, si vous actualisez vos référentiels IP après le démarrage, mais avant la fin de l'exportation dans HLS, l'IP ne sera temporairement pas là, attendez qu'elle se termine et actualisez à nouveau.)

À ce stade, une fenêtre devrait apparaître avec les informations indiquant qu'une adresse IP a été modifiée sur le disque et vous donne la possibilité de la mettre à jour avec un bouton "Mettre à niveau la sélection". Si le changement était un changement de version mineur et qu'aucune des interfaces n'a changé, puis appuyer sur ce bouton remplacera automatiquement l'ancienne adresse IP par la nouvelle, sinon plus de travail peut être nécessaire.

Étape 9: Détails et informations supplémentaires

Les étapes suivantes fournissent plus d'informations sur le fonctionnement de la synthèse HLS et sur ce que vous pouvez en faire.

Pour un exemple de projet utilisant un bloc IP synthétisé HLS, consultez cette instructable.

Étape 10: sortie et entrée

Les sorties et les entrées du bloc IP final sont déterminées à partir d'une analyse effectuée par le synthétiseur du flux de données entrant et sortant de la fonction supérieure.

Semblable à VHDL ou verilog, HLS vous permet de spécifier des détails sur les connexions entre IP. Ces lignes en sont des exemples:

void image_filter(AXI_STREAM& video_in, AXI_STREAM& video_out, int& x, int& y) {

#pragma HLS INTERFACE axe port=video_in bundle=INPUT_STREAM #pragma HLS INTERFACE axis port=video_out bundle=OUTPUT_STREAM #pragma HLS INTERFACE s_axilite port=x bundle=CONTROL_BUS offset=0x14#pragma HLS INTERFACE s_axilite port=y bundle=CONTROL_BUS offset=0x14#pragma HLS INTERFACE s_axilite port=y bundle=CONTROL_BUS offset

Vous pouvez voir comment les ports présentés sur le bloc IP sont influencés par ces directives.

Étape 11: Interfaçage du registre AXI

Afin d'obtenir des entrées/sorties de/vers votre bloc IP vers le PS, une bonne façon de le faire est de passer par une interface AXI.

Vous pouvez le spécifier dans votre code HLS, y compris les décalages à utiliser pour accéder à la valeur plus tard comme ceci:

void image_filter(AXI_STREAM& video_in, AXI_STREAM& video_out, int& x, int& y) {

#pragma HLS INTERFACE s_axilite port=x bundle=CONTROL_BUS offset=0x14

#pragma HLS INTERFACE s_axilite port=y bundle=CONTROL_BUS offset=0x1C #pragma HLS dataflow

x = 42;

y = 0xDEADBEEF; }

Une fois connecté correctement dans Vivado, vous pouvez accéder aux valeurs en utilisant ce code dans Vivado SDK:

#include "paramètres.h"

#define xregoff 0x14 #define yregoff 0x1c x = Xil_In32(XPAR_IMAGE_FILTER_0_S_AXI_CONTROL_BUS_BASEADDR+xregoff); y = Xil_In32(XPAR_IMAGE_FILTER_0_S_AXI_CONTROL_BUS_BASEADDR+yregoff);

Cela vous fera vous retrouver avec 42 en x et 0xdeadbeef en y

Étape 12: Dataflow Pragma

Dans le #pragma DATAFLOW, la façon dont le code est implémenté change par rapport au C++ normal. Le code est pipeline de sorte que toutes les instructions s'exécutent à tout moment dans différentes parties des données (pensez-y comme une chaîne de montage dans une usine, chaque station travaille en continu en effectuant une fonction et en la transmettant à la station suivante)

à partir de l'image, vous pouvez voir que chacune des directives

Bien qu'ils semblent être des variables normales, les objets img sont en réalité implémentés comme de petits tampons entre les commandes. Utiliser une image en entrée d'une fonction la "consomme" et la rend inutilisable. (D'où la nécessité des commandes en double)