Pular para o conteúdo
Notícias e tutoriais sobre Linux
Kernel Linux

Linux pode dobrar desempenho do CephFS em operações comuns de arquivos

Otimização interna do kernel destrava o verdadeiro poder de requisições do CephFS!

linux dobra desempenho cephfs arquivos

Uma nova série de otimizações para o cliente CephFS do kernel Linux, publicada nesta sexta-feira (20), altera a forma como o sistema gerencia bloqueios internos e resolve um gargalo histórico de concorrência. A sétima versão dos patches, enviada pelo desenvolvedor Xiubo Li, reduz o tempo em que diferentes operações ficam esperando por uma mesma trava global.

Em testes específicos de metadados, o ganho ultrapassou 100%, saltando de 692 mil para 1,42 milhão de consultas por segundo. O resultado não significa que toda transferência de arquivo no Linux ficou subitamente duas vezes mais rápida. A mudança soluciona uma lentidão crônica no processamento de metadados, permitindo que servidores e clusters lidem com milhões de requisições simultâneas de forma muito mais eficiente.

O CephFS estava fazendo muitas operações esperarem pela mesma trava

O Ceph é uma plataforma de armazenamento distribuído amplamente utilizada em datacenters, ambientes de nuvem e infraestruturas com Kubernetes. Ele fornece diferentes tipos de armazenamento, sendo o CephFS o seu sistema de arquivos distribuído. O Linux possui um cliente CephFS integrado diretamente ao kernel, conhecido como kclient. É exatamente este componente que recebe a nova otimização.

Um sistema de arquivos não trabalha apenas transferindo o conteúdo dos arquivos. Ele precisa lidar com um volume imenso de consultas de metadados: verificar se um arquivo existe, ler permissões, checar tamanhos ou listar o conteúdo de um diretório. Em infraestruturas corporativas, essas requisições ocorrem aos milhões.

O problema de desempenho estava centralizado em um mecanismo chamado mdsc->mutex. O mutex é uma trava de exclusão mútua necessária para impedir corrupção de dados e condições de corrida. Ele garante que apenas uma operação modifique determinada região do código por vez.

No entanto, o cliente CephFS mantinha essa trava fechada durante trabalhos demorados, como a preparação de mensagens, caminhada por caminhos de diretórios (dentries) e a própria construção da requisição. Enquanto uma unidade de processamento (CPU) fazia tudo isso, outras CPUs precisavam esperar ociosas. Em cargas altas, essa fila formava um gargalo severo.

Entenda sem termos técnicos

Imagine um escritório com 32 funcionários. Todos precisam consultar documentos em um grande arquivo central, mas existe apenas uma chave para acessar a sala.

No sistema antigo, quando um funcionário pegava a chave, ele entrava na sala, procurava os documentos, preparava os formulários necessários, escrevia a sua solicitação, organizava tudo e só então devolvia a chave para o próximo. Durante todo esse tempo, os outros 31 funcionários ficavam no corredor, esperando sem produzir nada.

A otimização percebe que apenas uma pequena parte desse processo realmente precisa acontecer dentro da sala trancada. Com o novo método, o funcionário pega a chave, faz rapidamente aquilo que exige exclusividade, devolve a chave e termina a maior parte da papelada do lado de fora.

Dessa forma, os outros funcionários conseguem avançar com suas próprias tarefas ao mesmo tempo. Essa é, de maneira simplificada, a ideia por trás da redução de contenção do mdsc->mutex.

A região crítica caiu de milhares para dezenas de microssegundos

Para comprovar a eficiência da mudança, o desenvolvedor utilizou a ferramenta bpftrace em um cenário com 32 threads lendo um diretório com 5.000 arquivos. Os números mostram exatamente o tempo em que o código fica retido pelas travas.

Na função __do_request, o tempo de espera caiu de uma faixa de 354 a 2.327 microssegundos para apenas 10 a 68 microssegundos. Isso representa uma redução de aproximadamente 34 vezes. Em handle_reply, o tempo caiu cerca de 13 vezes. Já em submit_request, a redução foi de aproximadamente 5 vezes.

