Saturday, July 23, 2016

Lazy GNU make variables

GNU make has two 'flavors' of variable: simple and recursive. Everyone is familiar the the recursive style (which uses = for definition):

    BAR = banana
    FOO = one $(BAR), two $(BAR)s
    BAR = guava

The value of FOO is determined each time FOO is used. In a large Makefile that can mean that FOO is expanded over and over again. If expanding FOO is an expensive operation then determining its value each time can slow down the Makefile. For example,

    TODAY = $(shell date +%d/%m/%y)

would be very expensive is it would shell out to run date every time TODAY is used (and might have the strange effect of returning different dates if you run your make near midnight).

(I've written about that before and in my book on GNU make)

The other flavor of make variable is simple: its value is fixed the moment it's defined:

    BAR = banana
    FOO := one $(BAR), two $(BAR)s
    BAR = guava

There FOO is set to one banana, two bananas and not one guava, two guavas (as was the case above) because the right hand side of the := is expanded when FOO is being defined and BAR has the value banana at that point.

But suppose you wanted a mixture of the two: a variable that is only ever expanded once and only expanded if it is used. This might be useful if the variable was used rarely as part of the build and was expensive to expand.

You can concoct a recipe for that like this. Suppose you want to define a variable FOO to have value expensive-to-calculate then you can use the following pattern:

    FOO = $(eval FOO := expensive-to-evaluate)$(FOO)

It's initially a recursive variable and so the right-hand side is not expanded until it is used. But the first time it is used FOO is redefined (by the $(eval)) and becomes a simple variable with the value of expensive-to-evaluate.

Having become a simple variable it's possible to return its value (note that if FOO was still recursive it would not be allowed to reference itself like that).

You can see that in action with the following Makefile. To make it clear when NOW is actually expanded I've added a call to $(info). And calls to $(flavor) to show when NOW changes from recursive to simple.

    $(info Start Parse)

    NOW = $(eval NOW := $(info Expand NOW)$(shell date -u))$(NOW)

    .PHONY: all foo
    all: foo ; @echo "$@ /    $(flavor NOW) / $(NOW) / $(flavor NOW)"
    foo: ; @echo "$@ / $(flavor NOW) / $(NOW) / $(flavor NOW)" && sleep 1

    $(info End Parse)

Which will output

    Start Parse
    End Parse
    Expand NOW
    foo / recursive / Sat Jul 23 15:01:15 UTC 2016 / simple
    all /    simple / Sat Jul 23 15:01:15 UTC 2016 / simple

The one gotcha with this is that you need to be sure that when NOW is expanded any variable it depends on have the values you expect.

It's possible to wrap that up in a function like this:

    $(info Start Parse)

    make-lazy = $(eval $1 = $​$(eval $1 := $(value $(1)))$​$($1))

    NOW = $(info Expand NOW)$(shell date -u)
    $(call make-lazy,NOW)

    .PHONY: all foo
    all: foo ; @echo "$@ /    $(flavor NOW) / $(NOW) / $(flavor NOW)"

    foo: ; @echo "$@ / $(flavor NOW) / $(NOW) / $(flavor NOW)" && sleep 1

    $(info End Parse)

Just $(call) make-lazy on any recursive variable to make it lazy.


Oliver said...

I ran in to problems with GNU make sometimes crashing if I recursively modified a variable from within the variable.

I've ended up with the following macro:
cache = $(eval $1 = \
$$(if $$(cache.$1),,$$(eval cache.$1 := $(value 2)))$$(cache.$1))

Using it needs doubled $ signs, e.g:

$(call cache,LDSTDCXX,$$(realpath $$(shell g++

My original macro that caused GNU make to crash sometimes was just:

cache = $(eval $1 = $$(eval $1 := $(value 2))$$($1))

Anonymous said...

I Wonder if this could this break make -j parallelism one day

Victor Shih said...

I use this technique frequently, having seen it here.

This tended to segfault in GNU make around version 3.81 though, due this bug. This has been fixed in more recent versions, and there is even a patch for 3.81 mentioned.

One situation I haven't found a solution for is, is there a way to do this for pattern-specific variables?