Guia para usar Git com Unified Vitis IDE

Introdução ao Git no Vitis IDE

Usar o Git com o novo IDE "Unified Vitis", baseado em VSCode, apresenta desafios únicos em comparação com a versão mais antiga baseada em Eclipse. O assistente de importação/exportação do projeto está ausente na versão mais recente, causando dificuldades no gerenciamento eficaz do controle de versão.

Este guia tem como objetivo abordar os problemas encontrados ao usar o Git no Vitis, incluindo o tratamento de arquivos gerados com caminhos absolutos e a garantia de uma colaboração tranquila entre diferentes sistemas de desenvolvimento. Exploraremos um fluxo de trabalho prático para gerenciar seus projetos Vitis de forma eficiente com Git.

Explicando os scripts de automação Vitis

O primeiro script automatiza a configuração de um projeto Vitis usando Python. Começa importando os módulos necessários, especificamente vitis e os. Em seguida, ele define o caminho raiz e cria o diretório de construção se ele não existir usando os.makedirs(). O script configura os caminhos esperados para o arquivo XSA e o diretório de origem principal. Em seguida, ele cria um cliente Vitis e define o espaço de trabalho para o diretório de construção recém-criado. O componente da plataforma é criado com client.create_platform_component(), especificando a configuração de hardware, sistema operacional e CPU. Depois que o componente de plataforma é construído, um componente de aplicativo é criado e vinculado ao componente de plataforma. Por fim, os arquivos necessários são importados para o projeto Vitis e o componente é construído.

O segundo script é um shell script que inicializa o projeto Vitis e configura a integração do Git. Ele define o caminho raiz e o diretório de construção, criando o diretório se ele não existir. O script então executa o script Python usando vitis -s tools/build_app.py para automatizar a configuração do projeto. Após a execução do script Python, o script shell configura um repositório Git navegando até o diretório raiz, inicializando o Git com git inite adicionando diretórios de compilação ao .gitignore arquivo. Ele organiza os arquivos relevantes com git add e os envia para o repositório com git commit -m. Essa abordagem garante que os diretórios de construção sejam excluídos do controle de versão, ao mesmo tempo que mantém os arquivos de projeto necessários rastreados.

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

Compreendendo o Vitis IDE e o controle de versão

Um aspecto do uso do novo IDE “Unified Vitis” com Git envolve a compreensão da estrutura e dos componentes dos projetos Vitis. O Vitis IDE gera vários arquivos, muitos deles com caminhos absolutos, o que complica o controle de versão. Esses arquivos incluem configurações de plataforma, descrições de hardware e metadados específicos do IDE. Quando esses arquivos são controlados por versão sem o tratamento adequado, os desenvolvedores podem enfrentar problemas como erros de compilação devido a caminhos incompatíveis em diferentes sistemas.

Para mitigar esses problemas, uma prática comum é excluir as pastas gerenciadas pelo Vitis do controle de versão. Em vez disso, arquivos de configuração cruciais, como scripts de vinculador, arquivos CMake e outros arquivos essenciais do projeto, são copiados manualmente para os locais apropriados esperados pelo Vitis. Essa abordagem garante que apenas os arquivos necessários sejam controlados por versão, reduzindo o risco de conflitos e erros ao colaborar com outros desenvolvedores. Além disso, o uso de scripts de automação como Python ou shell scripts pode agilizar esse processo, garantindo que a configuração do projeto e o gerenciamento de arquivos sejam consistentes e reproduzíveis.

Pontos-chave para controle de versão eficiente no Vitis IDE

A implementação do controle de versão com o novo IDE Unified Vitis envolve várias etapas críticas. Comece excluindo as pastas geradas pelo Vitis do controle de versão para evitar conflitos e erros. Em vez disso, concentre-se no rastreamento de arquivos de configuração essenciais, como scripts de vinculador, arquivos CMake e outros componentes vitais do projeto. Os scripts de automação, especialmente aqueles escritos em Python, podem agilizar significativamente esse processo, automatizando a configuração do projeto e garantindo que todos os arquivos necessários estejam nos locais corretos.

Ao automatizar a configuração, você pode garantir um ambiente de desenvolvimento consistente em diferentes sistemas, reduzindo a probabilidade de problemas relacionados ao caminho. Essa abordagem não apenas simplifica o gerenciamento de projetos, mas também facilita uma colaboração mais tranquila entre os desenvolvedores. Além disso, manter os arquivos de origem em seus diretórios originais e usar o CMake para apontar para esses diretórios permite uma edição e controle de versão mais fáceis, evitando as complexidades de lidar com as estruturas internas de arquivos do Vitis.