Règle GNU Makefile générant quelques cibles à partir d'un seul fichier source

J'essaye de faire ce qui suit. Il existe un programme, appelez-le foo-bin, qui prend un seul fichier d'entrée et génère deux fichiers de sortie. Une règle Makefile stupide pour cela serait:

file-a.out file-b.out: input.in
    foo-bin input.in file-a.out file-b.out

Cependant, cela n'indique makeen aucun cas que les deux cibles seront générées simultanément. C'est bien lors de l'exécution makeen série, mais cela causera probablement des problèmes si l'on essaie make -j16ou quelque chose d'aussi fou.

La question est de savoir s'il existe un moyen d'écrire une règle Makefile appropriée pour un tel cas? Clairement, cela générerait un DAG, mais d'une manière ou d'une autre, le manuel de fabrication de GNU ne spécifie pas comment ce cas pourrait être traité.

Exécuter le même code deux fois et générer un seul résultat est hors de question, car le calcul prend du temps (pensez: heures). La sortie d'un seul fichier serait également assez difficile, car il est fréquemment utilisé comme entrée dans GNUPLOT qui ne sait pas gérer seulement une fraction d'un fichier de données.

Je le résoudrais comme suit:

file-a.out: input.in
    foo-bin input.in file-a.out file-b.out   

file-b.out: file-a.out
    #do nothing
    noop

Dans ce cas, la création parallèle «sérialisera» la création de a et b mais puisque la création de b ne fait rien, cela ne prend pas de temps.

L'astuce consiste à utiliser une règle de modèle avec plusieurs cibles. Dans ce cas, make supposera que les deux cibles sont créées par une seule invocation de la commande.

tout: fichier-a.out fichier-b.out
file-a% out file-b% out: input.in
    foo-bin input.in fichier-a $ * out fichier-b $ * out

Cette différence d'interprétation entre les règles de modèle et les règles normales n'a pas vraiment de sens, mais elle est utile pour des cas comme celui-ci, et elle est documentée dans le manuel.

Cette astuce peut être utilisée pour n'importe quel nombre de fichiers de sortie tant que leurs noms ont une sous-chaîne commune à laquelle le %doit correspondre. (Dans ce cas, la sous-chaîne commune est ".")

Make n'a aucun moyen intuitif de le faire, mais il existe deux solutions de contournement décentes.

Premièrement, si les cibles impliquées ont une racine commune, vous pouvez utiliser une règle de préfixe (avec GNU make). Autrement dit, si vous souhaitez corriger la règle suivante:

object.out1 object.out2: object.input
    foo-bin object.input object.out1 object.out2

Vous pouvez l'écrire de cette façon:

%.out1 %.out2: %.input
    foo-bin $*.input $*.out1 $*.out2

(En utilisant la variable de règle de modèle $ *, qui correspond à la partie correspondante du modèle)

Si vous voulez être portable vers des implémentations non-GNU Make ou si vos fichiers ne peuvent pas être nommés pour correspondre à une règle de modèle, il existe un autre moyen:

file-a.out file-b.out: input.in.intermediate ;

.INTERMEDIATE: input.in.intermediate
input.in.intermediate: input.in
    foo-bin input.in file-a.out file-b.out

Cela indique à make que input.in.intermediate n'existera pas avant que make ne soit exécuté, donc son absence (ou son horodatage) ne provoquera pas une exécution erronée de foo-bin. Et que file-a.out ou file-b.out ou les deux soient obsolètes (par rapport à input.in), foo-bin ne sera exécuté qu'une seule fois. Vous pouvez utiliser .SECONDARY au lieu de .INTERMEDIATE, ce qui demandera à make NOT de supprimer un nom de fichier hypothétique input.in.intermediate. Cette méthode est également sûre pour les builds parallèles.

Le point-virgule sur la première ligne est important. Cela crée une recette vide pour cette règle, de sorte que Make sache que nous allons vraiment mettre à jour file-a.out et file-b.out (merci @siulkiulki et d'autres qui l'ont signalé)

Ceci est basé sur la deuxième réponse de @ deemer qui ne repose pas sur des règles de modèle, et corrige un problème que je rencontrais avec les utilisations imbriquées de la solution de contournement.

file-a.out file-b.out: input.in.intermediate
    @# Empty recipe to propagate "newness" from the intermediate to final targets

