Définition automatique de l'emploi (-j) indicateur d'un système multicœur?

J'ai un Makefile sur une machine qui a une tonne de carottes, mais j'oublie toujours d'écrire -jX lors de la compilation de mon projet et il prend plus de temps qu'il ne le devrait.

Est-il un moyen que je puisse régler le -j drapeau par le biais d'une variable d'environnement ou de certains autres persistante fichier de configuration de sorte que faire automatiquement exécuter plusieurs tâches en parallèle sur cette machine?

  • Connexes: stackoverflow.com/questions/2527496/...
  • quel système d'exploitation avez-vous besoin? Et pourquoi ne pas alias make='make -j$(getconf _NPROCESSORS_ONLN)' travail pour vous?
  • Alias ne suffira pas parce que j'ai besoin d'éditer le fichier Makefile et avoir encore de travail. J'en ai besoin pour GNU Make 4.1. @TarunLalwani
InformationsquelleAutor KarateSnowMachine | 2011-01-24
  1. 33

    Il semble que la MAKEFLAGS variable d'environnement peut passer des options qui font partie de chaque make exécuter (au moins pour GNU make). Je n'ai pas eu beaucoup de chance avec moi-même, mais il pourrait être possible d'utiliser -l plutôt que -j pour exécuter automatiquement autant d'emplois que sont appropriés pour le nombre de cœurs disponibles.

    • Eh bien, vous pouvez passer -l ou -j mais sans arguments. Essayez par vous-même: gist.github.com/sanmai/dcc31ae20afa6e8ba4721f174fe05fd9
    • Notez que le passage -l désactive la charge de limitation alors que -j sans arguments dire make pour démarrer nombre illimité de paraller processus.
    InformationsquelleAutor Jeremiah Willcock
  2. 37

    Je suis en supposant que vous êtes en utilisant Linux. C'est à partir de mon ~/.bashrc

    # parallel make
export NUMCPUS=`grep -c '^processor' /proc/cpuinfo`
alias pmake='time nice make -j$NUMCPUS --load-average=$NUMCPUS'

    exemple d'utilisation

    samm@host src> echo $NUMCPUS
8
samm@host src> pmake

    devient time nice make -j8 --load-average=8.

    Pour répondre à votre question spécifique à propos de mettre cela dans une Makefile, je ne trouve pas pratique de les saupoudrer de cette logique, tous mes fichiers "Makefile". Mettre dans un haut niveau de Makefile n'est pas une bonne solution, car j'ai souvent construire à partir de sous-répertoires et souhaitent construire en parallèle ainsi. Toutefois, si vous avez une assez plat de la source de la hiérarchie, il peut travailler pour vous.

    • Bonne idée auto-détection du nombre de cœurs. Bien que j'ai fini par aller avec $((NUMCPUS*2)) puisque c'est ce que j'ai généralement de la compilation avec. Merci!
    • %NOMBRE_DE_PROCESSEURS% peut être utilisé avec gnu make sur les systèmes windows
    • Vous pouvez également avoir le nombre de processeurs avec nproc de commande.
    • Juste une remarque: nproc n'existe pas sur certaines des plus vieilles distributions (en vous regardant, RHEL5)
    • Note supplémentaire sur nproc à partir de la page de man: "Imprimer le nombre d'unités de traitement disponibles pour le processus actuel, qui peut être inférieur au nombre de ligne de processeurs"
    InformationsquelleAutor Sam Miller
  3. 27

    Comme Jérémie Willcock dit, l'utilisation des MAKEFLAGS, mais voici comment le faire:

    export MAKEFLAGS="-j $(grep -c ^processor /proc/cpuinfo)"

    ou vous pouvez définir une valeur fixe comme ceci:

    export MAKEFLAGS="-j 8"

    Si vous voulez vraiment augmenter les performances, vous devez utiliser ccache en ajoutant quelque chose comme ce qui suit à votre Makefile:

    CCACHE_EXISTS := $(shell ccache -V)
ifdef CCACHE_EXISTS
    CC := ccache $(CC)
    CXX := ccache $(CXX)