Esses números impressionam, mas representam apenas a redução do tempo gasto na região crítica da trava. Eles não significam que o CephFS inteiro ficou 34 vezes mais veloz, mas explicam por que o ganho nos benchmarks de operações reais foi tão expressivo.

Consultas stat chegaram a 2,1x no benchmark

A série apresenta os resultados práticos utilizando o teste test_i_caps em um cenário agregado de cache. Os números mostram como a liberação da trava afeta cada tipo de requisição:

  • stat storm (single thread): saltou de 692 mil para 1,420 milhão de operações por segundo (+105%, ganho de 2,1x).
  • stat storm (multithread): subiu de 722 mil para 1,373 milhão de operações por segundo (+90%).
  • stat hot (cache): passou de 353 mil para 540 mil operações por segundo (+53%).
  • open/close: cresceu de 403 mil para 524 mil operações por segundo (+30%).

O tempo total da bateria de testes caiu de 195 segundos para 121 segundos, uma redução de 38%.

Nem todas as operações registraram avanços. O teste de readdir oscilou de 877 para 832 operações por segundo. O próprio autor classifica esse resultado específico como um cenário sem ganho significativo, confirmando que a otimização brilha nas requisições mais penalizadas pela trava global.

Por que stat ganhou tanto?

O desenvolvedor aponta o quarto patch da série como o principal responsável pelo ganho de throughput nas consultas stat.

A mudança move o mdsc->mutex para ser adquirido somente dentro da função __do_request() quando estritamente necessário. O segredo é que a trava passa a ser liberada antes da fase __send_request(). Como essa etapa envolve caminhar pelas estruturas de diretórios e codificar a mensagem que será enviada ao servidor de metadados, o trabalho pesado passa a ser feito concorrentemente por várias CPUs.

Ceph troca uma árvore interna por XArray

A série, composta por cinco patches, faz mais do que apenas mover o bloqueio. O segundo patch altera o modo como o kernel armazena requisições pendentes.

Antes, essas requisições eram mantidas em uma árvore rubro-negra (rbtree), indexadas pelo ID da transação. Agora, o sistema adota a estrutura XArray, nativa do kernel. A principal diferença prática é que a busca em uma rbtree tem complexidade O(log N), enquanto a XArray permite busca por índice de forma imediata O(1), além de fornecer mecanismos internos de sincronização mais modernos.

Outras mudanças incluem a redução da dependência de travas para ler a variável oldest_tid (usando mecanismos de leitura atômica) e a criação de um bloqueio específico (wait_list_lock) para gerenciar filas de espera sem parar toda a infraestrutura do cliente.

Há uma consequência: CephFS passa a depender de 64 bits

O uso do XArray traz um detalhe técnico importante. Essa estrutura utiliza o tipo unsigned long como índice. Como os IDs de transação do Ceph são inteiros de 64 bits (u64), a conversão em arquiteturas de 32 bits provocaria o truncamento dos dados e corromperia as operações.

A solução adotada na série foi adicionar a diretiva “depends on 64BIT” na configuração do CephFS (CONFIG_CEPH_FS). Se a versão for integrada ao Linux nesses termos, o cliente CephFS do kernel deixará de ser compilável em arquiteturas 32-bit.

O autor argumenta que não existem usuários conhecidos rodando clientes CephFS em hardware de 32 bits hoje em dia. Vale notar que essa restrição afeta exclusivamente o cliente presente no kernel Linux e não altera o funcionamento dos servidores Ceph ou de outras bibliotecas do ecossistema.

A v7 mostra como otimizar concorrência é perigoso

A série já chegou à sua sétima versão justamente porque manipular travas no kernel é uma tarefa crítica. O objetivo do desenvolvedor, explicitado na apresentação dos patches, é garantir que “nenhuma mudança funcional seja pretendida”. O código deve fazer exatamente o que fazia antes, apenas esperando menos.

