Compilação mais rápida no Rust com frontend paralelo na versão nightly

Compilação mais rápida com o frontend paralelo do compilador Rust

• O frontend do compilador Rust pode reduzir significativamente o tempo de compilação ao usar execução paralela.
• O frontend paralelo é um recurso experimental e pode ser testado no compilador nightly usando a opção -Z threads=8.
• O lançamento em um compilador estável está previsto para 2024.

Tempo de compilação e paralelismo

• O tempo de compilação no Rust é uma preocupação constante, e o grupo de trabalho de desempenho do compilador vem melhorando continuamente a performance do compilador há vários anos.
• Nos primeiros 10 meses de 2023, o tempo de compilação caiu em média 13%, o uso de memória 15% e o tamanho dos binários 7%.
• O compilador já foi muito otimizado, tornando mais difícil encontrar novas melhorias, e o paralelismo continua sendo uma melhoria grande, porém desafiadora.

Paralelismo existente entre processos

• Ao compilar programas Rust, o Cargo executa vários processos rustc em paralelo para compilar múltiplos crates.
• A execução paralela funciona bem quando há poucas dependências entre crates, mas diminui à medida que as dependências aumentam.

Paralelismo existente dentro do processo: backend

• O compilador é dividido em frontend e backend, e o backend é responsável pela geração de código, que o LLVM processa em paralelo.
• O frontend realiza parsing, type checking e outras tarefas, mas até esta semana não podia usar execução paralela.

Novo paralelismo dentro do processo: frontend

• O frontend agora pode executar tarefas de compilação com paralelismo de granularidade fina usando Rayon.
• Quando o frontend paralelo é ativado e configurado para usar 8 threads, é possível ver uma redução significativa no tempo de execução do frontend.

Integração geral

• A compilação Rust já se beneficiava há muito tempo do paralelismo entre processos via Cargo e do paralelismo dentro do processo no backend, e agora também pode aproveitar o paralelismo dentro do processo no frontend.
• O compilador usa o protocolo jobserver para limitar o número de threads criadas e não exceder a quantidade de núcleos.

Como usar

• O compilador nightly foi lançado com o frontend paralelo ativado, mas por padrão roda em modo single-thread.
• Os usuários podem mudar para o modo multithread usando a opção -Z threads.

Impacto no desempenho

• Ao executar o frontend paralelo em modo single-thread, o tempo de compilação pode ficar de 0% a 2% mais lento em relação ao anterior.
• No modo multithread, o tempo de compilação pode cair em até 50%, mas o efeito varia bastante conforme as características do código e a configuração do build.

Correção

• No modo single-thread, espera-se um alto nível de confiabilidade.
• No modo multithread, pode haver bugs conhecidos e deadlocks, e os binários gerados pelo compilador devem ser os mesmos independentemente do frontend usado.

Feedback

• Se houver problemas com o frontend paralelo, é possível verificar issues com a label "WG-compiler-parallel" e abrir uma nova issue.

Trabalhos futuros

• Estão em andamento trabalhos para melhorar o desempenho do frontend paralelo e corrigir bugs no modo multithread.
• Há planos para estabilizar a opção -Z threads para que, em 2024, ela passe a rodar por padrão em modo multithread na release estável.

Opinião do GN⁺

O ponto mais importante deste artigo é que o frontend do compilador Rust agora oferece suporte à execução paralela, permitindo reduzir significativamente o tempo de compilação. Isso traz um grande benefício para desenvolvedores Rust na forma de maior velocidade de compilação e contribui para um ambiente de desenvolvimento mais eficiente. A introdução do frontend paralelo é uma notícia empolgante para a comunidade Rust e pode ser vista como resultado dos esforços contínuos de melhoria de desempenho.

[GN⁺]

Comentários do Hacker News

• Expectativa por melhorias na velocidade de compilação do Rust
  • A lentidão de compilação do Rust é apontada como uma desvantagem, especialmente ao trabalhar em repositórios grandes, pois aumenta os custos de CI/CD e atrasa o tempo de desenvolvimento. Isso é particularmente problemático quando é preciso limpar o cache (algo que às vezes acontece por causa de bugs no Docker). Reação positiva a esse avanço.
• Experiência pessoal com a velocidade de compilação do Rust
  • Quando usou Rust há muito tempo, a compilação era lenta, mas ao voltar a usá-lo recentemente, quase não precisou mais se preocupar com o tempo de compilação. Ainda assim, conforme o projeto cresce, às vezes a demora fica perceptível, então essa melhoria é uma notícia muito bem-vinda em nível pessoal.
• Pergunta sobre o processo de compilação do Rust
  • Pergunta se o backend do Rust precisa esperar o frontend terminar a verificação de empréstimos para então começar a trabalhar. Levanta a dúvida se, ao encontrar erros de borrow checking, o backend não poderia simplesmente descartar trabalho especulativo.
• Observação sobre a compilação de crates binárias em Rust
  • Diferentemente das library crates, as binary crates tendem a ser grandes e monolíticas por padrão, então a compilação não se paraleliza e o maior crate tende a ficar serializado. Melhorias para esse problema são bem-vindas.
• Pergunta sobre uso de núcleos de CPU
  • Pergunta se é possível fazer a compilação usar automaticamente a quantidade de núcleos de CPU disponíveis, ou se é necessário definir um valor fixo em um arquivo de configuração que também será usado em outras máquinas.
• Alerta sobre bugs no modo multithread
  • Há bugs conhecidos e deadlocks no modo multithread, e se a compilação travar, é possível que seja um desses problemas. Postura cautelosa em relação ao uso da opção -Z threads.
• Avaliação positiva do estado atual da velocidade de compilação do Rust
  • Depois de passar alguns anos sem usar Rust, ao voltar recentemente, a velocidade de compilação parece quase instantânea. Com ferramentas como o ChatGPT, problemas de Rust que antes eram difíceis de resolver agora podem ser resolvidos com facilidade, então o estado atual parece muito bom.
• Dúvida sobre a direção da otimização da compilação do Rust
  • Como a compilação do Rust já é altamente paralelizada no nível de arquivos, há preocupação de que acelerar a compilação de um único arquivo possa acabar tirando recursos do paralelismo de mais alto nível entre arquivos. A falta de dados concretos sobre isso é apontada como um problema.
• Comentário de boas-vindas à melhoria na velocidade de compilação do Rust