Параллельный ./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% одного ядра — это уже не смешно, это настоящее ускорение.