Параллельный ./configure

Извините, но в 2025 году — это просто смешно:

$ time ./configure
...
./configure  13.80s user 12.72s system 69% cpu 38.018 total
$ time make -j48
...
make -j48  12.05s user 4.70s system 593% cpu 2.822 total

Я заплатил приличные деньги за 24 ядра CPU, а ./configure умудряется грузить только 69% одного ядра! В результате этот рандомный проект конфигурится в 13.5 раз медленнее, чем потом реально собирается.

Назначение ./configure — это просто много раз вызвать компилятор и проверить, какие тесты прошли. Типа: есть ли нужные заголовки, функции, структуры, поля — чтобы писать переносимый код. Эта задача идеально параллелится, но автотулы (autoconf, cmake, meson и прочие) до сих пор не умеют это делать.

Типичная структура configure скрипта выглядит так:

CFLAGS="-g"
if $CC $CFLAGS -Wall empty.c; then
    CFLAGS="$CFLAGS -Wall"
fi

: >config.h
if $CC $CFLAGS have_statx.c; then
    echo "#define HAVE_STATX 1" >>config.h
else
    echo "#define HAVE_STATX 0" >>config.h
fi
...

То есть проверки идут последовательно. Хотя на практике их спокойно можно было бы гнать параллельно. Более того, инструмент для параллельного исполнения у нас уже есть — make!

Почему бы не использовать его? Идея простая: У нас будет специальный configure.mk, который будет генерить Makefile и config.h через make -j:

# configure.mk
# The default goal generates both outputs, and merges the logs together
config: Makefile config.h
    cat Makefile.log config.h.log >$@.log
    rm Makefile.log config.h.log

Проверки превращаются в независимые таргеты. Например:

# configure.mk

# Дефолтные значения на всякий случай:
CC ?= cc
CPPFLAGS ?= -D_GNU_SOURCE
CFLAGS ?= -g
LDFLAGS ?=

# Экспортируем их, чтобы избежать удаления обратных слешей:
export _CC=${CC}
export _CPPFLAGS=${CPPFLAGS}
export _CFLAGS=${CFLAGS}
export _LDFLAGS=${LDFLAGS}

#Генерируем Makefile:
Makefile:
    printf 'CC := %s\n' "$$_CC" >$@
    printf 'CPPFLAGS := %s\n' "$$_CPPFLAGS" >>$@
    printf 'CFLAGS := %s\n' "$$_CFLAGS" >>$@
    printf 'LDFLAGS := %s\n' "$$_LDFLAGS" >>$@

Экспортирование export сделано так, чтобы избежать удаления обратных слешей из вызовов типа таких:

$ ./configure CPPFLAGS='-DMACRO=\"string\"'

Теперь проверим поддержку флагов (-Wall, -pthread, и т.д.) с помощью небольшого скрипта flags.sh:

#!/bin/sh

set -eu

VAR="$1"
FLAGS="$2"
shift 2

if "$@" $FLAGS; then
    printf '%s += %s\n' "$VAR" "$FLAGS"
fi

Простой пример:

$ ./flags.sh CFLAGS -Wall cc empty.c
 CFLAGS += -Wall

Скрипт выведет CFLAGS += -Wall только если cc empty.c -Wall завершится успешно.

Мы можем использовать такой подход для генерации некоторых фрагментов makefile, которые включают только поддерживаемые флаги.

ALL_FLAGS = ${CPPFLAGS} ${CFLAGS} ${LDFLAGS}

# Запускаем компилятор с заданными флагами, отправляя
#
# - stdout в foo.mk (напр. CFLAGS += -flag)
# - stderr в foo.mk.log (напр. error: unrecognized command-line option ‘-flag’)
# - бинарники в foo.mk.out
#   - а потом сразу их удаляем
TRY_CC = ${CC} ${ALL_FLAGS} empty.c -o $@.out >$@ 2>$@.log && rm -f $@.out $@.d

deps.mk:
    ./flags.sh CPPFLAGS "-MP -MD" ${TRY_CC}
Wall.mk:
    ./flags.sh CFLAGS -Wall ${TRY_CC}
pthread.mk:
    ./flags.sh CFLAGS -pthread ${TRY_CC}
bind-now.mk:
    ./flags.sh LDFLAGS -Wl,-z,now ${TRY_CC}

Каждый из этих таргетов генерит крошечный фрагмент мэйкфайла, отвечающий за один флаг и каждый из них может работать независимо, параллельно!

Как только тесты будут готовы, мы можем объединить их все в основной файл Makefile и очистить мусор:

FLAGS := \
    deps.mk \
    Wall.mk \
    pthread.mk \
    bind-now.mk

Makefile: ${FLAGS}
    printf 'CC := %s\n' "$$_CC" >$@
    ...
    cat ${FLAGS} >>$@
    cat ${FLAGS:%=%.log} >$@.log
    rm ${FLAGS} ${FLAGS:%=%.log}

Осталось добавить в Makefile ту часть которая фактически собирает наше приложение. Мы можем написать простой main.mk следующим образом:

#main.mk
OBJS := main.o

app: ${OBJS}
    ${CC} ${CFLAGS} ${LDFLAGS} ${OBJS} -o $@

${OBJS}:
    ${CC} ${CPPFLAGS} ${CFLAGS} -c ${@:.o=.c} -o $@

-include ${OBJS:.o=.d}

А затем добавить его в Makefile после всех флагов:

Makefile: ${FLAGS}
    ...
    cat main.mk >>$@

Ещё нам нужно сгенерировать config.h, который определяет макросы, сообщающие нам, существуют ли определенные библиотеки/заголовки/функции/поля структур и т.д.

Проверка фичи делается тоже через компиляцию микро-программок, например:

проверка statx() have_statx.c :

#include <fcntl.h>
#include <sys/stat.h>

int main(void) {
    struct statx stx;
    return statx(AT_FDCWD, ".", 0, STATX_BTIME, &stx);
}

проверка st_birthtim() have_st_birthtim.c :

#include <sys/stat.h>

int main(void) {
    struct stat sb = {0};
    return sb.st_birthtim.tv_sec;
}

А define.sh превратит результат выполнения в макрос:

#!/bin/sh

set -eu

MACRO=$1
shift

if "$@"; then
    printf '#define %s 1\n' "$MACRO"
else
    printf '#define %s 0\n' "$MACRO"
fi

который сгенерирует что-то типа в зависимости от результата выполнения:

#define HAVE_STATX 1
#define HAVE_ST_BIRTHTIM 0

Мы можем использовать его в makefile вот так:

#configure.mk

# Use a recursive make to pick up our auto-detected *FLAGS from above
config.h: Makefile
    +${MAKE} -f header.mk $@

#header.mk

# Get the final *FLAGS values from the Makefile
include Makefile

# We first generate a lot of small headers, before merging them into one big one
HEADERS := \
    have_statx.h \
    have_st_birthtim.h \
    have_st_birthtimespec.h \
    have___st_birthtim.h

# Strip .h and capitalize the macro name
MACRO = $$(printf '%s' ${@:.h=} | tr 'a-z' 'A-Z')

ALL_FLAGS = ${CPPFLAGS} ${CFLAGS} ${LDFLAGS}

${HEADERS}:
    ./define.sh ${MACRO} ${CC} ${ALL_FLAGS} ${@:.h=.c} -o $@.out >$@ 2>$@.log
    rm -f $@.out $@.d

И потом всё это склеить в config.h с защитой от двойного включения вот так:

#header.mk
config.h: ${HEADERS}
    printf '#ifndef CONFIG_H\n' >$@
    printf '#define CONFIG_H\n' >>$@
    cat ${HEADERS} >>$@
    printf '#endif\n' >>$@
    cat ${HEADERS:%=%.log} >$@.log
    rm ${HEADERS} ${HEADERS:%=%.log}

В итоге, полноценный ./configure превращается в просто:

#!/bin/sh

set -eu

# Guess a good number for make -j<N>
jobs() {
    {
        nproc \
            || sysctl -n hw.ncpu \
            || getconf _NPROCESSORS_ONLN \
            || echo 1
    } 2>/dev/null
}

# Default to MAKE=make
MAKE="${MAKE-make}"

# Set MAKEFLAGS to -j$(jobs) if it's unset
export MAKEFLAGS="${MAKEFLAGS--j$(jobs)}"

$MAKE -r -f configure.mk "$@"

Я сделал рабочий пример на GitHub где все эти файлы представлены полностью — можете скопировать себе. Демо печатает время создания файла, если оно поймет как делать это на вашей системе.

Я также давно использую подобную сборку в своем проекте bfs, и разница в производительности колоссальная:

$ time ./configure
...
./configure  1.44s user 1.78s system 802% cpu 0.401 total

$ time make -j48
...
make -j48  1.89s user 0.64s system 817% cpu 0.310 total

Конечно, часть выигрыша приходит от того, что я просто уменьшил количество ненужных проверок, но загрузка CPU на 802% вместо 69% одного ядра — это уже не смешно, это настоящее ускорение.