yosyshq/nextpnrnextpnr outil portable de placement et routage pour FPGA
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](https://github.com/YosysHQ/icestorm) * Les périphériques Lattice ECP5 pris en charge par [Project Trellis](https://github.com/YosysHQ/prjtrellis) * Les périphériques Lattice Nexus pris en charge par [Project Oxide](https://github.com/gatecat/prjoxide) * Les périphériques Gowin LittleBee et Aurora V pris en charge par [Project Apicula](https://github.com/YosysHQ/apicula) * Les périphériques NanoXplore NG-Ultra pris en charge par [Project Beyond](https://github.com/YosysHQ-GmbH/prjbeyond-db) * Les périphériques Cologne Chip GateMate pris en charge par [Project Peppercorn](https://github.com/YosysHQ/prjpeppercorn) * *(expérimental)* Les périphériques Cyclone V pris en charge par [Mistral](https://github.com/Ravenslofty/mistral) * *(expérimental)* Les périphériques Lattice MachXO2 pris en charge par [Project Trellis](https://github.com/YosysHQ/prjtrellis) * *(expérimental)* Les périphériques Xilinx 7-series pris en charge par [Project X-Ray](https://github.com/F4PGA/prjxray) * *(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](https://arxiv.org/abs/1903.10407). Voici une capture d'écran de nextpnr pour iCE40. Les instructions de construction et [notes de démarrage](#getting-started) se trouvent ci-dessous. <img src="https://assets.kitploit.com/production/public/readmes/10385/12bab50b683472060ad2a49530d9b6fe58b2c2b70efd1144b849ff83a8a6e80b.png" width="640"/> Voir aussi : - [F.A.Q.](https://github.com/yosyshq/nextpnr/blob/main/docs/faq.md) - [Architecture API](https://github.com/yosyshq/nextpnr/blob/main/docs/archapi.md) 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](https://github.com/Microsoft/vcpkg/blob/master/ports/python3/CONTROL) - 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` - Pour les builds statiques, ajoutez `-static` à chacun des noms de paquets. Par exemple, remplacez `eigen3:x64-windows` par `eigen3:x64-windows-static` - Une copie de Python correspondant à la version dans vcpkg (actuellement Python 3.6.4). Vous pouvez télécharger le [Fichier zip embarquable](https://www.python.org/downloads/release/python-364/) et l'extraire. Vous devrez peut-être extraire `python36.zip` du fichier zip embarquable dans un nouveau répertoire appelé « Lib ». - Pour la construction sous macOS, l'utilitaire brew est nécessaire. - Installez tous les paquets nécessaires `brew install cmake python boost eigen` Démarrage ---------- Tout d'abord, exécutez : ``` git submodule update --init --recursive ``` ### nextpnr-ice40 Pour la prise en charge iCE40, installez [Project IceStorm](https://github.com/YosysHQ/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](https://github.com/YosysHQ/prjtrellis) 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](https://github.com/YosysHQ/prjtrellis/tree/main/examples). ### nextpnr-nexus Pour la prise en charge Nexus, installez [Project Oxide](https://github.com/gatecat/prjoxide) 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](https://github.com/gatecat/prjoxide/tree/main/examples). ### nextpnr-mistral Pour la prise en charge Cyclone V, clonez [Mistral](https://github.com/Ravenslofty/mistral/tree/nextpnr-latest) 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](https://github.com/yosyshq/nextpnr/blob/main/generic/examples). Voir aussi la [documentation de l'architecture générique](https://github.com/yosyshq/nextpnr/blob/main/docs/generic.md). ### 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](https://github.com/YosysHQ/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](https://github.com/YosysHQ/apicula/tree/master/examples). #### ng-ultra Pour la prise en charge NanoXplore NG-Ultra, clonez le dépôt [Project Beyond DB](https://github.com/yosyshq-GmbH/prjbeyond-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](https://github.com/YosysHQ/prjpeppercorn) ``` 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` - Ensuite, ouvrez `ice40-coverage/index.html` dans votre navigateur pour consulter le rapport de couverture - Notez que `lcov` est nécessaire pour générer les rapports Liens et références -------------------- ### Synthèse, simulation et optimisation logique - [Yosys](https://yosyshq.net/yosys/) - [Icarus Verilog](http://iverilog.icarus.com/) - [ABC](https://people.eecs.berkeley.edu/~alanmi/abc/) ### Projets de documentation (et d'outils) de bitstream FPGA - [Project IceStorm (Lattice iCE40)](https://github.com/YosysHQ/icestorm) - [Project Trellis (Lattice ECP5)](https://yosyshq.github.io/prjtrellis-db/) - [Project X-Ray (Xilinx 7-Series)](https://github.com/F4PGA/prjxray) - [Project Chibi (Intel MAX-V)](https://github.com/rqou/project-chibi) ### Autres projets de placement et routage FPGA open source - [Arachne PNR](https://github.com/cseed/arachne-pnr) - [VPR/VTR](https://verilogtorouting.org/) - [SymbiFlow](https://github.com/SymbiFlow/symbiflow-arch-defs)
