yosyshq/nextpnrnextpnr herramienta portátil de ubicación y enrutado para FPGA
nextpnr -- una herramienta portátil de colocación y enrutamiento para FPGA =============================================== nextpnr pretende ser una herramienta FOSS de colocación y enrutamiento para FPGA, independiente del fabricante y guiada por la temporización. Actualmente, nextpnr soporta: * Dispositivos Lattice iCE40 compatibles con [Project IceStorm](https://github.com/YosysHQ/icestorm) * Dispositivos Lattice ECP5 compatibles con [Project Trellis](https://github.com/YosysHQ/prjtrellis) * Dispositivos Lattice Nexus compatibles con [Project Oxide](https://github.com/gatecat/prjoxide) * Dispositivos Gowin LittleBee y Aurora V compatibles con [Project Apicula](https://github.com/YosysHQ/apicula) * Dispositivos NanoXplore NG-Ultra compatibles con [Project Beyond](https://github.com/YosysHQ-GmbH/prjbeyond-db) * Dispositivos Cologne Chip GateMate compatibles con [Project Peppercorn](https://github.com/YosysHQ/prjpeppercorn) * *(experimental)* dispositivos Cyclone V compatibles con [Mistral](https://github.com/Ravenslofty/mistral) * *(experimental)* dispositivos Lattice MachXO2 compatibles con [Project Trellis](https://github.com/YosysHQ/prjtrellis) * *(experimental)* dispositivos Xilinx serie 7 compatibles con [Project X-Ray](https://github.com/F4PGA/prjxray) * *(experimental)* un back-end "genérico" para arquitecturas definidas por el usuario Un breve artículo (académico) que describe el flujo Yosys+nextpnr se puede encontrar en [arXiv](https://arxiv.org/abs/1903.10407). Aquí se muestra una captura de pantalla de nextpnr para iCE40. Las instrucciones de compilación y las [notas de inicio rápido](#getting-started) se pueden encontrar a continuación. <img src="https://assets.kitploit.com/production/public/readmes/10385/12bab50b683472060ad2a49530d9b6fe58b2c2b70efd1144b849ff83a8a6e80b.png" width="640"/> Véase también: - [F.A.Q.](https://github.com/yosyshq/nextpnr/blob/main/docs/faq.md) - [API de arquitectura](https://github.com/yosyshq/nextpnr/blob/main/docs/archapi.md) Requisitos previos ------------- Es necesario instalar los siguientes paquetes para compilar nextpnr, independientemente de la arquitectura seleccionada: - CMake 3.25 o posterior - Compilador moderno de C++17 (`clang-format` necesario para el desarrollo) - Python 3.5 o posterior, incluidas las bibliotecas de desarrollo (`python3-dev` en Ubuntu) - Se requiere Python 3.9 o posterior para `nextpnr-himbaechel` - en Windows, asegúrate de instalar la misma versión compatible con [vcpkg](https://github.com/Microsoft/vcpkg/blob/master/ports/python3/CONTROL) - Bibliotecas Boost (`libboost-dev libboost-filesystem-dev libboost-thread-dev libboost-program-options-dev libboost-iostreams-dev libboost-dev` o `libboost-all-dev` en Ubuntu) - Eigen3 (`libeigen3-dev` en Ubuntu) - Yosys es necesario para sintetizar el diseño de demostración - Para compilar en Windows con MSVC, se recomienda el uso de vcpkg para la instalación de dependencias. - Para compilaciones de 32 bits: `vcpkg install boost-filesystem boost-program-options boost-thread eigen3` - Para compilaciones de 64 bits: `vcpkg install boost-filesystem:x64-windows boost-program-options:x64-windows boost-thread:x64-windows eigen3:x64-windows` - Para compilaciones estáticas, añade `-static` a cada uno de los nombres de paquete. Por ejemplo, cambia `eigen3:x64-windows` a `eigen3:x64-windows-static` - Una copia de Python que coincida con la versión en vcpkg (actualmente Python 3.6.4). Puedes descargar el [archivo ZIP integrable](https://www.python.org/downloads/release/python-364/) y extraerlo. Puede que necesites extraer `python36.zip`, que está dentro del archivo ZIP integrable, a un nuevo directorio llamado "Lib". - Para compilar en macOS, se necesita la utilidad brew. - Instala todos los paquetes necesarios `brew install cmake python boost eigen` Primeros pasos --------------- En primer lugar, ejecuta: ``` git submodule update --init --recursive ``` ### nextpnr-ice40 Para soporte de iCE40, instala [Project IceStorm](https://github.com/YosysHQ/icestorm) en `/usr/local` u otra ubicación, que debe pasarse como `-DICESTORM_INSTALL_PREFIX=/usr` a CMake. Luego compila e instala `nextpnr-ice40` con los siguientes comandos: ``` mkdir -p build && cd build cmake .. -DARCH=ice40 make -j$(nproc) sudo make install ``` En Windows, puedes especificar las rutas explícitamente: ``` 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 crear una compilación estática de release, cambia el triplet de destino de `x64-windows` a `x64-windows-static` y añade `-DBUILD_STATIC=ON`. Un ejemplo sencillo que se ejecuta en la placa de desarrollo iCEstick se puede encontrar en `ice40/examples/blinky/blinky.*`. Ejemplo de uso: ``` cd ice40/examples/blinky yosys -p 'synth_ice40 -top blinky -json blinky.json' blinky.v # synthesize into blinky.json nextpnr-ice40 --hx1k --json blinky.json --pcf blinky.pcf --asc blinky.asc # run place and route icepack blinky.asc blinky.bin # generate binary bitstream file iceprog blinky.bin # upload design to iCEstick ``` Ejecutar nextpnr en modo GUI (consulta a continuación las instrucciones para compilar nextpnr con soporte GUI): ``` nextpnr-ice40 --json blinky.json --pcf blinky.pcf --asc blinky.asc --gui ``` (Usa los botones de la barra de herramientas o la consola de comandos de Python para realizar acciones como empaquetar, colocar, enrutar y escribir archivos de salida). ### nextpnr-ecp5 Para soporte de ECP5, instala [Project Trellis](https://github.com/YosysHQ/prjtrellis) en `/usr/local` u otra ubicación, que debe pasarse como `-DTRELLIS_INSTALL_PREFIX=/usr/local` a CMake. Luego compila e instala `nextpnr-ecp5` con los siguientes comandos: ``` mkdir -p build && cd build cmake .. -DARCH=ecp5 -DTRELLIS_INSTALL_PREFIX=/usr/local make -j$(nproc) sudo make install ``` - Ejemplos del flujo ECP5 para una variedad de placas se pueden encontrar en los [Ejemplos de Project Trellis](https://github.com/YosysHQ/prjtrellis/tree/main/examples). ### nextpnr-nexus Para soporte de Nexus, instala [Project Oxide](https://github.com/gatecat/prjoxide) en `$HOME/.cargo` u otra ubicación, que debe pasarse como `-DOXIDE_INSTALL_PREFIX=$HOME/.cargo` a CMake. Luego compila e instala `nextpnr-nexus` con los siguientes comandos: ``` mkdir -p build && cd build cmake .. -DARCH=nexus -DOXIDE_INSTALL_PREFIX=$HOME/.cargo make -j$(nproc) sudo make install ``` - Ejemplos del flujo Nexus para una variedad de placas se pueden encontrar en los [Ejemplos de Project Oxide](https://github.com/gatecat/prjoxide/tree/main/examples). ### nextpnr-mistral Para soporte de Cyclone V, clona [Mistral](https://github.com/Ravenslofty/mistral/tree/nextpnr-latest) en `$HOME/mistral` u otra ubicación y pasa esta ruta como `-DMISTRAL_ROOT=$HOME/mistral` a CMake. Luego compila e instala `nextpnr-mistral` con los siguientes comandos: ``` mkdir -p build && cd build cmake .. -DARCH=mistral -DMISTRAL_ROOT=$HOME/mistral make -j$(nproc) sudo make install ``` El soporte para Cyclone V es actualmente experimental y cuenta con pruebas limitadas. El backend está siendo sometido a una refactorización activa de su API, y su estructura, requisitos de compilación y puntos de integración pueden cambiar entre versiones. ### nextpnr-generic El target genérico permite ejecutar la colocación y el enrutamiento para arquitecturas personalizadas arbitrarias. ``` mkdir -p build && cd build cmake .. -DARCH=generic make -j$(nproc) sudo make install ``` Un ejemplo de cómo usar el flujo genérico está en [generic/examples](https://github.com/yosyshq/nextpnr/blob/main/generic/examples). Consulta también la [documentación de Generic Architecture](https://github.com/yosyshq/nextpnr/blob/main/docs/generic.md). ### nextpnr-himbaechel El target himbaechel permite ejecutar la colocación y el enrutamiento para arquitecturas más grandes que comparten una estructura común. #### gowin Para soporte de Gowin, instala [Project Apicula](https://github.com/YosysHQ/apicula) ``` mkdir -p build && cd build cmake .. -DARCH="himbaechel" -DHIMBAECHEL_UARCH="gowin" make -j$(nproc) sudo make install ``` - Ejemplos del flujo Gowin para una variedad de placas se pueden encontrar en los [Ejemplos de Project Apicula](https://github.com/YosysHQ/apicula/tree/master/examples). #### ng-ultra Para soporte de NanoXplore NG-Ultra, clona el repositorio [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 ``` *Ten en cuenta que la creación de bitstreams binarios requiere la herramienta Impulse de NanoXplore.* #### gatemate Para soporte de 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 de nextpnr no se compila por defecto, para reducir el número de dependencias en una compilación estándar sin interfaz (headless). Para habilitarla, añade `-DBUILD_GUI=ON` a la línea de comandos de CMake y asegúrate de que Qt5/Qt6 y OpenGL estén disponibles: Para Qt6: - En Ubuntu 22.04 LTS o posterior, instala `qt6-base-dev` - Para MSVC vcpkg, instala `qt-base` (32 bits) o `qt-base:x64-windows` (64 bits) - Para Homebrew, instala `qt6` y añade qt6 al PATH: `echo 'export PATH="/usr/local/opt/qt/bin:$PATH"' >> ~/.bash_profile` ` - este cambio tiene efecto en la próxima sesión de terminal, así que vuelve a abrir la ventana de terminal antes de compilar Para Qt5: - En Ubuntu 22.04 LTS, instala `qtbase5-dev qtchooser qt5-qmake qtbase5-dev-tools` - En otras versiones de Ubuntu, instala `qt5-default` - Para MSVC vcpkg, instala `qt5-base` (32 bits) o `qt5-base:x64-windows` (64 bits) - Para Homebrew, instala `qt5` y añade qt5 al PATH: `echo 'export PATH="/usr/local/opt/qt/bin:$PATH"' >> ~/.bash_profile` ` - este cambio tiene efecto en la próxima sesión de terminal, así que vuelve a abrir la ventana de terminal antes de compilar ### Múltiples arquitecturas Para compilar nextpnr para varias arquitecturas a la vez, se puede usar una lista separada por punto y coma con `-DARCH`. ``` mkdir -p build && cd build cmake .. -DARCH="ice40;ecp5" make -j$(nproc) sudo make install ``` Para compilar todas las arquitecturas estables disponibles, usa `-DARCH=all`. Para incluir arquitecturas experimentales (actualmente nexus), usa `-DARCH=all+alpha`. ### Himbächel por microarquitectura Para compilar un único ejecutable nextpnr-himbachel para cada una de las microarquitecturas compatibles, usa `-DHIMBAECHEL_SPLIT`. ``` mkdir -p build && cd build cmake .. -DARCH="himbaechel" -DHIMBAECHEL_UARCH="gowin;ng-ultra" make -j$(nproc) sudo make install ``` En una compilación de este tipo, en lugar de un único binario `nextpnr-himbaechel`, se generan dos binarios: `nextpnr-himbaechel-gowin` y `nextpnr-himbaechel-ng-ultra`. Aunque se instalan juntos, cada microarquitectura es completamente independiente de la otra y solo necesita su correspondiente directorio de base de datos de chips `.../share/himbaechel/<microarchitecture>/` para ejecutarse. La compilación dividida reduce el tamaño de los artefactos distribuidos individualmente (aunque el tamaño total aumenta) y permite la coinstalación de artefactos de diferentes versiones. Compilación cruzada ----------------- Además de las bases de datos de chips, nextpnr requiere que la herramienta `bba` se compile para el sistema de compilación. Esta herramienta se puede compilar como un proyecto separado: ``` cd bba cmake . make ``` Esto creará un archivo `bba-export.cmake`. Proporciona la ruta a este archivo cuando compiles nextpnr de forma cruzada usando `-DBBA_IMPORT=/path/to/bba-export.cmake`. Notas adicionales para compilar nextpnr ------------------------------------- Lo siguiente ejecuta una compilación de depuración de la arquitectura iCE40 sin GUI, sin soporte de Python, sin el colocador analítico HeAP y solo con soporte HX1K: ``` mkdir -p build && cd build cmake .. -DARCH=ice40 -DCMAKE_BUILD_TYPE=Debug -DBUILD_PYTHON=OFF -DICE40_DEVICES=1k make -j$(nproc) ``` Para hacer una compilación estática de release para la arquitectura iCE40, usa lo siguiente: ``` mkdir -p build && cd build cmake .. -DARCH=ice40 -DBUILD_PYTHON=OFF -DSTATIC_BUILD=ON make -j$(nproc) ``` El solver del colocador HeAP puede usar opcionalmente OpenMP para acelerar diseños muy grandes. Habilítalo pasando `-DUSE_OPENMP=yes` a cmake (el soporte del compilador puede variar). Puedes cambiar la ubicación donde se instalará nextpnr (normalmente será `/usr/local` por defecto) usando `-DCMAKE_INSTALL_PREFIX=/install/prefix`. Notas para desarrolladores -------------------- - Todo el código se formatea con `clang-format` de acuerdo con las reglas de estilo de `.clang-format` (basado en LLVM con mayores anchos de sangría y ajuste de llaves después de las clases). - Para formatear automáticamente todo el código fuente, ejecuta `make clangformat`. - Consulta la wiki para obtener documentación adicional sobre la API de arquitectura. Grabar un vídeo ----------------- - Para guardar una grabación en vídeo de la colocación y el enrutamiento, haz clic en el icono de grabación de la barra de herramientas, selecciona un directorio vacío donde se almacenarán los archivos de grabación y elige los fotogramas que se deben omitir. - Inicia manualmente todas las operaciones de PnR que desees - Vuelve a hacer clic en el icono de grabación para detener la grabación - Ve al directorio que contiene los archivos y ejecuta `ffmpeg -f image2 -r 1 -i movie_%05d.png -c:v libx264 nextpnr.mp4` Pruebas ------- - Para compilar también los binarios de prueba, usa `-DBUILD_TESTS=ON` y, después de `make`, ejecuta `make test` para ejecutarlos, o puedes ejecutar los binarios por separado. - Para usar sanitizadores de código, usa las opciones de `cmake`: - `-DSANITIZE_ADDRESS=ON` - `-DSANITIZE_MEMORY=ON -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++` - `-DSANITIZE_THREAD=ON` - `-DSANITIZE_UNDEFINED=ON` - Ejemplo de ejecución con valgrind: `valgrind --leak-check=yes --tool=memcheck ./nextpnr-ice40 --json ice40/blinky.json` - Para ejecutar las pruebas con cobertura de código, usa `-DBUILD_TESTS=ON -DCOVERAGE` y, después de `make`, ejecuta `make ice40-coverage` - Después, abre `ice40-coverage/index.html` en tu navegador para ver el informe de cobertura - Ten en cuenta que se necesita `lcov` para generar los informes Enlaces y referencias -------------------- ### Síntesis, simulación y optimización lógica - [Yosys](https://yosyshq.net/yosys/) - [Icarus Verilog](http://iverilog.icarus.com/) - [ABC](https://people.eecs.berkeley.edu/~alanmi/abc/) ### Proyectos de documentación de bitstreams FPGA (y herramientas) - [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) ### Otros proyectos FOSS de colocación y enrutamiento para FPGA - [Arachne PNR](https://github.com/cseed/arachne-pnr) - [VPR/VTR](https://verilogtorouting.org/) - [SymbiFlow](https://github.com/SymbiFlow/symbiflow-arch-defs)
