distcc(1)

NAME
distcc - distributed C/C++/ObjC compiler

SYNOPSIS
distcc <compiler> [COMPILER OPTIONS]

distcc [COMPILER OPTIONS]

<compiler> [COMPILER OPTIONS]

DESCRIPTION

distcc distributes compilation of C code across several machines on a network. distcc should always generate the same results as a local compile, is simple to install and use, and is often much faster than a local compile.

distcc sends the complete preprocessed source code and compiler arguments across the network for each job, so the machines do not need to share a filesystem, have the same headers or libraries installed, or have synchronized clocks.

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, the linker, and other stages of the build process. Any number of "volunteer" machines help the client to build the program, by running the C compiler and assembler as required.

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 clients must run the distccd(1) daemon either directly or from inetd. For SSH connections distccd me be installed but should not be listening for connections.

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.

distcc is intended to be used with GNU Make's -j option, which runs several compiler processes concurrently. distcc spreads the jobs across both local and remote CPUs. Because the overhead of distcc and network traffic is low relative to the work of running the compiler, this can greatly reduce build time. The -j value should normally be set to about twice the number of available CPUs, to allow for some tasks being blocked waiting for disk or network IO. distcc can also work with other build control tools such as SCons.

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.

QUICKSTART

1   For each machine, download distcc, unpack, and install.

2   On each of the servers, run distccd --daemon with --allow options to restrict access.

3   Put the names of the servers in your environment:
    $ export DISTCC_HOSTS='localhost red green blue'

4   Build!
    $ make -j8 CC=distcc

HOW IT WORKS
distcc only ever runs the compiler and assembler remotely. 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.

The compiler and assembler take only a single input file, the preprocessed source, produce a single output, the object file. distcc ships these two files across the network and can therefore run the compiler/assembler remotely.

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.

distcc examines its command line to determine which of these phases are being invoked, and whether the job can be distributed.

OPTION SUMMARY
Most options passed to distcc are interpreted as compiler options. Two options are understood by distcc itself:

--help
    Displays summary instructions.

--version
    Displays the distcc client version.

INSTALLING DISTCC
There are three different ways to call distcc, to suit different circumstances:

    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.

    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.

    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.

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 dirirectory 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.

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.

For example:

    # 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++

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.

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.

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.

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.

The simplest way to use ccache with distcc is to create masquerade directories for both of them, and list the ccache directory on the path before distcc. For example:

    PATH=/usr/lib/ccache/bin:/usr/lib/distcc/bin:/usr/bin:/bin

Alternatively you can set CCACHE_PREFIX=distcc and use CC="ccache gcc" .

HOST SPECIFICATIONS
A "host list" tells distcc which machines to use for compilation. In order, distcc looks in the $DISTCC_HOSTS environment variable, the user's ~/.distcc/hosts file, and the system-wide host file. If no host list can be found, distcc emits a warning and compiles locally.

The host list is a simple whitespace separated list of host specifications. The simplest and most common form is a host names, such as

    localhost red green blue

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. Because the overheads for running jobs locally are low, localhost should normally be first. If the client is much slower (for example, a handheld machine) then it can be listed later or not at all.

The syntax is

  DISTCC_HOSTS = HOSTSPEC ...
  HOSTSPEC = LOCAL_HOST | SSH_HOST | TCP_HOST | OLDSTYLE_TCP_HOST
  LOCAL_HOST = localhost[/LIMIT]
  SSH_HOST = [USER]@HOSTID[/LIMIT][:COMMAND][OPTIONS]
  TCP_HOST = HOSTID[:PORT][/LIMIT][OPTIONS]
  OLDSTYLE_TCP_HOST = HOSTID[/LIMIT][:PORT][OPTIONS]
  HOSTID = HOSTNAME | IPV4
  OPTIONS = ,OPTION[OPTIONS]
  OPTION = lzo

Here are some individual examples of the syntax:

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.)

IPV4
    A literal IPv4 address, such as 10.0.0.1

HOSTNAME
    A hostname to be looked up using the resolver.

:PORT
    Connect to a specified decimal port number, rather than the default of 3632.

