Guida all'utilizzo di Git con Unified Vitis IDE

Iniziare con Git in Vitis IDE

L'utilizzo di Git con il nuovo IDE "Unified Vitis", basato su VSCode, presenta sfide uniche rispetto alla versione precedente basata su Eclipse. La procedura guidata di importazione/esportazione del progetto non è presente nell'ultima versione, causando difficoltà nella gestione efficace del controllo della versione.

Questa guida mira ad affrontare i problemi riscontrati durante l'utilizzo di Git in Vitis, inclusa la gestione dei file generati con percorsi assoluti e la garanzia di una collaborazione fluida tra diversi sistemi di sviluppo. Esploreremo un flusso di lavoro pratico per gestire i tuoi progetti Vitis in modo efficiente con Git.

Spiegare gli script di Vitis Automation

Il primo script automatizza la configurazione di un progetto Vitis utilizzando Python. Si inizia importando i moduli necessari, in particolare vitis E os. Quindi definisce il percorso root e crea la directory di build se non esiste utilizzando os.makedirs(). Lo script imposta i percorsi previsti per il file XSA e la directory di origine principale. Successivamente, crea un client Vitis e imposta l'area di lavoro nella directory di build appena creata. Il componente della piattaforma viene creato con client.create_platform_component(), specificando la configurazione dell'hardware, del sistema operativo e della CPU. Una volta creato il componente della piattaforma, viene creato un componente dell'applicazione e collegato al componente della piattaforma. Infine, i file necessari vengono importati nel progetto Vitis e il componente viene creato.

Il secondo script è uno script di shell che inizializza il progetto Vitis e configura l'integrazione Git. Definisce il percorso root e la directory di build, creando la directory se non esiste. Lo script esegue quindi lo script Python utilizzando vitis -s tools/build_app.py per automatizzare la configurazione del progetto. Dopo l'esecuzione dello script Python, lo script shell configura un repository Git accedendo alla directory root, inizializzando Git con git inite aggiungendo le directory di build al file .gitignore file. Mette in scena i file rilevanti con git add e li impegna nel repository con git commit -m. Questo approccio garantisce che le directory di build siano escluse dal controllo della versione mantenendo traccia dei file di progetto necessari.

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

Comprensione dell'IDE Vitis e del controllo della versione

Un aspetto dell'utilizzo del nuovo IDE "Unified Vitis" con Git implica la comprensione della struttura e dei componenti dei progetti Vitis. L'IDE Vitis genera numerosi file, molti con percorsi assoluti, il che complica il controllo della versione. Questi file includono configurazioni della piattaforma, descrizioni dell'hardware e metadati specifici dell'IDE. Quando questi file sono controllati dalla versione senza una corretta gestione, gli sviluppatori potrebbero dover affrontare problemi come errori di compilazione dovuti a percorsi non corrispondenti tra sistemi diversi.

Per mitigare questi problemi, una pratica comune è quella di escludere le cartelle gestite da Vitis dal controllo della versione. Invece, i file di configurazione cruciali come script del linker, file CMake e altri file di progetto essenziali vengono copiati manualmente nelle posizioni appropriate previste da Vitis. Questo approccio garantisce che solo i file necessari siano controllati in base alla versione, riducendo il rischio di conflitti ed errori durante la collaborazione con altri sviluppatori. Inoltre, l'utilizzo di script di automazione come Python o script di shell può semplificare questo processo, garantendo che l'impostazione del progetto e la gestione dei file siano coerenti e riproducibili.

Punti chiave per un controllo efficiente della versione in Vitis IDE

L'implementazione del controllo della versione con il nuovo Unified Vitis IDE comporta diversi passaggi critici. Inizia escludendo le cartelle generate da Vitis dal controllo della versione per evitare conflitti ed errori. Concentrati invece sul monitoraggio dei file di configurazione essenziali come script del linker, file CMake e altri componenti vitali del progetto. Gli script di automazione, in particolare quelli scritti in Python, possono semplificare in modo significativo questo processo automatizzando l'impostazione del progetto e garantendo che tutti i file necessari siano nelle posizioni corrette.

Automatizzando la configurazione, puoi garantire un ambiente di sviluppo coerente tra diversi sistemi, riducendo la probabilità di problemi relativi al percorso. Questo approccio non solo semplifica la gestione dei progetti, ma facilita anche una collaborazione più fluida tra gli sviluppatori. Inoltre, mantenere i file sorgente nelle loro directory originali e utilizzare CMake per puntare a queste directory consente una modifica e un controllo della versione più semplici, evitando le complessità legate alla gestione delle strutture di file interne di Vitis.