Serving de LLMs con vLLM

Qué vas a provocar: Sacar tú los números de bolsillo del C10 desde el config.json del modelo: parámetros, pesos por dtype, KV por token, lugar para KV, secuencias, la línea que imprimiría vLLM y la ley de Little.

Necesitas: Python 3 de macOS (solo stdlib); sin GPU ni internet.

1. Paso 1Copiar

   mkdir -p ~/lab-vllm && cd ~/lab-vllm
   cat > bolsillo.py <<'EOF'
   # bolsillo.py: los números de bolsillo del C10, desde el config.json del modelo (solo stdlib)
   import math
   
   # config.json de Llama 3.3 70B Instruct: la arquitectura con que el C10 hace sus cuentas
   d, capas, heads, kv_heads, ffn, vocab = 8192, 80, 64, 8, 28672, 128256
   head_dim = d // heads  # 8192 ÷ 64 = 128
   por_capa = (2 * d * d                      # q y o
               + 2 * d * kv_heads * head_dim  # k y v: solo 8 KV heads (GQA)
               + 3 * d * ffn                  # gate, up y down del MLP
               + 2 * d)                       # las dos RMSNorm
   P = capas * por_capa + 2 * vocab * d + d   # + embeddings y lm_head (no comparten pesos) + la norma final
   print(f"parámetros: {P:,} ≈ {P / 1e9:.1f} B (embeddings + lm_head: {2 * vocab * d / 1e9:.1f} B)")
   for nombre, b in (("BF16", 2), ("FP8", 1), ("INT4", 0.5)):
       print(f"  pesos en {nombre}: {P * b / 1e9:.1f} GB")
   
   kv = 2 * capas * kv_heads * head_dim * 2   # K y V × capas × KV heads × head_dim × 2 B (BF16)
   print(f"KV por token: {kv:,} B = {kv // 1024} KiB en BF16, {kv // 2 // 1024} KiB en FP8; "
         f"con un KV head por head ({heads}): {kv * heads // kv_heads / 2**20:.1f} MiB")
   
   # Una réplica del C10 (los números redondos del caso): 2 × H100 de 80 GB, TP=2, pesos FP8
   libre = 2 * 80e9 * 0.90 - 70.6e9 - 5e9     # gpu_memory_utilization 0.90, ≈ 5 GB de overhead (estimación)
   seq = 2_250 * kv                           # 2,000 de prompt + 250 de salida
   print(f"lugar para KV: {libre / 1e9:.1f} GB; una secuencia de 2,250 tokens: {seq / 1e9:.3f} GB; "
         f"caben {libre / seq:.2f} → {math.floor(libre / seq)}")
   bloques = math.floor((libre / 2) // (16 * kv / 2))  # por GPU: la mitad del lugar y la mitad de los KV heads
   print(f"como lo cuenta vLLM: {bloques:,} bloques de 16 → GPU KV cache size: {bloques * 16:,} tokens, "
         f"Maximum concurrency for 8,192 tokens per request: {bloques / (8192 // 16):.2f}x")
   
   ttft, tpot, n = 0.5, 0.040, 250
   e2e = ttft + (n - 1) * tpot
   print(f"E2E = {ttft} + {n - 1} × {tpot} = {e2e:.2f} s; Little: 60 rps × 10.5 s = {60 * 10.5:.0f} vivas "
         f"÷ 16 réplicas = {60 * 10.5 / 16:.1f} por réplica")
   EOF

   Qué deberías ver: Sin salida: el archivo queda escrito. Los enteros del principio son los del config.json de Llama 3.3 70B Instruct (hidden_size, num_hidden_layers, num_attention_heads, num_key_value_heads, intermediate_size y vocab_size).

2. Paso 2Copiar

   python3 bolsillo.py

   Qué deberías ver: Ocho líneas: parámetros: 70,553,706,496 ≈ 70.6 B (embeddings + lm_head: 2.1 B); pesos en BF16 141.1 GB, en FP8 70.6 GB y en INT4 35.3 GB; KV por token: 327,680 B = 320 KiB en BF16, 160 KiB en FP8, y 2.5 MiB con un KV head por head (sin GQA); lugar para KV: 68.4 GB, una secuencia de 2,250 tokens 0.737 GB, caben 92.77 → 92; como lo cuenta vLLM: 13,046 bloques de 16 → GPU KV cache size: 208,736 tokens, Maximum concurrency for 8,192 tokens per request: 25.48x; y E2E = 0.5 + 249 × 0.04 = 10.46 s con Little: 630 vivas ÷ 16 réplicas = 39.4 por réplica. Los 141.1 GB salen de la cuenta exacta; el C10 redondea a 70.6 × 2 = 141.2.

3. Paso 3Copiar

   cd ~ && rm -rf ~/lab-vllm

   Qué deberías ver: Nada: no queda rastro del lab.

Probado de verdad en macOS (Apple M4), con Python 3.14.3 y 3.9.6. La misma salida, byte a byte. Los 70,553,706,496 parámetros son los 70.6 B del C10; los bloques y la línea de vLLM siguen vllm/v1/core/kv_cache_utils.py de v0.30.0 (bloques enteros por GPU; tokens = concurrencia × max_model_len).

Qué vas a provocar: Recorrer la cadena de un request con streaming en un motor de juguete: ver cada eslabón con su hora y los eventos SSE que llegan al cliente, y medir TTFT, TPOT, ITL y E2E con las fórmulas de vllm bench serve. Después, poner un proxy con buffer en el medio y ver qué le pasa al TTFT.

Necesitas: Python 3 de macOS (solo stdlib); sin GPU ni internet.

1. Paso 1Copiar

   mkdir -p ~/lab-vllm && cd ~/lab-vllm
   cat > cadena.py <<'EOF'
   # cadena.py: un request de chat con streaming recorriendo la cadena, en miniatura (solo stdlib; tiempos simulados)
   import json, queue, sys, threading, time
   
   COLA_S, PREFILL_S, PASO_S, MAX_TOKENS = 0.10, 0.40, 0.040, 30  # TTFT ≈ 0.5 s y ≈ 40 ms por token, como el C10
   CON_PROXY = "--proxy" in sys.argv
   t0 = time.perf_counter()
   
   
   def log(eslabon, texto):
       print(f"  [vLLM  +{time.perf_counter() - t0:5.2f} s] {eslabon:<10} {texto}", flush=True)
   
   
   def motor(salida):  # lo que pasa dentro de vLLM, simulado con sleeps
       log("tokenizer", "chat template + tokenizer: 2,000 tokens de prompt (2,000 + 30 ≤ 8,192: entra)")
       time.sleep(COLA_S)
       log("scheduler", "sale de waiting y entra al batch")
       time.sleep(PREFILL_S)
       log("prefill", "los 2,000 tokens, de una vez: su KV queda en 125 bloques de 16; sale el token 1")
       reloj = time.perf_counter()
       for i in range(1, MAX_TOKENS + 1):
           if i > 1:  # un paso de decode: relee los pesos y el KV de todo el batch
               reloj += PASO_S
               time.sleep(max(0.0, reloj - time.perf_counter()))  # contra el reloj: sleep solo se pasa de largo
           fin = "length" if i == MAX_TOKENS else None  # llegó a max_tokens
           salida.put("data: " + json.dumps({"choices": [{"index": 0, "delta": {"content": f" t{i}"}, "finish_reason": fin}]}))
       salida.put("data: " + json.dumps({"choices": [], "usage": {"prompt_tokens": 2000, "completion_tokens": MAX_TOKENS,
                                                                   "total_tokens": 2000 + MAX_TOKENS}}))
       salida.put("data: [DONE]")
       log("fin", f"{MAX_TOKENS} tokens = max_tokens → finish_reason length; se liberan sus bloques")
   
   
   def proxy_con_buffer(entrada, salida):  # un proxy que junta toda la respuesta antes de reenviarla
       eventos = []
       while not eventos or eventos[-1] != "data: [DONE]":
           eventos.append(entrada.get())
       for e in eventos:
           salida.put(e)
   
   
   hacia_motor, hacia_cliente = queue.Queue(), queue.Queue()
   st = time.perf_counter()  # como vllm bench serve: el reloj arranca al mandar el request
   if CON_PROXY:
       threading.Thread(target=motor, args=(hacia_motor,)).start()
       threading.Thread(target=proxy_con_buffer, args=(hacia_motor, hacia_cliente)).start()
   else:
       threading.Thread(target=motor, args=(hacia_cliente,)).start()
   
   ttft, ultimo, itl, n = None, st, [], 0
   while True:
       linea = hacia_cliente.get()
       ahora = time.perf_counter()
       if linea == "data: [DONE]":
           print(f"  [cliente +{ahora - st:5.2f} s] {linea}")
           break
       evento = json.loads(linea[len("data: "):])
       if not evento["choices"]:  # el chunk de usage (stream_options.include_usage)
           usage = evento["usage"]
           print(f"  [cliente +{ahora - st:5.2f} s] data: {{\"choices\": [], \"usage\": {json.dumps(usage)}}}")
           continue
       if ttft is None:
           ttft = ahora - st  # el primer chunk con choices
       else:
           itl.append(ahora - ultimo)  # el hueco desde el chunk anterior
       ultimo, n = ahora, n + 1
       if n <= 2 or n == MAX_TOKENS:
           print(f"  [cliente +{ahora - st:5.2f} s] {linea}")
       elif n == 3:
           print("  [cliente   ...  ] (un evento cada ≈ 40 ms)" if not CON_PROXY else "  [cliente   ...  ] (todos juntos)")
   
   e2e = ultimo - st
   tpot = (e2e - ttft) / (usage["completion_tokens"] - 1)  # la fórmula de vllm bench serve
   itl.sort()
   print(f"TTFT {ttft:.2f} s · TPOT {tpot * 1e3:.1f} ms · ITL p50 {itl[len(itl) // 2] * 1e3:.1f} ms · E2E {e2e:.2f} s"
         f" · {usage['completion_tokens'] / e2e:.1f} tokens/s{' (con proxy)' if CON_PROXY else ''}")
   EOF

   Qué deberías ver: Sin salida: el archivo queda escrito. Es una simulación: no hay modelo ni GPU. vLLM de verdad manda antes un evento que solo trae el rol, sin texto (sección 5); aquí se omite. Los tiempos son los del C10 (cola 0.1 s y prefill 0.4 s, para un TTFT ≈ 0.5 s, y 40 ms por token), con una respuesta de 30 tokens para que dure menos de 2 s.

2. Paso 2Copiar

   python3 cadena.py

   Qué deberías ver: Tres líneas [vLLM …] (tokenizer en +0.00 s, scheduler en ≈ +0.10 s y prefill en ≈ +0.50 s), los eventos data: con " t1", " t2"…, uno cada ≈ 40 ms, la línea [vLLM … fin] y el último evento con " t30" y "finish_reason": "length" en ≈ +1.67–1.69 s, el de usage (prompt_tokens 2000, completion_tokens 30) y data: [DONE]. Al final: TTFT 0.50–0.52 s · TPOT ≈ 40 ms · ITL p50 ≈ 40 ms · E2E ≈ 1.67–1.69 s · ≈ 18 tokens/s.

3. Paso 3Copiar

   python3 cadena.py --proxy

   Qué deberías ver: El motor hace lo mismo, pero el cliente no ve nada hasta ≈ +1.67–1.69 s: entonces llegan todos los eventos juntos. Al final: TTFT ≈ 1.67–1.69 s · TPOT 0.0 ms · ITL p50 0.0 ms · E2E igual al TTFT. El servidor generó igual de rápido; la persona esperó toda la respuesta para ver la primera palabra.

4. Paso 4Copiar

   cd ~ && rm -rf ~/lab-vllm

   Qué deberías ver: Nada: no queda rastro del lab.

Probado de verdad en un Mac. Ejecutado con Python 3.14.3 y 3.9.6 en macOS (Apple M4), varias veces (y 14 más en la revisión): directo, TTFT 0.50–0.52 s, TPOT 40.0–40.3 ms y E2E 1.67–1.69 s; con el proxy, TTFT = E2E = 1.67–1.69 s. Las fórmulas de TTFT, ITL, TPOT y E2E son las de vllm/benchmarks/serve.py y vllm/benchmarks/lib/endpoint_request_func.py de v0.30.0.

Qué vas a provocar: Calcular, con la réplica del C10 y la hoja de datos de la H100, por qué el prefill es cómputo y el decode es memoria: operaciones por byte, el piso del prefill y el de cada paso de decode con 1, 40 y 92 secuencias.

Necesitas: Python 3 de macOS (solo stdlib); sin GPU ni internet.

1. Paso 1Copiar

   mkdir -p ~/lab-vllm && cd ~/lab-vllm
   cat > roofline.py <<'EOF'
   # roofline.py: por qué el prefill es cómputo y el decode es memoria, en una réplica del C10 (solo stdlib)
   P, B_PESO, TP = 70.6e9, 1, 2   # parámetros, bytes por peso (FP8) y GPUs de la réplica
   FLOPS = 1_979e12               # H100 SXM, FP8 denso, por GPU (la hoja dice 3,958 "with sparsity")
   BW = 3.35e12                   # H100 SXM: 3.35 TB/s de memoria, por GPU
   KV = 327_680                   # bytes de KV por token en BF16 (sección 0)
   print(f"punto de quiebre de una H100 en FP8: {FLOPS / BW:.0f} FLOPs por byte leído")
   
   # Prefill: 2 FLOPs por parámetro y por token; los pesos se leen UNA vez para todo el prompt
   T = 2_000
   flops, bytes_ = 2 * P * T, P * B_PESO + T * KV          # + escribir el KV del prompt
   print(f"prefill de {T:,} tokens: {flops / bytes_:,.0f} FLOPs/B → manda el cómputo; "
         f"piso {flops / (TP * FLOPS) * 1e3:.0f} ms ({flops / (TP * FLOPS / 2) * 1e3:.0f} ms en BF16)")
   
   # Decode: un token por secuencia por paso; cada paso relee TODOS los pesos y el KV de cada secuencia
   for B in (1, 40, 92):
       flops, bytes_ = 2 * P * B, P * B_PESO + B * 2_250 * KV  # KV de B secuencias de 2,250 tokens (peor caso)
       paso = bytes_ / (TP * BW)
       print(f"decode, batch de {B:>2}: {flops / bytes_:5.1f} FLOPs/B → manda la memoria; paso ≥ {paso * 1e3:4.1f} ms"
             f" → ≤ {1 / paso:3.0f} tokens/s por secuencia, ≤ {B / paso:5,.0f} en total")
   EOF

   Qué deberías ver: Sin salida: el archivo queda escrito.

2. Paso 2Copiar

   python3 roofline.py

   Qué deberías ver: punto de quiebre de una H100 en FP8: 591 FLOPs por byte leído; prefill de 2,000 tokens: 3,963 FLOPs/B → manda el cómputo; piso 71 ms (143 ms en BF16); y tres líneas de decode: batch de 1, 2.0 FLOPs/B y paso ≥ 10.6 ms (≤ 94 tokens/s); batch de 40, 56.4 FLOPs/B y paso ≥ 14.9 ms (≤ 67 tokens/s por secuencia, ≤ 2,678 en total); batch de 92, 93.8 FLOPs/B y paso ≥ 20.7 ms (≤ 48 por secuencia, ≤ 4,453 en total). Aun con 92 secuencias, el decode queda ≈ 6× por debajo del punto de quiebre: más batch sube el total, no la velocidad de cada usuario.

3. Paso 3Copiar

   cd ~ && rm -rf ~/lab-vllm

   Qué deberías ver: Nada: no queda rastro del lab.

Probado de verdad en macOS (Apple M4), con Python 3.14.3 y 3.9.6. La misma salida, byte a byte. Datos de la H100 SXM de la página de NVIDIA: 80 GB, 3.35 TB/s y 3,958 TFLOPS FP8 with sparsity.

Qué vas a provocar: Ver cómo valida la ventana vLLM v0.30 y cómo lo hace v0.32 (con sus mensajes reales), cuánto cuesta un request del C10, cuánto más pesa una respuesta en español y qué estima el gateway antes de tokenizar.

Necesitas: Python 3 de macOS (solo stdlib); sin GPU ni internet.

1. Paso 1Copiar

   mkdir -p ~/lab-vllm && cd ~/lab-vllm
   cat > presupuesto.py <<'EOF'
   # presupuesto.py: la ventana de contexto como la valida vLLM, lo que cuesta un token y cuánto pesa el español (solo stdlib)
   import math
   
   CTX = 8192  # --max-model-len del C10
   
   
   def v030(prompt, max_tokens):  # vllm/renderers/params.py en v0.30.0: max_tokens se RESERVA de la ventana
       if max_tokens is not None and prompt > CTX - max_tokens:
           return (f"400 This model's maximum context length is {CTX} tokens. However, you requested {max_tokens} output "
                   f"tokens and your prompt contains {prompt} input tokens, for a total of {prompt + max_tokens} tokens. "
                   "Please reduce the length of the input prompt or the number of requested output tokens.")
       return f"entra: genera hasta {min(x for x in (CTX - prompt, max_tokens) if x is not None):,} tokens"
   
   
   def v032(prompt, max_tokens):  # desde v0.32.0: max_tokens es un tope; solo el prompt tiene que caber
       if prompt > CTX:
           return (f"400 This model's maximum context length is {CTX} tokens. However, your prompt contains {prompt} "
                   "input tokens, which exceeds this limit even without any output tokens. Please reduce the length of the input prompt.")
       return f"entra: genera hasta {min(x for x in (CTX - prompt, max_tokens) if x is not None):,} tokens"
   
   
   for prompt, max_tokens in ((2_000, 1_024), (7_500, 1_024), (2_000, None), (8_300, 256)):
       print(f"prompt {prompt:,} + max_tokens {max_tokens}:")
       print(f"  v0.30 → {v030(prompt, max_tokens)}")
       print(f"  v0.32 → {v032(prompt, max_tokens)}")
   
   # Precios de lista ILUSTRATIVOS del C10 (US$ por millón de tokens)
   P_IN, P_OUT = 2.50, 10.00
   costo = (2_000 * P_IN + 250 * P_OUT) / 1e6
   print(f"un request de soporte (2,000 de entrada + 250 de salida): US${costo:.4f}; la salida es el "
         f"{250 * P_OUT / 1e6 / costo:.0%} del costo con el {250 / 2_250:.0%} de los tokens")
   
   # Fertilidad del tokenizer de Llama 3.1-70B en noticias (Nayeem et al., 2025): tokens por palabra
   for idioma, f in (("inglés", 1.23), ("español", 1.61)):
       t = round(200 * f)
       print(f"una respuesta de 200 palabras en {idioma}: ≈ {t} tokens → US${t * P_OUT / 1e6:.5f}, "
             f"≈ {t * 0.040:.1f} s de decode a 40 ms por token, {t * 327_680 / 1e6:.0f} MB de KV")
   
   # La estimación del gateway del C10 (gateway/quota.py), copiada tal cual
   CHARS_PER_TOKEN = 3.0
   TOKENS_PER_MESSAGE = 4
   
   
   def estimate_prompt_tokens(messages):
       chars = sum(len(m["content"]) for m in messages)
       return math.ceil(chars / CHARS_PER_TOKEN) + TOKENS_PER_MESSAGE * len(messages)
   
   
   chats = {
       "español": [{"role": "system", "content": "Eres el asistente de soporte del marketplace. Responde breve y con amabilidad."},
                   {"role": "user", "content": "Hola, compré unos audífonos hace diez días y todavía no llegan. ¿Me ayudas a rastrear mi pedido?"}],
       "inglés": [{"role": "system", "content": "You are the marketplace's support assistant. Answer briefly and kindly."},
                  {"role": "user", "content": "Hi, I bought some headphones ten days ago and they still haven't arrived. Can you help me track my order?"}],
   }
   for idioma, msgs in chats.items():
       palabras = sum(len(m["content"].split()) for m in msgs)
       f = 1.61 if idioma == "español" else 1.23
       print(f"chat en {idioma}: {sum(len(m['content']) for m in msgs)} caracteres, {palabras} palabras → gateway "
             f"{estimate_prompt_tokens(msgs)} tokens (caracteres ÷ 3 + 4 por mensaje); por palabra, ≈ {round(palabras * f)}")
   EOF

   Qué deberías ver: Sin salida: el archivo queda escrito. Las dos funciones de validación siguen vllm/renderers/params.py de v0.30.0 y de v0.32.0, con sus mensajes; estimate_prompt_tokens es la de gateway/quota.py del C10 (la versión del lab solo acepta content de texto). Con un prompt de texto, el vLLM real deja de tokenizar un token después del límite y su mensaje dice «at least 7169 … at least 8193»; el lab muestra el largo completo, como cuando mandas token IDs a /v1/completions.

2. Paso 2Copiar

   python3 presupuesto.py | head -n 12

   Qué deberías ver: Cuatro casos. 2,000 + 1,024: entra en las dos y genera hasta 1,024. 7,500 + 1,024: v0.30 → 400 This model's maximum context length is 8192 tokens. However, you requested 1024 output tokens and your prompt contains 7500 input tokens, for a total of 8524 tokens. Please reduce the length of the input prompt or the number of requested output tokens.; v0.32 → entra: genera hasta 692 tokens. 2,000 sin max_tokens: las dos generan hasta 6,192. 8,300 + 256: las dos dan 400, y el texto de v0.32 dice which exceeds this limit even without any output tokens.

3. Paso 3Copiar

   python3 presupuesto.py | tail -n 5

   Qué deberías ver: un request de soporte (2,000 de entrada + 250 de salida): US$0.0075, y la salida es el 33% del costo con el 11% de los tokens; 200 palabras en inglés ≈ 246 tokens (US$0.00246, ≈ 9.8 s de decode, 81 MB de KV) y en español ≈ 322 (US$0.00322, ≈ 12.9 s, 106 MB); y los dos chats: en español, 174 caracteres y 29 palabras → gateway 66 tokens, ≈ 47 por palabra; en inglés, 176 caracteres y 30 palabras → gateway 67, ≈ 37 por palabra. Las dos son estimaciones: los tokens reales los da POST /tokenize con el modelo servido.

4. Paso 4Copiar

   cd ~ && rm -rf ~/lab-vllm

   Qué deberías ver: Nada: no queda rastro del lab.

Probado de verdad en macOS (Apple M4), con Python 3.14.3 y 3.9.6. La misma salida, byte a byte. Los mensajes de error son los de vllm/renderers/params.py en las etiquetas v0.30.0 y v0.32.0 (PR #57035), sin el «at least» que vLLM agrega cuando corta la tokenización; la fertilidad, la de la tabla 1 de Nayeem et al. (2025).

Qué vas a provocar: Simular el pool de bloques de KV de una réplica del C10: cuántos bloques hay, cuántas secuencias caben y qué pasa con 72, 92 y 128 requests en vuelo, con el KV en BF16 y en FP8, y con fcfs (por orden de llegada) contra priority (por prioridad).

Necesitas: Python 3 de macOS (solo stdlib); sin GPU ni internet.

1. Paso 1Copiar

   mkdir -p ~/lab-vllm && cd ~/lab-vllm
   cat > bloques.py <<'EOF'
   # bloques.py: el pool de bloques de KV de una réplica del C10 y la preemption, en miniatura (solo stdlib)
   # Modelo simplificado del scheduler de vLLM V1: bloques de 16 tokens, primero los que ya corren, después la cola;
   # si a uno que corre le falta un bloque, sale el último admitido (fcfs) o el de menor prioridad (priority) y
   # después recalcula todo su prefill. Sin chunked prefill ni prefix caching: el peor caso.
   import math
   
   BLOQUE, TP = 16, 2
   LIBRE = 2 * 80e9 * 0.90 - 70.6e9 - 5e9  # 68.4 GB para KV en la réplica (sección 0)
   
   
   def bloques_totales(kv_token):  # como vLLM: por GPU (la mitad del lugar y de los KV heads), bloques enteros
       return math.floor((LIBRE / TP) // (BLOQUE * kv_token / TP))
   
   
   def simular(en_vuelo, kv_token=327_680, max_num_seqs=128, politica="fcfs", batch=0, prompt=2_000, salida=250, total=1_000):
       """Barrido cerrado, como vllm bench serve --max-concurrency: siempre hay `en_vuelo` requests vivos.
       `batch` de ellos tienen priority 10 (el batch nocturno) y el resto 0 (interactivo), como manda el gateway."""
       libres = bloques_totales(kv_token)
       nuevo = lambda i, prio: {"gen": 0, "bloques": 0, "prio": prio, "llegada": i}
       waiting, running = [nuevo(i, 10 if i >= en_vuelo - batch else 0) for i in range(en_vuelo)], []
       llegadas, hechos, preempt, por_prio, pasos, pico, recalc = en_vuelo, 0, 0, {0: 0, 10: 0}, 0, 0, 0
       while hechos < total:
           pasos += 1
           i = 0
           while i < len(running):  # 1) decode: cada secuencia que corre necesita lugar para su token nuevo
               r = running[i]
               falta = math.ceil((prompt + r["gen"]) / BLOQUE) - r["bloques"]
               while falta > libres:  # sin bloque libre: preemption
                   v = max(running, key=lambda x: (x["prio"], x["llegada"])) if politica == "priority" else running[-1]
                   running.remove(v)
                   libres += v["bloques"]
                   v["bloques"] = 0  # vuelve al frente de la cola; al reentrar recalcula prompt + lo generado
                   waiting.insert(0, v)
                   preempt += 1
                   por_prio[v["prio"]] += 1
                   if v is r:
                       break
               if r not in running:  # el que necesitaba lugar salió él mismo
                   continue
               i = running.index(r)  # con priority, el desalojado pudo estar antes en la lista
               libres -= falta
               r["bloques"] += falta
               r["gen"] += 1
               if r["gen"] == salida:  # terminó: libera sus bloques y entra otro request de la misma clase
                   running.remove(r)
                   libres += r["bloques"]
                   hechos += 1
                   waiting.append(nuevo(llegadas, r["prio"]))
                   llegadas += 1
                   continue
               i += 1
           if politica == "priority":
               waiting.sort(key=lambda x: (x["prio"], x["llegada"]))
           while waiting and len(running) < max_num_seqs:  # 2) admitir de la cola mientras haya bloques
               w = waiting[0]
               necesita = math.ceil((prompt + w["gen"]) / BLOQUE)
               if necesita > libres:
                   break
               waiting.pop(0)
               if w["gen"]:  # volvía de una preemption: su prefill se repite entero
                   recalc += prompt + w["gen"]
               libres -= necesita
               w["bloques"] = necesita
               w["gen"] += 1  # el prefill termina con un token
               running.append(w)
           pico = max(pico, len(running))
       return preempt, por_prio, pasos, pico, recalc
   
   
   B16 = bloques_totales(327_680)
   print(f"bloques de KV en la réplica: {B16:,} → GPU KV cache size: {B16 * BLOQUE:,} tokens, "
         f"Maximum concurrency for 8,192 tokens per request: {B16 / (8192 // BLOQUE):.2f}x")
   print(f"una secuencia de 2,250 tokens usa {math.ceil(2_250 / BLOQUE)} bloques → caben {B16 // math.ceil(2_250 / BLOQUE)}; "
         f"si cada una reservara 8,192 contiguos (512 bloques), {B16 // 512}")
   casos = [("72 en vuelo (el tope del gateway: 4 × 288 ÷ 16 réplicas)", dict(en_vuelo=72)),
            ("92 en vuelo", dict(en_vuelo=92)),
            ("128 en vuelo (= --max-num-seqs)", dict(en_vuelo=128)),
            ("128 en vuelo con KV en FP8", dict(en_vuelo=128, kv_token=163_840)),
            ("128 en vuelo, fcfs: 72 chat + 56 batch", dict(en_vuelo=128, batch=56)),
            ("128 en vuelo, priority: 72 chat + 56 batch", dict(en_vuelo=128, politica="priority", batch=56))]
   for nombre, kw in casos:
       p, prio, pasos, pico, recalc = simular(**kw)
       extra = f" (chat {prio[0]}, batch {prio[10]})" if kw.get("batch") else ""
       print(f"{nombre}: {p:,} preemptions{extra}, {recalc:,} tokens recalculados; {pasos:,} pasos para 1,000 requests;"
             f" hasta {pico} a la vez")
   EOF

   Qué deberías ver: Sin salida: el archivo queda escrito. Es un modelo simplificado del scheduler de V1: todos los prompts de 2,000 tokens, salidas de 250, sin chunked prefill ni prefix caching.

2. Paso 2Copiar

   python3 bloques.py

   Qué deberías ver: bloques de KV en la réplica: 13,046 → GPU KV cache size: 208,736 tokens, Maximum concurrency for 8,192 tokens per request: 25.48x; una secuencia de 2,250 tokens usa 141 bloques → caben 92, y reservando 8,192 contiguos (512 bloques), 25. Después: con 72 en vuelo, 0 preemptions (3,487 pasos para 1,000 requests); con 92, 0 (2,740 pasos); con 128, 130 preemptions y 273,100 tokens recalculados, hasta 104 a la vez y los mismos 2,740 pasos; con 128 y el KV en FP8, 0 (1,993 pasos, 128 a la vez); con 72 chats y 56 batch en fcfs, 130 preemptions (chat 72, batch 58); y en priority, 130 (chat 0, batch 130).

3. Paso 3Copiar

   cd ~ && rm -rf ~/lab-vllm

   Qué deberías ver: Nada: no queda rastro del lab.

Probado de verdad en macOS (Apple M4), con Python 3.14.3 y 3.9.6. La misma salida, byte a byte. Las reglas del scheduler (desalojar al último admitido en fcfs, o al de menor prioridad y llegada más tardía en priority; liberar sus bloques, volverlo al frente de la cola y recalcular desde 0) son las de vllm/v1/core/sched/scheduler.py en v0.30.0; la cuenta de bloques, la de vllm/v1/core/kv_cache_utils.py.

Qué vas a provocar: Correr los pasos 2 a 4 del init container fetch-weights sobre una revisión falsa y ver qué atrapa cada uno: un archivo cambiado, un archivo agregado y un SHA256SUMS reescrito.

Necesitas: Una terminal de macOS o Linux con sh, sha256sum (o shasum), find, sed, sort, cut y comm. Nada que instalar, sin AWS ni GPU: el paso 1 del init container (aws s3 sync) se reemplaza por archivos falsos.

1. Paso 1Copiar

   mkdir -p ~/lab-vllm/models/rev-1 && cd ~/lab-vllm/models/rev-1
   printf '{"architectures": ["LlamaForCausalLM"], "num_hidden_layers": 80}\n' > config.json
   printf '{"version": "1.0"}\n' > tokenizer.json
   head -c 1048576 /dev/urandom > model-00001-of-00002.safetensors
   head -c 1048576 /dev/urandom > model-00002-of-00002.safetensors
   sha256sum config.json model-0000*.safetensors tokenizer.json > SHA256SUMS
   export MANIFEST_SHA256="$(sha256sum SHA256SUMS | cut -c1-64)"
   wc -l < SHA256SUMS; echo "$MANIFEST_SHA256" | cut -c1-12

   Qué deberías ver: 4 (las líneas de SHA256SUMS: hash, dos espacios y nombre) y los primeros 12 caracteres del hash del manifiesto, distintos en cada corrida. En producción ese hash lo escribe el pipeline de release en el YAML. Los safetensors son 1 MB de bytes al azar: no hay modelo.

2. Paso 2Copiar

   cat > ~/lab-vllm/verificar.sh <<'EOF'
   #!/bin/sh
   # Pasos 2 a 4 del init container fetch-weights (reference/c10/k8s/vllm-70b.yaml, líneas 133-149)
   set -eu
   cd "$1"
   echo "${MANIFEST_SHA256}  SHA256SUMS" | sha256sum -c -
   sha256sum -c SHA256SUMS
   find . -type f ! -name SHA256SUMS | sed 's|^\./||' | sort > ~/lab-vllm/descargados  # el YAML: find -printf '%P\n' (GNU)
   cut -c67- SHA256SUMS | sort > ~/lab-vllm/esperados
   extra="$(comm -23 ~/lab-vllm/descargados ~/lab-vllm/esperados)"
   if [ -n "$extra" ]; then
     echo "archivos que no están en SHA256SUMS: $extra" >&2
     exit 1
   fi
   echo "listo: vllm serve puede arrancar"
   EOF
   sh ~/lab-vllm/verificar.sh ~/lab-vllm/models/rev-1; echo "exit=$?"

   Qué deberías ver: SHA256SUMS: OK, después config.json, los dos safetensors y tokenizer.json: OK, y «listo: vllm serve puede arrancar» con exit=0.

3. Paso 3Copiar

   cp model-00002-of-00002.safetensors ~/lab-vllm/respaldo.bin
   printf 'x' >> model-00002-of-00002.safetensors
   sh ~/lab-vllm/verificar.sh ~/lab-vllm/models/rev-1; echo "exit=$?"
   cp ~/lab-vllm/respaldo.bin model-00002-of-00002.safetensors

   Qué deberías ver: SHA256SUMS: OK, pero model-00002-of-00002.safetensors: FAILED y el aviso sha256sum: WARNING: 1 computed checksum did NOT match (en macOS puede salir antes de la lista), con exit=1. Un byte de más alcanza. El último cp deja el archivo como estaba.

4. Paso 4Copiar

   printf '{%% for m in messages %%}{{ m.content }}{%% endfor %%}\n' > chat_template.jinja
   sh ~/lab-vllm/verificar.sh ~/lab-vllm/models/rev-1; echo "exit=$?"
   rm chat_template.jinja

   Qué deberías ver: Cinco OK (sha256sum -c solo revisa lo que está listado) y después archivos que no están en SHA256SUMS: chat_template.jinja, con exit=1. Un template de chat agregado podría cambiar cómo se arma cada prompt sin tocar un solo peso: para eso está el paso 4.

5. Paso 5Copiar

   printf '{"version": "1.0", "added_tokens": ["<|tool|>"]}\n' > tokenizer.json
   sha256sum config.json model-0000*.safetensors tokenizer.json > SHA256SUMS
   sh ~/lab-vllm/verificar.sh ~/lab-vllm/models/rev-1; echo "exit=$?"

   Qué deberías ver: SHA256SUMS: FAILED (con el WARNING) y exit=1, antes de mirar ningún archivo. Quien cambia un archivo y regenera el manifiesto no puede cambiar el hash fijado en el YAML: eso agrega el paso 2.

6. Paso 6Copiar

   cd ~ && rm -rf ~/lab-vllm

   Qué deberías ver: Sin salida.

Probado de verdad en un Mac. Ejecutado en macOS 26.6.2 con /bin/sh, el sha256sum de Darwin y el find de BSD; también se probó shasum -a 256. El YAML usa find -printf '%P\n' (GNU findutils, el de la imagen de aws-cli); aquí va find | sed, que da la misma lista en BSD y en GNU.

Qué vas a provocar: Levantar un servidor falso con la forma de la API de vLLM y leerlo: con curl, un request normal, un stream con include_usage y un modelo equivocado; con un cliente de 30 líneas, el mismo stream parseado evento por evento.

Necesitas: Python 3 sin paquetes extra y curl, que vienen en macOS y en Linux. Ni vLLM ni GPU: el mock responde palabras fijas, no es un modelo.

1. Paso 1Copiar

   mkdir -p ~/lab-vllm && cd ~/lab-vllm
   cat > mock_vllm.py <<'EOF'
   # mock_vllm.py: un servidor con la forma de la API de vLLM (solo stdlib). NO es un modelo: responde
   # palabras fijas, una por "token", con 0.3 s hasta el primer token y 40 ms entre tokens.
   import json, os, time, uuid
   from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
   
   MODEL = "chat-70b-fp8-2026-09-28"           # el --served-model-name del C10
   RESPUESTA = "Tu pedido sale mañana y llega en dos o tres días hábiles .".split()
   TTFT_S, TPOT_S = 0.3, 0.04
   
   class Handler(BaseHTTPRequestHandler):
       def log_message(self, *args):            # sin una línea de log por request
           pass
   
       def _json(self, code, obj):
           body = json.dumps(obj, ensure_ascii=False).encode()
           self.send_response(code)
           self.send_header("Content-Type", "application/json")
           self.send_header("Content-Length", str(len(body)))
           self.end_headers()
           self.wfile.write(body)
   
       def do_GET(self):
           if self.path == "/health":            # 200 si el motor vive (vLLM: 503 si murió)
               self.send_response(200); self.send_header("Content-Length", "0"); self.end_headers()
           elif self.path == "/v1/models":
               self._json(200, {"object": "list", "data": [{"id": MODEL, "object": "model",
                                "root": "/models/" + MODEL, "max_model_len": 8192}]})
           else:
               self._json(404, {"error": {"message": "Not Found", "type": "NotFoundError", "code": 404}})
   
       def do_POST(self):
           req = json.loads(self.rfile.read(int(self.headers["Content-Length"])))
           if req.get("model") != MODEL:         # el mismo texto que devuelve vLLM v0.30.0
               return self._json(404, {"error": {"message": f"The model `{req.get('model')}` does not exist.",
                                                 "type": "NotFoundError", "param": "model", "code": 404}})
           tope = req.get("max_completion_tokens") or req.get("max_tokens") or len(RESPUESTA)
           palabras = RESPUESTA[:tope]
           fin = "length" if len(RESPUESTA) > tope else "stop"   # length: se cortó por el tope
           prompt = sum(len(m["content"].split()) for m in req["messages"])   # palabras como tokens
           usage = {"prompt_tokens": prompt, "completion_tokens": len(palabras),
                    "total_tokens": prompt + len(palabras)}
           base = {"id": "chatcmpl-" + uuid.uuid4().hex[:8], "created": int(time.time()), "model": MODEL}
           if not req.get("stream"):
               time.sleep(TTFT_S + TPOT_S * (len(palabras) - 1))
               return self._json(200, dict(base, object="chat.completion", usage=usage, choices=[
                   {"index": 0, "message": {"role": "assistant", "content": " ".join(palabras)},
                    "finish_reason": fin}]))
           self.send_response(200)
           self.send_header("Content-Type", "text/event-stream")
           self.send_header("Cache-Control", "no-cache")
           self.end_headers()
           def evento(obj):                      # un evento SSE: "data: {json}" y una línea vacía
               self.wfile.write(f"data: {json.dumps(obj, ensure_ascii=False)}\n\n".encode())
               self.wfile.flush()
           chunk = dict(base, object="chat.completion.chunk")
           try:
               time.sleep(TTFT_S)                # cola + prefill
               evento(dict(chunk, choices=[{"index": 0, "delta": {"role": "assistant", "content": ""},
                                            "finish_reason": None}]))
               for i, p in enumerate(palabras):
                   if i:
                       time.sleep(TPOT_S)        # un paso de decode
                   ultimo = i == len(palabras) - 1
                   evento(dict(chunk, choices=[{"index": 0, "delta": {"content": (" " if i else "") + p},
                                                "finish_reason": fin if ultimo else None}]))
               if (req.get("stream_options") or {}).get("include_usage"):
                   evento(dict(chunk, choices=[], usage=usage))   # choices vacío: solo la cuenta
               self.wfile.write(b"data: [DONE]\n\n")
           except (BrokenPipeError, ConnectionResetError):
               print(f"[mock] el cliente cortó en el token {i + 1}: vLLM abortaría el request y liberaría su KV",
                     flush=True)
   
   if __name__ == "__main__":
       puerto = int(os.environ.get("PORT", "18000"))
       print(f"[mock] escuchando en http://localhost:{puerto}", flush=True)
       ThreadingHTTPServer(("127.0.0.1", puerto), Handler).serve_forever()
   EOF
   python3 mock_vllm.py & echo $! > ~/lab-vllm/mock.pid
   sleep 1
   curl -s -o /dev/null -w '%{http_code}\n' localhost:18000/health
   curl -s localhost:18000/v1/models; echo

   Qué deberías ver: [mock] escuchando en http://localhost:18000, después 200 y la lista con id chat-70b-fp8-2026-09-28, su root y max_model_len 8192. El mock usa el puerto 18000 para no chocar con un Triton o un vLLM que tengas en el 8000.

2. Paso 2Copiar

   curl -s localhost:18000/v1/chat/completions -H 'Content-Type: application/json' \
     -d '{"model": "chat-70b-fp8-2026-09-28", "messages": [{"role": "user", "content": "¿Cuándo llega mi pedido?"}], "max_completion_tokens": 5}'; echo

   Qué deberías ver: A los ≈ 0.46 s, un JSON con message.content "Tu pedido sale mañana y", finish_reason "length" (se cortó en 5) y usage con prompt_tokens 4, completion_tokens 5 y total_tokens 9. El mock cuenta palabras como si fueran tokens.

3. Paso 3Copiar

   curl -sN localhost:18000/v1/chat/completions -H 'Content-Type: application/json' \
     -d '{"model": "chat-70b-fp8-2026-09-28", "messages": [{"role": "user", "content": "¿Cuándo llega mi pedido?"}], "stream": true, "stream_options": {"include_usage": true}, "max_completion_tokens": 4}'

   Qué deberías ver: Siete eventos data:, separados por líneas vacías: el rol (content vacío), Tu, pedido, sale, mañana (este con finish_reason length), el del usage con choices: [] y data: [DONE]. Los dos primeros (el rol y Tu) llegan juntos a los ≈ 0.3 s; cada token siguiente, ≈ 40 ms después; el usage y el [DONE], enseguida del último.

4. Paso 4Copiar

   cat > leer_sse.py <<'EOF'
   # leer_sse.py: un cliente mínimo de SSE, como el lector del gateway del C10 (solo stdlib).
   import http.client, json
   
   def eventos(resp):                     # junta líneas data: hasta una línea vacía: eso es un evento
       datos = []
       for linea in resp:
           linea = linea.decode().rstrip("\r\n")
           if linea == "":
               if datos:
                   yield "\n".join(datos)
                   datos = []
           elif linea.startswith("data:"):
               datos.append(linea[5:].lstrip())   # "data: {...}" → "{...}"
           # las líneas ": comentario", "event:" e "id:" no las usa la API de OpenAI
   
   conn = http.client.HTTPConnection("localhost", 18000)
   conn.request("POST", "/v1/chat/completions", json.dumps({
       "model": "chat-70b-fp8-2026-09-28", "stream": True, "stream_options": {"include_usage": True},
       "messages": [{"role": "user", "content": "¿Cuándo llega mi pedido?"}]}),
       {"Content-Type": "application/json"})
   texto, fin, usage = [], None, None
   for ev in eventos(conn.getresponse()):
       if ev == "[DONE]":                 # no es JSON: el fin del stream
           break
       chunk = json.loads(ev)
       if chunk.get("usage"):
           usage = chunk["usage"]
       for choice in chunk["choices"]:     # en el chunk de usage, la lista viene vacía
           texto.append(choice["delta"].get("content") or "")
           fin = choice.get("finish_reason") or fin
   print("texto:", "".join(texto))
   print("finish_reason:", fin, "· usage:", usage)
   try:
       chunk["choices"][0]                 # lo que hace un cliente apurado con el último chunk
   except IndexError as e:
       print("choices[0] en el chunk de usage:", type(e).__name__ + ":", e)
   EOF
   python3 leer_sse.py

   Qué deberías ver: texto: Tu pedido sale mañana y llega en dos o tres días hábiles . (el punto es un token aparte), finish_reason: stop · usage: {'prompt_tokens': 4, 'completion_tokens': 13, 'total_tokens': 17} y, al final, choices[0] en el chunk de usage: IndexError: list index out of range. El lector junta líneas data: hasta una línea vacía, corta en [DONE] y recorre choices sin suponer que trae algo.

5. Paso 5Copiar

   curl -s -w '\nHTTP %{http_code}\n' localhost:18000/v1/chat/completions -H 'Content-Type: application/json' \
     -d '{"model": "chat-default", "messages": [{"role": "user", "content": "hola"}]}'

   Qué deberías ver: {"error": {"message": "The model `chat-default` does not exist.", "type": "NotFoundError", "param": "model", "code": 404}} y HTTP 404: chat-default es un alias del gateway, no un nombre que conozca vLLM. Es el mismo mensaje que devuelve vLLM v0.30.0.

6. Paso 6Copiar

   kill "$(cat ~/lab-vllm/mock.pid)"
   cd ~ && rm -rf ~/lab-vllm

   Qué deberías ver: Sin salida, o un aviso de la terminal de que el proceso en segundo plano terminó. El puerto 18000 queda libre.

Probado de verdad en un Mac. Ejecutado en macOS 26.6.2 con Python 3.14.3 y curl 8.7.1 (leer_sse.py también con 3.13.16 y 3.9.6): las salidas son las de arriba. El texto del 404 y el orden de los eventos (rol, tokens, finish_reason en el último texto, usage con choices vacío y [DONE]) siguen el código de vLLM v0.30.0; los chunks reales traen más campos. El corte de la sección fix se probó 8 veces: el aviso sale siempre, en el token 5 o 6.

Qué vas a provocar: Ver paso a paso por qué continuous batching ocupa más la GPU que el batching estático, y cómo el presupuesto de tokens por paso mueve el TTFT de un prompt nuevo contra el hueco que sienten los demás.

Necesitas: Python 3, sin paquetes extra. Ni vLLM ni GPU.

1. Paso 1Copiar

   mkdir -p ~/lab-vllm && cd ~/lab-vllm
   cat > bus.py <<'EOF'
   # bus.py: batching estático contra continuous batching, paso a paso (solo stdlib).
   # 6 requests llegan juntos; cada una necesita n tokens de salida; hay 4 lugares en el batch.
   # En cada paso, cada secuencia del batch saca 1 token (el primero sale del paso de su prefill).
   PEDIDOS = {"A": 3, "B": 8, "C": 2, "D": 5, "E": 4, "F": 3}
   LUGARES = 4
   
   def estatico():
       filas, cola = [[] for _ in range(LUGARES)], list(PEDIDOS)
       while cola:
           grupo, cola = cola[:LUGARES], cola[LUGARES:]       # el bus sale lleno y vuelve vacío
           largo = max(PEDIDOS[r] for r in grupo)            # espera al más lento del grupo
           for lugar in range(LUGARES):
               r = grupo[lugar] if lugar < len(grupo) else None
               filas[lugar] += [f"{r}{t + 1}" if r and t < PEDIDOS[r] else "·" for t in range(largo)]
       return filas
   
   def continuo():
       filas, cola = [[] for _ in range(LUGARES)], list(PEDIDOS)
       activo, hecho = [None] * LUGARES, {}
       while cola or any(activo):
           for lugar in range(LUGARES):                     # en cada paso: sube el que espera
               if activo[lugar] is None and cola:
                   r = cola.pop(0)
                   activo[lugar], hecho[r] = r, 0
           for lugar, r in enumerate(activo):
               if r is None:
                   filas[lugar].append("·")
                   continue
               hecho[r] += 1
               filas[lugar].append(f"{r}{hecho[r]}")
               if hecho[r] == PEDIDOS[r]:
                   activo[lugar] = None                     # baja al terminar: el lugar queda libre
       return filas
   
   for nombre, filas in (("estático", estatico()), ("continuo", continuo())):
       pasos = len(filas[0])
       utiles = sum(c != "·" for f in filas for c in f)
       print(f"{nombre}: {pasos} pasos, {utiles} de {pasos * LUGARES} lugares-paso con trabajo ({utiles / (pasos * LUGARES):.0%})")
       for lugar, f in enumerate(filas):
           print(f"  lugar {lugar + 1}: " + " ".join(f"{c:>2}" for c in f))
       primero = {c[0]: i + 1 for f in filas for i, c in enumerate(f) if c.endswith("1") and len(c) == 2}
       print("  primer token (paso):", " ".join(f"{r}={primero[r]}" for r in PEDIDOS))
   EOF
   python3 bus.py

   Qué deberías ver: estático: 12 pasos, 25 de 48 lugares-paso con trabajo (52%), con la grilla del lugar 1 A1 A2 A3 · · · · · E1 E2 E3 E4 y primer token E=9 F=9. continuo: 8 pasos, 25 de 32 (78%), lugar 1 A1 A2 A3 F1 F2 F3 · · y primer token E=3 F=4. Las mismas 25 unidades de trabajo, un tercio menos de pasos.

2. Paso 2Copiar

   cat > trozos.py <<'EOF'
   # trozos.py: chunked prefill con un modelo de juguete del tiempo de un paso (ILUSTRATIVO, no medido):
   #   paso = 45 ms (72 decodes, ≈ el TPOT del codo del C10) + 0.075 ms por token de prefill
   #   (≈ 150 ms por 2,000 tokens, el número de ejemplo de M14).
   # Llega un prompt de 6,000 tokens sin caché mientras 72 secuencias generan.
   import math
   
   DECODES, PROMPT = 72, 6000
   
   def paso_ms(tokens_prefill):
       return 45 + 0.075 * tokens_prefill
   
   print(" budget  pasos de prefill  TTFT del nuevo  peor hueco de los 72")
   for budget in (8192, 2048, 512):
       trozo = budget - DECODES                    # primero entran los 72 decodes, el resto es prefill
       pasos = math.ceil(PROMPT / trozo)
       trozos = [trozo] * (pasos - 1) + [PROMPT - trozo * (pasos - 1)]
       tiempos = [paso_ms(t) for t in trozos]
       print(f"{budget:>7} {pasos:>17} {sum(tiempos):>12.0f} ms {max(tiempos):>17.0f} ms")
   print(f"sin el prompt nuevo: un paso de decode = {paso_ms(0):.0f} ms para los 72")
   EOF
   python3 trozos.py

   Qué deberías ver: 8192: 1 paso de prefill, TTFT del nuevo 495 ms y peor hueco de los 72 495 ms · 2048: 4 pasos, 630 ms y 193 ms · 512: 14 pasos, 1080 ms y 78 ms; sin el prompt nuevo, un paso de decode = 45 ms. Presupuesto chico: los que generan casi no lo sienten, el nuevo espera más.

3. Paso 3Copiar

   cd ~ && rm -rf ~/lab-vllm

   Qué deberías ver: Sin salida.

Probado de verdad en un Mac. Ejecutado en macOS 26.6.2 con Python 3.14.3, 3.13.16 y 3.9.6: salidas idénticas. bus.py simplifica (un token por paso y por secuencia, el primero en el paso del prefill); el orden de trozos.py, primero los decodes y después el prefill hasta llenar el presupuesto, es el del scheduler de vLLM V1 (v0.30.0).

Qué vas a provocar: Leer el barrido del C10 como lo hace pick_concurrency.py (comprobar Little y el throughput, y elegir el codo) y ver por qué un TPOT que cumple el SLO puede esconder tirones que el ITL sí muestra.

Necesitas: Python 3 sin paquetes extra y el repo del curso (el paso 1 copia los fixtures y pick_concurrency.py). Ni vLLM ni GPU.

1. Paso 1Copiar

   mkdir -p ~/lab-vllm/results
   cp apps/ml-system-design/reference/c10/bench/tests/fixtures/sweep-c*.json ~/lab-vllm/results/
   cp apps/ml-system-design/reference/c10/bench/tests/fixtures/p99-only.json apps/ml-system-design/reference/c10/bench/pick_concurrency.py ~/lab-vllm/
   cd ~/lab-vllm && ls results

   Qué deberías ver: sweep-c016.json, sweep-c032.json … sweep-c096.json: los siete puntos sintéticos del barrido. Este paso se corre desde la raíz del repo del curso.

2. Paso 2Copiar

   cat > barrido.py <<'EOF'
   # barrido.py: lee los JSON de vllm bench serve --save-result (uno por concurrencia) y comprueba
   # Little, el throughput y el codo con los SLOs del C10 (solo stdlib).
   import json, sys
   
   TTFT_SLO, TPOT_SLO = 1000, 50                    # ms, p95 (los del C10)
   puntos = sorted((json.load(open(f)) for f in sys.argv[1:]), key=lambda d: d["max_concurrency"])
   print("   c  req/s  W=c/λ (s)  TTFT+249·TPOT (s)  tok/s  λ·250  TTFT p95  TPOT p95  goodput")
   elegido, roto = None, False
   for d in puntos:
       c, lam = d["max_concurrency"], d["request_throughput"]
       n_out = d["total_output_tokens"] / d["completed"]                 # 250 tokens por request
       w_little = c / lam                                                # Little: W = L / λ
       w_medido = (d["mean_ttft_ms"] + (n_out - 1) * d["mean_tpot_ms"]) / 1000
       ok = d["p95_ttft_ms"] <= TTFT_SLO and d["p95_tpot_ms"] <= TPOT_SLO
       roto = roto or not ok             # después del primer punto malo no se elige otro: sería ruido
       if ok and not roto:
           elegido = d
       print(f"{c:>4} {lam:>6.2f} {w_little:>10.2f} {w_medido:>18.2f} {d['output_throughput']:>6.0f} "
             f"{lam * n_out:>6.0f} {d['p95_ttft_ms']:>6.0f} ms {d['p95_tpot_ms']:>5.1f} ms "
             f"{d['request_goodput'] / lam:>7.0%}  {'ok' if ok else 'fuera'}")
   lam = elegido["request_throughput"]
   print(f"codo: c = {elegido['max_concurrency']} → {lam:.2f} req/s; planeado al 70 %: {lam * 0.7:.2f} req/s por réplica")
   EOF
   python3 barrido.py results/sweep-c*.json

   Qué deberías ver: Siete filas: W = c/λ y TTFT + 249 × TPOT dan lo mismo en cada una (6.16, 7.98 … 15.04 s: los fixtures se armaron con Little), tok/s = λ × 250, el goodput baja de 100 % a 95 % en 72 y a 42 % en 96, y 80 y 96 salen fuera. Al final: codo: c = 72 → 6.06 req/s; planeado al 70 %: 4.24 req/s por réplica.

3. Paso 3Copiar

   python3 pick_concurrency.py results/sweep-c*.json --ttft-ms 1000 --tpot-ms 50 --percentile 95
   python3 pick_concurrency.py p99-only.json; echo "exit=$?"

   Qué deberías ver: La misma elección: ← elegida en 72, capacidad: 6.06 req/s a x=72; planeada al 70%: 4.24 req/s por réplica y goodput: 95% de los requests cumplen el SLO uno por uno. Con p99-only.json: error: p99-only.json: faltan ['p95_ttft_ms', 'p95_tpot_ms'] (hay ['p99_ttft_ms']) y la orden de correr vllm bench serve con --metric-percentiles 50,95,99, con exit=2. Es lo que pasa si olvidas --metric-percentiles.

4. Paso 4Copiar

   cat > tirones.py <<'EOF'
   # tirones.py: por qué el TPOT puede cumplir el SLO mientras la persona siente tirones (solo stdlib).
   # 100 requests de 250 tokens = 249 huecos cada uno. Un hueco normal dura ≈ 43 ms; un paso que trae
   # un prefill grande, ≈ 150 ms. Las cuentas son las de vllm bench serve: TPOT por request (promedio de
   # sus huecos) e ITL con los huecos de todos los requests juntos. Números de juguete, no medidos.
   import random, statistics
   
   def pct(xs, q):                                  # percentil con interpolación lineal, como numpy
       xs = sorted(xs)
       k = (len(xs) - 1) * q / 100
       i = int(k)
       return xs[i] + (xs[min(i + 1, len(xs) - 1)] - xs[i]) * (k - i)
   
   def barrido(frac_saltos, semilla=7):
       rnd = random.Random(semilla)
       tpots, itl = [], []
       for _ in range(100):
           huecos = [rnd.gauss(150, 20) if rnd.random() < frac_saltos else max(30.0, rnd.gauss(43, 3))
                     for _ in range(249)]
           tpots.append(statistics.fmean(huecos))  # = (E2E − TTFT) / (250 − 1)
           itl += huecos
       return tpots, itl
   
   for frac in (0.02, 0.06):
       tpots, itl = barrido(frac)
       veredicto = "cumple" if pct(tpots, 95) <= 50 else "no cumple"
       print(f"{frac:.0%} de pasos con prefill: TPOT p50 {pct(tpots, 50):.1f} · p95 {pct(tpots, 95):.1f} ms ({veredicto} 50 ms)"
             f" | ITL p50 {pct(itl, 50):.1f} · p95 {pct(itl, 95):.1f} · p99 {pct(itl, 99):.1f} ms")
   EOF
   python3 tirones.py

   Qué deberías ver: Con 2 % de pasos con prefill: TPOT p50 45.0 · p95 47.0 ms (cumple 50 ms) e ITL p50 43.1 · p95 48.6 · p99 150.6 ms. Con 6 %: TPOT p95 51.9 ms (no cumple) e ITL p95 130.6 · p99 168.8 ms. El TPOT promedia los tirones dentro de cada request; el ITL junta los huecos de todos y su p99 los muestra, como en los fixtures (TPOT p95 49.6 ms con ITL p99 109 ms en c = 72).

5. Paso 5Copiar

   cd ~ && rm -rf ~/lab-vllm

   Qué deberías ver: Sin salida.

Probado de verdad en un Mac. Ejecutado en macOS 26.6.2 con Python 3.14.3, 3.13.16 y 3.9.6: salidas idénticas (tirones.py usa una semilla fija). Las cuentas de tirones.py son las de vllm/benchmarks/serve.py en v0.30.0: TPOT por request y la lista de ITL de todos los requests juntos, con percentiles interpolados. Los 12 tests de bench/tests también pasan (pytest 9.1.1, Python 3.14.3).