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 source code 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 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, whenever you 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

Portage will automatically use ccache if it's installed. However, you can alter the default cache size used by ccache by providing a CCACHE_SIZE variable in /etc/make.conf:

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

If you would like to use ccache for non-Portage compilations, add /usr/lib/ccache/bin to the beginning of your PATH variable (before /usr/bin). This can be accomplished by editing /etc/env.d/00basic:

# nano -w /etc/env.d/00basic
# env-update && source /etc/profile

We have already discussed how to work with prebuilt packages, but how do you create your own prebuilt 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 useful 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.

FEATURES="buildpkg"

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 by 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"

Portage can be told to automatically deal with potentially dangerous file permissions that could pose a security risk. It does this by removing the "group" and "other" readable bits on setuid files and removing the "other" readable bit on setgid files in the pre install phase. To activate the smart file permissions, add the sfperms keyword to the FEATURES variable:

FEATURES="sfperms"

Occasionally you need to have several versions of a software title installed at the same time to satisfy your system's dependencies. Whereas most distributions allow this by having their packages called to the version (such as freetype and freetype2) Portage uses the concept of SLOTs.

A SLOT is a (part of a) version number that tells Portage that all equally named packages with a different SLOT are able to coexist on the same system. Portage is able to track both branches of a certain package and update them if updates to the respective branches are available.

When you perform an update Portage will only automatically unmerge the old instance of a package if it uses the same SLOT. This is why kernel sources are never automatically unmerged as their SLOT is the complete version.

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