Parallel ./configure

https://tavianator.com/2025/configure.html

by brooke2k • 1 year ago

219 186 1 year ago

epistasis• 1 year ago

I've spent a fair amount of time over the past decades to make autotools work on my projects, and I've never felt like it was a good use of time.

It's likely that C will continue to be used by everyone for decades to come, but I know that I'll personally never start a new project in C again.

I'm still glad that there's some sort of push to make autotools suck less for legacy projects.

tidwall• 1 year ago

I've stopped using autotools for new projects. Just a Makefile, and the -j flag for concurrency.

monkeyelite3• 1 year ago

You can use make without configure. If needed, you can also write your own configure instead of using auto tools.

Creating a make file is about 10 lines and is the lowest friction for me to get programming of any environment. Familiarity is part of that.

edoceo• 1 year ago

Write your own configure? For an internal project, where much is under domain control, sure. But for the 1000s of projects trying to multi-plarform and/or support flavours/versions - oh gosh.

viraptor• 1 year ago

It's a bit of a balance once you get bigger dependencies. A generic autoconf is annoying to write, but rarely an issue when packaging for a distro. Most issues I've had to fix in nixpkgs were for custom builds unfortunately.

But if you don't plan to distribute things widely (or have no deps).. Whatever, just do what works for you.

psyclobe2• 1 year ago

cmake ftw

aldanor• 1 year ago

You mean cargo build

malkia4• 1 year ago

cmake uses configure, or configure-like too!

JCWasmx86• 1 year ago

Or meson is a serious alternative to cmake (Even better than cmake imho)

torarnv2• 1 year ago

CMake also does sequential configuration AFAIK. Is there any work to improve on that somewhere?

eqvinox• 1 year ago

To extend on sibling comments:

autoconf is in no way, shape or form an "official" build system associated with C. It is a GNU creation and certainly popular, but not to a "monopoly" degree, and it's share is declining. (plain make & meson & cmake being popular alternatives)

blibble4• 1 year ago

is this really a big deal given you run ./configure once?

it's like systemd trading off non-determinism for boot speed, when it takes 5 minutes to get through the POST

LegionMammal9784• 1 year ago

If you do a lot of bisecting, or bootstrapping, or building compatibility matrices, or really anything that needs you to compile lots of old versions, the repeated ./configure steps really start feeling like a drag.

kazinator7• 1 year ago

In a "reasonably well-behaved program", if you have the artifacts from a current configure, like a "config.h" header, they are compatible with older commits, even if configurations changed, as long as the configuration changes were additive: introducing some new test, along with a new symbol in "config.h".

It's possible to skip some of the ./configure steps. Especially for someone who knows the program very well.

csdvrx• 1 year ago

it's like systemd trading off non-determinism for boot speed, when it takes 5 minutes to get through the POST

That's a bad analogy: if a given deterministic service ordering is needed for a service to correctly start (say because it doesn't start with the systemd unit), it means the non-deterministic systemd service units are not properly encoding the dependencies tree in the Before= and After=

When done properly, both solutions should work the same. However, the solution properly encoding the dependency graph (instead of just projecting it on a 1-dimensional sequence of numbers) will be more flexible: it's the better solution, because it will give you more speed but also more flexibility: you can see the branches any leaf depends on, remove leaves as needed, then cull the useless branches. You could add determinism if you want, but why bother?

It's like using the dependencies of linux packages, and leaving the job of resolving them to package managers (apt, pacman...): you can then remove the useless packages which are no longer required.

Compare that to doing a `make install` of everything to /usr/local in a specific order, as specified by a script: when done properly, both solutions will work, but one solution is clearly better than the other as it encodes more finely the existing dependencies instead of projecting them to a sequence.

You can add determinism if you want to follow a sequence (ex: `apt-get install make` before adding gcc, then add cuda...), or you can use meta package like build-essentials, but being restricted to a sequence gains you nothing.

blibble4• 1 year ago

I don't think it is a bad analogy

given how complicated the boot process is ([1]), and it occurs once a month, I'd rather it was as deterministic as possible

vs. shaving 1% off the boot time

[1]: distros continue to ship subtlety broken unit files, because the model is too complicated

Aurornis2• 1 year ago

is this really a big deal given you run ./configure once

