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
Dispositivi Lattice ECP5 supportati da Project Trellis
Dispositivi Lattice Nexus supportati da Project Oxide
Dispositivi Gowin LittleBee e Aurora V supportati da Project Apicula
Dispositivi NanoXplore NG-Ultra supportati da Project Beyond
Dispositivi Cologne Chip GateMate supportati da Project Peppercorn
(sperimentale) Dispositivi Cyclone V supportati da Mistral
(sperimentale) Dispositivi Lattice MachXO2 supportati da Project Trellis
(sperimentale) Dispositivi Xilinx 7-series supportati da Project X-Ray
(sperimentale) un backend "generico" per architetture definite dall'utente

Un breve articolo (accademico) che descrive il flusso Yosys+nextpnr può essere trovato su arXiv.

Ecco uno screenshot di nextpnr per iCE40. Le istruzioni di compilazione e le note per iniziare si trovano qui sotto.

Vedi anche:

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
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 iniziare

Prima di tutto, esegui:

git submodule update --init --recursive

nextpnr-ice40

Per il supporto iCE40, installa Project 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 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.

nextpnr-nexus

Per il supporto Nexus, installa Project Oxide 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.

nextpnr-mistral

Per il supporto Cyclone V, clona Mistral 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. Vedi anche la documentazione dell'architettura generica.

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

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.

ng-ultra

Per il supporto NanoXplore NG-Ultra, clona il repository 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

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

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

nextpnr

Più Popolari