nextpnr -- uma ferramenta portátil de posicionamento e roteamento para FPGA

nextpnr visa ser uma ferramenta de posicionamento e roteamento para FPGA neutra em relação ao fabricante, orientada por temporização e de código aberto (FOSS).

Atualmente, o nextpnr suporta:

Dispositivos Lattice iCE40 suportados pelo Project IceStorm
Dispositivos Lattice ECP5 suportados pelo Project Trellis
Dispositivos Lattice Nexus suportados pelo Project Oxide
Dispositivos Gowin LittleBee e Aurora V suportados pelo Project Apicula
Dispositivos NanoXplore NG-Ultra suportados pelo Project Beyond
Dispositivos Cologne Chip GateMate suportados pelo Project Peppercorn
(experimental) Dispositivos Cyclone V suportados pelo Mistral
(experimental) Dispositivos Lattice MachXO2 suportados pelo Project Trellis
(experimental) Dispositivos Xilinx 7-series suportados pelo Project X-Ray
(experimental) um back-end "genérico" para arquiteturas definidas pelo usuário

Um breve artigo (acadêmico) descrevendo o fluxo Yosys+nextpnr pode ser encontrado no arXiv.

Aqui está uma captura de tela do nextpnr para iCE40. Instruções de compilação e notas de início rápido podem ser encontradas abaixo.

Veja também:

Pré-requisitos

Os seguintes pacotes precisam ser instalados para compilar o nextpnr, independentemente da arquitetura selecionada:

CMake 3.25 ou posterior
Compilador C++17 moderno (clang-format necessário para desenvolvimento)
Python 3.5 ou posterior, incluindo bibliotecas de desenvolvimento (python3-dev no Ubuntu)
- Python 3.9 ou posterior é necessário para nextpnr-himbaechel
- no Windows, certifique-se de instalar a mesma versão suportada pelo vcpkg
Bibliotecas Boost (libboost-dev libboost-filesystem-dev libboost-thread-dev libboost-program-options-dev libboost-iostreams-dev libboost-dev ou libboost-all-dev no Ubuntu)
Eigen3 (libeigen3-dev no Ubuntu)
Yosys é necessário para sintetizar o design de demonstração
Para compilar no Windows com MSVC, recomenda-se o uso do vcpkg para instalação das dependências.
- Para compilações de 32 bits: vcpkg install boost-filesystem boost-program-options boost-thread eigen3
- Para compilações de 64 bits: vcpkg install boost-filesystem:x64-windows boost-program-options:x64-windows boost-thread:x64-windows eigen3:x64-windows

Início rápido

Primeiro, execute:

git submodule update --init --recursive

nextpnr-ice40

Para suporte a iCE40, instale o Project IceStorm em /usr/local ou outro local, que deve ser passado como -DICESTORM_INSTALL_PREFIX=/usr para o CMake. Em seguida, compile e instale o nextpnr-ice40 usando os seguintes comandos:

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

No Windows, você pode especificar caminhos explicitamente:

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

Para compilar uma versão estática, altere o triplet de destino de x64-windows para x64-windows-static e adicione -DBUILD_STATIC=ON.

Um exemplo simples que roda na placa de desenvolvimento iCEstick pode ser encontrado em ice40/examples/blinky/blinky.*. Exemplo de uso:

cd ice40/examples/blinky
yosys -p 'synth_ice40 -top blinky -json blinky.json' blinky.v               # sintetizar em blinky.json
nextpnr-ice40 --hx1k --json blinky.json --pcf blinky.pcf --asc blinky.asc   # executar posicionamento e roteamento
icepack blinky.asc blinky.bin                                               # gerar arquivo bitstream binário
iceprog blinky.bin                                                          # enviar design para iCEstick

Executando o nextpnr no modo GUI (veja abaixo instruções para compilar o nextpnr com suporte a GUI):

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

(Use os botões da barra de ferramentas ou o console de comandos Python para executar ações como pack, place, route e escrever arquivos de saída.)

nextpnr-ecp5

Para suporte a ECP5, instale o Project Trellis em /usr/local ou outro local, que deve ser passado como -DTRELLIS_INSTALL_PREFIX=/usr/local para o CMake. Em seguida, compile e instale o nextpnr-ecp5 usando os seguintes comandos:

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

Exemplos do fluxo ECP5 para uma variedade de placas podem ser encontrados nos Exemplos do Project Trellis.

nextpnr-nexus

Para suporte a Nexus, instale o Project Oxide em $HOME/.cargo ou outro local, que deve ser passado como -DOXIDE_INSTALL_PREFIX=$HOME/.cargo para o CMake. Em seguida, compile e instale o nextpnr-nexus usando os seguintes comandos:

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

Exemplos do fluxo Nexus para uma variedade de placas podem ser encontrados nos Exemplos do Project Oxide.

nextpnr-mistral

Para suporte a Cyclone V, clone o Mistral para $HOME/mistral ou outro local e passe este caminho como -DMISTRAL_ROOT=$HOME/mistral para o CMake. Em seguida, compile e instale o nextpnr-mistral usando os seguintes comandos:

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

O suporte a Cyclone V é atualmente experimental e tem testes limitados. O backend está passando por uma refatoração ativa da API, e sua estrutura, requisitos de compilação e pontos de integração podem mudar entre versões.

nextpnr-generic

O alvo genérico permite executar posicionamento e roteamento para arquiteturas personalizadas arbitrárias.

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

Um exemplo de como usar o fluxo genérico está em generic/examples. Veja também a documentação da Arquitetura Genérica.

nextpnr-himbaechel

O alvo himbaechel permite executar posicionamento e roteamento para arquiteturas maiores que compartilham uma estrutura comum.

