~/studies/work 2026-11-13 · published 2026-11-21
Um salto de plugin que não se pagou
Um estudo de latência para o tsugite, o protocolo de plugins: um journal atrás de uma chamada remota passou no gate, mas uma transação de banco de dados transmitida por um plugin falhou nos dois limites, em dois engines.
- tsugite
- latency
- grpc
- postgres
- negative-result
- ~/project/versatile-sh
A pergunta
tsugite é o protocolo que permite que um plugin fora de processo sirva os ports de um engine. Antes de construir a metade de store, eu queria saber quanto custa um salto remoto quando o que está atrás é uma transação de banco de dados. O gate: no máximo 2 ms de p99 adicionado por sessão de escrita e no máximo 15% de perda de throughput. Os dois limites precisam valer.
O mesmo estudo mediu o caso do journal para o engine de workflows. Essa parte passou e está coberta em What exactly-once over a journal costs. Este post é sobre a parte que falhou.
Método e condições
- Máquina: 16 núcleos, Linux 7.2, Go 1.27.3, gRPC 1.83.2, tudo em uma só caixa, `nice -n 10`.
- Postgres 16.16 alpine em um container, em tmpfs. tmpfs barateia os commits, então a perda relativa de throughput é pessimista e o p99 absoluto adicionado não é afetado. Um dos dois engines também rodou contra um volume Docker em disco.
- O protótipo importou o pacote store real de cada engine, então o SQL era SQL de produção.
- Formato de wire: um stream bidirecional gRPC, frames JSON, um round trip síncrono por operação. Sem schema, sem batching.
- A latência é de malha fechada com um único chamador; o throughput usa 16 goroutines por 8 s após 3 s de warm-up, 5 execuções, medianas reportadas. Warm-up antes de cada medição.
A máquina não estava quieta: load average de 12 a 21 em 16 núcleos para o primeiro engine, de 7 a 20 para o segundo. p99 e throughput são ruidosos. Uma execução por tcp-loopback teve p99 de 1864 us contra 162 a 265 us nas outras.
Um salto é barato
Um echo gRPC unário, um chamador, 20000 chamadas por execução: 63 us de p50 e 222 us de p99 sobre um unix socket com payload de 64 B, 80 us e 184 us sobre tcp loopback. Um salto custa de 0.06 a 0.10 ms em p50 e cerca de 0.2 ms em p99. Isso bateu com a hipótese para p50 e a superou para p99.
Uma operação de store pelo stream de sessão custa cerca de 115 us de p50 por operação, que é o salto mais JSON e a goroutine do plugin. Pouco, até você multiplicar.
As sessões multiplicam
Uma sessão de escrita são várias operações dentro de uma transação: para o primeiro engine, create são 8 operações. A transação e sua conexão do pool ficam abertas durante todos os round trips.
| Variante, primeiro engine | create p50 us | create p99 us | sessões/s, 16 chamadores |
|---|---|---|---|
| in-process | 1346 | 2743 | 3801 |
| session stream, unix | 2274 | 4883 | 2565 (-32.5%) |
| session stream, tcp | 2673 | 5232 | 3017 (-20.6%) |
O p99 adicionado para create foi de +2140 us sobre unix e +2489 us sobre tcp. A perda de throughput foi de 21 a 33%. Os dois limites falharam. O estudo observa que o unix ter saído mais lento que o tcp é ruído da carga da máquina: as execuções variaram de 2378 a 3048 para tcp e de 2565 a 3500 para unix.
Para o store do hakoniwa, as sessões quentes têm 7 operações (reportar um passo, terminar uma execução). Em tmpfs o p99 adicionado foi de 2.1 a 6.8 ms nos caminhos de execução quentes, e o throughput caiu 41.9% sobre unix e 47.4% sobre tcp. Com Postgres em disco a perda no unix foi de 28.5% e no tcp de 7.5%, mas essa execução é inconclusiva: limitada por fsync, só 3 rodadas, com picos de p99 adicionado de +21 a +42 ms em várias linhas.
Por quê, e o que fiz em vez disso
A explicação do estudo, que bate com os números: a transação segura uma conexão do pool por N round trips, então um pool de 16 conexões satura mais cedo, e o host e o plugin gastam CPU na mesma caixa. Os locks tomados dentro da transação também ficam presos durante todos eles.
A consequência foi uma mudança de plano, não um plugin abandonado. O store toma o caminho mais barato: um tier embutido mais operações em formato de comando, onde um RPC carrega uma transação inteira. A tabela de plano do estudo coloca os dois plugins de store nesse caminho. Os commits do hakoniwa do mesmo dia incluem o template do tier de store embutido.
Uma sessão com pipeline, que manda escritas às cegas sem esperar e mostra os erros na próxima leitura ou commit, projeta-se em aproximadamente +0.4 a 0.5 ms de p50 e de 1 a 1.3 ms de p99 para create. É uma projeção a partir de contagens de round trips. Não foi construída nem medida, e mudaria o significado de um erro de escrita.
Não medido: entre nós, contenção de locks entre chamadores e a suíte completa de testes do store pelo caminho remoto, já que o protótipo só fez proxy dos métodos do workload.