nextpnr -- un outil portable de placement et routage FPGA

nextpnr vise à être un outil de placement et routage FPGA neutre vis-à-vis des fournisseurs, piloté par le timing, et open source.

Actuellement, nextpnr prend en charge :

Les périphériques Lattice iCE40 pris en charge par Project IceStorm
Les périphériques Lattice ECP5 pris en charge par Project Trellis
Les périphériques Lattice Nexus pris en charge par Project Oxide
Les périphériques Gowin LittleBee et Aurora V pris en charge par Project Apicula
Les périphériques NanoXplore NG-Ultra pris en charge par Project Beyond
Les périphériques Cologne Chip GateMate pris en charge par Project Peppercorn
(expérimental) Les périphériques Cyclone V pris en charge par Mistral
(expérimental) Les périphériques Lattice MachXO2 pris en charge par Project Trellis
(expérimental) Les périphériques Xilinx 7-series pris en charge par Project X-Ray
(expérimental) un back-end « générique » pour des architectures définies par l'utilisateur

Un bref article (académique) décrivant le flux Yosys+nextpnr peut être trouvé sur arXiv.

Voici une capture d'écran de nextpnr pour iCE40. Les instructions de construction et notes de démarrage se trouvent ci-dessous.

Voir aussi :

Prérequis

Les paquets suivants doivent être installés pour construire nextpnr, indépendamment de l'architecture sélectionnée :

CMake 3.25 ou ultérieur
Compilateur C++17 moderne (clang-format requis pour le développement)
Python 3.5 ou ultérieur, y compris les bibliothèques de développement (python3-dev pour Ubuntu)
- Python 3.9 ou ultérieur est requis pour nextpnr-himbaechel
- sous Windows, assurez-vous d'installer la même version que celle prise en charge par vcpkg
Bibliothèques Boost (libboost-dev libboost-filesystem-dev libboost-thread-dev libboost-program-options-dev libboost-iostreams-dev libboost-dev ou libboost-all-dev pour Ubuntu)
Eigen3 (libeigen3-dev pour Ubuntu)
Yosys est requis pour synthétiser le design de démonstration
Pour la construction sous Windows avec MSVC, l'utilisation de vcpkg est recommandée pour l'installation des dépendances.
- Pour les builds 32 bits : vcpkg install boost-filesystem boost-program-options boost-thread eigen3
- Pour les builds 64 bits : vcpkg install boost-filesystem:x64-windows boost-program-options:x64-windows boost-thread:x64-windows eigen3:x64-windows

Démarrage

Tout d'abord, exécutez :

git submodule update --init --recursive

nextpnr-ice40

Pour la prise en charge iCE40, installez Project IceStorm dans /usr/local ou un autre emplacement, qui doit être passé comme -DICESTORM_INSTALL_PREFIX=/usr à CMake. Ensuite, construisez et installez nextpnr-ice40 en utilisant les commandes suivantes :

mkdir -p build && cd build
cmake .. -DARCH=ice40
make -j$(nproc)
sudo make install

Sous Windows, vous pouvez spécifier les chemins explicitement :

cmake . -B build -DARCH=ice40 -DICESTORM_INSTALL_PREFIX=C:/ProgramData/icestorm -DCMAKE_TOOLCHAIN_FILE=C:/vcpkg/scripts/buildsystems/vcpkg.cmake -DVCPKG_TARGET_TRIPLET=x64-windows -G "Visual Studio 15 2017 Win64" -DPython3_EXECUTABLE=C:/Python364/python.exe -DPython3_LIBRARY=C:/vcpkg/packages/python3_x64-windows/lib/python36.lib -DPython3_INCLUDE_DIR=C:/vcpkg/packages/python3_x64-windows/include/python3.6
cmake --build build --config Release

Pour construire une version statique, remplacez le triplet cible x64-windows par x64-windows-static et ajoutez -DBUILD_STATIC=ON.

Un exemple simple qui fonctionne sur la carte de développement iCEstick se trouve dans ice40/examples/blinky/blinky.*. Exemple d'utilisation :

cd ice40/examples/blinky
yosys -p 'synth_ice40 -top blinky -json blinky.json' blinky.v               # synthétiser dans blinky.json
nextpnr-ice40 --hx1k --json blinky.json --pcf blinky.pcf --asc blinky.asc   # exécuter le placement et le routage
icepack blinky.asc blinky.bin                                               # générer le fichier binaire du bitstream
iceprog blinky.bin                                                          # télécharger le design sur iCEstick

Exécution de nextpnr en mode GUI (voir ci-dessous pour les instructions de construction de nextpnr avec support GUI) :

nextpnr-ice40 --json blinky.json --pcf blinky.pcf --asc blinky.asc --gui

(Utilisez les boutons de la barre d'outils ou la console de commandes Python pour effectuer des actions telles que le pack, le placement, le routage et l'écriture des fichiers de sortie.)

nextpnr-ecp5