.INTERMEDIATE: input.in.intermediate
input.in.intermediate: input.in
    foo-bin input.in file-a.out file-b.out

J'aurais ajouté ceci en commentaire à la réponse de @ deemer, mais je ne peux pas car je viens de créer ce compte et je n'ai aucune réputation.

Explication: La recette vide est nécessaire pour permettre à Make de faire la comptabilité appropriée pour marquer file-a.outet file-b.outcomme ayant été reconstruite. Si vous avez encore une autre cible intermédiaire qui dépend de file-a.out, Make choisira de ne pas construire l'intermédiaire externe, en affirmant:

No recipe for 'file-a.out' and no prerequisites actually changed.
No need to remake target 'file-a.out'.

Après GNU Make 4.3 (19 janvier 2020), vous pouvez utiliser des «cibles explicites groupées». Remplacez :par &:.

file-a.out file-b.out &: input.in
    foo-bin input.in file-a.out file-b.out

Le fichier NEWS de GNU Make dit:

Nouvelle fonctionnalité: cibles explicites groupées

Les règles de modèle ont toujours eu la capacité de générer plusieurs cibles avec un seul appel de la recette. Il est désormais possible de déclarer qu'une règle explicite génère plusieurs cibles avec un seul appel. Pour l'utiliser, remplacez le jeton ":" par "&:" dans la règle. Pour détecter cette fonctionnalité, recherchez «grouped-target» dans la variable spéciale .FEATURES. Mise en œuvre fournie par Kaz Kylheku <kaz@kylheku.com>

Voilà comment je fais. Premièrement, je sépare toujours les pré-demandes des recettes. Puis dans ce cas une nouvelle cible pour faire la recette.

all: file-a.out file-b.out #first rule

file-a.out file-b.out: input.in

file-a.out file-b.out: dummy-a-and-b.out

.SECONDARY:dummy-a-and-b.out
dummy-a-and-b.out:
    echo creating: file-a.out file-b.out
    touch file-a.out file-b.out

La première fois:
1. Nous essayons de construire file-a.out, mais dummy-a-and-b.out doit d'abord le faire, alors make lance la recette dummy-a-and-b.out.
2. Nous essayons de construire file-b.out, dummy-a-and-b.out est à jour.

La deuxième fois et les suivantes:
1. Nous essayons de construire file-a.out: examinez les prérequis, les prérequis normaux sont à jour, les prérequis secondaires sont manquants donc ignorés.
2. Nous essayons de construire file-b.out: examinez les prérequis, les prérequis normaux sont à jour, les prérequis secondaires sont manquants donc ignorés.

Comme extension de la réponse de @ deemer, je l'ai généralisée en une fonction.

sp :=
sp +=
inter = .inter.$(subst $(sp),_,$(subst /,_,$1))

ATOMIC=\
    $(eval s1=$(strip $1)) \
    $(eval target=$(call inter,$(s1))) \
    $(eval $(s1): $(target) ;) \
    $(eval .INTERMEDIATE: $(target) ) \
    $(target)

$(call ATOMIC, file-a.out file-b.out): input.in
    foo-bin input.in file-a.out file-b.out

Panne:

$(eval s1=$(strip $1))

Supprimez tous les espaces de début / fin du premier argument

$(eval target=$(call inter,$(s1)))

Créez une cible variable avec une valeur unique à utiliser comme cible intermédiaire. Dans ce cas, la valeur sera .inter.file-a.out_file-b.out.

$(eval $(s1): $(target) ;)

Créez une recette vide pour les sorties avec la cible unique comme dépendance.

$(eval .INTERMEDIATE: $(target) ) 

Déclarez la cible unique comme intermédiaire.

$(target)

Terminez par une référence à la cible unique pour que cette fonction puisse être utilisée directement dans une recette.

Notez également que l'utilisation de eval ici est due au fait que eval se développe en rien et que l'expansion complète de la fonction est juste la cible unique.

Doit donner du crédit aux règles atomiques dans GNU Make dont cette fonction est inspirée.

Pour empêcher l'exécution multiple parallèle d'une règle avec plusieurs sorties avec make -jN, utilisez .NOTPARALLEL: outputs. Dans ton cas :

.NOTPARALLEL: file-a.out file-b.out

file-a.out file-b.out: input.in
    foo-bin input.in file-a.out file-b.out