Porém, quanto mais trabalho ocorre em paralelo, maior é o risco de condições de corrida, uso de memória já liberada (use-after-free) ou envios duplicados de mensagens. Um dos caminhos mais complexos envolve o mecanismo de replay_unsafe_requests(), acionado durante falhas e reconexões. O quinto patch coleta as requisições necessárias com a trava fechada, salva referências seguras e realiza a reprodução pesada do lado de fora da região crítica.

Revisões de desenvolvedores como Alex Markuze forçaram correções importantes da versão 6 para a 7, incluindo o tratamento seguro de requisições que ainda estão sendo despachadas e a cópia protegida de contadores antes da liberação do mutex.

Mais de 24 horas de testes pressionaram falhas e reconexões

Para comprovar a estabilidade, a equipe executou cargas de estresse com dbench e fsstress por mais de 24 horas ininterruptas. O ambiente de validação utilizou três servidores de metadados ativos, três em modo de espera e geradores de carga de 32 threads com os principais depuradores do kernel ativados.

Foram provocados mais de 100 failovers. As sessões reconectaram corretamente, sem travamentos (hangs) ou perda de alertas. Em um cenário extremo, os testadores executaram um encerramento forçado (SIGKILL) em 5.084 processos simultâneos para pressionar o código de cancelamento de requisições do CephFS. O sistema sobreviveu sem corromper listas internas.

Em uma das baterias (cenário r4), ocorreu um travamento prolongado durante operações de truncate. A análise técnica revelou que o problema estava em um loop infinito de limpeza de cache causado por componentes que a otimização não alterou, e o erro receberá uma correção independente.

Os testes encontraram bugs preexistentes no CephFS?

A campanha intensa de validação acabou descobrindo dois problemas que já existiam no kernel principal (versão 7.2 vanilla). Os desenvolvedores relataram uma falha de referência nula durante operações de escrita (writeback) e um erro de gerenciamento de memória no cancelamento de pedidos. Ambos puderam ser reproduzidos sem a série de otimização instalada e estão sendo tratados paralelamente pela comunidade.

Quem realmente pode perceber a melhoria?

linux dobra desempenho cephfs arquivos 1
Linux pode dobrar desempenho do CephFS em operações comuns de arquivos 3

Usuários domésticos ou instalações de desktop convencionais não sentirão nenhuma diferença. O ganho de desempenho afeta exclusivamente infraestruturas que dependem do cliente CephFS do kernel.

O benefício será notado em datacenters, clusters de alta performance, orquestração de containers e servidores corporativos que armazenam milhões de arquivos em um namespace unificado. Workloads paralelos, compilações massivas e sistemas que realizam aberturas e verificações constantes de arquivos poderão registrar ganhos imediatos na taxa de transferência sustentada e na economia de ciclos de CPU.

Quando isso pode chegar ao Linux?

A versão 7 da série de patches foi submetida nesta sexta-feira (20) à lista de discussão de desenvolvimento do Ceph no Linux. Até o momento desta publicação, o código passa por escrutínio rigoroso de mantenedores e especialistas em sistemas de arquivos para garantir que as condições de corrida tenham sido completamente neutralizadas.

Se o código for validado e não exigir uma oitava versão, os patches serão testados na árvore de desenvolvimento (linux-next) antes de entrarem oficialmente em uma futura janela de integração (merge window) do kernel Linux.

RECURSOS DO ARTIGO

Links e recursos

Materiais oficiais e referências técnicas relacionadas à matéria.
QUEM ESCREVE
Emanuel Negromonte

Sobre o autor

Emanuel Negromonte é Jornalista, Mestre em Tecnologia da Informação e atualmente cursa a segunda graduação em Engenharia de Software. Com 14 anos de experiência escrevendo sobre GNU/Linux, Software Livre e Código Aberto, dedica-se a descomplicar o universo tecnológico para entusiastas e profissionais. Seu foco é em notícias, tutoriais e análises aprofundadas, promovendo o conhecimento e a liberdade digital no Brasil.