Pour la prise en charge ECP5, installez Project Trellis dans /usr/local ou un autre emplacement, qui doit être passé comme -DTRELLIS_INSTALL_PREFIX=/usr/local à CMake. Ensuite, construisez et installez nextpnr-ecp5 en utilisant les commandes suivantes :

mkdir -p build && cd build
cmake .. -DARCH=ecp5 -DTRELLIS_INSTALL_PREFIX=/usr/local
make -j$(nproc)
sudo make install

Des exemples du flux ECP5 pour une gamme de cartes se trouvent dans les Exemples Project Trellis.

nextpnr-nexus

Pour la prise en charge Nexus, installez Project Oxide dans $HOME/.cargo ou un autre emplacement, qui doit être passé comme -DOXIDE_INSTALL_PREFIX=$HOME/.cargo à CMake. Ensuite, construisez et installez nextpnr-nexus en utilisant les commandes suivantes :

mkdir -p build && cd build
cmake .. -DARCH=nexus -DOXIDE_INSTALL_PREFIX=$HOME/.cargo
make -j$(nproc)
sudo make install

Des exemples du flux Nexus pour une gamme de cartes se trouvent dans les Exemples Project Oxide.

nextpnr-mistral

Pour la prise en charge Cyclone V, clonez Mistral dans $HOME/mistral ou un autre emplacement et passez ce chemin comme -DMISTRAL_ROOT=$HOME/mistral à CMake. Ensuite, construisez et installez nextpnr-mistral en utilisant les commandes suivantes :

mkdir -p build && cd build
cmake .. -DARCH=mistral -DMISTRAL_ROOT=$HOME/mistral
make -j$(nproc)
sudo make install

La prise en charge de Cyclone V est actuellement expérimentale et a été testée de manière limitée. Le back-end subit une refonte active de son API, et sa structure, ses prérequis de construction et ses points d'intégration peuvent changer entre les versions.

nextpnr-generic

La cible générique permet d'exécuter le placement et le routage pour des architectures personnalisées arbitraires.

mkdir -p build && cd build
cmake .. -DARCH=generic
make -j$(nproc)
sudo make install

Un exemple d'utilisation du flux générique se trouve dans generic/examples. Voir aussi la documentation de l'architecture générique.

nextpnr-himbaechel

La cible himbaechel permet d'exécuter le placement et le routage pour des architectures plus grandes qui partagent une structure commune.

gowin

Pour la prise en charge Gowin, installez Project Apicula

mkdir -p build && cd build
cmake .. -DARCH="himbaechel" -DHIMBAECHEL_UARCH="gowin"
make -j$(nproc)
sudo make install

Des exemples du flux Gowin pour une gamme de cartes se trouvent dans les Exemples Project Apicula.

ng-ultra

Pour la prise en charge NanoXplore NG-Ultra, clonez le dépôt Project Beyond DB

mkdir -p build && cd build
cmake .. -DARCH="himbaechel" -DHIMBAECHEL_UARCH="ng-ultra" -DHIMBAECHEL_PRJBEYOND_DB=/path/to/prjbeyond-db -DHIMBAECHEL_NGULTRA_DEVICES=ng-ultra
make -j$(nproc)
sudo make install

Veuillez noter que la création du bitstream binaire nécessite l'outil Impulse de NanoXplore.

gatemate

Pour la prise en charge Cologne Chip GateMate, clonez Project Peppercorn

mkdir -p build && cd build
cmake .. -DARCH="himbaechel" -DHIMBAECHEL_UARCH="gatemate" -DHIMBAECHEL_PEPPERCORN_PATH=/path/to/prjpeppercorn
make -j$(nproc)
sudo make install

GUI

L'interface graphique (GUI) de nextpnr n'est pas construite par défaut, afin de réduire le nombre de dépendances pour une construction standard sans tête. Pour l'activer, ajoutez -DBUILD_GUI=ON à la ligne de commande CMake et assurez-vous que Qt5/Qt6 et OpenGL sont disponibles :

Pour Qt6 :

Sur Ubuntu 22.04 LTS ou ultérieur, installez qt6-base-dev
Pour MSVC vcpkg, installez qt-base (32 bits) ou qt-base:x64-windows (64 bits)
Pour Homebrew, installez qt6 et ajoutez qt6 dans le chemin : echo 'export PATH="/usr/local/opt/qt/bin:$PATH"' >> ~/.bash_profile ` - ce changement est effectif dans la prochaine session de terminal, veuillez donc rouvrir la fenêtre du terminal avant de construire

Pour Qt5 :

Sur Ubuntu 22.04 LTS, installez qtbase5-dev qtchooser qt5-qmake qtbase5-dev-tools
Sur les autres versions d'Ubuntu, installez qt5-default
Pour MSVC vcpkg, installez qt5-base (32 bits) ou qt5-base:x64-windows (64 bits)
Pour Homebrew, installez qt5 et ajoutez qt5 dans le chemin : echo 'export PATH="/usr/local/opt/qt/bin:$PATH"' >> ~/.bash_profile ` - ce changement est effectif dans la prochaine session de terminal, veuillez donc rouvrir la fenêtre du terminal avant de construire

