~/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.

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.

Varianteserial p50serial p99passos/s, 16 chamadores
DBOS in-process752 us1776 us5810
Direct insert, no hop156 us309 us29913
Remote Record, unix socket295 us615 us18653
Remote Record, tcp291 us509 us15772

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.

BenchmarkCondiçõesResultado
Transitions8 clientes, Create mais quatro chamadas Append por execução, inserts de outbox incluídos676 a 784 transitions/s
Outbox relay4 fontes com shard, 30000 eventos pré-carregados, lotes de 500, sink no-op17000 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.