Chips que puedes recablear
La minería FPGA explicada, de Spartan-6 a VU9P

Capítulo I: Una pequeña discusión en Discord

Todo empezó, como casi todo en el mundo cripto, en un canal de chat. Acabábamos de publicar nuestro bitstream FPGA para Proxima y alguien planteó una pregunta perfectamente razonable: “¿Una GPU no es simplemente mucho mejor y más eficiente?” Otra persona confesó que nunca había tenido una FPGA y que todo aquello parecía tremendamente complicado.

Dos observaciones justas, y ambas merecen una respuesta en condiciones y no una línea suelta entre dos muros de texto sobre publicidad de pools. Así que aquí va: qué son estos chismes, de dónde vienen, por qué pueden ser tan eficientes y, igual de importante, en qué casos son la herramienta completamente equivocada. Intentaremos llevar la jerga bien atada en corto.

Capítulo II: Entonces, ¿qué es exactamente una FPGA?

FPGA son las siglas de Field-Programmable Gate Array, es decir, matriz de puertas programable en campo. Si lo desmenuzas, es bastante literal: una matriz de puertas lógicas que puedes programar “en campo”, o sea, después de que el chip haya salido de la fábrica.

Una CPU o una GPU es un circuito fijo que ejecuta software: va leyendo instrucciones una tras otra y las ejecuta. Una FPGA no ejecuta instrucciones en absoluto. Es una enorme cuadrícula de pequeños bloques de construcción con una centralita telefónica programable entre ellos, y tú decides cómo se conectan esos bloques. Una vez cableado, los datos simplemente fluyen por el circuito que has construido.

Los bloques de construcción son:

• Tablas de consulta (LUT): memorias diminutas capaces de imitar cualquier función lógica de un puñado de entradas. AND, XOR, un trocito de sumador: una LUT se presta encantada a ser cualquiera de ellas.
• Flip-flops: celdas de almacenamiento de un bit que guardan resultados de un ciclo de reloj al siguiente. Son lo que permite construir pipelines (cadenas de etapas).
• Bloques DSP: multiplicadores y sumadores cableados de fábrica para la aritmética pesada.
• Block RAM (y en los chips más nuevos, UltraRAM): pequeñas memorias integradas en el chip, unos pocos megabytes en un modelo de gama media y unas cuantas decenas de megabytes en uno grande. Recuerda esta cifra; más adelante importa.
• Enrutamiento: el cableado programable que conecta todo lo anterior. En una FPGA grande, el enrutamiento ocupa más silicio que la propia lógica.

¿Y el bitstream?

El bitstream es el archivo que fija cada uno de esos interruptores. Describes tu circuito en un lenguaje de descripción de hardware como Verilog o VHDL. Después, las herramientas del fabricante lo sintetizan en LUT y flip-flops, colocan cada pieza en algún lugar del chip, enrutan los cables entre ellas y, por último, comprueban que cada señal llegue a tiempo para el siguiente ciclo de reloj. Ese último paso se llama cierre de temporización (timing closure), y es donde los ingenieros de FPGA envejecen a ojos vista.

Cargas el bitstream (por USB en una placa ZTEX, por JTAG en una tarjeta VU9P) y un chip en blanco se convierte, por ejemplo, en una fila de núcleos BLAKE2b. Cargas otro distinto y el mismo chip pasa a ser un minero de SHA-3, un codificador de vídeo o un filtro de radar. Es el equivalente electrónico de un Mecano que se vuelve a montar solo en menos de un minuto.

¿Para qué se usan normalmente las FPGA?

La minería es un espectáculo secundario. Sus trabajos habituales son mucho más respetables:

• Telecomunicaciones: estaciones base de telefonía móvil y conmutadores de red, donde los estándares cambian más deprisa de lo que nadie tarda en fabricar un chip.
• Trading de alta frecuencia: cuando los nanosegundos valen dinero, pones la lógica de trading directamente en la tarjeta de red.
• Aeroespacial y defensa: radares, satélites y aviónica, donde los volúmenes pequeños hacen que los chips a medida no salgan a cuenta.
• Prueba y medida: las tripas de osciloscopios y analizadores lógicos.
• Aceleración en centros de datos: Microsoft metió FPGA en sus servidores para acelerar Bing, en un caso muy sonado, y Amazon alquila chips VU9P por horas como instancias EC2 F1. Sí, la misma familia de chips con la que minamos Proxima.
• Retro gaming: proyectos como MiSTer recrean consolas y ordenadores domésticos antiguos en hardware en lugar de emularlos por software. Tu Commodore 64 sigue vivo, en forma de puertas lógicas.
• Construir ASIC, que merece capítulo propio.

Capítulo III: Todo ASIC nace como una FPGA

Un ASIC (Application-Specific Integrated Circuit, circuito integrado de aplicación específica) es un chip diseñado para hacer una sola cosa. Un ASIC de Bitcoin hace SHA-256 y absolutamente nada más, que es precisamente por lo que se le da tan bien. El problema es lo que cuesta llegar hasta ahí. Un tape-out moderno implica fotomáscaras, tiradas de ingeniería y meses de fábrica, lo que suma millones de dólares en un proceso de vanguardia, y si hay un fallo en el silicio te toca volver a pagarlo todo.

Por eso nadie con dos dedos de frente manda un diseño a fábrica sin probarlo. El mismo Verilog que acabará siendo el ASIC se ejecuta primero en FPGA: en una sola placa si el diseño es pequeño, o en racks enormes llenos de ellas si es el procesador de un móvil. Las grandes empresas de diseño de chips venden sistemas completos de “prototipado” y emulación construidos con FPGA precisamente para esto. Encuentras los fallos a precio de FPGA en lugar de a precio de fábrica, y el equipo de software puede empezar a escribir drivers meses antes de que exista el silicio de verdad.

El hardware de minería siguió exactamente ese camino. Los núcleos SHA-256 que funcionaban en FPGA en 2011 y 2012 fueron, en espíritu y a menudo en código fuente real, los prototipos de los primeros ASIC de Bitcoin. Butterfly Labs vendía mineros FPGA antes que sus ASIC; los diseños de aficionados demostraron que el pipeline funcionaba y luego los fabricantes de ASIC lo “congelaron” en silicio.

Ese “impuesto por flexibilidad” está bien documentado en la literatura académica: las mediciones clásicas sitúan a una FPGA, muy a grandes rasgos, en 20–35× el área de silicio, unas 10–15× la potencia dinámica y 3–4× más lenta que el mismo circuito hecho ASIC. Lo que plantea la pregunta obvia: si las FPGA pagan un impuesto tan alto, ¿cómo demonios consiguen ganar a las GPU?

Capítulo IV: Por qué un buen bitstream supera a una GPU por vatio

Porque una GPU también paga un impuesto, y con el algoritmo adecuado es todavía mayor.

Una GPU es un magnífico ordenador paralelo de propósito general. En cada ciclo, cada uno de sus decenas de miles de núcleos lee una instrucción, la decodifica, la planifica, lee los operandos de un banco de registros, hace la operación propiamente dicha y escribe el resultado de vuelta. Solo ese paso, la operación en sí, es hashing. Todo lo demás es sobrecarga, y mover datos dentro y fuera de los bancos de registros y las cachés cuesta mucha más energía que la propia aritmética. Una GPU es una orquesta sinfónica que tiene que leer la partitura entera en voz alta antes de tocar cada nota.

Un minero en una FPGA no tiene instrucciones que leer. La función hash es el circuito. Cada ronda del algoritmo se convierte en una etapa de lógica física, las etapas se encadenan en un pipeline y, en cada ciclo de reloj, entra un nonce nuevo por un extremo mientras sale un hash terminado por el otro. No hay decodificación de instrucciones, ni planificador, ni tráfico con el banco de registros: solo datos fluyendo a través de puertas lógicas.