Architectures multiples

Pour construire nextpnr pour plusieurs architectures à la fois, une liste séparée par des points-virgules peut être utilisée avec -DARCH.

mkdir -p build && cd build
cmake .. -DARCH="ice40;ecp5"
make -j$(nproc)
sudo make install

Pour construire toutes les architectures stables disponibles, utilisez -DARCH=all. Pour inclure les architectures expérimentales (actuellement nexus), utilisez -DARCH=all+alpha.

Himbächel par microarchitecture

Pour construire un seul exécutable nextpnr-himbachel pour chacune des microarchitectures prises en charge, utilisez -DHIMBAECHEL_SPLIT.

mkdir -p build && cd build
cmake .. -DARCH="himbaechel" -DHIMBAECHEL_UARCH="gowin;ng-ultra"
make -j$(nproc)
sudo make install

Dans une telle construction, au lieu d'un seul binaire nextpnr-himbaechel, deux binaires nextpnr-himbaechel-gowin et nextpnr-himbaechel-ng-ultra sont construits. Bien qu'ils soient installés ensemble, chaque microarchitecture est complètement indépendante de l'autre et n'a besoin que de son répertoire de base de données de puces .../share/himbaechel/<microarchitecture>/ correspondant pour fonctionner. La construction fractionnée réduit la taille des artefacts individuels distribués (bien que la taille totale augmente) et permet la co-installation d'artefacts de différentes versions.

Cross-compilation

En dehors des bases de données de puces, nextpnr nécessite l'outil bba pour être compilé pour le système de construction. Cet outil peut être compilé en tant que projet séparé :

cd bba
cmake .
make

Cela créera un fichier bba-export.cmake. Fournissez le chemin de ce fichier lors de la cross-compilation de nextpnr en utilisant -DBBA_IMPORT=/chemin/vers/bba-export.cmake.

Notes supplémentaires pour la construction de nextpnr

Ce qui suit exécute une construction de débogage de l'architecture iCE40 sans GUI, sans support Python, sans le placeur analytique HeAP et seulement avec le support HX1K :

mkdir -p build && cd build
cmake .. -DARCH=ice40 -DCMAKE_BUILD_TYPE=Debug -DBUILD_PYTHON=OFF -DICE40_DEVICES=1k
make -j$(nproc)

Pour réaliser une construction statique de version pour l'architecture iCE40, utilisez ce qui suit :

mkdir -p build && cd build
cmake .. -DARCH=ice40 -DBUILD_PYTHON=OFF -DSTATIC_BUILD=ON
make -j$(nproc)

Le solveur du placeur HeAP peut éventuellement utiliser OpenMP pour une accélération sur les très grands designs. Activez cette option en passant -DUSE_OPENMP=yes à cmake (le support du compilateur peut varier).

Vous pouvez modifier l'emplacement où nextpnr sera installé (la valeur par défaut est généralement /usr/local) en utilisant -DCMAKE_INSTALL_PREFIX=/prefixe/installation.

Notes pour les développeurs

Tout le code est formaté en utilisant clang-format selon les règles de style dans .clang-format (basé sur LLVM avec des largeurs d'indentation augmentées et des retours à la ligne après les classes).
Pour formater automatiquement tout le code source, exécutez make clangformat.
Consultez le wiki pour une documentation supplémentaire sur l'API d'architecture.

Enregistrement d'une vidéo

Pour enregistrer une vidéo du placement-et-routage, cliquez sur l'icône d'enregistrement dans la barre d'outils et sélectionnez un répertoire vide où les fichiers d'enregistrement seront stockés et sélectionnez les images à ignorer.
Lancez manuellement toutes les opérations de PnR souhaitées
Cliquez à nouveau sur l'icône d'enregistrement pour arrêter l'enregistrement
Allez dans le répertoire contenant les fichiers et exécutez ffmpeg -f image2 -r 1 -i movie_%05d.png -c:v libx264 nextpnr.mp4

Tests

Pour également construire les binaires de test, utilisez -DBUILD_TESTS=ON et après make exécutez make test pour les lancer, ou vous pouvez exécuter des binaires séparés.
Pour utiliser les sanitizers de code, utilisez les options cmake :
- -DSANITIZE_ADDRESS=ON
- -DSANITIZE_MEMORY=ON -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++
- -DSANITIZE_THREAD=ON
- -DSANITIZE_UNDEFINED=ON
Exemple d'exécution de valgrind : valgrind --leak-check=yes --tool=memcheck ./nextpnr-ice40 --json ice40/blinky.json
Pour exécuter les tests avec couverture de code, utilisez -DBUILD_TESTS=ON -DCOVERAGE et après make exécutez make ice40-coverage

nextpnr

Populaires