distcc is a program to distribute compilations across several, not necessarily identical, machines on a network. The distcc client sends all necessary information to the available DistCC servers (running distccd) so they can compile pieces of sourcecode for the client. The net result is a faster compilation time.

You can find more elaborate information about distcc (and information on how to have it work with Gentoo) in our Gentoo Distcc Documentation.

Distcc ships with a graphical monitor to monitor tasks that your computer is sending away for compilation. If you use Gnome then put 'gnome' in your USE setting. However, if you don't use Gnome and would still like to have the monitor then you should put 'gtk' in your USE setting.

Installing distcc is, as is with all software available through Gentoo's Portage, extremely easy:

# emerge distcc

Well, if installation is easy, the rest should be easy too :) So let us quickly activate the Portage support for distcc.

First, open /etc/make.conf and edit the FEATURES variable so it contains the distcc keyword. Next, edit the MAKEOPTS variable so it reads -jX with X the number of CPUs that run distccd (including the current host) plus one:

# Suppose you have 2 single-CPU distccd hosts excluding this host:
MAKEOPTS="-j4"

Now, still inside /etc/make.conf, uncomment the PORTAGE_TMPDIR line and add the following line at the end of the file:

# Don't forget to uncomment the PORTAGE_TMPDIR variable
DISTCC_DIR=${PORTAGE_TMPDIR}/portage/.distcc

Now run distcc-config and enter the list of available DistCC servers. For a simple example we assume that the available DistCC servers are 192.168.1.102 (the current host), 192.168.1.103 and 192.168.1.104 (two "remote" hosts):

# distcc-config --set-hosts "192.168.1.102 192.168.1.103 192.168.1.104"

Of course, don't forget to run the distccd daemon too:

# /etc/init.d/distccd start

Congratulations, your system will now use distributed compiling! For more in-depth information about DistCC and Gentoo, please read our Gentoo DistCC Documentation.

ccache is a fast compiler cache. When you compile a program, it will cache intermediate results so that, when you ever recompile the same program, the compilation time is greatly reduced. In common compilations this can result in 5 to 10 times faster compilation times.

If you are interested in the ins and outs of ccache, please visit the ccache homepage.

Installing ccache with Gentoo is a breeze. Just emerge it and you're done :)

# emerge ccache

First, edit /etc/make.conf and alter the FEATURES variable so that it contains the ccache keyword:

FEATURES="ccache"

Next, edit (or create) the CCACHE_SIZE variable (also in /etc/make.conf) so it contains the amount of diskspace you want to sacrifice for ccache:

CCACHE_SIZE="2G"

As of now, Portage will use ccache to speed up compilations where possible. If you are uncertain that ccache works, you can run ccache -s to view the ccache statistics:

# ccache -s

We have already discussed how to work with prebuild packages, but how do you create your own prebuild packages?

If the package is already installed, you can use the quickpkg command which will make a tarball of the installed files. This is very interesting for backup purposes!

# quickpkg gnumeric

If the package isn't installed yet, you can install it using emerge and ask to build a binary package too. emerge uses the --buildpkg option (-b in short) for this:

# emerge --buildpkg gnumeric

If you want Portage to do this by default, you should set the buildpkg keyword in the FEATURES variable declared in /etc/make.conf.

If you don't want to install the software, but only build the package, you can use the --buildpkgonly option (-B in short):

# emerge --buildpkgonly gnumeric

While building and installing packages, Portage uses a sandbox to protect your live system. This means that, as long as the package isn't installed on your system, the package cannot touch any file outside the sandbox. This ensures that Portage knows what files are created and modified by a package.

When the package compilation is finished, Portage will "preinstall" the package in the sandbox, registering what files are placed and where. It will then move those files from the sandbox on your live system.

Portage also supports building packages as non-root user (more precisely, as user "portage", group "portage"). This improves the security during the build process. You can opt to use user privileges with or without sandboxing. Of course, it goes without saying that user privileges and sandboxing is the most preferred method :)

Portage will use sandbox per default. If you want userpriv, you should add it to the FEATURES variable. Note that activating userpriv will drop sandbox support, unless you also activate usersandbox:

FEATURES="userpriv usersandbox"

Portage can be asked to react strongly to possibly dangerous conditions (such as missing or incorrect Manifest files). To activate this strict checking, add the strict keyword to the FEATURES variable:

FEATURES="strict"

There are several other keywords you can place in the FEATURES variable. Most of them are targeted towards developers and less interesting for the casual user. If you are interested in learning more about these features (or Portage generally), don't forget to read the make.conf manpage we provide.

# man make.conf