El ejemplo de BLAKE2b: aquí la comida gratis es una rotación gratis

La prueba de trabajo de Proxima es BLAKE2b, y muestra la diferencia de maravilla. BLAKE2b trabaja con palabras de 64 bits usando solo tres operaciones: suma, XOR y rotación de bits (de 32, 24, 16 y 63 bits). Ahora fíjate en lo que tiene que hacer cada tipo de chip:

• En una GPU, las unidades de enteros tienen 32 bits de ancho. Cada suma de 64 bits se convierte en dos sumas de 32 bits más la gestión del acarreo, y cada rotación de 64 bits se convierte en un par de operaciones de desplazamiento. Cada una de ellas es una instrucción, y cada instrucción arrastra la sobrecarga descrita arriba.
• En una FPGA, un sumador de 64 bits se construye directamente en el tejido lógico aprovechando las cadenas de acarreo dedicadas del chip. Y una rotación de una cantidad fija no cuesta absolutamente nada. No es un cálculo: simplemente conectas el cable 0 donde debería ir el cable 24. Cero lógica, cero consumo, cero ciclos de reloj. En algún lugar, una GPU llora en silencio.

Súmale que puedes dimensionar el circuito exactamente para la tarea (nada de carriles de 32 bits haciendo trabajo de 8 bits, nada de unidades de coma flotante ociosas) y obtienes un chip en el que casi cada transistor que conmuta está haciendo hashing útil. Ese es todo el truco.

Los números, con honestidad

Aquí tenemos que ser escrupulosamente justos, porque la edad del chip importa muchísimo. El proceso de fabricación (la cifra en “nm”) es el factor que más pesa en la eficiencia energética, y nuestras FPGA no son precisamente jóvenes.

Mediciones propias con ProxiChorizo (GPU) y suprminer-fpga (FPGA). La cifra de ZTEX corresponde al bitstream de 124 MHz; la prueba de concepto de 100 MHz incluida hace unos 100 MH/s. MH/J = megahashes por julio, es decir, por vatio-segundo.

Lee esa tabla con atención, porque dice dos cosas distintas.

Primero, la vieja placa Spartan-6 no es más eficiente que una GPU moderna. Hace aproximadamente una cuarta parte de los hashes por vatio de la 5090. Pero piensa en lo que es: un chip de 45 nm diseñado en 2009, cuatro o cinco generaciones de proceso por detrás, y aun así se queda a un factor de cuatro del buque insignia actual de NVIDIA. Es como si un Seiscientos de los sesenta aguantara el tipo frente a un utilitario moderno en consumo de gasolina. No gana, pero en realidad ni siquiera debería estar en la carrera. Además consume 25 W, se alimenta por USB, descansa en silencio en una estantería y no necesita una fuente de 1.000 W ni licencia de estufa.

Segundo, una FPGA moderna gana a la GPU sin paliativos. La VU9P tiene ya diez años y va tres generaciones de proceso por detrás de la 5090, y aun así ofrece aproximadamente el doble de hashes por vatio. Pon las dos en el mismo nodo de proceso y la diferencia sería todavía mayor. Esa es la ventaja arquitectónica, lisa y llanamente, una vez que alguien ha hecho el trabajo duro de construir un bitstream que cierre la temporización a una frecuencia de reloj decente.

Capítulo V: Una breve historia, o cuando una estantería de placas parpadeantes reinaba en Bitcoin

2009–2010: primero CPU, luego GPU

Bitcoin se minó al principio con CPU corrientes. En unos dieciocho meses la gente se dio cuenta de que las tarjetas gráficas eran muchísimo mejores en SHA-256, y las Radeon HD 5870 y 5970 se convirtieron en las mulas de carga, con unos pocos cientos de MH/s cada una y haciendo de paso de radiadores bastante eficaces.

2011: llega la FPGA