I end up running it dozens of times when changing versions, checking out different branches, chasing dependencies.

It’s a big deal.

it's like systemd trading off non-determinism for boot speed, when it takes 5 minutes to get through the POST

5 minute POST time is a bad analogy. systemd is used in many places, from desktops (that POST quickly) to embedded systems where boot time is critical.

If deterministic boot is important then you would specify it explicitly. Relying on emergent behavior for consistent boot order is bad design.

The number of systems that have 5 minute POST times and need deterministic boot is an edge case of an edge case.

mschuster91• 1 year ago

I end up running it dozens of times when changing versions, checking out different branches, chasing dependencies.

Yeah... but neither of that is going to change stuff like the size of a data type, the endianness of the architecture you're running on, or the features / build configuration of some library the project depends on.

Parallelization is a bandaid (although a sorely needed!) IMHO, C/C++ libraries desperately need to develop some sort of standard that doesn't require a full gcc build for each tiny test. I'd envision something like nodejs's package.json, just with more specific information about the build details themselves. And for the stuff like datatype sizes, that should be provided by gcc/llvm in a fast-parseable way so that autotools can pick it up.

blibble4• 1 year ago

to embedded systems where boot time is critical.

if it's critical on an embedded system then you're not running systemd at all

The number of systems that have 5 minute POST times and need deterministic boot is an edge case of an edge case.

desktop machines are the edge case, there's a LOT more servers running Linux than people using Linux desktops

Relying on emergent behavior for consistent boot order is bad design.

tell that to the distro authors who 10 years in can't tell the difference between network-online.target, network-pre.target, network.target

0x457• 1 year ago

from desktops (that POST quickly)

I take you don't run DDR5?

Twirrim2• 1 year ago

chasing dependencies.

This aspect of configure, in particular, drives me nuts. Obviously I'd like it to be faster, but it's not the end of the world. I forget what I was trying to build the other week, but I had to make 18 separate runs of configure to find all the things I was missing. When I dug into things it looked like it could probably have done it in 2 runs, each presenting a batch of things that were missing. Instead I got stuck with "configure, install missing package" over and over again.

asah• 1 year ago

For postgresql development, you run configure over and over...

fishgoesblub• 1 year ago

Very nice! I always get annoyed when my fancy 16 thread CPU is left barely used as one thread is burning away with the rest sitting and waiting. Bookmarking this for later to play around with whatever projects I use that still use configure.

Also, I was surprised when the animated text at the top of the article wasn't a gif, but actual text. So cool!

fmajid4• 1 year ago

And on macOS, the notarization checks for all the conftest binaries generated by configure add even more latency. Apple reneged on their former promise to give an opt-out for this.

SuperV1234• 1 year ago

CMake also needs this, badly...

torarnv2• 1 year ago

Agreed! The CMake Xcode generator is extremely slow because not only is it running the configure tests sequentially, but it generates a new Xcode project for each of them.

redleader55• 1 year ago

Why do we need to even run most of the things in ./configure? Why not just have a file in /etc which is updated when you install various packages which ./configure can read to learn various stats about the environment? Obviously it will still allow setting various things with parameters and create a Makefile, but much faster.

o11c4• 1 year ago

Keep in mind that the build intentionally depends on environment variables, people often install non-packaged dependencies in bad ways, and cross-compiling is a thing, so it's not that simple.

wolfgang42• 1 year ago

Some relevant discussion/pointers to other notes on this sort of proposal can be found here: https://utcc.utoronto.ca/~cks/space/blog/sysadmin/AutoconfVa...

(The conclusion I distilled out of reading that at the time, I think, was that this is actually sort of happening, but slowly, and autoconf is likely to stick around for a while, if only as a compatibility layer during the transition.)

pabs3• 1 year ago

Not every OS is going to have such a file, and you also don't know if it matches the actual system ./configure runs on.

17186274402• 1 year ago

That does already exist in GNU Autoconf: https://www.gnu.org/software/autoconf/manual/autoconf-2.65/h...

creatonez• 1 year ago

Noticed an easter egg in this article. The text below "I'm sorry, but in the year 2025, this is ridiculous:" is animated entirely without Javascript or .gif files. It's pure CSS.

