Compiler avec g ++ en utilisant plusieurs cœurs

Question

Question rapide: quel est l'indicateur de compilation permettant à g ++ de créer plusieurs instances pour lui-même afin de compiler des projets volumineux plus rapidement (par exemple, 4 fichiers sources à la fois pour un processeur multicœur)?

Answer 1

Vous pouvez le faire avec make - avec gnu, make est le drapeau -j (cela aidera également sur une machine à un seul processeur).

Par exemple, si vous voulez 4 tâches parallèles de make:

make -j 4

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

gcc -pipe

Ceci canalisera 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 la distcc , qui compilera la batterie avec celles-ci. aussi bien.

Answer 2

Il n’existe pas d’indicateur de ce type, et l’un contre l’autre correspond à la philosophie Unix selon laquelle chaque outil n’exécute qu’une seule fonction. Les processus de compilation générés sont conceptuellement le travail du système de construction. Ce que vous recherchez probablement est le drapeau -j (jobs) à GNU make, à la

make -j4

Vous pouvez également utiliser pmake ou un système de fabrication parallèle similaire.

Answer 3

Les gens ont mentionné make mais bjam prend également en charge un concept similaire. Utiliser bjam -jx indique à bjam de créer des commandes x concurrentes.

Nous utilisons les mêmes scripts de compilation sous Windows et Linux et cette option divise par deux notre temps de génération sur les deux plates-formes. Nice.

Answer 4

make le fera pour vous. Recherchez les commutateurs -j et -l dans la page de manuel. Je ne pense pas que g ++ soit parallélisable.

Answer 5

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 laquelle distcc est installé.

Answer 6

Si vous utilisez make, utilisez -j . A partir 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 disponibles (en fonction de votre environnement et de votre exécution dans de nombreux environnements, cela peut changer beaucoup), vous pouvez utiliser la fonction Python omniprésente cpu_count () :

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

Comme ceci:

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

Si vous vous demandez pourquoi 1.5 , je vais citer l'utilisateur sans bruit-bruit dans un commentaire ci-dessus:

  

Le nombre 1.5 est dû au problème lié aux entrées / sorties. C'est une règle de base. Environ le tiers des tâches attendront des E / S, les tâches restantes utiliseront donc les cœurs disponibles. Un nombre supérieur aux cœurs est meilleur et vous pouvez même aller jusqu'à 2x.

Answer 7

Je ne suis pas sûr de connaître g ++, mais si vous utilisez GNU Make, alors "make -j N". (où N est le nombre de threads que make peut créer) permettra à make d’exécuter plusieurs travaux g ++ simultanément (tant que les fichiers ne dépendent pas les uns des autres).

Answer 8

parallèle GNU

Je fabriquais une référence de compilation synthétique et ne pouvait pas la peine d’écrire un Makefile, alors j’ai utilisé:

sudo apt-get install parallel
ls | grep -E '\.c

 Explication: 


  {.}  prend l'argument d'entrée et supprime son extension 
  -t  affiche 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 à l'aide de celui-ci ... 


  parallel  est tellement pratique que je pourrais même faire une vérification de l'horodatage moi-même: 

ls | grep -E '\.c

  xargs -P  peut également exécuter des travaux en parallèle, mais il est un peu moins pratique de manipuler des extensions ou d'exécuter plusieurs commandes:  Appeler plusieurs commandes via xargs  

 Un lien parallèle a été demandé à l'adresse:  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. Il est donc peut-être aussi possible d’accélérer la compilation d’un fichier unique pour les gros fichiers. Mais je ne trouve pas de référence maintenant. 

 Testé sous Ubuntu 18.10. 
 | parallel -t --will-cite "gcc -c -o '{.}.o' '{}'"


 Explication: 


  {.}  prend l'argument d'entrée et supprime son extension 
  -t  affiche 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 à l'aide de celui-ci ... 


  parallel  est tellement pratique que je pourrais même faire une vérification de l'horodatage moi-même: 

<*>

  xargs -P  peut également exécuter des travaux en parallèle, mais il est un peu moins pratique de manipuler des extensions ou d'exécuter plusieurs commandes:  Appeler plusieurs commandes via xargs  

 Un lien parallèle a été demandé à l'adresse:  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. Il est donc peut-être aussi possible d’accélérer la compilation d’un fichier unique pour les gros fichiers. Mais je ne trouve pas de référence maintenant. 

 Testé sous Ubuntu 18.10. 
 | parallel -t --will-cite "\
  if ! [ -f '{.}.o' ] || [ '{}' -nt '{.}.o' ]; then
    gcc -c -o '{.}.o' '{}'
  fi
"

xargs -P peut également exécuter des travaux en parallèle, mais il est un peu moins pratique de manipuler des extensions ou d'exécuter plusieurs commandes: Appeler plusieurs commandes via xargs

Un lien parallèle a été demandé à l'adresse: 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. Il est donc peut-être aussi possible d’accélérer la compilation d’un fichier unique pour les gros fichiers. Mais je ne trouve pas de référence maintenant.

Testé sous Ubuntu 18.10.

| parallel -t --will-cite "gcc -c -o '{.}.o' '{}'"

Explication:

• {.} prend l'argument d'entrée et supprime son extension
• -t affiche 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 à l'aide de celui-ci ...

parallel est tellement pratique que je pourrais même faire une vérification de l'horodatage moi-même:

<*>

xargs -P peut également exécuter des travaux en parallèle, mais il est un peu moins pratique de manipuler des extensions ou d'exécuter plusieurs commandes: Appeler plusieurs commandes via xargs

Un lien parallèle a été demandé à l'adresse: 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. Il est donc peut-être aussi possible d’accélérer la compilation d’un fichier unique pour les gros fichiers. Mais je ne trouve pas de référence maintenant.

Testé sous Ubuntu 18.10.