~/studies/work 2026-11-21

Notas de leitura: o design shard-per-core do ScyllaDB

Notas sobre material público, não sobre meus benchmarks: o que ScyllaDB e Seastar dizem sobre um shard por core, memória por core e ausência de locks, e o que isso diz e não diz sobre a latência de cauda.

O que é isto

Estas são notas de leitura sobre documentação pública. Não rodei ScyllaDB nem Seastar, e cada número abaixo vem de uma página que linko, com as condições que essa página informa. Onde tiro uma implicação, marco como leitura minha.

Consultadas em 2026-11-21. O tutorial é uma página longa e li só a primeira parte e um trecho posterior, então cito apenas o que vi.

O modelo, como as fontes o descrevem

A página do ScyllaDB diz que cada core roda um shard que é dono de uma fatia dos dados. Os dados são particionados no cluster por faixa de tokens e, nas palavras da página, os shards dentro de cada nó são mapeados para vCPUs presos a cores específicos. Cada um tem seus próprios recursos dedicados, incluindo um cache separado, memtables e SSTables, e seu próprio canal de I/O de rede.

O Seastar, o framework por baixo, descreve a mesma coisa do lado da programação. Ele distribui as requisições em cores individuais e roda uma thread de aplicação por core, com comunicação por troca explícita de mensagens, não por memória compartilhada entre threads. O tutorial diz que a memória disponível é dividida entre os cores e cada core trabalha com dados na sua própria parte da memória. Cada thread recebe pré-alocado um grande pedaço de memória, no nó NUMA em que roda.

AfirmaçãoOnde
Uma thread de aplicação por core; requisições distribuídas pelos coresseastar.io/shared-nothing
Memória dividida entre os cores; cada um trabalha na sua própria parteSeastar tutorial, introdução
Comunicação entre cores por troca explícita de mensagens; recursos compartilhados entre cores devem ser tratados explicitamentePágina do ScyllaDB e página do Seastar
smp::submit_to(cpu, lambda) roda uma lambda em outro core e devolve um futureseastar.io/shared-nothing

Por que sem locks

O tutorial dá a razão em uma frase: práticas de programação não escaláveis, como tomar locks, podem devastar o desempenho em muitos cores. Ele acrescenta que primitivas de memória compartilhada e lock-free são dramaticamente mais lentas que operações sobre dados no cache de um único core, porque máquinas multi-core penalizam instruções atômicas, o pingue-pongue de linhas de cache e as barreiras de memória.

Aqui importa ler com cuidado. A página do Seastar não afirma que o sistema seja totalmente lock-free. Ela diz que o design evita primitivas de lock lentas e não escaláveis e os pingue-pongues de cache, oferece facilidades que limitam a comunicação entre cores e fornece primitivas não bloqueantes para quando a comunicação é inevitável. O exemplo que dá: duas requisições da mesma sessão caem em CPUs diferentes e dependem do mesmo estado de sessão, então um CPU encaminha explicitamente a requisição para o outro.

Um número da página do Seastar, com suas condições: um orçamento de 1670 ciclos de clock por pacote, para um processador de 2 GHz tratando pacotes de 1024 bytes na velocidade da linha em uma rede de 10 Gbps. A página atribui esse valor a uma apresentação da Intel sobre DPDK. Ele explica a pressão a que o design responde, não é uma medição do ScyllaDB.

Números, e o que eles não dizem

  • O tutorial relata que uma reescrita do Cassandra sobre Seastar teve ganho de até dez vezes em throughput, além de latências significativamente menores e mais consistentes. Essa página não dá hardware nem carga de trabalho.
  • A página principal do ScyllaDB diz que o design permite escalar para milhões de operações por segundo, sustentando latências médias abaixo de um milissegundo, mesmo com replicação regional e global. Um item de menu diz latências previsíveis de um dígito em milissegundos. Nenhum informa hardware, tamanho de cluster nem carga de trabalho.
  • Padrões do tutorial: uma thread de motor por thread de hardware; uma cota de tarefa de 500 microssegundos, após a qual a tarefa cede nos pontos de preempção; um reactor pode travar quando uma tarefa roda muito tempo sem ceder, com mais de 20 ms dado como exemplo.
  • Memória: toda a memória exceto uma reserva do SO é pré-alocada por padrão, e a reserva padrão é o maior entre 1.5G ou 7% da memória total.

Nenhum dos números de latência aqui são benchmarks que eu consiga comparar. São afirmações sem condições declaradas, e as médias citadas não dizem nada sobre a cauda.

O que isso implica para a latência de cauda: minha leitura

O abstract de The Tail at Scale diz que é difícil manter baixa a cauda da distribuição de latência em serviços interativos, e que episódios temporários de alta latência sem importância em sistemas de tamanho moderado podem passar a dominar em larga escala. A página do abstract não traz números de percentis, então não cito nenhum.

Hipóteses minhas, não das fontes. Primeiro, um shard é uma única pista de execução, então qualquer coisa que segure um core sem ceder atrasa toda requisição pertencente a esse core. Isso é coerente com o aviso do tutorial de que as continuations não podem bloquear, mas não medi. Segundo, o desbalanceamento vira problema de cauda: uma hot key concentra a carga em um shard enquanto os outros cores ficam ociosos, sem nenhum lock envolvido. Terceiro, uma requisição que precisa de dois shards paga um salto de mensagem e a mais lenta das duas filas.

O que eu testaria antes de acreditar em qualquer disso: uma carga de trabalho, uma máquina, a profundidade de fila por shard ao lado do p99 do lado do cliente, com o caso de hot key rodado de propósito. Não rodei.