Leitfaden zur Verwendung von Git mit Unified Vitis IDE

Erste Schritte mit Git in Vitis IDE

Die Verwendung von Git mit der neuen „Unified Vitis“-IDE, die auf VSCode basiert, stellt im Vergleich zur älteren Eclipse-basierten Version einzigartige Herausforderungen dar. Der Assistent zum Importieren/Exportieren von Projekten fehlt in der neuesten Version, was zu Schwierigkeiten bei der effektiven Verwaltung der Versionskontrolle führt.

Ziel dieses Leitfadens ist es, die Probleme zu beheben, die bei der Verwendung von Git in Vitis auftreten, einschließlich der Handhabung generierter Dateien mit absoluten Pfaden und der Gewährleistung einer reibungslosen Zusammenarbeit zwischen verschiedenen Entwicklungssystemen. Wir erkunden einen praktischen Workflow zur effizienten Verwaltung Ihrer Vitis-Projekte mit Git.

Erklären der Vitis-Automatisierungsskripte

Das erste Skript automatisiert die Einrichtung eines Vitis-Projekts mit Python. Zunächst werden zunächst die notwendigen Module importiert vitis Und os. Anschließend wird der Root-Pfad definiert und das Build-Verzeichnis erstellt, falls dieses nicht vorhanden ist os.makedirs(). Das Skript richtet die erwarteten Pfade für die XSA-Datei und das Hauptquellverzeichnis ein. Als nächstes erstellt es einen Vitis-Client und legt den Arbeitsbereich auf das neu erstellte Build-Verzeichnis fest. Die Plattformkomponente wird mit erstellt client.create_platform_component(), unter Angabe der Hardware-, Betriebssystem- und CPU-Konfiguration. Sobald die Plattformkomponente erstellt ist, wird eine Anwendungskomponente erstellt und mit der Plattformkomponente verknüpft. Abschließend werden die notwendigen Dateien in das Vitis-Projekt importiert und die Komponente erstellt.

Das zweite Skript ist ein Shell-Skript, das das Vitis-Projekt initialisiert und die Git-Integration einrichtet. Es definiert den Root-Pfad und das Build-Verzeichnis und erstellt das Verzeichnis, falls es nicht existiert. Das Skript führt dann das Python-Skript mit aus vitis -s tools/build_app.py um die Projekteinrichtung zu automatisieren. Nachdem das Python-Skript ausgeführt wurde, richtet das Shell-Skript ein Git-Repository ein, indem es zum Stammverzeichnis navigiert und Git mit initialisiert git initund Hinzufügen von Build-Verzeichnissen zum .gitignore Datei. Es stellt die relevanten Dateien mit bereit git add und übergibt sie an das Repository mit git commit -m. Dieser Ansatz stellt sicher, dass die Build-Verzeichnisse von der Versionskontrolle ausgeschlossen sind, während die notwendigen Projektdateien weiterhin verfolgt werden.

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

Vitis IDE und Versionskontrolle verstehen

Ein Aspekt der Verwendung der neuen „Unified Vitis“-IDE mit Git besteht darin, die Struktur und Komponenten von Vitis-Projekten zu verstehen. Die Vitis-IDE generiert zahlreiche Dateien, viele davon mit absoluten Pfaden, was die Versionskontrolle erschwert. Zu diesen Dateien gehören Plattformkonfigurationen, Hardwarebeschreibungen und IDE-spezifische Metadaten. Wenn diese Dateien ohne ordnungsgemäße Handhabung einer Versionskontrolle unterliegen, können Entwickler aufgrund nicht übereinstimmender Pfade auf verschiedenen Systemen mit Problemen wie Buildfehlern konfrontiert werden.

Um diese Probleme zu mildern, besteht eine gängige Praxis darin, von Vitis verwaltete Ordner von der Versionskontrolle auszuschließen. Stattdessen werden wichtige Konfigurationsdateien wie Linker-Skripte, CMake-Dateien und andere wichtige Projektdateien manuell an die entsprechenden, von Vitis erwarteten Speicherorte kopiert. Durch diesen Ansatz wird sichergestellt, dass nur die erforderlichen Dateien einer Versionskontrolle unterliegen, wodurch das Risiko von Konflikten und Fehlern bei der Zusammenarbeit mit anderen Entwicklern verringert wird. Darüber hinaus kann die Verwendung von Automatisierungsskripten wie Python oder Shell-Skripten diesen Prozess rationalisieren und sicherstellen, dass die Projekteinrichtung und Dateiverwaltung konsistent und reproduzierbar sind.

Wichtige Punkte für eine effiziente Versionskontrolle in Vitis IDE

Die Implementierung der Versionskontrolle mit der neuen Unified Vitis IDE umfasst mehrere wichtige Schritte. Beginnen Sie damit, von Vitis generierte Ordner von der Versionskontrolle auszuschließen, um Konflikte und Fehler zu vermeiden. Konzentrieren Sie sich stattdessen auf die Verfolgung wichtiger Konfigurationsdateien wie Linker-Skripte, CMake-Dateien und anderer wichtiger Projektkomponenten. Automatisierungsskripte, insbesondere solche, die in Python geschrieben sind, können diesen Prozess erheblich rationalisieren, indem sie die Projekteinrichtung automatisieren und sicherstellen, dass sich alle erforderlichen Dateien an den richtigen Speicherorten befinden.

Durch die Automatisierung der Einrichtung können Sie eine konsistente Entwicklungsumgebung über verschiedene Systeme hinweg sicherstellen und so die Wahrscheinlichkeit pfadbezogener Probleme verringern. Dieser Ansatz vereinfacht nicht nur das Projektmanagement, sondern ermöglicht auch eine reibungslosere Zusammenarbeit zwischen Entwicklern. Darüber hinaus ermöglicht die Beibehaltung der Quelldateien in ihren ursprünglichen Verzeichnissen und die Verwendung von CMake, um auf diese Verzeichnisse zu verweisen, eine einfachere Bearbeitung und Versionskontrolle, während gleichzeitig die Komplexität des Umgangs mit den internen Dateistrukturen von Vitis vermieden wird.