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.

Comando	Descrizione
import vitis	Importa l'API Vitis per interagire con i progetti Vitis a livello di codice.
client.set_workspace()	Imposta la directory dello spazio di lavoro per il client Vitis per gestire i file di progetto.
client.create_platform_component()	Crea un nuovo componente della piattaforma nell'area di lavoro Vitis utilizzando i parametri hardware e del sistema operativo specificati.
platform.build()	Attiva il processo di compilazione per il componente della piattaforma specificato in Vitis.
client.create_app_component()	Crea un nuovo componente dell'applicazione collegato al componente della piattaforma specificata in Vitis.
comp.import_files()	Importa i file necessari dalla directory di origine nel componente dell'applicazione Vitis.
os.makedirs()	Crea la struttura di directory specificata, incluse le eventuali directory principali necessarie.
vitis -s tools/build_app.py	Esegue lo script Python specificato utilizzando l'interfaccia della riga di comando di Vitis per impostare il progetto.
echo "build-vitis/" >>echo "build-vitis/" >> .gitignore	Aggiunge la directory build al file Git ignore per escluderlo dal controllo della versione.
git commit -m	Esegue il commit delle modifiche graduali nel repository Git locale con un messaggio di commit specificato.

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 E . Quindi definisce il percorso root e crea la directory di build se non esiste utilizzando . 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 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 e aggiungendo le directory di build al file file. Mette in scena i file rilevanti con git add e li impegna nel repository con . 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.

1. Come inizializzo un repository Git per un progetto Vitis?
2. Puoi inizializzare un repository Git accedendo alla root del progetto ed eseguendo . Aggiungi i file necessari a per escludere file indesiderati.
3. Quali file devono essere inclusi nel file per un progetto Vitis?
4. Includi cartelle specifiche dell'IDE come E per evitare il controllo della versione dei file generati automaticamente.
5. Come posso automatizzare la configurazione di un progetto Vitis?
6. Utilizza uno script Python per automatizzare attività come la creazione di componenti della piattaforma e l'importazione dei file necessari. Esegui lo script utilizzando .
7. Perché devo copiare manualmente i file di configurazione?
8. Vitis prevede che determinati file di configurazione si trovino in posizioni specifiche. La copia di questi file manualmente o tramite script garantisce che l'IDE li trovi correttamente.
9. Come posso gestire le cartelle della piattaforma e dell'applicazione in Vitis?
10. Escludi queste cartelle dal controllo della versione e utilizza gli script per gestire i file necessari, garantendo coerenza ed evitando conflitti di percorso.
11. Posso modificare i file sorgente direttamente in Vitis mentre utilizzo Git?
12. Sì, ma assicurati che la configurazione di CMake punti alle directory di origine corrette. Vitis potrebbe non riconoscere correttamente include e nomi per l'evidenziazione della sintassi.
13. Quali sono i vantaggi derivanti dall'utilizzo degli script per l'impostazione del progetto?
14. Gli script garantiscono un'impostazione del progetto coerente e ripetibile, riducendo gli errori manuali e semplificando la collaborazione tra ambienti diversi.
15. Come posso aggiornare la configurazione del mio progetto se vengono apportate modifiche?
16. Modifica gli script di automazione per riflettere le modifiche ed eseguili nuovamente. Ciò garantisce che tutti gli aggiornamenti necessari vengano applicati correttamente.
17. Cosa devo fare se riscontro errori di compilazione dovuti a problemi di percorso?
18. Controlla gli script di configurazione del progetto e assicurati che tutti i percorsi siano specificati correttamente. Utilizzare percorsi relativi ove possibile per evitare conflitti.

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.

L'integrazione di Git con Unified Vitis IDE richiede un approccio strategico per gestire il controllo della versione in modo efficace. Escludendo le cartelle gestite da Vitis e concentrandosi sui file di configurazione essenziali, gli sviluppatori possono evitare le trappole comuni associate ai percorsi assoluti e ai metadati specifici dell'IDE. Gli script di automazione migliorano ulteriormente questo processo fornendo una configurazione di progetto ripetibile e coerente. Queste strategie garantiscono che i progetti Vitis rimangano gestibili e collaborativi, anche in ambienti di sviluppo complessi.