~/studies/work 2026-11-13 · published 2026-11-21
Lo que cuesta el exactly-once sobre un journal
Números medidos de poner la memoria de un engine de workflows durable detrás de un journal transaccional y un outbox: latencia por paso, throughput del relay y dónde el mismo salto no se pagó.
- workflow
- postgres
- outbox
- latency
- ~/project/versatile-sh
Qué significa la afirmación
Nadie obtiene entrega exactly-once sobre una red. Lo que un engine de workflows durable puede dar son efectos exactly-once: un paso puede ejecutarse dos veces, pero su resultado registrado se escribe una vez y se lee de vuelta en el replay. nagare, el engine de workflows durable en el que trabajo, está construido sobre esa división.
El engine mantiene su intérprete en el host y trata la parte durable como un journal: una secuencia append-only de entradas por ejecución. Los pasos son at-least-once por decisión (ADR-0002). Un paso que se ejecutó pero no se registró vuelve a ejecutarse cuando expira su lease. El journal hace exactly-once todo lo que viene después del registro.
Este post trata de lo que eso cuesta en milisegundos. Todas las cifras salen de las notas de rendimiento del engine, un ADR y un estudio de latencia. Cada una lleva sus condiciones, y ninguna es una promesa para otro hardware.
El mecanismo
- Cada llamada durable (step, now, id, sleep, wait, recv, start-child) toma el siguiente número de secuencia. El replay devuelve la entrada registrada y hace fallar la ejecución como no determinista cuando el kind o la key difieren.
- Una ejecución se arrienda con un fence. Claim incrementa el fence y el conteo de intentos, y cada escritura lleva (run_id, fence). Una escritura con un fence obsoleto no cambia nada, así que un executor zombi no puede sobrescribir al vivo.
- Receive consume un mensaje del mailbox hacia la entrada recv de forma atómica. El mensaje nunca se pierde ni se lee dos veces tras un crash, y un id de dedup queda entregado durante toda la vida de la ejecución.
- Los eventos salen por un outbox transaccional. Un cambio de estado y su fila de evento se confirman en una transacción, y un relay publica después.
El lado del outbox es Postgres llano. Un trigger de statement AFTER INSERT llama a pg_notify, una conexión LISTEN despierta a los workers, y el polling cada 2 s queda como fallback. Los workers se reparten por hash(tenant/kind/stream/epoch) módulo N, así que un stream nunca es atendido por dos workers de un proceso. Las réplicas se reparten el trabajo con FOR UPDATE SKIP LOCKED. Los eventos entregados se liquidan con un UPDATE ... FROM unnest(...) en lugar de una sentencia por evento.
Costo por paso
La primera pregunta era si un journal detrás de un salto gRPC añadiría latencia frente a una librería durable en proceso. El estudio midió un workflow de 3000 pasos no-op que devuelven un resultado de 1 KB, 5 ejecuciones, 1000 pasos de warm-up, Postgres 16 en tmpfs, una máquina.
| Variante | serial p50 | serial p99 | pasos/s, 16 llamadores |
|---|---|---|---|
| DBOS in-process | 752 us | 1776 us | 5810 |
| Direct insert, no hop | 156 us | 309 us | 29913 |
| Remote Record, unix socket | 295 us | 615 us | 18653 |
| Remote Record, tcp | 291 us | 509 us | 15772 |
El salto costó +0.14 ms en p50 y +0.2 a 0.3 ms en p99 sobre un insert directo. El journal remoto fue más rápido por paso que DBOS en proceso, que hace más trabajo por paso: sus propias tablas de sistema, una comprobación y luego una escritura. La lectura del estudio es que DBOS hace más por paso, no que el salto sea gratis.
El ADR volvió a medir entonces con el journal real: 2000 pasos secuenciales de 1 KB, Postgres de compose, gRPC sobre loopback, 3 ejecuciones. El p50 remoto fue de 1.13 a 1.17 ms y el p99 de 1.71 a 1.80 ms. DBOS tuvo p50 de 1.11 a 1.19 ms y p99 de 1.68 a 2.27 ms. En ese punto los dos son indistinguibles. Un paso real es una llamada externa que tarda varios milisegundos, así que 0.3 ms es menos del 10% de ella.
El estudio no midió Claim, Heartbeat, Load, Wake ni Signal, y la tabla de su prototipo no tenía check de fencing. Un Record real es algo más lento que la fila del prototipo. El load average de la ejecución fue de 12 a 21 en 16 núcleos, así que el p99 es ruidoso.
Throughput y el outbox
Dos benchmarks del repositorio del engine cubren el store de Postgres. Ambos corrieron el 2026-11-07 en un AMD Ryzen 7 5700X con Postgres 16 en Docker en el mismo host, con configuración por defecto.
| Benchmark | Condiciones | Resultado |
|---|---|---|
| Transitions | 8 clientes, Create más cuatro llamadas Append por ejecución, inserts de outbox incluidos | 676 a 784 transitions/s |
| Outbox relay | 4 fuentes con sharding, 30000 eventos precargados, lotes de 500, sink no-op | 17000 a 18600 eventos/s |
Así que el relay drena unas 25 veces más rápido de lo que el store produce en esta caja. Esa razón importa más que cualquiera de los dos números: el outbox no es el cuello de botella, lo es el camino de escritura transaccional.
Una tercera medición protege un costo distinto. Las ejecuciones en el nivel 1 del intérprete miran de reojo un mensaje del inbox ya entregado antes de cada llamada o subflow. El gate era como máximo 2 ms de p99 añadido por llamada y como máximo 15% de pérdida de throughput. En 30 workflows de 10 llamadas stub secuenciales, el engine en memoria añadió 0.04 ms por llamada en p99 (3.4% de pérdida de throughput), y el journal remoto no mostró pérdida. Antes de la lectura no bloqueante, la misma ejecución le costaba a Temporal 9.9 ms por llamada.
Dónde el salto no se pagó
El mismo estudio probó la misma idea en otro workload: poner un store transaccional detrás de una sesión en streaming, un round trip por llamada al store. Ese falló su gate, y creo que es la mitad más útil del resultado.
- Una sesión create de 8 llamadas añadió 928 us en p50 sobre un unix socket y 1327 us sobre tcp, con p99 añadido de +2140 us y +2489 us. El gate era 2 ms.
- El throughput mixto con 16 llamadores cayó de 20.6% a 32.5% frente a in-process, contra un límite de 15%.
- Un segundo workload, de orquestación de tests, con sesiones de 7 llamadas perdió de 42 a 47% de throughput en tmpfs.
La causa es estructural. Una transacción y su conexión del pool permanecen abiertas durante cada round trip, así que un pool de 16 conexiones se satura antes y los locks se mantienen más tiempo. Un journal no tiene esa forma: cada Record es una sentencia y una llamada unaria, sin transacción abierta entre llamadas. Mi conclusión es una hipótesis, no una prueba: el salto es barato cuando cada llamada es independiente, y caro cuando las llamadas comparten una transacción.
Límites de estos números
- Una máquina, sockets loopback o unix. No se midió la latencia entre nodos.
- tmpfs abarata los commits. Postgres respaldado por disco estuvo limitado por fsync en la única ejecución en disco que tengo y no fue concluyente.
- Los benchmarks de outbox y transitions son ejecuciones únicas en una fecha. Los rangos son lo que reporta el repositorio.
- El fencing de leases bajo contención, el tiempo de recuperación tras un crash y las esperas largas están cubiertos por tests, no por estos números de latencia.
Lo que me llevaría: los efectos exactly-once son baratos cuando el journal es una interfaz unaria delgada sobre sentencias individuales, y el costo aparece cuando estiras una transacción a través de una red.