Handleiding voor het gebruik van Git met Unified Vitis IDE

Aan de slag met Git in Vitis IDE

Het gebruik van Git met de nieuwe "Unified Vitis" IDE, gebaseerd op VSCode, biedt unieke uitdagingen vergeleken met de oudere, op Eclipse gebaseerde versie. De import/export-projectwizard ontbreekt in de nieuwste versie, wat problemen veroorzaakt bij het effectief beheren van versiebeheer.

Deze gids is bedoeld om de problemen aan te pakken die je tegenkomt bij het gebruik van Git in Vitis, inclusief het omgaan met gegenereerde bestanden met absolute paden en het garanderen van een soepele samenwerking tussen verschillende ontwikkelingssystemen. We verkennen een praktische workflow om uw Vitis-projecten efficiënt te beheren met Git.

Uitleg van de Vitis Automation-scripts

Het eerste script automatiseert de opzet van een Vitis-project met behulp van Python. Het begint met het importeren van specifiek de benodigde modules vitis En os. Vervolgens wordt het hoofdpad gedefinieerd en wordt de build-map gemaakt als deze niet bestaat os.makedirs(). Het script stelt de verwachte paden in voor het XSA-bestand en de hoofdbronmap. Vervolgens wordt een Vitis-client gemaakt en wordt de werkruimte ingesteld op de nieuw gemaakte build-directory. De platformcomponent is gemaakt met client.create_platform_component(), met vermelding van de hardware-, besturingssysteem- en CPU-configuratie. Zodra de platformcomponent is gebouwd, wordt er een applicatiecomponent gemaakt en aan de platformcomponent gekoppeld. Ten slotte worden de benodigde bestanden in het Vitis-project geïmporteerd en wordt het onderdeel gebouwd.

Het tweede script is een shellscript dat het Vitis-project initialiseert en Git-integratie instelt. Het definieert het hoofdpad en de build-map, en maakt de map aan als deze niet bestaat. Het script voert vervolgens het Python-script uit met behulp van vitis -s tools/build_app.py om de projectconfiguratie te automatiseren. Nadat het Python-script is uitgevoerd, stelt het shell-script een Git-repository in door naar de hoofdmap te navigeren en Git te initialiseren met git init, en het toevoegen van build-mappen aan de .gitignore bestand. Het ensceneert de relevante bestanden met git add en verbindt ze met de repository git commit -m. Deze aanpak zorgt ervoor dat de build-mappen worden uitgesloten van versiebeheer, terwijl de benodigde projectbestanden worden bijgehouden.

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

Inzicht in Vitis IDE en versiebeheer

Eén aspect van het gebruik van de nieuwe "Unified Vitis" IDE met Git betreft het begrijpen van de structuur en componenten van Vitis-projecten. De Vitis IDE genereert talloze bestanden, waarvan vele met absolute paden, wat het versiebeheer bemoeilijkt. Deze bestanden bevatten platformconfiguraties, hardwarebeschrijvingen en IDE-specifieke metagegevens. Wanneer deze bestanden versiebeheer krijgen zonder de juiste afhandeling, kunnen ontwikkelaars te maken krijgen met problemen zoals bouwfouten als gevolg van niet-overeenkomende paden op verschillende systemen.

Om deze problemen te verhelpen, is het gebruikelijk om door Vitis beheerde mappen uit te sluiten van versiebeheer. In plaats daarvan worden cruciale configuratiebestanden zoals linkerscripts, CMake-bestanden en andere essentiële projectbestanden handmatig gekopieerd naar de juiste locaties die Vitis verwacht. Deze aanpak zorgt ervoor dat alleen de noodzakelijke bestanden versiebeheer hebben, waardoor de kans op conflicten en fouten bij het samenwerken met andere ontwikkelaars wordt verkleind. Bovendien kan het gebruik van automatiseringsscripts zoals Python of shell-scripts dit proces stroomlijnen, waardoor de projectconfiguratie en het bestandsbeheer consistent en reproduceerbaar zijn.

Kernpunten voor efficiënt versiebeheer in Vitis IDE

Het implementeren van versiebeheer met de nieuwe Unified Vitis IDE omvat verschillende cruciale stappen. Begin met het uitsluiten van door Vitis gegenereerde mappen van versiebeheer om conflicten en fouten te voorkomen. Concentreer u in plaats daarvan op het bijhouden van essentiële configuratiebestanden, zoals linkerscripts, CMake-bestanden en andere essentiële projectcomponenten. Automatiseringsscripts, vooral die geschreven in Python, kunnen dit proces aanzienlijk stroomlijnen door de projectconfiguratie te automatiseren en ervoor te zorgen dat alle benodigde bestanden zich op de juiste locaties bevinden.

Door de installatie te automatiseren, kunt u zorgen voor een consistente ontwikkelomgeving op verschillende systemen, waardoor de kans op padgerelateerde problemen wordt verkleind. Deze aanpak vereenvoudigt niet alleen het projectbeheer, maar maakt ook een soepelere samenwerking tussen ontwikkelaars mogelijk. Bovendien zorgt het bewaren van de bronbestanden in hun oorspronkelijke mappen en het gebruik van CMake om naar deze mappen te verwijzen voor eenvoudiger bewerken en versiebeheer, terwijl de complexiteit van het omgaan met de interne bestandsstructuren van Vitis wordt vermeden.