Default -j and -p values are too high on systems with many cores

From the documentation:

By default catkin build will build up to N packages in parallel and pass -jN -lN to make where N is the number of cores in your computer.

That means that catkin build will spawn up to 64 parallel gcc instances on an 8-core machine, which is enough to fill 16GB of RAM and cause the OOM killer to step in.

Is there a chance to enforce a global limit on the number of parallel make jobs? It seems GNU make has an interface for an external job server, maybe we could use that.

Otherwise, please consider lowering the default values for -p and -j. On a 4-core machine 16 processes might be okay, but 64 processes on an 8-core machine is too much.

[xqms]

I researched a bit and I believe I have found a solution which uses GNU make’s jobserver.

A bit of background to understand the following: GNU make creates a UNIX pipe for job management. To initialize the pipe, N tokens are written into it. All processes share the pipe, and when they want to execute something, they read a token from the pipe. After execution, they write it back into the pipe. In this way, it’s guaranteed that there are no more than N jobs running at a time.

Of course, the pipe has to be shared with the make subprocesses. To do this, make passes a --jobserver-fds=X,Y argument to its subprocesses. X and Y are the fd numbers of the pipe ends, which are not closed before spawning the subprocess and thus still available in the child.

To exploit this, while keeping catkin build in control of the actual make invocation in the packages (so we don’t loose the nice logging and progress percentage features), we could introduce an intermediate make before starting the individual package builds. This is what the process tree could look like:

catkin build
  ^- make -f catkin_makefile -jN
       ^- catkin build-helper --jobserver-fds 3,4
            ^- make -C build/my_package --jobserver-fds 3,4
            ^- make -C build/my_other_package --jobserver-fds 3,4

with catkin_makefile:

all:
    catkin build-helper $(MAKEFLAGS)

The root catkin build process just execs the root make process here. Everything else is shifted into the build-helper process. I think that is actually doable and portable. No black magic involved 😉

I’ll try to draw up a PR soon.

[jbohren]

This can be closed now that #155 has been merged.