Compilazione con g ++ usando più core

Domanda rapida: qual è il flag del compilatore per consentire a g ++ di generare più istanze di se stesso al fine di compilare più rapidamente progetti di grandi dimensioni (ad esempio 4 file sorgente alla volta per una CPU multi-core)?

Puoi farlo con make - con gnu make è il flag -j (questo aiuterà anche su una macchina uniprocessore).

Ad esempio, se si desidera creare 4 lavori paralleli da:

make -j 4

Puoi anche eseguire gcc in una pipe con

gcc -pipe

Questo condurrà le fasi di compilazione, contribuendo anche a mantenere occupati i core.

Se hai anche macchine aggiuntive disponibili, potresti controllare distcc , che verrà compilato anche su quelle.

Non esiste tale flag e avere una corsa contro la filosofia Unix secondo cui ogni strumento esegue una sola funzione e la esegue bene. La generazione dei processi del compilatore è concettualmente il lavoro del sistema di compilazione. Quello che probabilmente stai cercando è il flag -j (jobs) di GNU make, a la

make -j4

Oppure puoi usare pmake o simili sistemi di creazione parallela.

Le persone hanno menzionato makema bjamsupporta anche un concetto simile. L'utilizzo bjam -jxindica a bjam di creare xcomandi simultanei.

Usiamo gli stessi script di build su Windows e Linux e l'utilizzo di questa opzione dimezza i nostri tempi di compilazione su entrambe le piattaforme. Bello.

makelo farà per te. Indaga sugli interruttori -je -lnella pagina man. Non credo g++sia parallelizzabile.

Se si utilizza make, rilasciare con -j. Da 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 in particolare, se vuoi scrivere script o identificare il numero di core che hai a disposizione (a seconda del tuo ambiente, e se corri in molti ambienti, questo può cambiare molto) puoi usare l'onnipresente funzione Python cpu_count():

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

Come questo:

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

Se stai chiedendo perché 1.5citerò l'utente senza rumore in un commento sopra:

Il numero 1.5 è a causa del noto problema associato I / O. È una regola empirica. Circa 1/3 dei lavori saranno in attesa di I / O, quindi i lavori rimanenti utilizzeranno i core disponibili. Un numero maggiore dei core è migliore e potresti persino arrivare fino a 2 volte.

distcc può anche essere utilizzato per distribuire compilazioni non solo sulla macchina corrente, ma anche su altre macchine in una farm su cui è installato distcc.

Non sono sicuro di g ++, ma se stai usando GNU Make, allora "make -j N" (dove N è il numero di thread che può creare) consentirà a make di eseguire più lavori g ++ contemporaneamente (così a lungo poiché i file non dipendono l'uno dall'altro).

Parallelo GNU

Stavo facendo un benchmark di compilazione sintetico e non potevo preoccuparmi di scrivere un Makefile, quindi ho usato:

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

Spiegazione:

• {.} accetta l'argomento input e ne rimuove l'estensione
• -t stampa i comandi in esecuzione per darci un'idea del progresso
• --will-cite rimuove la richiesta di citare il software se si pubblicano risultati utilizzandolo ...

parallel è così conveniente che potrei anche fare un controllo del timestamp da solo:

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

xargs -Ppuò anche eseguire lavori in parallelo, ma è un po 'meno conveniente eseguire la manipolazione dell'estensione o eseguire più comandi con esso: chiamata di più comandi tramite xargs

È stato chiesto il collegamento parallelo su: gcc può usare più core durante il collegamento?

TODO: Penso di aver letto da qualche parte che la compilazione può essere ridotta alla moltiplicazione di matrici, quindi forse è anche possibile velocizzare la compilazione di singoli file per file di grandi dimensioni. Ma non riesco a trovare un riferimento ora.

Testato su Ubuntu 18.10.