Guide d'utilisation de Git avec l'IDE Unified Vitis

Premiers pas avec Git dans l'IDE Vitis

L'utilisation de Git avec le nouvel IDE « Unified Vitis », basé sur VSCode, présente des défis uniques par rapport à l'ancienne version basée sur Eclipse. L'assistant de projet d'import/export est absent dans la dernière version, ce qui entraîne des difficultés dans la gestion efficace du contrôle de version.

Ce guide vise à résoudre les problèmes rencontrés lors de l'utilisation de Git dans Vitis, notamment la gestion des fichiers générés avec des chemins absolus et la garantie d'une collaboration fluide entre différents systèmes de développement. Nous explorerons un flux de travail pratique pour gérer efficacement vos projets Vitis avec Git.

Commande	Description
import vitis	Importe l'API Vitis pour interagir avec les projets Vitis par programmation.
client.set_workspace()	Définit le répertoire de l'espace de travail pour que le client Vitis gère les fichiers de projet.
client.create_platform_component()	Crée un nouveau composant de plate-forme dans l'espace de travail Vitis à l'aide des paramètres matériels et du système d'exploitation spécifiés.
platform.build()	Déclenche le processus de construction pour le composant de plate-forme spécifié dans Vitis.
client.create_app_component()	Crée un nouveau composant d'application lié au composant de plateforme spécifié dans Vitis.
comp.import_files()	Importe les fichiers nécessaires du répertoire source dans le composant d'application Vitis.
os.makedirs()	Crée la structure de répertoires spécifiée, y compris tous les répertoires parents nécessaires.
vitis -s tools/build_app.py	Exécute le script Python spécifié à l'aide de l'interface de ligne de commande Vitis pour configurer le projet.
echo "build-vitis/" >>echo "build-vitis/" >> .gitignore	Ajoute le répertoire build au fichier ignorer Git pour l'exclure du contrôle de version.
git commit -m	Valide les modifications par étapes dans le référentiel Git local avec un message de validation spécifié.

Expliquer les scripts d'automatisation de Vitis

Le premier script automatise la configuration d'un projet Vitis à l'aide de Python. Cela commence par importer les modules nécessaires, notamment et . Il définit ensuite le chemin racine et crée le répertoire de construction s'il n'existe pas en utilisant . Le script configure les chemins attendus pour le fichier XSA et le répertoire source principal. Ensuite, il crée un client Vitis et définit l'espace de travail sur le répertoire de construction nouvellement créé. Le composant plateforme est créé avec client.create_platform_component(), spécifiant la configuration du matériel, du système d'exploitation et du processeur. Une fois le composant de plateforme construit, un composant d'application est créé et lié au composant de plateforme. Enfin, les fichiers nécessaires sont importés dans le projet Vitis et le composant est construit.

Le deuxième script est un script shell qui initialise le projet Vitis et configure l'intégration Git. Il définit le chemin racine et le répertoire de construction, créant le répertoire s'il n'existe pas. Le script exécute ensuite le script Python en utilisant pour automatiser la configuration du projet. Une fois le script Python exécuté, le script shell configure un référentiel Git en accédant au répertoire racine et en initialisant Git avec , et en ajoutant des répertoires de construction au déposer. Il met en scène les fichiers pertinents avec git add et les valide dans le référentiel avec . Cette approche garantit que les répertoires de construction sont exclus du contrôle de version tout en gardant le suivi des fichiers de projet nécessaires.

import vitis
import os

ROOT_PATH = os.path.abspath(os.path.dirname(__file__))
VITIS_BUILD_DIR_PATH = os.path.join(ROOT_PATH, "build-vitis")
os.makedirs(VITIS_BUILD_DIR_PATH, exist_ok=True)
EXPECTED_XSA_FILE_PATH = os.path.join(ROOT_PATH, "build-vivado", "mydesign.xsa")
COMPONENT_NAME = "MyComponent"
MAIN_SRC_PATH = os.path.join(ROOT_PATH, "src")

client = vitis.create_client()
client.set_workspace(path=VITIS_BUILD_DIR_PATH)

PLATFORM_NAME = "platform_baremetal"
platform = client.create_platform_component(
    name=PLATFORM_NAME,
    hw=EXPECTED_XSA_FILE_PATH,
    os="standalone",
    cpu="mycpu"
)

platform = client.get_platform_component(name=PLATFORM_NAME)
status = platform.build()

comp = client.create_app_component(
    name=COMPONENT_NAME,
    platform=os.path.join(VITIS_BUILD_DIR_PATH, PLATFORM_NAME, "export", PLATFORM_NAME, f"{PLATFORM_NAME}.xpfm"),
    domain="mydomainname"
)

comp = client.get_component(name=COMPONENT_NAME)
status = comp.import_files(
    from_loc=MAIN_SRC_PATH,
    files=["CMakeLists.txt", "UserConfig.cmake", "lscript.ld", "NOTUSED.cpp"],
    dest_dir_in_cmp="src"
)

comp.build()

#!/bin/bash

ROOT_PATH=$(pwd)
VITIS_BUILD_DIR_PATH="$ROOT_PATH/build-vitis"
mkdir -p "$VITIS_BUILD_DIR_PATH"
EXPECTED_XSA_FILE_PATH="$ROOT_PATH/build-vivado/mydesign.xsa"
COMPONENT_NAME="MyComponent"
MAIN_SRC_PATH="$ROOT_PATH/src"

vitis -s tools/build_app.py

# After running the Python script, set up Git repository
cd "$ROOT_PATH"
git init
echo "build-vitis/" >> .gitignore
echo "build-vivado/" >> .gitignore
git add src/ tools/ .gitignore
git commit -m "Initial commit with project structure and scripts"