En 2011 empezaron a aparecer en BitcoinTalk diseños SHA-256 de código abierto para FPGA, primero en placas de desarrollo y después en placas construidas expresamente para minar. El chip más popular, con diferencia, fue la Xilinx Spartan-6 LX150: barata para su tamaño, con lógica de sobra y un consumo modesto. Era el chip adecuado en el momento adecuado.

De ahí salió un pequeño zoológico de placas que los veteranos todavía recuerdan con los ojos húmedos:

• ZTEX USB-FPGA 1.15x y 1.15y, de Alemania: una o cuatro LX150 con un controlador USB, unos 210 MH/s por chip en SHA-256, así que unos 860 MH/s para la 1.15y cuádruple. Plug-and-play para los estándares de la época, y la placa con la que todavía minamos Proxima.
• Cairnsmore1, de Enterpoint en Malvern (Inglaterra): una placa con cuatro LX150 que daba unos 800 MH/s y admitía overclock. Una placa de minería británica, motivo más que suficiente para mencionarla con cierto orgullo y una galleta en la mano.
• Icarus: un diseño de hardware abierto con dos LX150, procedente de China, de unos 380 MH/s.
• X6500: otra placa con dos LX150, de unos 400 MH/s.
• BFL Single de Butterfly Labs: unos 830 MH/s en una caja con un ventilador que se oía en el pueblo de al lado.

El atractivo era la eficiencia. Una Radeon hacía unos 2–3 MH/J en SHA-256; una placa Spartan-6 rondaba los 20. Diez veces más hashes con la misma electricidad, casi en silencio y sin incendios domésticos. cgminer y, más tarde, BFGMiner incorporaron drivers para la mayoría de estas placas, y durante unos dieciocho gloriosos meses los mineros serios eran los que tenían una estantería llena de placas FPGA parpadeando.

2013: sube la marea de los ASIC

Entonces, a principios de 2013, se enviaron los primeros ASIC de Bitcoin. Avalon, los Block Erupters de ASICMiner y, al final, los chips tantas veces retrasados de la propia Butterfly Labs: los núcleos SHA-256 de las FPGA habían quedado congelados en silicio y, de repente, un pincho USB hacía lo mismo que una placa FPGA entera. Tal y como predice el Capítulo III, la FPGA había sido el prototipo y, en cuanto llegó el ASIC, el prototipo quedó obsoleto para ese algoritmo. Miles de placas Spartan-6 acabaron en cajones, desvanes y algún que otro cobertizo.

2017–2020: los años del hierro pesado

Las FPGA volvieron para las altcoins, y esta vez en formato de centro de datos. La estrella fue la Xilinx Virtex UltraScale+ VU9P, un monstruo de 16 nm con aproximadamente 1,2 millones de celdas lógicas. Apareció en las instancias en la nube F1 de Amazon y, lo que es más importante para los mineros, en tarjetas PCIe como la placa de desarrollo VCU1525 y su prima con sabor a minería, la BCU1525. Más tarde llegaron chips aún mayores, como la VU13P de la CVP-13 de Squirrel Research Labs.

Squirrel (SQRL) también fabricó las simpáticas placas Acorn: FPGA Artix-7 en tarjetas M.2 que podías meter en una ranura libre. A su alrededor surgió toda una industria artesanal: desarrolladores de bitstreams que vendían imágenes de algoritmos, a menudo con dev fee, para monedas cuyos algoritmos todavía no tenían ASIC. Algunas monedas incluso fueron en sentido contrario y se diseñaron a propósito para FPGA. Odocrypt, de DigiByte, cambia de algoritmo cada diez días, algo que una FPGA puede seguir con un bitstream nuevo y un ASIC no.

2026: desempolvando las Spartan