endif
    • ne fonctionne pas pour osx (et windows)
    • Ne pas travailler pour GNU Make 4.1 - voir l'exemple ici
    • Je suis en utilisant MAKEFLAGS ici pas MAKEOPTS utilisé dans votre exemple. Je crois GNU Make 4.1 a encore MAKEFLAGS.
    • Nope. Voyez vous-même: strings /usr/bin/make | grep MAKEFLAGS
    InformationsquelleAutor jcoffland
  4. 15

    J'ai l'habitude de le faire comme suit dans mes scripts bash:

    make -j$(nproc)
    InformationsquelleAutor Bl00dh0und
  5. 6

    Vous pouvez ajouter une ligne à votre fichier Makefile semblable à la suivante:

    NUMJOBS=${NUMJOBS:-" -j4 "}

    Puis ajouter un ${NUMJOBS} ligne dans vos règles, ou de l'ajouter dans un autre Makefile var (comme MAKEFLAGS). Cela permettra d'utiliser le NUMJOBS envvar, si elle existe; si elle ne fonctionne pas, utiliser automatiquement -j4. Vous pouvez régler ou de le renommer à votre goût.

    (N. B.: Personnellement, je préfère le défaut d'être -j1 ou "", surtout si ça va être distribués à d'autres, parce que même si j'ai plusieurs cœurs aussi, je compile sur de nombreuses plateformes différentes, et oublie souvent de dis-mesure de la -jX réglage.)

    • Merci pour cette réponse. Je suis allé avec Jérémie réponse parce que c'est un peu plus facile à comprendre et je n'ai pas à modifier le makefile à tous (laisser les gens le téléchargement de la configuration de projet, quel que soit -j drapeau ils le souhaitent, mais ils veulent). Instructif tout de même.
    • Aussi loin que je peux dire, en ajoutant -jX à MAKEFLAGS a cessé de travailler sur la dernière version de GNU make dans le courant de l'année dernière. Quelqu'un at-il vécu cela?
    InformationsquelleAutor Sdaz MacSkibbons
  6. 6

    Les alias ne sont pas développés à l'intérieur de scripts. Il est préférable de créer un make script et de le placer dans l'une des $PATH répertoires:

    #!/bin/sh

if [ -f /proc/cpuinfo ]; then
    CPUS=`grep processor /proc/cpuinfo | wc -l`
else
    CPUS=1
fi
/usr/bin/make -j`expr $CPUS + 1` "$@"
    InformationsquelleAutor svlasov
  7. 2

    Sur Ubuntu 16.4 à l'aide de tous les cœurs de PROCESSEUR:

    export MAKEFLAGS='-j$(nproc)'

    ou 

    export MAKEFLAGS='-j 2'
    InformationsquelleAutor mwweb
  8. 2

    Jusqu'à ce que le courant de 2016, vous pouvez mettre ceci dans votre makefile: (GNU make testé)

    MAKEFLAGS += "-j$(NUM_CORES) -l$(NUM_CORES)

    (où NUM_PPROCS est calculée ou ensemble selon l'une des nombreuses autres réponses ici) Et, bam! vous avez multi-processus de construction en cours.

    Étant donné que cela a cessé de travailler, la meilleure chose que je puisse arriver, c'est ça, où le makefile appelle elle-même, mais avec -jX et -lX. 

    ifeq ($(PARALELL_WRAPPER_ABXCOEOEKCOEBMQJKHTOEUB),done)

all: ...
   ...

other_target: ...
    ...

else
# add parallelism equal to number of cores every time.
# "random" strings are to ensure uniqueness
NUM_CORES ?= $(shell grep -c "vendor_id" /proc/cpuinfo)
MAKEFLAGS +=" -j$(NUM_CORES) -l$(NUM_CORES) "

# for the default target case
parallel_wrapper_default_target_anthsqjkshbeohcbmeuthnoethoaeou:
    $(MAKE) PARALELL_WRAPPER_ABXCOEOEKCOEBMQJKHTOEUB=done

# catches everything else
% :
    $(MAKE) $@ PARALELL_WRAPPER_ABXCOEOEKCOEBMQJKHTOEUB=done

endif
    InformationsquelleAutor golvok
  9. 1

    Au début d'un Makefile:

    MAKEFLAGS+="j"

    Il ne prendra pas les arguments numériques pour n'importe quelle version de GNU Make avant 4.2. Après 4.2 vous pouvez le faire:

    MAKEFLAGS+="j2"

    Pour les versions antérieures à 4.2 si vous avez certains emplois à court de mémoire, vous pouvez les faire courir un seul à la fois avec flock de util-linux-ng. Par exemple, un convert utilitaire de ImageMagick va utiliser toutes les ressources qu'elle peut obtenir lorsqu'il est utilisé pour optimiser les images selon les recommandations de Google, donc il n'y a pas de point de l'exécuter en parallèle. 

    %.min.jpg: %.jpg
    @flock --wait 600 Makefile convert $< -sampling-factor 4:2:0 -strip $@

    Il est important de définir un temps d'attente est long parce que faire sera toujours exécuté la plupart de ces commandes en parallèle. Par conséquent, les temps d'attente doit être comme le plus profond de la file d'attente temps d'exécution. Si vous avez huit cœurs, et de huit grandes images prenez une minute pour optimiser, vous devez définir le temps d'attente d'au moins une minute.

    Avec des centaines de cœurs et des images énormes, six cents secondes défini ci-dessus peut ne pas être suffisant.

    • La façon dont j'interprète que le changelog est que maintenant il est possible de dire ce que le parallélisme est dans un Makefile par l'inspection MAKEFLAGS. GNU Make utilise un emploi à base de jetons système, de sorte que le réel parallélisme est que le nombre de jetons que le job server est prêt à donner. Aussi, les réponses ici que l'utilisation MAKEFLAGS faire réellement le travail, même si moi aussi j'avais remarqué que MAKEFLAGS utilisé pour ne pas avoir le nombre.
    • Ils ne travaillent en réalité, comme l'explique depuis la 4.2, tout comme illustré ici.
    InformationsquelleAutor sanmai
  10. -1

    Je voudrais juste poser

    alias make='make -j'

    dans ~/.profile ou ~/.bashrc.

    Selon la manuel:

    Si il n'y a rien de ressemblant à un entier après le ‘-j’ option, il n'y a pas de limite sur le nombre de machines à sous.

    • Sur mon core 2 machine inconditionnel -j rapidement mange de tout mon mémoire sur une grande construction. Pas recommandé.
    • Oui, cela semble être quelque chose qui serait la cause d'une fourche à la bombe sur votre ordinateur avec un grand Makefile.
    InformationsquelleAutor Alberto