path: root/man/distcc.1

.TH distcc 1 "9 June 2008"
.SH "NAME"
distcc \- distributed C/C++/ObjC compiler with distcc-pump extensions
.SH "SYNOPSIS"
.B distcc 
.I <compiler> [COMPILER OPTIONS] 
.PP
.B distcc
.I [COMPILER OPTIONS]
.PP
.B <compiler>
.I [COMPILER OPTIONS]
.PP
.B distcc
.I [DISTCC OPTIONS]
.SH "DESCRIPTION"
.P 
distcc distributes compilation of C code across several machines on a
network.  distcc should always generate the same results as a local
compile, it is simple to install and use, and it is often much faster than a
local compile.
.PP
This version incorporates plain distcc as well as an enhancement called
pump mode or distcc-pump.
.PP
For each job, distcc in plain mode sends the complete preprocessed source code
and compiler arguments across the network from the client to a compilation
server.  In pump mode, distcc sends the source code and recursively included
header files (excluding those from the default system header directories),
so that both preprocessing and compilation can take place on the
compilation servers. This speeds up the delivery of compilations by up to an
order of magnitude over plain distcc.
.PP
Compilation is driven by a client machine, which is typically the developer's
workstation or laptop.  The distcc client runs on this machine, as does make,
the preprocessor (if distcc's pump mode is not used), the linker, and other
stages of the build process.  Any number of volunteer machines act as
compilation servers and help the client to build the program, by running the
.B distccd(1) 
daemon, C compiler and assembler
as required.
.PP
distcc can run across either TCP sockets (on port 3632 by default), or
through a tunnel command such as ssh(1).  For TCP connections the
volunteers must run the distccd(1) daemon either directly or from inetd.
For SSH connections distccd must be installed but should
.B not
be listening for connections.  
.PP
TCP connections should only be used on secure networks because there
is no user authentication or protection of source or object code.  SSH
connections are typically 25% slower because of processor overhead for
encryption, although this can vary greatly depending on CPUs, network
and the program being built.
.PP
distcc is intended to be used with GNU Make's
.B -j 
option, which runs several compiler processes concurrently.  distcc
spreads the jobs across both local and remote CPUs.  Because distcc is
able to distribute most of the work across the network, a higher
concurrency level can be used than for local builds.  As a rule of thumb, 
the
.B -j 
value should be set to about twice the total number of available server
CPUs but subject to client limitations.  This setting allows for maximal
interleaving of tasks being blocked waiting for disk or network IO. Note that
distcc can also work with other build control tools, such as SCons, where similar
concurrency settings must be adjusted.
.PP
The
.B -j
setting, especially for large values of
.B -j,
must take into account the CPU load
on the client.  Additional measures may be needed to curtail the client load.
For example, concurrent linking should be severely curtailed using auxiliary
locks.  The effect of other build activity, such as Java compilation when
building mixed code, should be considered.  The
.B --localslots_cpp
parameter is by default set to 16.
This limits the number of concurrent processes that do preprocessing in 
plain distcc (non-pump) mode.
Therefore, larger 
.B -j 
values than 16 may be used without overloading a single-CPU
client due to preprocessing.  Such large values may speed up parts of the build
that do not involve C compilations, but they may not be useful to distcc
efficiency in plain mode.
.PP
In contrast, using pump mode and say 40 servers, a setting of
.B -j80
or larger may be appropriate even for single-CPU clients.
.PP
It is strongly recommended that you install the same compiler version
on all machines participating in a build.  Incompatible compilers may
cause mysterious compile or link failures.
.SH "QUICKSTART"
.TP
1
For each machine, download distcc, unpack, and install.
.TP
2
On each of the servers, run 
.B distccd --daemon
with 
.B --allow
options to restrict access.
.TP 
3
Put the names of the servers in your environment:
.RS
$ export DISTCC_HOSTS='localhost red green blue'
.RE
.TP
4
Build!
.RS
$ make -j8 CC=distcc
.RE
.SH "QUICKSTART FOR DISTCC-PUMP MODE"
Proceed as above, but in Step 3, specify that the remote hosts are to carry the
burden of preprocessing and that the files sent over the network should be
compressed:

.RS
$ export DISTCC_HOSTS='--randomize localhost red,cpp,lzo green,cpp,lzo blue,cpp,lzo'
.RE

The 
.B --randomize
option enforces a uniform usage of compile servers.  While you will
get some benefit from distcc's pump mode with only a few servers, you
get increasing benefit with more server CPUs (up to the hundreds!).
Wrap your build inside the pump command, here assuming 10 servers:

.RS
$ pump make -j20 CC=distcc
.RE

.SH "QUICKSTART FOR DISTCC-GSSAPI MODE"
Proceed as per the
.B QUICKSTART
but in Step 3, specify that the remote hosts are to mutually
authenticate with the client:

.RS
$ export DISTCC_HOSTS='--randomize localhost red,auth green,auth blue,auth'
.RE

If distccd runs under a specific principal name then execute the
following command prior to step 4:

.RS
export DISTCC_PRINICIPAL=<name>
.RE

.SH "HOW PLAIN (NON-PUMP) DISTCC WORKS"
distcc only ever runs the compiler and assembler remotely.  With plain distcc,
the preprocessor must always run locally because it needs to access various
header files on the local machine which may not be present, or may not be the
same, on the volunteer.  The linker similarly needs to examine libraries and
object files, and so must run locally.
.PP
The compiler and assembler take only a single input file (the
preprocessed source) and produce a single output (the object file).
distcc ships these two files across the network and can therefore run
the compiler/assembler remotely.
.PP
Fortunately, for most programs running the preprocessor is
relatively cheap, and the linker is called relatively
infrequent, so most of the work can be distributed.
.PP
distcc examines its command line to determine which of these
phases are being invoked, and whether the job can be
distributed.

.SH "HOW DISTCC-PUMP MODE WORKS"
In pump mode, distcc runs the preprocessor remotely too.  To do so, the
preprocessor must have access to all the files that it would have accessed if
had been running locally.  In pump mode, therefore, distcc gathers all of the
recursively included headers, except the ones that are default system headers,
and sends them along with the source file to the compilation server.
.PP
In distcc-pump mode, the server unpacks the set of all source files in a
temporary directory, which contains a directory tree that mirrors the part of
the file system that is relevant to preprocessing, including symbolic links.
.PP
The compiler is then run from the path in the temporary directory that
corresponds to the current working directory on the client.  To find and
transmit the many hundreds of files that are often part of a single compilation,
pump mode uses an incremental include analysis algorithm.  The include server is
a Python program that implements this algorithm.  The pump command starts the
include server so that throughout the build it can answer include queries by
distcc commands.
.PP
The include server uses static analysis of the macro language to deal
with conditional compilation and computed includes.  It uses the
property that when a given header file has already been analyzed for
includes, it is not necessary to do so again if all the include
options (-I's) are unchanged (along with other conditions).
.PP
For large builds, header files are included, on average, hundreds of
times each. With distcc-pump mode each such file is analyzed only a
few times, perhaps just once, instead of being preprocessed hundreds
of times.  Also, each source or header file is now compressed only
once, because the include server memoizes the compressed files.  As a
result, the time used for preparing compilations may drop by up to an
order of magnitude over the preprocessing of plain distcc.
.PP
Because distcc in pump mode is able to push out files up to about ten
times faster, build speed may increase 3X or more for large builds
compared to plain distcc mode.

.SH "RESTRICTIONS FOR PUMP MODE"

Using pump mode requires both client and servers to use release 3.0 or
later of distcc and distccd (respectively).  
.PP
The incremental include analysis of distc-pump mode rests on
the fundamental assumption that source and header files do not change
during the build process.  A few complex build systems, such as that
for Linux kernel 2.6, do not quite satisfy this requirement.  To
overcome such issues, and other corner cases such as absolute
filepaths in includes, see the
.BR include_server(1)
man page.
.PP
Another important assumption is that the include configuration of all machines
must be identical.  Thus the headers under the default system path must be the
same on all servers and all clients.  If a standard GNU compiler installation
is used, then this requirement applies to all libraries whose header files are
installed under /usr/include or /usr/local/include/.  Note that installing
software packages often lead to additional headers files being placed in
subdirectories of either.
.PP
If this assumption does not hold, then it is possible to break builds with
distcc-pump mode, or worse, to get wrong results without warning.  Presently
this condition is not verified, and it is on our TODO list to address this
issue.
.PP
An easy way to guarantee that the include configurations are identical is to use
a cross-compiler that defines a default system search path restricted to
directories of the compiler installation.
.PP
See the \fBinclude_server\fR(1) manual for more information on symptoms and
causes of violations of distcc-pump mode assumptions.

.SH "HOW DISTCC-GSSAPI MODE WORKS"

In this mode distcc will use the GSS-API framework to access the currently
configured security mechanism and perform mutual authentication with the
daemon.

.SH "OPTION SUMMARY"
Most options passed to distcc are interpreted as compiler options.
The following options are understood by distcc itself.
If any of these options are specified, distcc will not invoke the
compiler.

.TP
.B --help
Displays summary instructions.
.PP
.TP
.B --version
Displays the distcc client version.
.PP
.TP
.B --show-hosts
Displays the host list that distcc would use.
See the Host Specifications section.
.PP
.TP
.B --scan-includes
Displays the list of files that distcc would send to the
remote machine, as computed by the include server.  This is a conservative
(over-)approximation of the files that would be read by the C compiler.
This option only works in pump mode.  See the "How Distcc-pump Mode Works"
section for details on how this is computed.
.RS
.P
The list output by \fBdistcc --scan-includes\fR will
contain one entry per line.  Each line contains a category followed by a path.
The category is one of FILE, SYMLINK, DIRECTORY, or SYSTEMDIR:
.IP
.B FILE
indicates a source file or header file that would
be sent to the distcc server host.
.IP
.B SYMLINK
indicates a symbolic link that would be sent to
the distcc server host.
.IP
.B DIRECTORY
indicates a directory that may be needed in order to
compile the source file.  For example, a directory "foo" may be needed
because of an include of the form #include "foo/../bar.h".
Such directories would be created on the distcc server host.
.IP
.B SYSTEMDIR
indicates a system include directory, i.e. a directory
which is on the compiler's default include path, such as "/usr/include";
such directories are assumed to be present on the distcc server host,
and so would not be sent to the distcc server host.
.RE
.TP
.B -j
Displays distcc's concurrency level, as calculated from the host list;
it is the maximum number of outstanding jobs issued by this client
to all servers.
By default this will be four times the number of hosts in the host list,
unless the /LIMIT option was used in the host list.
See the Host Specifications section.
.PP
.TP
.B --show-principal
Displays the name of the distccd security principal extracted from the
environment.
.B This option is only available if distcc was compiled with
.B the --with-auth configure option.

.SH "INSTALLING DISTCC"
There are three different ways to call distcc, to suit different
circumstances:
.RS
.PP
distcc can be installed under the name of the real compiler, to
intercept calls to it and run them remotely.  This "masqueraded"
compiler has the widest compatibility with existing source trees, and
is convenient when you want to use distcc for all compilation.  The
fact that distcc is being used is transparent to the makefiles.
.PP
distcc can be prepended to compiler command lines, such as "distcc cc
-c hello.c" or CC="distcc gcc".  This is convenient when you want to
use distcc for only some compilations or to try it out, but can cause
trouble with some makefiles or versions of libtool that assume $CC
does not contain a space.
.PP
Finally, distcc can be used directly as a compiler.  "cc" is always
used as the name of the real compiler in this "implicit" mode.  This
can be convenient for interactive use when "explicit" mode does not
work but is not really recommended for new use.
.RE
.PP
Remember that you should not use two methods for calling distcc at the
same time.  If you are using a masquerade directory, don't change CC and/or
CXX, just put the directory early on your PATH.  If you're not using
a masquerade directory, you'll need to either change CC and/or CXX, or
modify the makefile(s) to call distcc explicitly.
.SH "MASQUERADING"
The basic idea is to create a "masquerade directory" which contains
links from the name of the real compiler to the distcc binary.  This
directory is inserted early on the PATH, so that calls to the compiler
are intercepted and distcc is run instead.  distcc then removes itself
from the PATH to find the real compiler.
.PP
For example:
.PP
.RS
.nf
# mkdir /usr/lib/distcc/bin
# cd /usr/lib/distcc/bin
# ln -s ../../../bin/distcc gcc
# ln -s ../../../bin/distcc cc
# ln -s ../../../bin/distcc g++
# ln -s ../../../bin/distcc c++
.fi
.RE
.PP
Then, to use distcc, a user just needs to put the directory
/usr/lib/distcc/bin early in the PATH, and have set a host list in
DISTCC_HOSTS or a file.  distcc will handle the rest.  
.PP
Note that this masquerade directory must occur on the PATH earlier
than the directory that contains the actual compilers of the same
names, and that any auxiliary programs that these compilers call (such
as as or ld) must also be found on the PATH in a directory after the
masquerade directory since distcc calls out to the real compiler with
a PATH value that has all directory up to and including the masquerade
directory trimmed off.
.PP
It is possible to get a "recursion error" in masquerade mode, which
means that distcc is somehow finding itself again, not the real
compiler.  This can indicate that you have two masquerade directories
on the PATH, possibly because of having two distcc installations in
different locations.  It can also indicate that you're trying to mix
"masqueraded" and "explicit" operation.
.PP
Recursion errors can be avoided by using shell scripts instead of links.
For example, in /usr/lib/distcc/bin create a file cc which contains:
.PP
.RS
.nf
#!/bin/sh 
distcc /usr/bin/gcc "$@"
.fi
.RE
.PP
In this way, we are not dependent on distcc having to locate the real gcc by
investigating the PATH variable. Instead, the compiler location is explicitly
provided.

.SH "USING DISTCC WITH CCACHE"
ccache is a program that speeds software builds by caching the results
of compilations.  ccache is normally called before distcc, so that
results are retrieved from a normal cache.  Some experimentation may
be required for idiosyncratic makefiles to make everything work together.
.PP
The most reliable method is to set
.IP
.B CCACHE_PREFIX="distcc"
.PP
This tells ccache to run distcc as a wrapper around the real
compiler.  ccache still uses the real compiler to detect compiler
upgrades.
.PP
ccache  can then be run using either a masquerade directory 
.I or 
by
setting
.IP
.B CC="ccache gcc"
.PP
As of version 2.2, ccache does not cache compilation from preprocessed
source and so will never get a cache hit if it is run from distccd or
distcc.  It must be run only on the client side and before distcc to
be any use.

distcc's pump mode is not compatible with ccache.
.SH "HOST SPECIFICATIONS"
A "host list" tells distcc which machines to use for compilation.  In
order, distcc looks in the 
.B $DISTCC_HOSTS
environment variable, the user's 
.B $DISTCC_DIR/hosts
file, and the system-wide host 
file.  If no host list can be found, distcc emits a warning and
compiles locally.
.PP
The host list is a simple whitespace separated list of host
specifications.  The simplest and most common form is a host names,
such as
.PP
.RS
.B localhost red green blue
.RE
.PP
distcc prefers hosts towards the start of the list, so machines should
be listed in descending order of speed.  In particular, when only a
single compilation can be run (such as from a configure script), the
first machine listed is used (but see
.I --randomize
below).
.PP
Placing 
.I localhost
at the right point in the list is important to getting good
performance.  Because overhead for running jobs locally is low,
localhost should normally be first.  However, it is important that the
client have enough cycles free to run the local jobs and the distcc
client.  If the client is slower than the volunteers, or if there are
many volunteers, then the client should be put later in the list or
not at all.  As a general rule, if the aggregate CPU speed of the
client is less than one fifth of the total, then the client should be
left out of the list.
.PP
If you have a large shared build cluster and a single shared hosts file,
the above rules would cause the first few machines in the hosts
file to be tried first even though they are likely to be busier than machines
later in the list.  To avoid this, place the keyword
.I --randomize
into the host list.  This will cause the host list to be randomized,
which should improve performance slightly for large build clusters.
.PP
There are two special host names 
.B --localslots
and
.B --localslots_cpp
which are useful for adjusting load on the local machine.  The 
.B --localslots
host specifies how many jobs that cannot be run remotely that can be run concurrently 
on the local machine, while 
.B --localslots_cpp
controls how many preprocessors will run in parallel on the local machine.  Tuning
these values can improve performance.  Linking on large projects
can take large amounts of memory.  Running parallel linkers, which cannot be 
executed remotely,  may
force the machine to swap, which reduces performance over just running the
jobs in sequence without swapping.   Getting the number of parallel preprocessors just
right allows you to use larger parallel factors with make, since the local machine
now has some machanism for measuring local resource usage.     
.PP
Finally there is the host entry
.PP
Performance depends on the details of the source and makefiles used
for the project, and the machine and network speeds.  Experimenting
with different settings for the host list and
.B -j
factor may improve performance.
.PP
The syntax is
.PP
.nf
  DISTCC_HOSTS = HOSTSPEC ...
  HOSTSPEC = LOCAL_HOST | SSH_HOST | TCP_HOST | OLDSTYLE_TCP_HOST
                        | GLOBAL_OPTION
                        | ZEROCONF
  LOCAL_HOST = localhost[/LIMIT]
             | --localslots=<int>
             | --localslots_cpp=<int>
  SSH_HOST = [USER]@HOSTID[/LIMIT][:COMMAND][OPTIONS]
  TCP_HOST = HOSTID[:PORT][/LIMIT][OPTIONS]
  OLDSTYLE_TCP_HOST = HOSTID[/LIMIT][:PORT][OPTIONS]
  HOSTID = HOSTNAME | IPV4 | IPV6
  OPTIONS = ,OPTION[OPTIONS]
  OPTION = lzo | cpp | auth
  GLOBAL_OPTION = --randomize
  ZEROCONF = +zeroconf
.fi
.PP
Here are some individual examples of the syntax:
.TP
.B localhost
The literal word "localhost" is interpreted specially to cause
compilations to be directly executed, rather than passed to a daemon
on the local machine.  If you do want to connect to a daemon on the
local machine for testing, then give the machine's IP address or real
hostname.  (This will be slower.)
.TP
.B IPV6
A literal IPv6 address enclosed in square brackets, such as
.B [::1]
.TP
.B IPV4
A literal IPv4 address, such as 
.B 10.0.0.1
.TP
.B HOSTNAME
A hostname to be looked up using the resolver.
.TP
.B :PORT
Connect to a specified decimal port number, rather than the default of
3632.
.TP
.B @HOSTID
Connect to the host over SSH, rather than TCP.  Options for the SSH
connection can be set in 
.B ~/.ssh/config
.TP
.B USER@
Connect to the host over SSH as a specified username.
.TP
.B :COMMAND 
Connect over SSH, and use a specified path to find the distccd
server.  This is normally only needed if for some reason you can't
install distccd into a directory on the default PATH for SSH
connections.  Use this if you get errors like "distccd: command not
found" in SSH mode.     
.TP
.B /LIMIT
A decimal limit can be added to any host specification to restrict the
number of jobs that this client will send to the machine.  The limit
defaults to four per host (two for localhost), but may be further
restricted by the server.  You should only need to increase this for
servers with more than two processors.
.TP
.B ,lzo
Enables LZO compression for this TCP or SSH host.
.TP
.B ,cpp
Enables distcc-pump mode for this host.  Note: the build command must be 
wrapped in the pump script in order to start the include server.
.TP
.B ,auth
Enables GSSAPI-based mutual authentication for this host.
.TP
.B --randomize
Randomize the order of the host list before execution.
.TP
.B +zeroconf
.B This option is only available if distcc was compiled with Avahi support enabled at configure time.
When this special entry is present in the hosts list, distcc will use
Avahi Zeroconf DNS Service Discovery (DNS-SD) to locate any available
distccd servers on the local network.  This avoids the need to explicitly
list the host names or IP addresses of the distcc server machines.
The distccd servers must have been
started with the "--zeroconf" option to distccd.
An important caveat is that in the current implementation,
pump mode (",cpp") and compression (",lzo") will never be
used for hosts located via zeroconf.
.PP
Here is an example demonstrating some possibilities:
.PP
.RS
.nf
.B localhost/2 @bigman/16:/opt/bin/distccd oldmachine:4200/1
.B  # cartman is down
.B distant/3,lzo
.fi
.RE
.PP
Comments are allowed in host specifications.  Comments start with a
hash/pound sign (\fB#\fP) and run to the end of the line.
.PP
If a host in the list is not reachable distcc will emit a warning and
ignore that host for about one minute.
.SH "COMPRESSION"
The 
.B lzo 
host option specifies that LZO compression should be used for data
transfer, including preprocessed source, object code and error
messages.  Compression is usually economical on networks slower than
100Mbps, but results may vary depending on the network, processors and
source tree.
.PP 
Enabling compression makes the distcc client and server use more CPU time, but
less network traffic.  The added CPU time is insignificant for pump mode.  The
compression ratio is typically 4:1 for source and 2:1 for object code.
.PP
Using compression requires both client and server to use at least
release 2.9 of distcc.  No server configuration is required: the
server always responds with compressed replies to compressed requests.
.PP
Pump mode requires the servers to have the lzo host option on.
.SH "SEARCH PATHS"
.PP
If the compiler name is an absolute path, it is passed verbatim to the
server and the compiler is run from that directory.  For example:
.PP
.RS
.B distcc /usr/local/bin/gcc-3.1415 -c hello.c
.RE
.PP
If the compiler name is not absolute, or not fully qualified,
distccd's PATH is searched.  When distcc is run from a masquerade
directory, only the base name of the compiler is used.  The client's
PATH is used only to run the preprocessor and has no effect on the
server's path.
.SH "TIMEOUTS"
.PP
Both the distcc client and server impose timeouts on transfer of data
across the network.  This is intended to detect hosts which are down
or unreachable, and to prevent compiles hanging indefinitely if a
server is disconnected while in use.  If a client-side timeout
expires, the job will be re-run locally.
.PP
The timeouts are not configurable at present.
.SH "DIAGNOSTICS"
Error messages or warnings from local or remote compilers are passed
through to diagnostic output on the client.
.PP
distcc can supply extensive debugging information when the verbose
option is used.  This is controlled by the 
.B DISTCC_VERBOSE
environment variable on the client, and the
.B --verbose
option on the server.  For troubleshooting, examine both the client
and server error messages.
.SH "EXIT CODES"
The exit code of distcc is normally that of the compiler:
zero for successful compilation and non-zero otherwise.
.PP
distcc distinguishes between "genuine" errors such as a syntax error
in the source, and "accidental" errors such as a networking problem
connecting to a volunteer.  In the case of accidental errors, distcc
will retry the compilation locally unless the DISTCC_FALLBACK option
has been disabled.
.PP
If the compiler exits with a signal, distcc returns an exit code of
128 plus the signal number.
.PP
distcc internal errors cause an exit code between 100 and 127.  In
particular
.TP
100
General distcc failure.
.TP
101
Bad arguments.
.TP
102
Bind failed.
.TP
103
Connect failed.
.TP
104
Compiler crashed.
.TP 
105
Out of memory.
.TP
106
Bad Host SPEC
.TP
107
I/O Error
.TP
108
Truncated.
.TP
109
Protocol Error.
.TP 
110
The given compiler was not found on the remote host.  Check that $CC is set appropriately and that it's installed in a directory on the search path for distccd.
.TP
111
Recursive call to distcc.
.TP
112
Failed to discard privileges.
.TP
113
Network access denied.
.TP
114
In use by another process.
.TP
115
No such file.
.TP 
116
No hosts defined and fallbacks disabled.
.TP
118
Timeout.
.TP
119
GSS-API - Catchall error code for GSS-API related errors.

.SH "FILES"
If $DISTCC_HOSTS is not set, distcc reads a host list from either 
.B $DISTCC_DIR/hosts
or a system-wide configuration file set at compile time.  The file
locations are shown in the output from
.B distcc --help
.PP
distcc creates a number of temporary and lock files underneath the
temporary directory.
.SH "ENVIRONMENT VARIABLES"
distcc's behaviour is controlled by a number of environment variables.
For most cases nothing need be set if the host list is stored in a
file.
.TP
.B "DISTCC_HOSTS"
Space-separated list of volunteer host specifications.
.TP
.B "DISTCC_VERBOSE"
If set to 1, distcc produces explanatory messages on the standard
error stream or in the log file.  This can be helpful in debugging
problems.  Bug reports should include verbose output.
.TP
.B "DISTCC_LOG"
Log file to receive messages from distcc itself, rather
than stderr.
.TP
.B "DISTCC_FALLBACK"
By default distcc will compile locally if it fails to distribute a job
to the intended machine, or if no host list can be found.  If this
variable is set to 0 then fallbacks are disabled and those
compilations will simply fail.  Note that this does not affect jobs
which must always be local such as linking.
.TP
.B "DISTCC_BACKOFF_PERIOD"
Specifies how long (in seconds) distcc will avoid trying to use a
particular compilation server after that server yields a compile
failure.  By default set to 60 seconds.  To disable the backoff
behavior altogether, set this to 0.
.TP
.B "DISTCC_IO_TIMEOUT"
Specifies how long (in seconds) distcc will wait before deciding a
distributed job has timed out.  If a distributed job is expected to
takes a long time, consider increasing this value so the job does
not time out and fallback to a local compile.  By default set to
300 seconds.
.TP
.B "DISTCC_PAUSE_TIME_MSEC"
Specifies how long (in milliseconds) distcc will pause when all
compilation servers are in use.
By default set to 1000 milliseconds (1 second).
Setting this to a smaller value (e.g. 10 milliconds) may improve
throughput for some configurations, at the expense of increased CPU
load on the distcc client machine.
.TP
.B "DISTCC_SAVE_TEMPS"
If set to 1, temporary files are not deleted after use.  Good for
debugging, or if your disks are too empty.
.TP
.B "DISTCC_TCP_CORK"
If set to 0, disable use of "TCP corks", even if they're present on
this system.  Using corks normally helps pack requests into fewer
packets and aids performance.  This should normally be left enabled.
.TP
.B DISTCC_SSH
Specifies the command used for opening SSH connections.  Defaults to
"ssh" but may be set to a different connection command such as "lsh"
or "tsocks-ssh" that accepts a similar command line.  The command is
not split into words and is not executed through the shell. 
.TP
.B DISTCC_SKIP_LOCAL_RETRY
If set, when a remote compile fails, distcc will no longer try to
recompile that file locally. 
.TP
.B "DISTCC_DIR"
Per-user configuration directory to store lock files and state files.
By default 
.B ~/.distcc/ 
is used.
.TP
.B "TMPDIR"
Directory for temporary files such as preprocessor output.  By default
/tmp/ is used.
.TP
.B "UNCACHED_ERR_FD"
If set and if DISTCC_LOG is not set, distcc errors are written to the
file descriptor identified by this variable.  This variable is
intended mainly for automatic use by ccache, which sets it to avoid
caching transient errors such as network problems.
.TP
.B "DISTCC_ENABLE_DISCREPANCY_EMAIL"
If set, distcc sends an email when a compilation failed remotely, but succeeded
locally.  Built-in heuristics prevent some such discrepancy email from being sent if 
the problem is that a local file changed between the failing remote compilation
and the succeeding local compilation.
.TP
.B "DISTCC_MAX_DISCREPANCY"
The maximum number of remote compilation failures allowed in pump mode before
distcc switches to plain distcc mode. By default set to 1.
.TP
.B "DCC_EMAILLOG_WHOM_TO_BLAME"
The email address for discrepancy email; the default is "distcc-pump-errors".
.TP
.B "DISTCC_PRINCIPAL"
If set, specifies the name of the principal that distccd runs under, and is used
to authenticate the server to the client.
.B This environment variable is only used if distcc was compiled with
.B the --with-auth configure option and the ",auth" per host option is specified.
.SH "CROSS COMPILING"
Cross compilation means building programs to run on a
machine with a different processor, architecture, or
operating system to where they were compiled.  distcc
supports cross compilation, including teams of
mixed-architecture machines, although some changes to the
compilation commands may be required.
.PP
The compilation command passed to distcc must be one that
will execute properly on every volunteer machine to produce
an object file of the appropriate type.  If the machines
have different processors, then simply using 
.B distcc cc
will probably not work, because that will normally invoke the
volunteer's native compiler.
.PP
Machines with the same CPU but different operating systems may not
necessarily generate compatible .o files.
.PP
Several different gcc configurations can be installed
side-by-side on any machine.  If you build gcc from source,
you should use the 
.B --program-suffix configuration
options to cause it to be installed with a name that encodes
the gcc version and the target platform.
.PP
The recommended convention for the gcc name is
.I TARGET-gcc-VERSION
such as
.B i686-linux-gcc-3.2
\&.  GCC 3.3 will install itself
under this name, in addition to 
.I TARGET-gcc
and, if it's native, 
.I gcc-VERSION 
and 
.I gcc
\&. 
.PP
The compiler must be installed under the same name on the
client and on every volunteer machine.
.SH "BUGS"
If you think you have found a  distcc bug, please see the file
.I reporting-bugs.txt
in the documentation directory for information on how to report it.
.PP
Some makefiles have missing or extra dependencies that cause incorrect
or slow parallel builds.  Recursive make is inefficient and can leave
processors unnecessarily idle for long periods.  (See
.I Recursive Make Considered Harmful
by Peter Miller.)  Makefile bugs are the most common cause of trees
failing to build under distcc.  Alternatives to Make such as
.I SCons
can give much faster builds for some projects.
.PP
Using different versions of gcc can cause confusing build problems
because the header files and binary interfaces have changed over time,
and some distributors have included incompatible patches without
changing the version number.  distcc does not protect against using
incompatible versions.  Compiler errors about link problems or
declarations in system header files are usually due to mismatched or
incorrectly installed compilers.
.PP
gcc's 
.B -MD 
option can produce output in the wrong directory if the source and
object files are in different directories and the 
.B -MF 
option is not used.  There is no perfect solution because of
incompatible changes between gcc versions.  Explicitly specifying the
dependency output file with 
.B -MF
will fix the problem.
.PP
TCP mode connections should only be used on trusted networks.
.PP
Including slow machines in the list of volunteer hosts can slow the
build down.
.PP
When distcc or ccache is used on NFS, the filesystem must be exported
with the
.B no_subtree_check 
option to allow reliable renames between directories.
.PP
The compiler can be invoked with a command line
.B gcc hello.c
to both compile and link.  distcc doesn't split this into separate
parts, but rather runs the whole thing locally.
.PP
distcc-pump mode reverts to plain distcc mode for source files that contain 
includes with absolute paths (either directly or in an included file).
.PP
Due to limitations in gcc, gdb may not be able to automatically find
the source files for programs built using distcc in some
circumstances.  The gdb 
.B directory
command can be used.  For distcc's plain (non-pump) mode, 
this is fixed in gcc 3.4 and later.  For pump mode, the fix in
gcc 3.4 does not suffice; we've worked around the gcc limitation
by rewriting the object files that gcc produces, but this is only
done for ELF object files, but not for other object file formats.
.PP
The .o files produced by discc in pump mode will be different from those produced
locally: for non-ELF files, the debug information will specify compile
directories of the server.  The code itself should be identical.
.PP
For the ELF-format, distcc rewrites the .o files to correct compile directory
path information.  While the resulting .o files are not bytewise identical to
what would have been produced by compiling on the local client (due to different
padding, etc), they should be functionally identical.
.PP
In distcc-pump mode, the include server is unable to handle certain very complicated computed
includes as found in parts of the Boost library. The include server will time
out and distcc will revert to plain mode.
.PP
In distcc-pump mode, certain assumptions are made that source and header files
do not change during the build.  See discussion in section DISTCC DISCREPANCY
SYMPTOMS of \fBinclude_server\fR(1().

Other known bugs may be documented on 
.I http://code.google.com/p/distcc/
.SH "AUTHOR"
distcc was written by Martin Pool <mbp@sourcefrog.net>, with the
co-operation of many scholars including Wayne Davison, Frerich Raabe,
Dimitri Papadopoulos and others noted in the NEWS file.  Please report
bugs to <distcc@lists.samba.org>.  See \fBpump\fR(1) for the authors of pump mode.
.SH "LICENCE"
You are free to use distcc.  distcc (including this manual) may be
copied, modified or distributed only under the terms of the GNU
General Public Licence version 2 or later.  distcc comes with
absolutely no warrany.  A copy of the GPL is included in the file
COPYING.
.SH "SEE ALSO"
\fBdistccd\fR(1), \fBpump\fR(1), \fBinclude_server\fR(1), \fBgcc\fR(1),
\fBmake\fR(1), and  \fBccache\fR(1).
.I http://code.google.com/p/distcc/
.I http://ccache.samba.org/