Lo que nos trae al presente. El cambio de Proxima a BLAKE2b en noviembre de 2026 dio lugar justo al tipo de algoritmo que encanta a las FPGA: aritmética pura de 64 bits y nada de memoria grande. Así que construimos bitstreams, y hemos publicado el software anfitrión y el bitstream de prueba de concepto para ZTEX como suprminer-fpga. Placas de quince años que se ganaron el pan por última vez con Bitcoin en 2012 vuelven a minar. Hay algo bastante maravilloso en eso.

Capítulo VI: Donde las FPGA son la herramienta equivocada, primera parte: la memoria

Aquí está la pega, y es gorda. ¿Recuerdas la memoria integrada en el chip del Capítulo II? Una FPGA grande como la VU9P tiene unas cuantas decenas de megabytes. Es de sobra para el estado del hash. Y es un desastre para un algoritmo de memoria intensiva.

Los algoritmos de memoria intensiva están diseñados para que cada hash necesite muchos datos que no puedes calcular sobre la marcha y que, por tanto, tienes que ir a buscar. Ethash (el antiguo algoritmo de Ethereum), KawPoW (Ravencoin), Autolykos y los distintos hashes basados en DAG, como el que usa Keryx, trabajan sobre un conjunto de datos de varios gigabytes y leen constantemente de posiciones aleatorias dentro de él (si te apetece, tenemos un artículo entero que explica los DAG). En estos algoritmos, la velocidad la decide el ancho de banda de memoria, no la lógica.

Y el ancho de banda de memoria es justo lo que una GPU para juegos tiene en cantidades obscenas. Una tarjeta moderna de gama alta mueve bastante más de un terabyte por segundo a través de su memoria GDDR. El tejido lógico de una FPGA puede ser todo lo listo que quiera; si está parado esperando datos, no está haciendo hashes.

“¿Y qué pasa con las placas FPGA con memoria?”

Buena pregunta, y la industria lo intentó. Algunas placas añadieron DDR4 (demasiado lenta para este trabajo), y los intentos serios apostaron por la HBM, la memoria apilada de alto ancho de banda que usan los aceleradores de centro de datos: tarjetas construidas en torno a chips Virtex con HBM y las propias tarjetas Alveo HBM de Xilinx. Podían minar Ethash, y algunas lo hacían con bastante dignidad. Pero con unos pocos cientos de gigabytes por segundo de ancho de banda y un precio de varios miles, nunca iban a dejar en evidencia a una GPU, que ofrece un terabyte por segundo por una fracción del coste y que además puedes revender después a un gamer. En un algoritmo limitado por la memoria, la ingeniosa lógica de la FPGA es un motor de Fórmula 1 atornillado a una manguera de jardín.

Capítulo VII: Donde las FPGA son la herramienta equivocada, segunda parte: RandomX y las monedas de CPU

Luego están los algoritmos diseñados desde cero para un tipo de chip muy concreto: el que ya llevas dentro del ordenador. El más conocido es RandomX, que Monero usa desde 2019.

RandomX no hace hashes en el sentido habitual. Para cada hash genera un programa aleatorio y lo ejecuta en una máquina virtual. Esos programas usan aritmética entera y de coma flotante, incluidas operaciones de doble precisión con distintos modos de redondeo, además de saltos condicionales e instrucciones AES. Leen y escriben en un scratchpad dimensionado para caber justito en las cachés de una CPU, y extraen datos de un conjunto de 2 GiB. Cada una de esas decisiones es deliberada. Los diseñadores de RandomX se propusieron que el “ASIC ideal para RandomX” se pareciera exactamente a una CPU moderna, con sus predictores de saltos, su ejecución fuera de orden, sus cachés grandes y su coma flotante rápida.

Entonces, ¿qué tendría que hacer una FPGA? Básicamente, construir una CPU a base de LUT y flip-flops. Los procesadores “soft” en FPGA existen, pero funcionan a unos pocos cientos de megahercios, mientras que el chip de tu sobremesa va a cuatro o cinco gigahercios con décadas de microarquitectura a sus espaldas. Es como intentar ganar a un Rolls-Royce con un coche de kit para montar en casa: técnicamente se puede construir, pero te adelantarán en el carril de incorporación.