This is how it was done: https://github.com/tavianator/tavianator.com/blob/cf0e4ef26d...

o11c4• 1 year ago

Unfortunately it forgets to HTML-escape the <wchar.h> etc.

tavianator6• 1 year ago

Whoops! Forgot to do that when I switched from a ``` block to raw html

moralestapia3• 1 year ago

The purpose of a ./configure script is basically to run the compiler a bunch of times and check which runs succeeded.

Wait is this true? (!)

Am4TIfIsER0ppos• 1 year ago

Yes.

klysm5• 1 year ago

The closer and deeper you look into the C toolchains the more grossed out you’ll be

acuozzo3• 1 year ago

Hands have to get dirty somewhere. "As deep as The Worker's City lay underground, so high above towered the City of Metropolis."

The choices are:

1. Restrict the freedom of CPU designers to some approximation of the PDP11. No funky DSP chips. No crazy vector processors.

2. Restrict the freedom of OS designers to some approximation of Unix. No bespoke realtime OSes. No research OSes.

3. Insist programmers use a new programming language for these chips and OSes. (This was the case prior to C and Unix.)

4. Insist programmers write in assembly and/or machine code. Perhaps a macro-assembler is acceptable here, but this is inching toward C.

The cost of this flexibility is gross tooling to make it manageable. Can it be done without years and years of accrued M4 and sh? Perhaps, but that's just CMake and CMake is nowhere near as capable as Autotools & friends are when working with legacy platforms.

gdwatson3• 1 year ago

Historically, different Unixes varied a lot more than they do today. Say you want your program to use the C library function foo on platforms where it’s available and the function bar where it isn’t: You can write both versions and choose between them based on a C preprocessor macro, and the program will use the best option available for the platform where it was compiled.

But now the user has to set the preprocessor macro appropriately when he builds your program. Nobody wants to give the user a pop quiz on the intricacies of his C library every time he goes to install new software. So instead the developer writes a shell script that tries to compile a trivial program that uses function foo. If the script succeeds, it defines the preprocessor macro FOO_AVAILABLE, and the program will use foo; if it fails, it doesn’t define that macro, and the program will fall back to bar.

That shell script grew into configure. A configure script for an old and widely ported piece of software can check for a lot of platform features.

im3w1l• 1 year ago

I'm not saying we should send everyone a docker container with a full copy of ubuntu, electron and foo.js whether they have foo in their c library or not, but maybe there is a middle ground?

BobbyTables22• 1 year ago

I was really hoping he worked some autoreconf/macro magic to transform existing configure.ac files into a parallelized result.

Nice writeup though.

psyclobe2• 1 year ago

(Luckily?) With c++ your build will nearly always take longer then the configuration step.

bitbasher• 1 year ago

rust: "hold my leggings"

LoganDark• 1 year ago

Since when? I far more often run into CMake taking ages than Cargo.

klysm5• 1 year ago

autotools is a complete disaster. It’s mind boggling to think that everything we build is usually on top of this arcane system

gorgoiler• 1 year ago

On the topic* of having 24 cores and wanting to put them to work: when I were a lad the promise was that pure functional programming would trivially allow for parallel execution of functions. Has this future ever materialized in a modern language / runtime?

  x = 2 + 2
  y = 2 * 2
  z = f(x, y)
  print(z)

…where x and y evaluate in parallel without me having to do anything. Clojure, perhaps?

*And superficially off the topic of this thread, but possibly not.

speed_spread• 1 year ago

I believe it's not the language preventing it but the nature of parallel computing. The overhead of splitting up things and then reuniting them again is high enough to make trivial cases not worth it. OTOH we now have pretty good compiler autovectorization which does a lot of parallel magic if you set things right. But it's not handled at the language level either.

deepsun• 1 year ago

Sure, Tensorflow and Pytorch, here ya go :)

chubot2• 1 year ago

That looks more like a SIMD problem than a multi-core problem

You want bigger units of work for multiple cores, otherwise the coordination overhead will outweigh the work the application is doing

I think the Erlang runtime is probably the best use of functional programming and multiple cores. Since Erlang processes are shared nothing, I think they will scale to 64 or 128 cores just fine

Whereas the GC will be a bottleneck in most languages with shared memory ... you will stop scaling before using all your cores

But I don't think Erlang is as fine-grained as your example ...

Some related threads:

https://news.ycombinator.com/item?id=40130079

https://news.ycombinator.com/item?id=31176264

AFAIU Erlang is not that fast an interpreter; I thought the Pony Language was doing something similar (shared nothing?) with compiled code, but I haven't heard about it in awhile

juped2• 1 year ago

There's some sharing used to avoid heavy copies, though GC runs at the process level. The implementation is tilted towards copying between isolated heaps over sharing, but it's also had performance work done over the years. (In fact, if I really want to cause a global GC pause bottleneck in Erlang, I can abuse persistent_term to do this.)

fmajid4• 1 year ago

Yes, Erlang's zero-sharing model is what I think Rust should have gone for in its concurrency model. Sadly too few people have even heard of it.

gdwatson3• 1 year ago

Superscalar processors (which include all mainstream ones these days) do this within a single core, provided there are no data dependencies between the assignment statements. They have multiple arithmetic logic units, and they can start a second operation while the first is executing.

But yeah, I agree that we were promised a lot more automatic multithreading than we got. History has proven that we should be wary of any promises that depend on a Sufficiently Smart Compiler.

lazide9• 1 year ago

Eh, in this case not splitting them up to compute them in parallel is the smartest thing to do. Locking overhead alone is going to dwarf every other cost involved in that computation.

que-encrypt• 1 year ago

Jax: https://docs.jax.dev/en/latest/_autosummary/jax.jit.html

colechristensen• 1 year ago

there have been fortran compilers which have done auto parallelization for decades, i think nvidia released a compiler that will take your code and do its best to run it on a gpu

this works best for scientific computing things that run through very big loops where there is very little interaction between iterations

inejge• 1 year ago

…where x and y evaluate in parallel without me having to do anything.

I understand that yours is a very simple example, but a) such things are already parallelized even on a single thread thanks to all the internal CPU parallelism, b) one should always be mindful of Amdahl's law, c) truly parallel solutions to various problems tend to be structurally different from serial ones in unpredictable ways, so there's no single transformation, not even a single family of transformations.

snackbroken• 1 year ago

Bend[1] and Vine[1] are two experimental programming languages that take similar approaches to automatically parallelizing programs; interaction nets[3]. IIUC, they basically turn the whole program into one big dependency graph, then the runtime figures out what can run in parallel and distributes the work to however many threads you can throw at it. It's also my understanding that they are currently both quite slow, which makes sense as the focus has been on making `write embarrassingly parallelizable program -> get highly parallelized execution` work at all until recently. Time will tell if they can manage enough optimizations that the approach enables you to get reasonably performing parallel functional programs 'for free'.

[1] https://github.com/HigherOrderCO/Bend [2] https://github.com/VineLang/vine [3] https://en.wikipedia.org/wiki/Interaction_nets

fweimer• 1 year ago

There have been experimental parallel graph reduction machines. Excel has a parallel evaluator these days.

Oddly enough, functional programming seems to be a poor fit for this because the fanout tends to be fairly low: individual operations have few inputs, and single-linked lists and trees are more common than arrays.

malkia4• 1 year ago

"./configure" has always been the wrong thing for a very long long time. Also slow...

codys4• 1 year ago

I did something like the system described in this article a few years back. [1]

Instead of splitting the "configure" and "make" steps though, I chose to instead fold much of the "configure" step into the "make".

To clarify, this article describes a system where `./configure` runs a bunch of compilations in parallel, then `make` does stuff depending on those compilations.

If one is willing to restrict what the configure can detect/do to writing to header files (rather than affecting variables examined/used in a Makefile), then instead one can have `./configure` generate a `Makefile` (or in my case, a ninja file), and then have the "run the compiler to see what defines to set" and "run compiler to build the executable" can be run in a single `make` or `ninja` invocation.

The simple way here results in _almost_ the same behavior: all the "configure"-like stuff running and then all the "build" stuff running. But if one is a bit more careful/clever and doesn't depend on the entire "config.h" for every "<real source>.c" compilation, then one can start to interleave the work perceived as "configuration" with that seen as "build". (I did not get that fancy)

[1] https://github.com/codyps/cninja/tree/master/config_h

tavianator6• 1 year ago

Nice! I used to do something similar, don't remember exactly why I had to switch but the two step process did become necessary at some point.

Just from a quick peek at that repo, nowadays you can write

#if __has_attribute(cold)

and avoid the configure test entirely. Probably wasn't a thing 10 years ago though :)

codys4• 1 year ago

yep. C's really come a long way with the special operators for checking if attributes exist, if builtins exist, if headers exist, etc.

Covers a very large part of what is needed, making fewer and fewer things need to end up in configure scripts. I think most of what's left is checking for items (types, functions) existence and their shape, as you were doing :). I can dream about getting a nice special operator to check for fields/functions, would let us remove even more from configure time, but I suspect we won't because that requires type resolution and none of the existing special operators do that.

o11c4• 1 year ago

The problem is that the various `__has_foo` aren't actually reliable in practice - they don't tell you if the attribute, builtin, include, etc. actually works the way it's supposed to without bugs, or if it includes a particular feature (accepts a new optional argument, or allows new values for an existing argument, etc.).

aaronmdjones• 1 year ago

    #if __has_attribute(cold)

You should use double underscores on attribute names to avoid conflicts with macros (user-defined macros beginning with double underscores are forbidden, as identifiers beginning with double underscores are reserved).

    #if __has_attribute(__cold__)
    #  warning "This works too"
    #endif

    static void __attribute__((__cold__))
    foo(void)
    {
        // This works too
    }

throwaway81523• 1 year ago

GNU Parallel seems like another convenient approach.

fmajid4• 1 year ago

It has no concept of dependencies between tasks, or doing a topological sort prior to running the task queue. GNU Make's parallel mode (-j) has that.

andreyv• 1 year ago

Autoconf can use cache files [1], which can greatly speed up repeated configures. With cache, a test is run at most once.

[1] https://www.gnu.org/savannah-checkouts/gnu/autoconf/manual/a...

fanf2• 1 year ago

Sadly the cache files don’t record enough about the environment to be usable if you change configure options. They are generally unreliable.

iforgotpassword• 1 year ago

The other issue is that people seem to just copy configure/autotools scripts over from older or other projects because either they are lazy or don't understand them enough to do it themselves. The result is that even with relatively modern code bases that only target something like x86, arm and maybe mips and only gcc/clang, you still get checks for the size of an int, or which header is needed for printf, or whether long long exists.... And then the entire code base never checks the generated macros in a single place, uses int64_t and never checks for stint.h in the configure script...

rbanffy3• 1 year ago

It’s always wise to be specific about the sizes you want for your variables. You don’t want your ancient 64-bit code to act differently on your grandkids 128-bit laptops. Unless, of course, you want to let the compiler decide whether to leverage higher precision types that become available after you retire.

IshKebab4• 1 year ago

I don't think it's fair to say "because they are lazy or don't understand". Who would want to understand that mess? It isn't a virtue.

A fairer criticism would be that they have no sense to use a more sane build system. CMake is a mess but even that is faaaaar saner than autotools, and probably more popular at this point.

xiaoyu2006• 1 year ago

Autotools use M4 to meta-program a bash script that meta-programs a bunch of C(++) sources and generates C(++) sources that utilizes meta-programming for different configurations; after which the meta-programmed script, again, meta-programs monolithic makefiles.

This is peak engineering.

knorker8• 1 year ago

autotools is the worst, except for all the others.

I'd like to think of myself as reasonable, so I'll just say that reasonable people may disagree with your assertion that cmake is in any way at all better than autotools.

smartmic• 1 year ago

I took the trouble (and even spent the money) to get to grips with autotools in a structured and detailed way by buying a book [1] about it and reading as much as possible. Yes, it's not trivial, but autotools are not witchcraft either, but as written elsewhere, a masterpiece of engineering. I have dealt with it without prejudice and since then I have been more of a fan of autotools than a hater. Anyway, I highly recommend the book and yes, after reading it, I think autotools is better than its reputation.

[1] https://nostarch.com/autotools2e

NekkoDroid• 1 year ago

CMake is a mess but even that is faaaaar saner than autotools, and probably more popular at this point.

Having done a deep dive into CMake I actually kinda like it (really modern cmake is actually very nice, except the DSL but that probably isn't changing any time soon), but that is also the problem: I had to do a deep dive into learning it.

kazinator7• 1 year ago

Someone who doesn't want to understand a huge mess should probably not be bringing it into their project.

In software you sometimes have to have the courage to reject doing what others do, especially if they're only doing it because of others.

epcoa• 1 year ago

either they are lazy or don't understand them enough to do it themselves.

Meh, I used to keep printed copies of autotools manuals. I sympathize with all of these people and acknowledge they are likely the sane ones.

Levitating2• 1 year ago

I've had projects where I spent more time configuring autoconf than actually writing code.

That's what you get for wanting to use a glib function.

rollcat4• 1 year ago

This.

Simple projects: just use plain C. This is dwm, the window manager that spawned a thousand forks. No ./configure in sight: <https://git.suckless.org/dwm/files.html>

If you run into platform-specific stuff, just write a ./configure in simple and plain shell: <https://git.suckless.org/utmp/file/configure.html>. Even if you keep adding more stuff, it shouldn't take more than 100ms.

If you're doing something really complex (like say, writing a compiler), take the approach from Plan 9 / Go. Make a conditionally included header file that takes care of platform differences for you. Check the $GOARCH/u.h files here:

<https://go.googlesource.com/go/+/refs/heads/release-branch.g...>

(There are also some simple OS-specific checks: <https://go.googlesource.com/go/+/refs/heads/release-branch.g...>)

This is the reference Go compiler; it can target any platform, from any host (modulo CGO); later versions are also self-hosting and reproducible.

knorker8• 1 year ago

Interesting that you would bring up Go. Go is probably the most head-desk language of all for writing portable code. Go will fight you the whole way.

Even plain C is easier.

You can have a whole file be for OpenBSD, to work around that some standard library parts have different types on different platforms.

So now you need one file for all platforms and architectures where Timeval.Usec is int32, and another file for where it is int64. And you need to enumerate in your code all GOOS/GOARCH combinations that Go supports or will ever support.

You need a file for Linux 32 bit ARM (int32/int32 bit), one for Linux 64 bit ARM (int64,int64), one for OpenBSD 32 bit ARM (int64/int32), etc…. Maybe you can group them, but this is just one difference, so in the end you'll have to do one file per combination of OS and Arch. And all you wanted was pluggable "what's a Timeval?". Something that all build systems solved a long time ago.

And then maybe the next release of OpenBSD they've changed it, so now you cannot use Go's way to write portable code at all.

So between autotools, cmake, and the Go method, the Go method is by far the worst option for writing portable code.

Levitating2• 1 year ago

I want to agree with you, but as someone who regularly packages software for multiple distributions I really would prefer people using autoconf.

Software with custom configure scripts are especially dreaded amongst packagers.

technion• 1 year ago

There's a trending post right now for printf implemented in bare metal and my first thought was "finally, all that autoconf code that checks for printf can handle the use can where it doesn't exist".

amelius• 1 year ago

What I'd like to see is a configure with guarantees that if the configure succeeds, then the build will succeed too.

Chocimier• 1 year ago

It is possible in theory to speed up existing configure scripts by switching interpreter from /bin/sh to something that scans file, splits it to independent blocks and runs them in parallel.

Is there any such previous work?

tavianator6• 1 year ago

I was looking for a relevant paper and found this one, which isn't what I was looking for but is related: https://sigops.org/s/conferences/hotos/2023/papers/liargkova...

rbanffy3• 1 year ago

I get the impression configure not only runs sequentially, but incrementally, where previous results can change the results of tests run later. Were it just sequential, running multiple tests as separate processes would be relatively simple.

Also, you shouldn’t need to run ./configure every time you run make.

fmajid4• 1 year ago

No, but if you are doing something like rebuilding a distro's worth of packages from source from scratch, the configure step starts to dominate. I build around 550, and it takes around 6 hours on a single node.

Most checks are common, so what can help is having a shared cache for all configure scripts so if you have 400 packages to rebuild, it doesn't check 400 times if you should use flock or fcntl. This approach is described here: https://jmmv.dev/2022/06/autoconf-caching.html

It doesn't help that autoconf is basically abandonware, with one forlorn maintainer trying to resuscitate it, but creating major regressions with new releases: https://lwn.net/Articles/834682/

rbanffy3• 1 year ago

It doesn't help that autoconf is basically abandonware

A far too common tragedy of our age.

tmtvl• 1 year ago

As a user I highly appreciate ./configure for the --help flag, which usually tells me how to build a program with or without particular functionalities which may or may not be applicable to my use-case.

saagarjha• 1 year ago

I actually think this is possible to improve if you have the autoconf files. You could parse it to find all the checks you know can run in parallel and run those.

mrrogot69• 1 year ago

Good idea!

tekknolagi2• 1 year ago

This doesn't mention another use of configure which is manually enabling or disabling features via --with-X -- I might send in a PR for that

tavianator6• 1 year ago

My actual "production" implementation of this concept does support that: https://github.com/tavianator/bfs/blob/main/configure

But I wanted the blog post sized version to be simpler for exposition.

tekknolagi2• 1 year ago

Very nice

gitroom• 1 year ago

Man, I've spent way too many hours wrestling with build systems like autotools and cmake and they both make me want to just toss my laptop sometimes - feels like it's way harder than it needs to be each time. You ever think we'll actually get to a point where building stuff just works, no endless config scripts or chasing weird cross-platform bugs?

pdimitar2• 1 year ago

I asked myself that probably no less than 200 times.

Thinking in terms of technological problems, that should be a 100% solved problem at this point! Build a DAG of all tasks and just solve it and invoke stuff, right? Well, not exactly. A lot of the build systems don't allow you to specify if something is safe to execute in parallel. And that's important because sometimes even though it seems three separate tasks are completely independent and can be executed in parallel they'd still share f.ex. a filesystem-level cache and would compete for it and likely corrupt it, so... not so fast. :(

But I feel the entire tech sector is collectively dragging their feet on this. We should be able to devise a good build system that allows us to encode more constraints and requirements than the current ones, and then simply build a single solver for its DAG and be done with it. How frakkin difficult can that be?

Of course the problem is actually social, not technical. Meaning that most programmers wouldn't ever migrate if the decision was left to them. I still would not care about them though; if I had the free time and energy then I would absolutely work on it. It's something that might swallow a lot of energy but if solved properly (meaning it has to be reasonably extensive without falling into the trap that no two projects would even use the same implementation -- let us NOT do that!) then it will be solved only once and never again.

We can dream.

But again, it very much does seem like a very solvable problem to me.

db48x• 1 year ago

Wrong solution. Just run ‘configure -C’ so that it caches the results, or reuses the cache if it already exists.

And of course most of the time you don't need to rerun configure at all, just make.

kazinator7• 1 year ago

I've implemented a configuration caching mechanism for myself (in one important project) which stores configuration artifacts in a cache directory, associated by the commit hash. It works as a git hook:

  $ git bisect good
  Bisecting: 7 revisions left to test after this (roughly 3 steps)
  restored cached configuration for 2f8679c346a88c07b81ea8e9854c71dae2ade167
  [2f8679c346a88c07b81ea8e9854c71dae2ade167] expander: noexpand mechanism.

The "restored cached configuration" message is from the git hook. What it's not saying is that it also saved the config for the commit it is navigating away from.

I primed the cache by executing a "git checkout" for each of a range of commits.

Going forward, it will populate itself.

This is the only issue I would conceivably care about with regard to configure performance. When not navigating in git history, I do not often run configure.

Downstream distros do not care; they keep their machines and cores busy by building multiple packages in parallel.

It's not ideal because the cache from one host is not applicable to another; you can't port it. I could write an intelligent script to populate it, which basically identifies commits (within some specified range) that have touched the config system, and then assumes that for all in-between commits, it's the same.

The hook could do this. When it notices that the current sha doesn't have a cached configuration, it could search backwards through history for the most recent commit which does have it. If the configure script (or something influencing it) has not been touched since that commit, then its cached material can be populated for all in-between commits right through the current one. That would take care of large swaths of commits in a typical bisect session.

kazinator7• 1 year ago

The right way to do this is not to rely on the git hashes, but to hash the inputs into the configuration system (those that are in version control, not the implicit environmental inputs from the platform).

For instance, if the only input to the configuration system is the body of the configure script, then we hash that. That is then our key to the generated materials.

Parallel ./configure

Related Stories