# Script end

Comprendre Vitis IDE et le contrôle de version

Un aspect de l'utilisation du nouvel IDE « Unified Vitis » avec Git implique de comprendre la structure et les composants des projets Vitis. L'IDE Vitis génère de nombreux fichiers, dont beaucoup avec des chemins absolus, ce qui complique le contrôle de version. Ces fichiers incluent les configurations de plate-forme, les descriptions du matériel et les métadonnées spécifiques à l'IDE. Lorsque ces fichiers sont contrôlés en version sans traitement approprié, les développeurs peuvent être confrontés à des problèmes tels que des erreurs de construction dues à des chemins incompatibles entre différents systèmes.

Pour atténuer ces problèmes, une pratique courante consiste à exclure les dossiers gérés par Vitis du contrôle de version. Au lieu de cela, les fichiers de configuration cruciaux tels que les scripts de l'éditeur de liens, les fichiers CMake et d'autres fichiers de projet essentiels sont copiés manuellement vers les emplacements appropriés attendus par Vitis. Cette approche garantit que seuls les fichiers nécessaires sont contrôlés en version, réduisant ainsi le risque de conflits et d'erreurs lors de la collaboration avec d'autres développeurs. De plus, l'utilisation de scripts d'automatisation tels que Python ou des scripts shell peut rationaliser ce processus, garantissant ainsi que la configuration du projet et la gestion des fichiers sont cohérentes et reproductibles.

1. Comment initialiser un dépôt Git pour un projet Vitis ?
2. Vous pouvez initialiser un référentiel Git en accédant à la racine du projet et en exécutant . Ajoutez les fichiers nécessaires à pour exclure les fichiers indésirables.
3. Quels fichiers doivent être inclus dans le pour un projet Vitis ?
4. Incluez des dossiers spécifiques à l'IDE comme et pour éviter le contrôle de version des fichiers générés automatiquement.
5. Comment automatiser le paramétrage d'un projet Vitis ?
6. Utilisez un script Python pour automatiser des tâches telles que la création de composants de plate-forme et l'importation des fichiers nécessaires. Exécutez le script en utilisant .
7. Pourquoi dois-je copier les fichiers de configuration manuellement ?
8. Vitis s'attend à ce que certains fichiers de configuration se trouvent dans des emplacements spécifiques. La copie de ces fichiers manuellement ou via un script garantit que l'EDI les trouve correctement.
9. Comment gérer les dossiers de plateforme et d’application dans Vitis ?
10. Excluez ces dossiers du contrôle de version et utilisez des scripts pour gérer les fichiers nécessaires, garantissant ainsi la cohérence et évitant les conflits de chemin.
11. Puis-je modifier les fichiers sources directement dans Vitis tout en utilisant Git ?
12. Oui, mais assurez-vous que votre configuration CMake pointe vers les répertoires sources corrects. Vitis peut ne pas reconnaître correctement les inclusions et les noms pour la coloration syntaxique.
13. Quels sont les avantages de l’utilisation de scripts pour la configuration de projets ?
14. Les scripts garantissent une configuration de projet cohérente et reproductible, réduisant les erreurs manuelles et simplifiant la collaboration entre différents environnements.
15. Comment puis-je mettre à jour la configuration de mon projet si des modifications sont apportées ?
16. Modifiez vos scripts d'automatisation pour refléter les modifications et réexécutez-les. Cela garantit que toutes les mises à jour nécessaires sont appliquées correctement.
17. Que dois-je faire si je rencontre des erreurs de build dues à des problèmes de chemin ?
18. Vérifiez les scripts de configuration de votre projet et assurez-vous que tous les chemins sont correctement spécifiés. Utilisez des chemins relatifs lorsque cela est possible pour éviter les conflits.

Points clés pour un contrôle de version efficace dans Vitis IDE

La mise en œuvre du contrôle de version avec le nouvel IDE Unified Vitis implique plusieurs étapes critiques. Commencez par exclure les dossiers générés par Vitis du contrôle de version pour éviter les conflits et les erreurs. Concentrez-vous plutôt sur le suivi des fichiers de configuration essentiels tels que les scripts de l'éditeur de liens, les fichiers CMake et d'autres composants essentiels du projet. Les scripts d'automatisation, en particulier ceux écrits en Python, peuvent rationaliser considérablement ce processus en automatisant la configuration du projet et en garantissant que tous les fichiers nécessaires se trouvent aux bons emplacements.

En automatisant la configuration, vous pouvez garantir un environnement de développement cohérent sur différents systèmes, réduisant ainsi le risque de problèmes liés au chemin. Cette approche simplifie non seulement la gestion de projet, mais facilite également une collaboration plus fluide entre les développeurs. De plus, conserver les fichiers sources dans leurs répertoires d'origine et utiliser CMake pour pointer vers ces répertoires permet une édition et un contrôle de version plus faciles, tout en évitant les complexités liées à la gestion des structures de fichiers internes de Vitis.

L'intégration de Git à l'IDE Unified Vitis nécessite une approche stratégique pour gérer efficacement le contrôle de version. En excluant les dossiers gérés par Vitis et en se concentrant sur les fichiers de configuration essentiels, les développeurs peuvent éviter les pièges courants associés aux chemins absolus et aux métadonnées spécifiques à l'EDI. Les scripts d'automatisation améliorent encore ce processus en fournissant une configuration de projet reproductible et cohérente. Ces stratégies garantissent que les projets Vitis restent gérables et collaboratifs, même dans des environnements de développement complexes.