Por eso las FPGA no pintan prácticamente nada en la minería de Monero, y por eso las CPU siguen siendo la herramienta adecuada ahí. Lo mismo vale, más o menos, para otros algoritmos orientados a CPU. Nuestra guía de minería con CPU tiene la lista actual.

Capítulo VIII: “Parece complicado”, o bien: ¿lo es de verdad?

Hace una década, sinceramente, sí. Hoy, mucho menos, al menos con las placas ZTEX. La ZTEX 1.15y tiene su propio controlador USB, así que todo el procedimiento es:

1. Conecta la placa al USB y a la corriente. Sin riser PCIe, sin fuente de 1.000 W, sin tocar la BIOS.
2. Compila suprminer-fpga (es un proyecto CMake normal para Linux, y el README te guía paso a paso).
3. Ejecútalo una vez con --program --selftest. Carga el bitstream en las cuatro FPGA y comprueba cada núcleo con respuestas conocidas.
4. Apúntalo a un pool y a minar.

# programar todas las placas ZTEX conectadas y ejecutar el autotest integrado
./suprminer-fpga -a proxima --fpga ztex --program --selftest

# minar Proxima (sustituye los marcadores por tus propios datos)
./suprminer-fpga -a proxima --fpga ztex --account my-account.json \
    --worker rig1 -o stratum+tcp://POOL:PORT

Cada acierto que informa la FPGA lo vuelve a calcular el anfitrión antes de enviarlo, así que una placa defectuosa aparece en el registro como error de hardware y no como shares rechazados. El minero funciona en proxi.suprnova.cc y en cualquier otro pool que implemente el stratum abierto de Suprnova.

Las tarjetas VU9P son más bien un proyecto para aficionados con paciencia: son tarjetas PCIe, así que necesitan un equipo anfitrión, una buena refrigeración y programación por JTAG, y hay que ajustar el voltaje del núcleo antes de cargar el bitstream. El minero se encarga de casi todo, pero no es cosa de enchufar e irse a tomar unas cañas. Hay imágenes ZTEX más rápidas (incluida la de 124 MHz) y bitstreams para VU9P disponibles bajo petición; consulta el repositorio.

Capítulo IX: El veredicto, con la tetera al fuego

Entonces, ¿una GPU es “simplemente mucho mejor”? La respuesta honesta es la que da todo ingeniero y odia todo periodista: depende.

• Por chip y por vatio, en un hash de puro cálculo, un diseño FPGA bien hecho gana con holgura a una GPU de la misma época, y una VU9P de diez años sigue superando a una RTX 5090 recién estrenada por aproximadamente dos a uno.
• Una vieja placa Spartan-6 pierde frente a una GPU moderna en eficiencia, pero consume 25 W, no hace ruido y probablemente estaba cogiendo polvo de todos modos. Para las placas que la gente ya tiene, eso es un final feliz.
• En los algoritmos de memoria intensiva, ganan las GPU gracias a su ancho de banda de memoria, incluso frente a placas FPGA con HBM.
• En RandomX, gana tu CPU, que era precisamente la idea.
• Y siempre que se acumule suficiente dinero en un algoritmo sencillo, tarde o temprano aparecerá un ASIC, y se habrá prototipado en una FPGA.

Las FPGA no son magia ni son el futuro de toda la minería. Son el chip al que recurres cuando un algoritmo es lo bastante sencillo como para convertirlo en cableado, lo bastante valioso como para que merezca un bitstream y lo bastante joven como para que nadie se haya gastado millones en congelarlo en silicio. Proxima, ahora mismo, cumple las tres condiciones. Y hay que reconocer que da un gusto especial ver cómo una placa que minó Bitcoin por última vez cuando el Gangnam Style sonaba en todas las listas vuelve a enviar shares sin hacer ruido.