Entenda o processo de construção do compilador GCC (GNU Compiler Collection) e como ele é realizado em diferentes arquiteturas de sistema. Este guia explora desde a obtenção do código fonte até a instalação e testes do compilador, oferecendo uma visão clara das etapas envolvidas e das diferenças de desempenho entre as arquiteturas AArch64 e x86.
O que é o GCC?
O GNU Compiler Collection (GCC) é um conjunto de compiladores do Projeto GNU, que suporta diversas linguagens de programação, arquiteturas de hardware e sistemas operacionais. Essencialmente, o GCC permite que o código escrito em uma linguagem de programação seja traduzido para uma forma que o computador possa entender e executar.
Obtendo o Código Fonte
O primeiro passo para a construção do compilador GCC é obter o código fonte. O código utilizado neste guia foi disponibilizado pela GNU. Para clonar o repositório, utilize o seguinte comando:
git clone git://gcc.gnu.org/git/gcc.git
Este processo é replicado em dois servidores com arquiteturas distintas: aarch64 e x86. A análise comparativa entre essas arquiteturas é crucial para entender o impacto no desempenho da compilação.
Aarch64 vs x86
Para entender qual arquitetura oferece melhor desempenho, é essencial comparar as especificações de cada uma. As diferenças no número de threads, tamanho do cache e conjuntos de instruções especializadas podem influenciar significativamente a velocidade da compilação.
Especificações da CPU
| Feature | x86_64 | aarch64 |
|---|---|---|
| CPU Cores | 10 cores, 20 threads (2 threads per core) | 16 cores, 16 threads (1 thread per core) |
| Clock Speed | 3.70GHz base, up to 4.70GHz | Not specified |
| Vendor | Intel | ARM |
Memória Cache
| Cache Level | x86_64 | aarch64 |
|---|---|---|
| L1 Data | 320 KiB total (32 KiB per core) | 512 KiB total (32 KiB per core) |
| L1 Instruction | 320 KiB total (32 KiB per core) | 768 KiB total (48 KiB per core) |
| L2 | 10 MiB total (1 MiB per core) | 8 MiB total (1 MiB per 2 cores) |
| L3 | 19.3 MiB (shared) | 8 MiB (shared) |
- Vantagem de Threads: O sistema x86_64 possui 20 threads, enquanto o sistema ARM tem 16.
- Cache: O sistema ARM tem caches L1 maiores, mas o sistema x86_64 tem um cache L3 significativamente maior (19.3MiB vs 8MiB). Como o GCC processa grandes quantidades de código, o cache L3 maior do x86_64 pode ser vantajoso.
- O x86_64 possui conjuntos de instruções especializadas que podem acelerar certas tarefas de compilação, enquanto o sistema ARM utiliza uma abordagem mais simplificada.
A expectativa inicial é que o sistema x86_64 complete a construção do compilador GCC mais rapidamente.
Preparação da Construção
Antes de iniciar a compilação, é necessário criar diretórios específicos para organizar o processo. Utilize os seguintes comandos:
mkdir -p git gcc-build-001
Em seguida, navegue até o diretório git e clone o repositório do GCC:
cd git
git clone git://gcc.gnu.org/git/gcc.git
Configure o código fonte do GCC para uma construção personalizada. Como já existe uma versão do GCC instalada em /usr/local, é recomendável instalar a nova versão em ~/gcc-test-001:
~/git/gcc/configure --prefix=$HOME/gcc-test-001
Utilizando o Screen
A compilação do GCC pode levar de 20 minutos a várias horas. Para evitar interrupções causadas por problemas de conexão, utilize a ferramenta screen. Essa ferramenta permite criar uma sessão destacada, onde o processo de compilação pode continuar mesmo se a conexão for interrompida.
- Crie uma sessão destacada:
screen -RaD
- Execute o comando de compilação:
make
- Para sair da sessão sem interromper o processo, use a combinação de teclas:
Ctrl+A+D
- Para reconectar à sessão, utilize o comando:
screen -RaD
Hora de Compilar!
Com a sessão screen iniciada, é hora de começar a construção do compilador GCC. Certifique-se de estar no diretório ~/gcc-build-001:
cd gcc-build-001
Execute o comando make, redirecionando a saída padrão e os erros para um arquivo de log para análise posterior:
time make -j 24 |& tee build.log
Resultados da Compilação
Após a conclusão do processo de compilação em ambas as arquiteturas, os resultados foram:
- x86_64: Concluído em 47 minutos e 37 segundos.
- AArch64: Concluído em 124 minutos e 55 segundos.
Como previsto, a arquitetura x86_64 apresentou um desempenho superior na construção do compilador GCC.
Instalação da Construção
Após a compilação, instale o GCC com o comando make install. Para garantir que a instalação foi bem-sucedida, verifique a versão do GCC antes e depois da instalação.
Durante a preparação da construção, o código fonte do GCC foi configurado para ser instalado no diretório ~/gcc-test-001. Após a instalação, verifique se o diretório foi criado.
Para utilizar a nova versão do GCC, ajuste a variável PATH:
PATH=$HOME/gcc-test-001/bin:$PATH
Resultado da Instalação
Após ajustar o PATH, verifique a versão do GCC para confirmar que a nova versão foi instalada corretamente. A versão instalada será uma versão experimental ou de desenvolvimento, diferente da versão instalada anteriormente.
A nova versão do GCC deve ser capaz de criar e compilar programas simples em C.
Experimentos Adicionais
Para avaliar o desempenho do GCC, foram realizados dois experimentos:
- Tempo necessário para recompilar o GCC após alterar o timestamp de um arquivo.
- Tempo necessário para recompilar o GCC sem fazer nenhuma alteração.
Alteração de Timestamp
Para alterar o timestamp de um arquivo, utilize o comando touch. O arquivo passes.cc foi utilizado para este experimento.
- Localize o arquivo passes.cc:
find ~/git/gcc -name "passes.cc"
result:
/home/amullagaliev/git/gcc/gcc/passes.cc
- Atualize o timestamp:
touch /home/amullagaliev/git/gcc/gcc/passes.cc
- Recompile o software.
Resultado do Experimento
A recompilação após a alteração do timestamp levou 59 segundos.
Recompilação sem Alterações
Recompile o software sem fazer nenhuma alteração prévia.
Resultado do Experimento
A recompilação sem alterações levou apenas 15 segundos.
Este conteúdo foi auxiliado por Inteligência Artificiado, mas escrito e revisado por um humano.
Via dev.to