I fully understand that this subject is for some people obsolete and is listed in the FAQ:
Error about "jobserver unavailable"
This indicates a problem with your Makefile or shell. See the explanation of this error from GNU make.
++the FAQ links to this post reply:
The message means that the child "make" program received information implying that it was the child of another "make" program, and was to run in parallel mode using the jobserver feature, but that when it tried to connect to the jobserver it couldn't do so.
There are (at least?) three reasons why this might be so:
1) The parent make didn't realize that the child process it was
invoking was actually a "make" program. In this case, it won't
allow the child to connect to the jobserver. This is typically
because the command to invoke the child uses "make" or similar
rather than the correct $(MAKE). See the docs on the "+" token to
understand the algorithm GNU make uses to determine if the child is
a sub-make or not. Adding the "+" to the invocation in the parent will fix this; hence
the message you got. 2) You have changed your SHELL to use csh or tcsh. These shells are
fundamentally broken and cannot coexist with the jobserver. You
will need to use a different SHELL, preferable a Bourne-compatible
one (sh, ksh, bash, zsh). 3) There is something about the LSF implementation of GNU make that
breaks this: note that for the jobserver to work correctly each
sub-make _MUST_ be a direct fork/exec of its parent. Running them
on remote systems, invoking them from servers, etc. will not work.++ So, as i didn't understand the meaning of this explanation, i went to the GNU make manual, appendix B error codes:
`warning: jobserver unavailable: using -j1. Add `+' to parent make rule.'
In order for make processes to communicate, the parent will pass information to the child. Since this could result in problems if the child process isn't actually a make, the parent will only do this if it thinks the child is a make. The parent uses the normal algorithms to determine this (see section 5.6.1 How the MAKE Variable Works). If the makefile is constructed such that the parent doesn't know the child is a make process, then the child will receive only part of the information necessary. In this case, the child will generate this warning message and proceed with its build in a sequential manner.
++ And still, no hint to my poor technical knowledge. So i followed the " section 5.6.1 How the MAKE Variable Works":
[...] The special feature makes this do what you want: whenever a command line of a rule contains the variable MAKE, the flags `-t', `-n' and `-q' do not apply to that line. Command lines containing MAKE are executed normally despite the presence of a flag that causes most commands not to be run. The usual MAKEFLAGS mechanism passes the The special feature makes this do what you want: whenever a command line of a rule contains the variable MAKE, the flags `-t', `-n' and `-q' do not apply to that line. Command lines containing MAKE are executed normally despite the presence of a flag that causes most commands not to be run. The usual MAKEFLAGS mechanism passes the flags to the sub-make (see section 5.6.3 Communicating Options to a Sub-make), so your request to touch the files, or print the commands, is propagated to the subsystem.
++ This seems to be closer from what i seek, that is, passing the -j option to the make child, so I had a look to the "section 5.6.3 Communicating Options to a Sub-make":
The `-j' option is a special case (see section 5.3 Parallel Execution). If you set it to some numeric value `N' and your operating system supports it (most any UNIX system will; others typically won't), the parent make and all the sub-makes will communicate to ensure that there are only `N' jobs running at the same time between them all. Note that any job that is marked recursive (see section 9.3 Instead of Executing the Commands) doesn't count against the total jobs (otherwise we could get `N' sub-makes running and have no slots left over for any real work!)
If your operating system doesn't support the above communication, then `-j 1' is always put into MAKEFLAGS instead of the value you specified. This is because if the `-j' option were passed down to sub-makes, you would get many more jobs running in parallel than you asked for. If you give `-j' with no numeric argument, meaning to run as many jobs as possible in parallel, this is passed down, since multiple infinities are no more than one.
++ Then to the "section 5.3 Parallel Execution", which, should tell me what i want to know:
5.3 Parallel Execution
GNU make knows how to execute several commands at once. Normally, make will execute only one command at a time, waiting for it to finish before executing the next. However, the `-j' or `--jobs' option tells make to execute many commands simultaneously.
On MS-DOS, the `-j' option has no effect, since that system doesn't support multi-processing.
If the `-j' option is followed by an integer, this is the number of commands to execute at once; this is called the number of job slots. If there is nothing looking like an integer after the `-j' option, there is no limit on the number of job slots. The default number of job slots is one, which means serial execution (one thing at a time).
One unpleasant consequence of running several commands simultaneously is that output generated by the commands appears whenever each command sends it, so messages from different commands may be interspersed.
Another problem is that two processes cannot both take input from the same device; so to make sure that only one command tries to take input from the terminal at once, make will invalidate the standard input streams of all but one running command. This means that attempting to read from standard input will usually be a fatal error (a `Broken pipe' signal) for most child processes if there are several.
It is unpredictable which command will have a valid standard input stream (which will come from the terminal, or wherever you redirect the standard input of make). The first command run will always get it first, and the first command started after that one finishes will get it next, and so on.
We will change how this aspect of make works if we find a better alternative. In the mean time, you should not rely on any command using standard input at all if you are using the parallel execution feature; but if you are not using this feature, then standard input works normally in all commands.
Finally, handling recursive make invocations raises issues. For more information on this, see section 5.6.3 Communicating Options to a Sub-make.
++ Now, My last alternative is to go back to the "section 5.6.3 Communicating Options to a Sub-make." Looks like i finally won't find any simple answer to my problem, and even go to a brain deadlock.
So is there any possibility to have a simple and explicit example of what make expects in order to run a kernel compilation using distcc ? The example string listed in the "man distcc" led (lead?) me to this:
make -j4 CC=distcc bzImage:
make[1]: warning:jobserver unavailble: using -j1. Add `+' to parent make rule.
How do I "Add `+' to parent make rule." in the command line ?
What variable / rule of the Makefile should I change to "Add `+' to parent make rule." ?
I once again apologize for such an indigest post, but this is how The Friendly Manual is. This post certainly written in poor english for it is not my native language, and i apologize for this too, but all over the web this place seems to be the only one where people should have the answer.
Thanks in advance and best regards,
G.Girard.
P.S: I'm using distcc 2.12.1 on a debian sarge with 2.4.24 kernel.
gcc version is 2.95.4-17, make version is 3.80-4. (according to debian packages).
__ distcc mailing list http://distcc.samba.org/
To unsubscribe or change options: http://lists.samba.org/mailman/listinfo/distcc
