( Parallel

Info Catalog ( Execution ( Commands ( Errors
 5.4 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  Communicating Options to a
 Sub-`make' Options/Recursion.
    If a command fails (is killed by a signal or exits with a nonzero
 status), and errors are not ignored for that command ( Errors in
 Commands Errors.), the remaining command lines to remake the same
 target will not be run.  If a command fails and the `-k' or
 `--keep-going' option was not given ( Summary of Options Options
 Summary.), `make' aborts execution.  If make terminates for any reason
 (including a signal) with child processes running, it waits for them to
 finish before actually exiting.
    When the system is heavily loaded, you will probably want to run
 fewer jobs than when it is lightly loaded.  You can use the `-l' option
 to tell `make' to limit the number of jobs to run at once, based on the
 load average.  The `-l' or `--max-load' option is followed by a
 floating-point number.  For example,
      -l 2.5
 will not let `make' start more than one job if the load average is
 above 2.5.  The `-l' option with no following number removes the load
 limit, if one was given with a previous `-l' option.
    More precisely, when `make' goes to start up a job, and it already
 has at least one job running, it checks the current load average; if it
 is not lower than the limit given with `-l', `make' waits until the load
 average goes below that limit, or until all the other jobs finish.
    By default, there is no load limit.
Info Catalog ( Execution ( Commands ( Errors
automatically generated byinfo2html