yosyshq/nextpnrnextpnr strumento portatile per posizionamento e instradamento FPGA
nextpnr -- uno strumento portatile di place and route per FPGA =============================================== nextpnr mira ad essere uno strumento di place and route per FPGA FOSS, neutrale rispetto al fornitore e guidato dal timing. Attualmente nextpnr supporta: * Dispositivi Lattice iCE40 supportati da [Project IceStorm](https://github.com/YosysHQ/icestorm) * Dispositivi Lattice ECP5 supportati da [Project Trellis](https://github.com/YosysHQ/prjtrellis) * Dispositivi Lattice Nexus supportati da [Project Oxide](https://github.com/gatecat/prjoxide) * Dispositivi Gowin LittleBee e Aurora V supportati da [Project Apicula](https://github.com/YosysHQ/apicula) * Dispositivi NanoXplore NG-Ultra supportati da [Project Beyond](https://github.com/YosysHQ-GmbH/prjbeyond-db) * Dispositivi Cologne Chip GateMate supportati da [Project Peppercorn](https://github.com/YosysHQ/prjpeppercorn) * *(sperimentale)* Dispositivi Cyclone V supportati da [Mistral](https://github.com/Ravenslofty/mistral) * *(sperimentale)* Dispositivi Lattice MachXO2 supportati da [Project Trellis](https://github.com/YosysHQ/prjtrellis) * *(sperimentale)* Dispositivi Xilinx 7-series supportati da [Project X-Ray](https://github.com/F4PGA/prjxray) * *(sperimentale)* un backend "generico" per architetture definite dall'utente Un breve articolo (accademico) che descrive il flusso Yosys+nextpnr può essere trovato su [arXiv](https://arxiv.org/abs/1903.10407). Ecco uno screenshot di nextpnr per iCE40. Le istruzioni di compilazione e le [note per iniziare](#getting-started) si trovano qui sotto. <img src="https://assets.kitploit.com/production/public/readmes/10385/12bab50b683472060ad2a49530d9b6fe58b2c2b70efd1144b849ff83a8a6e80b.png" width="640"/> Vedi anche: - [F.A.Q.](https://github.com/yosyshq/nextpnr/blob/main/docs/faq.md) - [API dell'architettura](https://github.com/yosyshq/nextpnr/blob/main/docs/archapi.md) Prerequisiti ------------- I seguenti pacchetti devono essere installati per compilare nextpnr, indipendentemente dall'architettura selezionata: - CMake 3.25 o successivo - Compilatore C++17 moderno (`clang-format` richiesto per lo sviluppo) - Python 3.5 o successivo, incluse le librerie di sviluppo (`python3-dev` per Ubuntu) - Python 3.9 o successivo è richiesto per `nextpnr-himbaechel` - su Windows assicurati di installare la stessa versione supportata da [vcpkg](https://github.com/Microsoft/vcpkg/blob/master/ports/python3/CONTROL) - Librerie Boost (`libboost-dev libboost-filesystem-dev libboost-thread-dev libboost-program-options-dev libboost-iostreams-dev libboost-dev` o `libboost-all-dev` per Ubuntu) - Eigen3 (`libeigen3-dev` per Ubuntu) - Yosys è richiesto per sintetizzare il design di esempio - Per la compilazione su Windows con MSVC, si consiglia l'uso di vcpkg per l'installazione delle dipendenze. - Per build a 32 bit: `vcpkg install boost-filesystem boost-program-options boost-thread eigen3` - Per build a 64 bit: `vcpkg install boost-filesystem:x64-windows boost-program-options:x64-windows boost-thread:x64-windows eigen3:x64-windows` - Per build statiche, aggiungi `-static` a ciascun nome di pacchetto. Ad esempio, cambia `eigen3:x64-windows` in `eigen3:x64-windows-static` - Una copia di Python che corrisponde alla versione in vcpkg (attualmente Python 3.6.4). Puoi scaricare il [file zip incorporabile](https://www.python.org/downloads/release/python-364/) ed estrarlo. Potrebbe essere necessario estrarre `python36.zip` all'interno del file zip incorporabile in una nuova directory chiamata "Lib". - Per la compilazione su macOS, è necessario lo strumento brew. - Installa tutti i pacchetti necessari `brew install cmake python boost eigen` Per iniziare --------------- Prima di tutto, esegui: ``` git submodule update --init --recursive ``` ### nextpnr-ice40 Per il supporto iCE40, installa [Project IceStorm](https://github.com/YosysHQ/icestorm) in `/usr/local` o in un'altra posizione, che dovrebbe essere passata come `-DICESTORM_INSTALL_PREFIX=/usr` a CMake. Quindi compila e installa `nextpnr-ice40` usando i seguenti comandi: ``` mkdir -p build && cd build cmake .. -DARCH=ice40 make -j$(nproc) sudo make install ``` Su Windows, puoi specificare i percorsi esplicitamente: ``` 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 ``` Per compilare una release statica, cambia il triplet di destinazione da `x64-windows` a `x64-windows-static` e aggiungi `-DBUILD_STATIC=ON`. Un semplice esempio che funziona sulla scheda di sviluppo iCEstick può essere trovato in `ice40/examples/blinky/blinky.*`. Esempio di utilizzo: ``` cd ice40/examples/blinky yosys -p 'synth_ice40 -top blinky -json blinky.json' blinky.v # sintetizza in blinky.json nextpnr-ice40 --hx1k --json blinky.json --pcf blinky.pcf --asc blinky.asc # esegui place and route icepack blinky.asc blinky.bin # genera il file bitstream binario iceprog blinky.bin # carica il design su iCEstick ``` Esecuzione di nextpnr in modalità GUI (vedi sotto per le istruzioni su come compilare nextpnr con supporto GUI): ``` nextpnr-ice40 --json blinky.json --pcf blinky.pcf --asc blinky.asc --gui ``` (Usa i pulsanti della barra degli strumenti o la console dei comandi Python per eseguire azioni come pack, place, route e scrivere file di output.) ### nextpnr-ecp5 Per il supporto ECP5, installa [Project Trellis](https://github.com/YosysHQ/prjtrellis) in `/usr/local` o in un'altra posizione, che dovrebbe essere passata come `-DTRELLIS_INSTALL_PREFIX=/usr/local` a CMake. Quindi compila e installa `nextpnr-ecp5` usando i seguenti comandi: ``` mkdir -p build && cd build cmake .. -DARCH=ecp5 -DTRELLIS_INSTALL_PREFIX=/usr/local make -j$(nproc) sudo make install ``` - Esempi del flusso ECP5 per una gamma di schede possono essere trovati negli [Esempi di Project Trellis](https://github.com/YosysHQ/prjtrellis/tree/main/examples). ### nextpnr-nexus Per il supporto Nexus, installa [Project Oxide](https://github.com/gatecat/prjoxide) in `$HOME/.cargo` o in un'altra posizione, che dovrebbe essere passata come `-DOXIDE_INSTALL_PREFIX=$HOME/.cargo` a CMake. Quindi compila e installa `nextpnr-nexus` usando i seguenti comandi: ``` mkdir -p build && cd build cmake .. -DARCH=nexus -DOXIDE_INSTALL_PREFIX=$HOME/.cargo make -j$(nproc) sudo make install ``` - Esempi del flusso Nexus per una gamma di schede possono essere trovati negli [Esempi di Project Oxide](https://github.com/gatecat/prjoxide/tree/main/examples). ### nextpnr-mistral Per il supporto Cyclone V, clona [Mistral](https://github.com/Ravenslofty/mistral/tree/nextpnr-latest) in `$HOME/mistral` o in un'altra posizione e passa questo percorso come `-DMISTRAL_ROOT=$HOME/mistral` a CMake. Quindi compila e installa `nextpnr-mistral` usando i seguenti comandi: ``` mkdir -p build && cd build cmake .. -DARCH=mistral -DMISTRAL_ROOT=$HOME/mistral make -j$(nproc) sudo make install ``` Il supporto per Cyclone V è attualmente sperimentale e ha test limitati. Il backend è in fase di refactoring attivo dell'API e la sua struttura, i requisiti di compilazione e i punti di integrazione possono cambiare tra le versioni. ### nextpnr-generic Il target generico permette di eseguire place and route per architetture personalizzate arbitrarie. ``` mkdir -p build && cd build cmake .. -DARCH=generic make -j$(nproc) sudo make install ``` Un esempio di come utilizzare il flusso generico si trova in [generic/examples](https://github.com/yosyshq/nextpnr/blob/main/generic/examples). Vedi anche la [documentazione dell'architettura generica](https://github.com/yosyshq/nextpnr/blob/main/docs/generic.md). ### nextpnr-himbaechel Il target himbaechel permette di eseguire place and route per architetture più grandi che condividono una struttura comune. #### gowin Per il supporto Gowin, installa [Project Apicula](https://github.com/YosysHQ/apicula) ``` mkdir -p build && cd build cmake .. -DARCH="himbaechel" -DHIMBAECHEL_UARCH="gowin" make -j$(nproc) sudo make install ``` - Esempi del flusso Gowin per una gamma di schede possono essere trovati negli [Esempi di Project Apicula](https://github.com/YosysHQ/apicula/tree/master/examples). #### ng-ultra Per il supporto NanoXplore NG-Ultra, clona il repository [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 ``` *Si prega di notare che la creazione del bitstream binario richiede lo strumento Impulse di NanoXplore.* #### gatemate Per il supporto Cologne Chip GateMate, clona [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 La GUI di nextpnr non viene compilata per impostazione predefinita, per ridurre il numero di dipendenze per una build headless standard. Per abilitarla, aggiungi `-DBUILD_GUI=ON` alla riga di comando di CMake e assicurati che Qt5/Qt6 e OpenGL siano disponibili: Per Qt6: - Su Ubuntu 22.04 LTS o successivo, installa `qt6-base-dev` - Per MSVC vcpkg, installa `qt-base` (32-bit) o `qt-base:x64-windows` (64-bit) - Per Homebrew, installa `qt6` e aggiungi qt6 nel percorso: `echo 'export PATH="/usr/local/opt/qt/bin:$PATH"' >> ~/.bash_profile` ` - questa modifica è effettiva nella prossima sessione del terminale, quindi riapri la finestra del terminale prima di compilare Per Qt5: - Su Ubuntu 22.04 LTS, installa `qtbase5-dev qtchooser qt5-qmake qtbase5-dev-tools` - Su altre versioni di Ubuntu, installa `qt5-default` - Per MSVC vcpkg, installa `qt5-base` (32-bit) o `qt5-base:x64-windows` (64-bit) - Per Homebrew, installa `qt5` e aggiungi qt5 nel percorso: `echo 'export PATH="/usr/local/opt/qt/bin:$PATH"' >> ~/.bash_profile` ` - questa modifica è effettiva nella prossima sessione del terminale, quindi riapri la finestra del terminale prima di compilare ### Architetture multiple Per compilare nextpnr per più architetture contemporaneamente, è possibile utilizzare un elenco separato da punto e virgola con `-DARCH`. ``` mkdir -p build && cd build cmake .. -DARCH="ice40;ecp5" make -j$(nproc) sudo make install ``` Per compilare ogni architettura stabile disponibile, usa `-DARCH=all`. Per includere architetture sperimentali (attualmente nexus), usa `-DARCH=all+alpha`. ### Per-microarchitettura Himbächel Per compilare un singolo eseguibile nextpnr-himbaechel per ciascuna delle microarchitetture supportate, usa `-DHIMBAECHEL_SPLIT`. ``` mkdir -p build && cd build cmake .. -DARCH="himbaechel" -DHIMBAECHEL_UARCH="gowin;ng-ultra" make -j$(nproc) sudo make install ``` In tale build, invece di un singolo binario `nextpnr-himbaechel`, vengono compilati due binari `nextpnr-himbaechel-gowin` e `nextpnr-himbaechel-ng-ultra`. Sebbene siano installati insieme, ogni microarchitettura è completamente indipendente dall'altra e necessita solo della corrispondente directory del database dei chip `.../share/himbaechel/<microarchitettura>/` per essere eseguita. La build separata riduce la dimensione dei singoli artefatti distribuiti (sebbene la dimensione totale aumenti) e consente la co-installazione di artefatti di versioni diverse. Cross-compilazione ----------------- Oltre ai database dei chip, nextpnr richiede che lo strumento `bba` sia compilato per il sistema di build. Questo strumento può essere compilato come progetto separato: ``` cd bba cmake . make ``` Questo creerà un file `bba-export.cmake`. Fornisci il percorso a questo file quando cross-compili nextpnr usando `-DBBA_IMPORT=/percorso/di/bba-export.cmake`. Note aggiuntive per compilare nextpnr ------------------------------------- Quanto segue esegue una build di debug dell'architettura iCE40 senza GUI, senza supporto Python, senza il placer analitico HeAP e solo supporto HX1K: ``` mkdir -p build && cd build cmake .. -DARCH=ice40 -DCMAKE_BUILD_TYPE=Debug -DBUILD_PYTHON=OFF -DICE40_DEVICES=1k make -j$(nproc) ``` Per creare una build statica release per l'architettura iCE40 usa quanto segue: ``` mkdir -p build && cd build cmake .. -DARCH=ice40 -DBUILD_PYTHON=OFF -DSTATIC_BUILD=ON make -j$(nproc) ``` Il risolutore del placer HeAP può opzionalmente utilizzare OpenMP per un'accelerazione su progetti molto grandi. Abilitalo passando `-DUSE_OPENMP=yes` a cmake (il supporto del compilatore può variare). Puoi cambiare la posizione in cui verrà installato nextpnr (di solito predefinita in `/usr/local`) usando `-DCMAKE_INSTALL_PREFIX=/percorso/di/installazione`. Note per gli sviluppatori -------------------- - Tutto il codice è formattato usando `clang-format` secondo le regole di stile in `.clang-format` (basato su LLVM con larghezze di indentazione aumentate e parentesi graffe dopo le classi). - Per formattare automaticamente tutto il codice sorgente, esegui `make clangformat`. - Vedi il wiki per documentazione aggiuntiva sull'API dell'architettura. Registrazione di un video ----------------- - Per salvare una registrazione video di place-and-route, clicca sull'icona di registrazione nella barra degli strumenti e seleziona una directory vuota in cui verranno archiviati i file di registrazione e seleziona i fotogrammi da saltare. - Avvia manualmente tutte le operazioni PnR che desideri - Clicca di nuovo sull'icona di registrazione per fermare la registrazione - Vai alla directory contenente i file ed esegui `ffmpeg -f image2 -r 1 -i movie_%05d.png -c:v libx264 nextpnr.mp4` Test ------- - Per compilare anche i binari di test, usa `-DBUILD_TESTS=ON` e dopo `make` esegui `make test` per eseguirli, oppure puoi eseguire binari separati. - Per utilizzare i sanitizer di codice usa le opzioni `cmake`: - `-DSANITIZE_ADDRESS=ON` - `-DSANITIZE_MEMORY=ON -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++` - `-DSANITIZE_THREAD=ON` - `-DSANITIZE_UNDEFINED=ON` - Esempio di esecuzione di valgrind `valgrind --leak-check=yes --tool=memcheck ./nextpnr-ice40 --json ice40/blinky.json` - Per eseguire test con copertura del codice usa `-DBUILD_TESTS=ON -DCOVERAGE` e dopo `make` esegui `make ice40-coverage` - Dopodiché apri `ice40-coverage/index.html` nel tuo browser per visualizzare il rapporto di copertura - Nota che `lcov` è necessario per generare i rapporti Link e riferimenti -------------------- ### Sintesi, simulazione e ottimizzazione logica - [Yosys](https://yosyshq.net/yosys/) - [Icarus Verilog](http://iverilog.icarus.com/) - [ABC](https://people.eecs.berkeley.edu/~alanmi/abc/) ### Progetti di documentazione (e strumenti) per 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) ### Altri progetti FOSS di place and route per FPGA - [Arachne PNR](https://github.com/cseed/arachne-pnr) - [VPR/VTR](https://verilogtorouting.org/) - [SymbiFlow](https://github.com/SymbiFlow/symbiflow-arch-defs)
