Ghid pentru utilizarea Git cu Unified Vitis IDE

Noțiuni introductive cu Git în Vitis IDE

Utilizarea Git cu noul IDE „Unified Vitis”, bazat pe VSCode, prezintă provocări unice în comparație cu versiunea mai veche bazată pe Eclipse. Expertul de import/export al proiectului lipsește în cea mai recentă versiune, ceea ce provoacă dificultăți în gestionarea eficientă a controlului versiunilor.

Acest ghid își propune să abordeze problemele întâlnite în timpul utilizării Git în Vitis, inclusiv gestionarea fișierelor generate cu căi absolute și asigurarea unei colaborări fără probleme între diferite sisteme de dezvoltare. Vom explora un flux de lucru practic pentru a vă gestiona eficient proiectele Vitis cu Git.

Explicarea scripturilor de automatizare Vitis

Primul script automatizează configurarea unui proiect Vitis folosind Python. Începe prin a importa modulele necesare, în special vitis și os. Apoi definește calea rădăcină și creează directorul de construcție dacă nu există folosind os.makedirs(). Scriptul stabilește căile așteptate pentru fișierul XSA și directorul sursă principal. Apoi, creează un client Vitis și setează spațiul de lucru în directorul de compilare nou creat. Componenta platformei este creată cu client.create_platform_component(), specificând configurația hardware, OS și CPU. Odată construită componenta platformei, o componentă a aplicației este creată și legată la componenta platformei. În cele din urmă, fișierele necesare sunt importate în proiectul Vitis, iar componenta este construită.

Al doilea script este un script shell care inițializează proiectul Vitis și setează integrarea Git. Definește calea rădăcină și directorul de compilare, creând directorul dacă acesta nu există. Scriptul rulează apoi scriptul Python folosind vitis -s tools/build_app.py pentru a automatiza configurarea proiectului. După ce rulează scriptul Python, scriptul shell configurează un depozit Git navigând la directorul rădăcină, inițialând Git cu git init, și adăugarea directoarelor de compilare la .gitignore fişier. Stadiază fișierele relevante cu git add și le trimite în depozit cu git commit -m. Această abordare asigură că directoarele de compilare sunt excluse de la controlul versiunilor, păstrând în același timp urmărite fișierele de proiect necesare.

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

Înțelegerea Vitis IDE și Controlul versiunilor

Un aspect al utilizării noului IDE „Unified Vitis” cu Git implică înțelegerea structurii și componentelor proiectelor Vitis. Vitis IDE generează numeroase fișiere, multe cu căi absolute, ceea ce complică controlul versiunilor. Aceste fișiere includ configurații de platformă, descrieri hardware și metadate specifice IDE. Atunci când aceste fișiere sunt controlate de versiune fără o gestionare adecvată, dezvoltatorii se pot confrunta cu probleme precum erori de compilare din cauza căilor nepotrivite în diferite sisteme.

Pentru a atenua aceste probleme, o practică comună este excluderea folderelor gestionate de Vitis de la controlul versiunilor. În schimb, fișierele de configurare esențiale, cum ar fi scripturile de linker, fișierele CMake și alte fișiere de proiect esențiale, sunt copiate manual în locațiile corespunzătoare așteptate de Vitis. Această abordare asigură că numai fișierele necesare sunt controlate în funcție de versiune, reducând riscul de conflicte și erori atunci când colaborați cu alți dezvoltatori. În plus, utilizarea scripturilor de automatizare precum Python sau script-urilor shell poate simplifica acest proces, asigurându-se că configurarea proiectului și gestionarea fișierelor sunt consecvente și reproductibile.

Puncte cheie pentru un control eficient al versiunilor în Vitis IDE

Implementarea controlului versiunilor cu noul Unified Vitis IDE implică câțiva pași critici. Începeți prin a exclude folderele generate de Vitis de la controlul versiunilor pentru a evita conflictele și erorile. În schimb, concentrați-vă pe urmărirea fișierelor de configurare esențiale, cum ar fi scripturile de linker, fișierele CMake și alte componente vitale ale proiectului. Scripturile de automatizare, în special cele scrise în Python, pot simplifica în mod semnificativ acest proces prin automatizarea configurației proiectului și asigurându-se că toate fișierele necesare sunt în locațiile corecte.

Prin automatizarea configurării, puteți asigura un mediu de dezvoltare consistent în diferite sisteme, reducând probabilitatea problemelor legate de cale. Această abordare nu numai că simplifică managementul proiectelor, dar facilitează și o colaborare mai fluidă între dezvoltatori. În plus, păstrarea fișierelor sursă în directoarele lor originale și utilizarea CMake pentru a indica aceste directoare permite editarea mai ușoară și controlul versiunilor, evitând în același timp complexitatea gestionării structurilor interne de fișiere Vitis.