Compilando com g ++ usando vários núcleos

Pergunta rápida: qual é o sinalizador do compilador que permite ao g ++ gerar várias instâncias de si mesmo para compilar projetos grandes mais rapidamente (por exemplo, 4 arquivos de origem por vez para uma CPU com vários núcleos)?

Você pode fazer isso com o make - com o gnu make é o sinalizador -j (isso também ajudará em uma máquina uniprocessadora).

Por exemplo, se você deseja 4 trabalhos paralelos do make:

make -j 4

Você também pode executar o gcc em um pipe com

gcc -pipe

Isso fará o pipeline dos estágios de compilação, o que também ajudará a manter os núcleos ocupados.

Se você tiver máquinas adicionais disponíveis, verifique o distcc , que também compila essas compilações.

Não existe esse sinalizador, e ter um deles é executado contra a filosofia do Unix de fazer com que cada ferramenta execute apenas uma função e a execute bem. Gerar processos do compilador é conceitualmente o trabalho do sistema de compilação. O que você provavelmente está procurando é o sinalizador -j (jobs) para o GNU make, a la

make -j4

Ou você pode usar pmake ou sistemas de fabricação paralela similares.

As pessoas mencionaram, makemas bjamtambém apóiam um conceito semelhante. O uso de bjam -jxinstrui o bjam a criar xcomandos simultâneos.

Usamos os mesmos scripts de compilação no Windows e Linux e essa opção reduz pela metade o tempo de compilação nas duas plataformas. Agradável.

makefará isso por você. Investigue as opções -je -lna página de manual. Eu não acho que g++é paralelizável.

Se estiver usando make, emita com -j. De man make:

  -j [jobs], --jobs[=jobs]
       Specifies the number of jobs (commands) to run simultaneously.  
       If there is more than one -j option, the last one is effective.
       If the -j option is given without an argument, make will not limit the
       number of jobs that can run simultaneously.

E, principalmente, se você deseja criar um script ou identificar o número de núcleos que você tem disponível (dependendo do seu ambiente e se você executa em muitos ambientes, isso pode mudar bastante), você pode usar a onipresente função Python cpu_count():

https://docs.python.org/3/library/multiprocessing.html#multiprocessing.cpu_count

Como isso:

make -j $(python3 -c 'import multiprocessing as mp; print(int(mp.cpu_count() * 1.5))')

Se você está perguntando por 1.5que citarei o ruído artless do usuário em um comentário acima:

O número 1.5 é devido ao problema de ligação de E / S observado. É uma regra de ouro. Cerca de 1/3 dos trabalhos aguardam E / S, portanto, os trabalhos restantes usarão os núcleos disponíveis. Um número maior que os núcleos é melhor e você pode até chegar a 2x.

O distcc também pode ser usado para distribuir compilações não apenas na máquina atual, mas também em outras máquinas em um farm que possui o distcc instalado.

Não tenho certeza sobre o g ++, mas se você estiver usando o GNU Make, "make -j N" (onde N é o número de threads que o make pode criar) permitirá que o make execute vários trabalhos do g ++ ao mesmo tempo (por muito tempo porque os arquivos não dependem um do outro).

Paralelo GNU

Eu estava fazendo um benchmark de compilação sintética e não me incomodei em escrever um Makefile, então usei:

sudo apt-get install parallel
ls | grep -E '\.c$' | parallel -t --will-cite "gcc -c -o '{.}.o' '{}'"

Explicação:

• {.} pega o argumento de entrada e remove sua extensão
• -t imprime os comandos que estão sendo executados para nos dar uma ideia do progresso
• --will-cite remove a solicitação de citação do software se você publicar resultados usando-o ...

parallel é tão conveniente que eu poderia até fazer um registro de data e hora:

ls | grep -E '\.c$' | parallel -t --will-cite "\
  if ! [ -f '{.}.o' ] || [ '{}' -nt '{.}.o' ]; then
    gcc -c -o '{.}.o' '{}'
  fi
"

xargs -Ptambém pode executar tarefas em paralelo, mas é um pouco menos conveniente fazer a manipulação de extensão ou executar vários comandos com ela: Chamando vários comandos através do xargs

A ligação paralela foi solicitada em: O gcc pode usar vários núcleos ao vincular?

TODO: Acho que li em algum lugar que a compilação pode ser reduzida à multiplicação de matrizes, então talvez também seja possível acelerar a compilação de arquivo único para arquivos grandes. Mas não consigo encontrar uma referência agora.

Testado no Ubuntu 18.10.