@HOST
    Connect to the host over SSH, rather than TCP. Options for the SSH connection can be set in ~/.ssh/config

USER@
    Connect to the host over SSH as a specified username.

: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.

/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, but may be further restricted by the server. You should only need to increase this for servers with more than two processors.

,lzo
    Enables LZO compression for this TCP or SSH host.

Here is an example demonstrating some possibilities:

    localhost/2 @bigman/16:/opt/bin/distccd oldmachine:4200/1 distant/3,lzo

If a host in the list is not reachable distcc will emit a warning and ignore that host for about one minute.

COMPRESSION

The 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.

Enabling compression makes the distcc client and server use more CPU time, but less network traffic. The compression ratio is typically 4:1 for source and 2:1 for object code.

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.

DIAGNOSTICS
Error messages or warnings from local or remote compilers are passed through to diagnostic output on the client.

distcc can supply extensive debugging information when the verbose option is used. This is controlled by the DISTCC_VERBOSE environment variable on the client, and the --verbose option on the server. For troubleshooting, examine both the client and server error messages.

EXIT CODES
The exit code of distcc is normally that of the compiler: zero for successful compilation and non-zero otherwise.

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 connection locally unless the DISTCC_FALLBACK option has been disabled.

If the compiler exits with a signal, distcc returns an exit code of 128 plus the signal number.

distcc internal errors cause an exit code between 100 and 127. In particular

100 General distcc failure.

105 Out of memory.

110 Compiler not found.

111 Recursive call to distcc.

116 No hosts defined and fallbacks disabled.

(Others are listed in exitcode.h.)

FILES
If $DISTCC_HOSTS is not set, distcc reads a host list from either ~/.distcc/hosts or a system-wide configuration file set at compile time. The file locations are shown in the output from distcc --help

distcc creates a number of temporary and lock files underneath the temporary directory.

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.

DISTCC_HOSTS
    Space-separated list of volunteer host specifications.

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.

DISTCC_LOG
    Log file to receive messages from distcc itself, rather than stderr.

DISTCC_FALLBACK
    By default distcc will compile locally if it fails to distribute a job to the indended machine, or if not 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.

DISTCC_SAVE_TEMPS
    If set to 1, temporary files are not deleted after use. Good for debugging, or if your disks are too empty.

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.

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.

TMPDIR
    System temporary directory. distcc creates a subdirectory whose name includes the hostname and userid inside this to store all its files. By default /tmp/ is used.

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.

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 distcc cc will probably not work, because that will normally invoke the volunteer's native compiler.

Machines with the same CPU but different operating systems may not necessarily generate compatible .o files.

Several different gcc configurations can be installed side-by-side on any machine. If you build gcc from source, you should use the --program-suffix configuration options to cause it to be installed with a name that encodes the gcc version and the target platform.

The recommended convention for the gcc name is TARGET-gcc-VERSION such as i686-linux-gcc-3.2 . GCC 3.3 will install itself under this name, in addition to TARGET-gcc and, if it's native, gcc-VERSION and gcc .

The compiler must be installed under the same name on the client and on every volunteer machine.

BUGS
If you think you have found a distcc bug, please see the file reporting-bugs.txt in the documentation directory for information on how to report it.

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 directory command can be used.

gcc's -MD option can produce output in the wrong directory if the source and object files are in different directories and the -MF option is not used. There is no perfect solution because of incompatible changes between gcc versions. Explicitly specifying the dependency output file with -MF will fix the problem.

TCP mode connections should only be used on trusted networks.

Including slow machines in the list of volunteer hosts can slow the build down.

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.

Some makefiles have missing or extra dependencies that cause incorrect or slow parallel builds. Fix the makefile by correcting the dependencies, report bugs to the maintainer, or don't build the tree in parallel.

Other known bugs may be documented on http://distcc.samba.org/

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>.

LICENCE
You are free to use distcc. It may be copied, modified or distributed only under the terms of the GNU General Public Licence version 2 or later. A copy of the GPL is included in the file COPYING.

SEE ALSO
distccd(1), ccache(1), gcc(1), make(1) http://distcc.samba.org/ http://ccache.samba.org/