Правило GNU Makefile, генерирующее несколько целей из одного исходного файла

Я пытаюсь сделать следующее. Есть программа, назовите ее foo-bin, которая принимает один входной файл и генерирует два выходных файла. Глупое правило Makefile для этого будет:

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

Однако это никоим образом не означает, makeчто обе цели будут созданы одновременно. Это нормально при makeпоследовательном запуске , но, скорее всего, вызовет проблемы, если кто-то попытается make -j16или что-то столь же безумное.

Вопрос в том, существует ли способ написать правильное правило Makefile для такого случая? Ясно, что это сгенерирует DAG, но почему-то в руководстве GNU make не указано, как этот случай может быть обработан.

Выполнить один и тот же код дважды и получить только один результат не может быть и речи, потому что вычисление требует времени (подумайте: часы). Вывод только одного файла также был бы довольно трудным, потому что часто он используется как вход для GNUPLOT, который не знает, как обрабатывать только часть файла данных.

Я бы решил это следующим образом:

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

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

В этом случае параллельная программа make будет «сериализовать», создавая a и b, но поскольку создание b ничего не делает, это не требует времени.

Уловка состоит в том, чтобы использовать шаблонное правило с несколькими целями. В этом случае make предположит, что обе цели созданы одним вызовом команды.

все: файл-a.out файл-b.out
файл-a% out файл-b% out: input.in
    foo-bin input.in файл-a $ * out файл-b $ * out

Эта разница в интерпретации между шаблонными и обычными правилами не совсем понятна, но она полезна для подобных случаев и задокументирована в руководстве.

Этот прием можно использовать для любого количества выходных файлов, если в их именах есть какая-то общая подстрока для %сопоставления. (В этом случае общая подстрока - ".")

У Make нет интуитивно понятного способа сделать это, но есть два достойных обходных пути.

Во-первых, если задействованные цели имеют общую основу, вы можете использовать правило префикса (с GNU make). То есть, если вы хотели исправить следующее правило:

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

Вы могли бы написать это так:

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

(Используя переменную правила шаблона $ *, которая обозначает совпадающую часть шаблона)

Если вы хотите быть переносимым на реализации Make, отличные от GNU, или если ваши файлы не могут быть названы в соответствии с шаблоном, есть другой способ:

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

Это сообщает программе make, что input.in.intermediate не будет существовать до запуска make, поэтому его отсутствие (или его временная метка) не приведет к ложному запуску foo-bin. И вне зависимости от того, устарели ли либо file-a.out, либо file-b.out, либо оба (относительно input.in), foo-bin будет запущен только один раз. Вы можете использовать .SECONDARY вместо .INTERMEDIATE, чтобы программа make НЕ удаляла гипотетическое имя файла input.in.intermediate. Этот метод также безопасен для параллельных сборок make.

Точка с запятой в первой строке важна. Он создает пустой рецепт для этого правила, так что Make знает, что мы действительно будем обновлять file-a.out и file-b.out (спасибо @siulkiulki и другим, указавшим на это)

Это основано на втором ответе @ deemer, который не полагается на правила шаблона, и исправляет проблему, с которой я столкнулся с вложенным использованием обходного пути.

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

Я бы добавил это как комментарий к ответу @ deemer, но я не могу, потому что я только что создал эту учетную запись и не имею никакой репутации.

Объяснение: Пустой рецепт нужен для того, чтобы позволить Make надлежащим образом отметить file-a.outи пометить file-b.outкак восстановленный. Если у вас есть еще одна промежуточная цель, которая зависит от file-a.out, то Make решит не создавать внешнюю промежуточную цель , утверждая:

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

После GNU Make 4.3 (19 января 2020 г.) вы можете использовать «сгруппированные явные цели». Заменить: на &:.

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

В файле NEWS GNU Make говорится:

Новая функция: сгруппированные явные цели

У шаблонных правил всегда была возможность сгенерировать несколько целей с помощью одного вызова рецепта. Теперь можно объявить, что явное правило генерирует несколько целей за один вызов. Чтобы использовать это, замените в правиле токен «:» на «&:». Чтобы обнаружить эту функцию, поищите 'grouped-target' в специальной переменной .FEATURES. Реализация предоставлена ​​Каз Кылхеку <kaz@kylheku.com>

Вот как я это делаю. Сначала я всегда отделяю предварительные требования от рецептов. Тогда в этом случае новая цель сделать рецепт.

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

В первый раз:
1. Мы пытаемся собрать файл a.out, но сначала нужно сделать dummy-a-and-b.out, поэтому make запускает рецепт dummy-a-and-b.out.
2. Пробуем собрать file-b.out, dummy-a-and-b.out в актуальном состоянии.

Второй и последующие разы:
1. Мы пытаемся собрать file-a.out: make просматривает предварительные требования, обычные предварительные требования актуальны, вторичные предварительные требования отсутствуют, поэтому игнорируются.
2. Мы пытаемся создать file-b.out: make просматривает предварительные требования, обычные предварительные требования актуальны, второстепенные предварительные требования отсутствуют, поэтому игнорируются.

В качестве расширения к ответу @ deemer я обобщил его в функцию.

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

Сломать:

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

Удалите любые начальные / конечные пробелы из первого аргумента

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

Создайте переменную цель с уникальным значением для использования в качестве промежуточной цели. В этом случае значение будет .inter.file-a.out_file-b.out.

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

Создайте пустой рецепт для выходов с уникальной целью в качестве зависимости.

$(eval .INTERMEDIATE: $(target) ) 

Объявите уникальную цель как промежуточную.

$(target)

Завершите со ссылкой на уникальную цель, чтобы эту функцию можно было использовать непосредственно в рецепте.

Также обратите внимание, что использование eval здесь связано с тем, что eval не расширяется до нуля, поэтому полное расширение функции является просто уникальной целью.

Следует отдать должное атомарным правилам в GNU Make, на которых основана эта функция.

Чтобы предотвратить параллельное многократное выполнение правила с несколькими выходами make -jN, используйте .NOTPARALLEL: outputs. В твоем случае :

.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