La gpu de 600 que perdio contra la de 300

El plan

Para quien no esté en esto: estábamos montando una pequeña infraestructura para generar mensajes automáticamente, con n8n organizando una cola de tareas (a través de Redis) y un modelo de lenguaje corriendo en local con llama.cpp para no depender de servicios externos. El modelo era un Qwen3.5-2B-AWQ — pequeño, nada espectacular en tamaño, pero de sobra para lo que necesitábamos.

Antes de meterlo en producción quería saber qué tan rápido podía responder ese modelo: los "tokens por segundo" (tps), básicamente la velocidad a la que el modelo "escribe" la respuesta.

Tenía dos gráficas para probarlo:

• Una RTX 4060 Ti de 16GB — la cara, la moderna, la que en teoría tenía que ganar sin discusión.
• Una RTX 2060 — vieja, con menos memoria, comprada hace años para otra cosa.

El primer susto

Hice la prueba. Ganó la 2060.

No guardé aquel benchmark (lo borré, como un genio), pero la diferencia se me quedó grabada: la 4060 Ti rondaba los 70 tokens por segundo, y la 2060 estaba entre 120 y 140. El doble. La gráfica de 300€ le estaba dando una paliza, en tokens por segundo, a la de 600€.

La pista del bus de memoria

Le di vueltas y terminé comentándolo con Claude (la IA, no el compañero), a ver si encontrábamos alguna explicación. Llegamos a dos posibles culpables:

1. Pude lanzar mal alguna instancia o configurar algo distinto entre las dos pruebas — nunca lo descarté del todo.
2. El bus de memoria — y este es el que más me convenció.

La RTX 2060 tiene un bus de 192 bits que le da unos 336 GB/s de ancho de banda. La 4060 Ti, pese a ser más nueva y tener más VRAM, se quedó con un bus de 128 bits — unos 288 GB/s. Nvidia recortó ahí para abaratar el chip, y en una tarea donde lo que más pesa es mover datos dentro y fuera de la memoria una y otra vez (que es justo lo que hace generar texto token a token, uno detrás de otro), ese recorte se nota. La gráfica "inferior" tenía, en ese aspecto muy concreto, mejores números que la cara.

Pudo ser eso. Pudo ser que metí mal algún parámetro. La cuestión es que, con llama.cpp, sin concurrencia, ganó la 2060. Eso pasó, con explicación clara o sin ella.

El plan real era otro

Pero el plan real nunca fue atender una petición sola detrás de otra. El plan era manejar una cola con varios mensajes esperando a la vez, como un camarero que tiene que atender varias mesas y no una sola. Para eso, llama.cpp no era la herramienta — necesitaba algo pensado para servir muchas peticiones en paralelo. Así que pasé a usar vLLM.

Y ahí la historia cambió del todo.

Con solo 5 usuarios escribiendo a la vez, la 4060 Ti ya remontaba: más tokens por segundo y, sobre todo, mucho menos tiempo de espera hasta que aparecía la primera palabra. Y cuando empujé la concurrencia a 64 usuarios simultáneos, la diferencia se volvió absurda — la 4060 Ti llegó a picos de más de 2.200 tokens por segundo, algo que la 2060 ni se planteaba.

La gráfica "lenta" en realidad nunca fue lenta. Era buena en un trabajo muy concreto: aguantar una conversación sola, sin compañía, donde el ancho de banda de memoria manda. En el momento en que tuvo que repartirse entre varios usuarios a la vez, el cuello de botella cambió de sitio, y la 4060 Ti —con más músculo de cálculo y más memoria para repartir— empezó a demostrar por qué costaba el doble.

La lección

No hay vuelta de tuerca dramática aquí, solo una lección que ya deberíamos habernos aplicado antes de comprar nada: el benchmark que haces tiene que parecerse al trabajo que vas a hacer de verdad.

Probar una gráfica con una sola petición cuando el plan final es atender una cola de mensajes de varios usuarios es como elegir coche probándolo solo en el garaje. Se mueve, sí. Pero eso no te dice nada de cómo se va a comportar en la carretera.