Compiler avec g ++ en utilisant plusieurs cœurs

Question rapide: quel est le drapeau du compilateur pour permettre à g ++ de générer plusieurs instances de lui-même afin de compiler plus rapidement de grands projets (par exemple 4 fichiers source à la fois pour un processeur multicœur)?

Vous pouvez le faire avec make - avec gnu make it est le drapeau -j (cela aidera également sur une machine monoprocesseur).

Par exemple, si vous voulez 4 jobs parallèles de make:

make -j 4

Vous pouvez également exécuter gcc dans un tube avec

gcc -pipe

Cela acheminera les étapes de compilation, ce qui aidera également à garder les cœurs occupés.

Si vous disposez également de machines supplémentaires, vous pouvez consulter distcc , qui les compilera également.

Il n'y a pas de tel drapeau, et en avoir un va à l'encontre de la philosophie Unix qui veut que chaque outil exécute une seule fonction et l'exécute correctement. La création de processus de compilation est conceptuellement le travail du système de construction. Ce que vous recherchez probablement, c'est l'indicateur -j (jobs) pour GNU make, a la

faire -j4

Ou vous pouvez utiliser pmake ou des systèmes de fabrication parallèles similaires.

Les gens ont mentionné makemais bjamsoutiennent également un concept similaire. L'utilisation bjam -jxindique à bjam de créer xdes commandes simultanées.

Nous utilisons les mêmes scripts de construction sur Windows et Linux et l'utilisation de cette option réduit de moitié nos temps de construction sur les deux plates-formes. Agréable.

makefera cela pour vous. Examinez les commutateurs -jet -ldans la page de manuel. Je ne pense pas que ce g++soit parallélisable.

Si vous utilisez make, sortez avec -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.

Et plus particulièrement, si vous souhaitez créer un script ou identifier le nombre de cœurs dont vous disposez (en fonction de votre environnement, et si vous exécutez dans de nombreux environnements, cela peut beaucoup changer), vous pouvez utiliser la fonction Python omniprésente cpu_count():

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

Comme ça:

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

Si vous demandez pourquoi 1.5je citerai l'utilisateur artless-noise dans un commentaire ci-dessus:

Le nombre 1.5 est dû au problème de liaison d'E / S noté. C'est une règle de base. Environ 1/3 des travaux seront en attente d'E / S, les travaux restants utiliseront donc les cœurs disponibles. Un nombre supérieur aux cœurs est meilleur et vous pouvez même aller jusqu'à 2x.

distcc peut également être utilisé pour distribuer des compilations non seulement sur la machine actuelle, mais également sur d'autres machines d'une ferme sur lesquelles distcc est installé.

Je ne suis pas sûr de g ++, mais si vous utilisez GNU Make alors "make -j N" (où N est le nombre de threads que peut créer) permettra à make d'exécuter plusieurs tâches g ++ en même temps (si longtemps car les fichiers ne dépendent pas les uns des autres).

GNU parallèle

Je faisais un benchmark de compilation synthétique et je ne pouvais pas être dérangé d'écrire un Makefile, alors j'ai utilisé:

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

Explication:

• {.} prend l'argument d'entrée et supprime son extension
• -t imprime les commandes en cours d'exécution pour nous donner une idée de la progression
• --will-cite supprime la demande de citer le logiciel si vous publiez des résultats en l'utilisant ...

parallel est si pratique que je pourrais même faire une vérification d'horodatage moi-même:

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

xargs -Ppeut également exécuter des tâches en parallèle, mais il est un peu moins pratique de faire la manipulation d'extension ou d'exécuter plusieurs commandes avec: Appel de plusieurs commandes via xargs

La liaison parallèle a été posée à l' adresse suivante : gcc peut-il utiliser plusieurs cœurs lors de la liaison?

TODO: Je pense avoir lu quelque part que la compilation peut être réduite à la multiplication matricielle, donc il est peut-être également possible d'accélérer la compilation d'un seul fichier pour les gros fichiers. Mais je ne trouve pas de référence maintenant.

Testé dans Ubuntu 18.10.