~/studies/work 2026-11-13 · published 2026-11-21
O que o exactly-once sobre um journal custa
Números medidos de colocar a memória de um engine de workflows durável atrás de um journal transacional e um outbox: latência por passo, throughput do relay e onde o mesmo salto não se pagou.
- workflow
- postgres
- outbox
- latency
- ~/project/versatile-sh
O que a afirmação significa
Ninguém consegue entrega exactly-once sobre uma rede. O que um engine de workflows durável pode dar são efeitos exactly-once: um passo pode rodar duas vezes, mas seu resultado registrado é escrito uma vez e lido de volta no replay. O nagare, o engine de workflows durável em que trabalho, é construído sobre essa divisão.
O engine mantém seu interpretador no host e trata a parte durável como um journal: uma sequência append-only de entradas por execução. Os passos são at-least-once por decisão (ADR-0002). Um passo que rodou mas não foi registrado roda de novo depois que o lease expira. O journal torna exactly-once tudo que vem depois do registro.
Este post é sobre o que isso custa em milissegundos. Todos os números vêm das notas de desempenho do engine, de um ADR e de um estudo de latência. Cada um traz suas condições, e nenhum é promessa para outro hardware.
O mecanismo
- Toda chamada durável (step, now, id, sleep, wait, recv, start-child) pega o próximo número de sequência. O replay devolve a entrada registrada e falha a execução como não determinística quando o kind ou a key diferem.
- Uma execução é alugada com um fence. Claim incrementa o fence e a contagem de tentativas, e toda escrita carrega (run_id, fence). Uma escrita com fence obsoleto não muda nada, então um executor zumbi não consegue sobrescrever o vivo.
- Receive consome uma mensagem do mailbox para a entrada recv de forma atômica. A mensagem nunca se perde nem é lida duas vezes após um crash, e um id de dedup fica entregue durante toda a vida da execução.
- Os eventos saem por um outbox transacional. Uma mudança de estado e sua linha de evento são confirmadas em uma transação, e um relay publica depois.
O lado do outbox é Postgres puro. Um trigger de statement AFTER INSERT chama pg_notify, uma conexão LISTEN acorda os workers, e o polling a cada 2 s fica como fallback. Os workers fazem shard por hash(tenant/kind/stream/epoch) módulo N, então um stream nunca é atendido por dois workers de um processo. As réplicas dividem o trabalho com FOR UPDATE SKIP LOCKED. Os eventos entregues são liquidados com um UPDATE ... FROM unnest(...) em vez de uma instrução por evento.
Custo por passo
A primeira pergunta era se um journal atrás de um salto gRPC adicionaria latência frente a uma biblioteca durável em processo. O estudo mediu um workflow de 3000 passos no-op que devolvem um resultado de 1 KB, 5 execuções, 1000 passos de warm-up, Postgres 16 em tmpfs, uma máquina.
| Variante | serial p50 | serial p99 | passos/s, 16 chamadores |
|---|---|---|---|
| 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 |
O salto custou +0.14 ms em p50 e +0.2 a 0.3 ms em p99 sobre um insert direto. O journal remoto foi mais rápido por passo que o DBOS em processo, que faz mais trabalho por passo: suas próprias tabelas de sistema, uma verificação e então uma escrita. A leitura do estudo é que o DBOS faz mais por passo, não que o salto seja de graça.
O ADR então mediu de novo com o journal real: 2000 passos sequenciais de 1 KB, Postgres do compose, gRPC sobre loopback, 3 execuções. O p50 remoto foi de 1.13 a 1.17 ms e o p99 de 1.71 a 1.80 ms. O DBOS teve p50 de 1.11 a 1.19 ms e p99 de 1.68 a 2.27 ms. Nesse ponto os dois são indistinguíveis. Um passo real é uma chamada externa que leva vários milissegundos, então 0.3 ms é menos de 10% dela.
O estudo não mediu Claim, Heartbeat, Load, Wake nem Signal, e a tabela do protótipo não tinha check de fencing. Um Record real é um pouco mais lento que a linha do protótipo. O load average da execução foi de 12 a 21 em 16 núcleos, então o p99 é ruidoso.
Throughput e o outbox
Dois benchmarks no repositório do engine cobrem o store de Postgres. Ambos rodaram em 2026-11-07 em um AMD Ryzen 7 5700X com Postgres 16 em Docker no mesmo host, com configuração padrão.
| Benchmark | Condições | Resultado |
|---|---|---|
| Transitions | 8 clientes, Create mais quatro chamadas Append por execução, inserts de outbox incluídos | 676 a 784 transitions/s |
| Outbox relay | 4 fontes com shard, 30000 eventos pré-carregados, lotes de 500, sink no-op | 17000 a 18600 eventos/s |
Ou seja, o relay drena umas 25 vezes mais rápido do que o store produz nesta caixa. Essa razão importa mais que qualquer um dos dois números: o outbox não é o gargalo, o caminho de escrita transacional é.
Uma terceira medição protege um custo diferente. As execuções no nível 1 do interpretador dão uma espiada em uma mensagem do inbox já entregue antes de cada chamada ou subflow. O gate era no máximo 2 ms de p99 adicionado por chamada e no máximo 15% de perda de throughput. Em 30 workflows de 10 chamadas stub sequenciais, o engine em memória adicionou 0.04 ms por chamada em p99 (3.4% de perda de throughput), e o journal remoto não mostrou perda. Antes da leitura não bloqueante, a mesma execução custava ao Temporal 9.9 ms por chamada.
Onde o salto não se pagou
O mesmo estudo testou a mesma ideia em outro workload: colocar um store transacional atrás de uma sessão em streaming, um round trip por chamada ao store. Esse falhou no gate, e acho que é a metade mais útil do resultado.
- Uma sessão create de 8 chamadas adicionou 928 us em p50 sobre um unix socket e 1327 us sobre tcp, com p99 adicionado de +2140 us e +2489 us. O gate era 2 ms.
- O throughput misto com 16 chamadores caiu de 20.6% a 32.5% frente a in-process, contra um limite de 15%.
- Um segundo workload, de orquestração de testes, com sessões de 7 chamadas perdeu de 42 a 47% de throughput em tmpfs.
A causa é estrutural. Uma transação e sua conexão do pool ficam abertas durante cada round trip, então um pool de 16 conexões satura mais cedo e os locks são segurados por mais tempo. Um journal não tem esse formato: cada Record é uma instrução e uma chamada unária, sem transação aberta entre chamadas. Minha conclusão é uma hipótese, não uma prova: o salto é barato quando cada chamada é independente, e caro quando as chamadas compartilham uma transação.
Limites desses números
- Uma máquina, sockets loopback ou unix. A latência entre nós não foi medida.
- tmpfs barateia os commits. O Postgres em disco ficou limitado por fsync na única execução em disco que tenho e foi inconclusivo.
- Os benchmarks de outbox e transitions são execuções únicas em uma data. As faixas são o que o repositório reporta.
- O fencing de leases sob contenção, o tempo de recuperação após crash e as esperas longas são cobertos por testes, não por estes números de latência.
O que eu levaria: efeitos exactly-once são baratos quando o journal é uma interface unária fina sobre instruções individuais, e o custo aparece quando você estica uma transação por uma rede.