Compilação com g ++ usando vários núcleos

Question

Pergunta rápida: qual é o sinalizador do compilador para permitir g ++ para desovar várias instâncias de si mesmo, a fim de compilar os grandes projectos mais rápido (por exemplo, 4 arquivos de origem de cada vez para uma CPU multi-core)

?

Answer 1

Você pode fazer isso com o make -. Com GNU make é a opção -j (Isso também irá ajudar em uma máquina uniprocessador)

Por exemplo, se você quiser 4 trabalhos paralelos de marca:

make -j 4

Você também pode executar gcc em um tubo com

gcc -pipe

Este gasoduto as etapas de compilação, que também irá ajudar a manter os núcleos ocupados.

Se você tem máquinas adicionais disponíveis também, você pode verificar para fora distcc , que vai cultivar compila àqueles também.

Answer 2

Não há tal bandeira, e ter um corre contra a filosofia Unix de ter cada ferramenta executar apenas uma função e executar bem. Desova processos compilador é conceitualmente o trabalho do sistema de compilação. O que você provavelmente está procurando é a opção -j (empregos) para GNU make, a la

make -j4

Ou você pode usar pmake ou sistemas paralelos make semelhantes.

Answer 3

As pessoas têm mencionado make mas bjam também suporta um conceito similar. Usando instrui bjam -jx bjam para construir até x comandos simultâneos.

Nós usamos os mesmos scripts de construção em Windows e Linux e usar esta opção metades nossos tempos de construção em ambas as plataformas. Nice.

Answer 4

make vai fazer isso por você. Investigar os interruptores -j e -l na página man. Eu não acho que g++ é paralelizável.

Answer 5

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

Answer 6

Se estiver usando maquiagem, problema 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ê quiser script ou identificar o número de núcleos que você tem disponível (dependendo do seu ambiente, e se você executar em muitos ambientes, isso pode mudar muito) você pode usar onipresente função Python cpu_count():

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

Como esta:

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

Se você está perguntando por que 1.5 Vou citar usuário ingênua ruído em um comentário acima:

O número 1.5 é por causa do problema conhecida I / O ligado. É uma regra de ouro. Cerca de 1/3 dos trabalhos estará esperando por I / O, assim que os trabalhos restantes estará usando os núcleos disponíveis. Um número maior do que os núcleos é melhor e você pode até mesmo ir tão alto como 2x.

Answer 7

Eu não tenho certeza sobre g ++, mas se você estiver usando o GNU Make, em seguida, "make -j N" (onde N é o número de threads fazem pode criar) permitirá make para executar trabalhos multple g ++, ao mesmo tempo (desde que os arquivos não dependem uns dos outros).

Answer 8

GNU paralelo

Eu estava fazendo um compilação de benchmark sintético e não poderia 't ser incomodado para escrever um Makefile, então eu usei:

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

Explicação:

• {.} leva o argumento de entrada e remove sua extensão
• -t imprime os comandos que está sendo executado para nos dar uma idéia de progresso
• --will-cite remove o pedido citar o software se você publicar resultados usando-o ...

parallel é tão conveniente que eu poderia mesmo fazer uma verificação timestamp mim mesmo:

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

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

ligação paralela foi perguntado em: pode usar gcc múltiplos núcleos quando liga

TODO: Eu acho que eu li em algum lugar que a compilação pode ser reduzido a multiplicação de matrizes, talvez por isso, também é possível acelerar a compilação único arquivo para arquivos grandes. Mas eu não posso encontrar uma referência agora.

Testado no Ubuntu 18.10.