gowin

Para suporte a Gowin, instale o Project Apicula

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

Exemplos do fluxo Gowin para uma variedade de placas podem ser encontrados nos Exemplos do Project Apicula.

ng-ultra

Para suporte a NanoXplore NG-Ultra, clone o repositório Project Beyond DB

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

Por favor, note que a criação do bitstream binário requer a ferramenta Impulse da NanoXplore.

gatemate

Para suporte a Cologne Chip GateMate, clone o Project Peppercorn

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

GUI

A GUI do nextpnr não é compilada por padrão para reduzir o número de dependências em uma compilação sem interface gráfica padrão. Para habilitá-la, adicione -DBUILD_GUI=ON à linha de comando do CMake e certifique-se de que Qt5/Qt6 e OpenGL estejam disponíveis:

Para Qt6:

No Ubuntu 22.04 LTS ou posterior, instale qt6-base-dev
Para MSVC vcpkg, instale qt-base (32-bit) ou qt-base:x64-windows (64-bit)
Para Homebrew, instale qt6 e adicione qt6 no caminho: echo 'export PATH="/usr/local/opt/qt/bin:$PATH"' >> ~/.bash_profile ` - esta alteração é efetiva na próxima sessão do terminal, então reabra a janela do terminal antes de compilar

Para Qt5:

No Ubuntu 22.04 LTS, instale qtbase5-dev qtchooser qt5-qmake qtbase5-dev-tools
Em outras versões do Ubuntu, instale qt5-default
Para MSVC vcpkg, instale qt5-base (32-bit) ou qt5-base:x64-windows (64-bit)
Para Homebrew, instale qt5 e adicione qt5 no caminho: echo 'export PATH="/usr/local/opt/qt/bin:$PATH"' >> ~/.bash_profile ` - esta alteração é efetiva na próxima sessão do terminal, então reabra a janela do terminal antes de compilar

Múltiplas arquiteturas

Para compilar o nextpnr para várias arquiteturas de uma vez, uma lista separada por ponto e vírgula pode ser usada com -DARCH.

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

Para compilar todas as arquiteturas estáveis disponíveis, use -DARCH=all. Para incluir arquiteturas experimentais (atualmente nexus), use -DARCH=all+alpha.

Por microarquitetura Himbächel

Para compilar um executável nextpnr-himbachel único para cada microarquitetura suportada, use -DHIMBAECHEL_SPLIT.

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

Em tal compilação, em vez de um único binário nextpnr-himbaechel, dois binários nextpnr-himbaechel-gowin e nextpnr-himbaechel-ng-ultra são compilados. Embora sejam instalados juntos, cada microarquitetura é completamente independente da outra, e precisa apenas do seu diretório de banco de dados de chip correspondente .../share/himbaechel/<microarquitetura>/ para executar. A compilação dividida reduz o tamanho dos artefatos individuais distribuídos (embora o tamanho total aumente) e permite a co-instalação de artefatos de diferentes versões.

Compilação cruzada

Além dos bancos de dados de chips, o nextpnr requer que a ferramenta bba seja compilada para o sistema de compilação. Esta ferramenta pode ser compilada como um projeto separado:

cd bba
cmake .
make

Isso criará um arquivo bba-export.cmake. Forneça o caminho para este arquivo ao compilar o nextpnr de forma cruzada usando -DBBA_IMPORT=/caminho/para/bba-export.cmake.

Notas adicionais para compilar o nextpnr

O seguinte executa uma compilação de depuração da arquitetura iCE40 sem GUI, sem suporte a Python, sem o posicionador analítico HeAP e apenas com suporte a HX1K:

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

Para criar uma compilação estática para a arquitetura iCE40, use o seguinte:

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

O solucionador do posicionador HeAP pode opcionalmente usar OpenMP para uma aceleração em designs muito grandes. Habilite isso passando -DUSE_OPENMP=yes para o cmake (o suporte do compilador pode variar).

Você pode alterar o local onde o nextpnr será instalado (normalmente será /usr/local) usando -DCMAKE_INSTALL_PREFIX=/prefixo/de/instalacao.

Notas para desenvolvedores

Todo o código é formatado usando clang-format de acordo com as regras de estilo em .clang-format (baseado em LLVM com larguras de indentação aumentadas e quebras de chave após classes).
Para formatar automaticamente todo o código-fonte, execute make clangformat.
Consulte a wiki para documentação adicional sobre a API de arquitetura.

Gravação de vídeo

Para salvar uma gravação de vídeo do posicionamento e roteamento, clique no ícone de gravação na barra de ferramentas e selecione um diretório vazio onde os arquivos de gravação serão armazenados e selecione os quadros a serem ignorados.
Inicie manualmente todas as operações de PnR desejadas
Clique novamente no ícone de gravação para parar a gravação
Vá para o diretório contendo os arquivos e execute ffmpeg -f image2 -r 1 -i movie_%05d.png -c:v libx264 nextpnr.mp4

Testes

Para compilar também os binários de teste, use -DBUILD_TESTS=ON e após make execute make test para executá-los, ou você pode executar binários separados.
Para usar sanitizadores de código, use as opções cmake:
- -DSANITIZE_ADDRESS=ON
- -DSANITIZE_MEMORY=ON -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++
- -DSANITIZE_THREAD=ON
- -DSANITIZE_UNDEFINED=ON
Exemplo de execução do valgrind valgrind --leak-check=yes --tool=memcheck ./nextpnr-ice40 --json ice40/blinky.json
Executando testes com cobertura de código use -DBUILD_TESTS=ON -DCOVERAGE e após make execute make ice40-coverage

nextpnr

Mais Populares