Guía para usar Git con Unified Vitis IDE

Empezando con Git en Vitis IDE

El uso de Git con el nuevo IDE "Unified Vitis", basado en VSCode, presenta desafíos únicos en comparación con la versión anterior basada en Eclipse. El asistente de importación/exportación de proyectos falta en la última versión, lo que provoca dificultades para gestionar el control de versiones de forma eficaz.

Esta guía tiene como objetivo abordar los problemas encontrados al usar Git en Vitis, incluido el manejo de archivos generados con rutas absolutas y garantizar una colaboración fluida entre diferentes sistemas de desarrollo. Exploraremos un flujo de trabajo práctico para gestionar sus proyectos Vitis de manera eficiente con Git.

Explicando los scripts de automatización de Vitis

El primer script automatiza la configuración de un proyecto Vitis usando Python. Comienza importando los módulos necesarios, específicamente vitis y os. Luego define la ruta raíz y crea el directorio de compilación si no existe usando os.makedirs(). El script configura las rutas esperadas para el archivo XSA y el directorio de origen principal. A continuación, crea un cliente Vitis y configura el espacio de trabajo en el directorio de compilación recién creado. El componente de plataforma se crea con client.create_platform_component(), especificando la configuración de hardware, sistema operativo y CPU. Una vez creado el componente de la plataforma, se crea un componente de la aplicación y se vincula al componente de la plataforma. Finalmente, se importan los archivos necesarios al proyecto Vitis y se construye el componente.

El segundo script es un script de shell que inicializa el proyecto Vitis y configura la integración de Git. Define la ruta raíz y el directorio de compilación, creando el directorio si no existe. Luego, el script ejecuta el script Python usando vitis -s tools/build_app.py para automatizar la configuración del proyecto. Después de ejecutar el script de Python, el script de shell configura un repositorio de Git navegando al directorio raíz e inicializando Git con git inity agregar directorios de compilación al .gitignore archivo. Presenta los archivos relevantes con git add y los envía al repositorio con git commit -m. Este enfoque garantiza que los directorios de compilación queden excluidos del control de versiones y, al mismo tiempo, se mantiene un seguimiento de los archivos de proyecto necesarios.

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

Comprender Vitis IDE y el control de versiones

Un aspecto del uso del nuevo IDE "Unified Vitis" con Git implica comprender la estructura y los componentes de los proyectos de Vitis. El IDE de Vitis genera numerosos archivos, muchos de ellos con rutas absolutas, lo que complica el control de versiones. Estos archivos incluyen configuraciones de plataforma, descripciones de hardware y metadatos específicos de IDE. Cuando la versión de estos archivos se controla sin un manejo adecuado, los desarrolladores pueden enfrentar problemas como errores de compilación debido a rutas no coincidentes entre diferentes sistemas.

Para mitigar estos problemas, una práctica común es excluir las carpetas administradas por Vitis del control de versiones. En su lugar, los archivos de configuración cruciales, como los scripts del enlazador, los archivos CMake y otros archivos de proyecto esenciales, se copian manualmente en las ubicaciones apropiadas que Vitis espera. Este enfoque garantiza que solo se controlen las versiones de los archivos necesarios, lo que reduce el riesgo de conflictos y errores al colaborar con otros desarrolladores. Además, el uso de scripts de automatización como Python o scripts de shell puede agilizar este proceso, garantizando que la configuración del proyecto y la gestión de archivos sean consistentes y reproducibles.

Puntos clave para un control de versiones eficiente en Vitis IDE

La implementación del control de versiones con el nuevo Unified Vitis IDE implica varios pasos críticos. Comience excluyendo las carpetas generadas por Vitis del control de versiones para evitar conflictos y errores. En su lugar, concéntrese en rastrear archivos de configuración esenciales, como scripts de vinculación, archivos CMake y otros componentes vitales del proyecto. Los scripts de automatización, en particular los escritos en Python, pueden agilizar significativamente este proceso al automatizar la configuración del proyecto y garantizar que todos los archivos necesarios estén en las ubicaciones correctas.

Al automatizar la configuración, puede garantizar un entorno de desarrollo coherente en diferentes sistemas, lo que reduce la probabilidad de que se produzcan problemas relacionados con las rutas. Este enfoque no sólo simplifica la gestión de proyectos sino que también facilita una colaboración más fluida entre los desarrolladores. Además, mantener los archivos fuente en sus directorios originales y usar CMake para apuntar a estos directorios permite una edición y control de versiones más fáciles, evitando al mismo tiempo las complejidades de lidiar con las estructuras de archivos internas de Vitis.