Distcc

From Gentoo Wiki
Jump to:navigation Jump to:search
This page is a translated version of the page Distcc and the translation is 50% complete.
Outdated translations are marked like this.
Other languages:
Deutsch • ‎English • ‎Türkçe • ‎español • ‎français • ‎italiano • ‎polski • ‎русский • ‎中文(中国大陆)‎ • ‎日本語 • ‎한국어
Resources

Distcc est un programme conçu pour répartir des tâches de compilation à travers un réseau vers des hôtes participants. Il comprend un serveur, distccd, et un client, distcc. Distcc peut travailler en toute transparence avec ccache, Portage et Automake moyennant un minimum de configuration.

Si vous envisagez d'utiliser distcc pour vous aider à préparer la chaîne des outils de compilation pour une installation de Gentoo, assurez vous de lire préalablement la section concernant l'utilisation de distcc pour l'amorçage (compilation des outils de compilation).

Installation

Avant de configurer distcc, commençons par nous intéresser à l'installation de sys-devel/distcc sur tous les hôtes.

Dépendances communes à tous les hôtes

Afin d'utiliser distcc, tous les ordinateurs sur votre réseau doivent posséder la même version de GCC. Pour être plus précis, mélanger 3.3.x (avec x variable) est accepté, mais mélanger 3.3.x avec 3.2.x peut conduire à des erreurs de compilation ou des erreurs en exécution.

Vérifiez que tous les systèmes utilisent la même version de binutils (eselect binutils list) ou de nombreux paquets vont échouer à l'édition de liens avec différentes erreurs telles que des relocalisations de texte.

Options de la variable USE

USE flags for sys-devel/distcc Distribute compilation of C code across several machines on a network

gssapi Enable support for net-libs/libgssglue
gtk Add support for x11-libs/gtk+ (The GIMP Toolkit)
hardened Activate default security enhancements for toolchain (gcc, glibc, binutils)
ipv6 Add support for IP version 6
selinux !!internal use only!! Security Enhanced Linux support, this must be set by the selinux profile or breakage will occur
xinetd Add support for the xinetd super-server
zeroconf Support for DNS Service Discovery (DNS-SD)

Emerge

Distcc comprend un utilitaire de surveillance graphique des tâches de compilation externes envoyées par un ordinateur. La présence de celui-ci est contrôlée par l'option gtk de la variable USE.

Une fois la variable USE configurée, installez le packet sys-devel/distcc.

root #emerge --ask sys-devel/distcc
Important
Rappelez-vous que vous devez installer sys-devel/distcc sur tous les ordinateurs participants.

Configuration

Service

Afin de mettre en place le démarrage automatique de distccd, suivez les instructions suivantes.

OpenRC

Éditez /etc/conf.d/distccd et assurez-vous de définir la directive --allow pour n'autoriser que les clients auxquels vous accordez votre confiance. Pour une sécurité renforcée, utilisez aussi la directive --listen afin de dire au daemon distccd quelles adresses IP écouter (pour les systèmes multi-adresses). Des informations complémentaires sur la sécurité avec distcc sont disponibles à l'adresse Distcc security notes.

Warning
N'importe-qui pouvant se connecter au port du serveur distcc peu exécuter des commandes quelconques sur cette machine en tant qu'utilisateur distcc.

L'exemple suivant autorise les clients distcc tournant sur 192.168.0.4 et 192.168.0.5 à se connecter au serveur distccd local.

FILE /etc/conf.d/distccdAutorisation de connexion depuis des clients spécifiques au serveur distccd
DISTCCD_OPTS="--port 3632 --log-level notice --log-file /var/log/distccd.log -N 15 --allow 192.168.0.4 --allow 192.168.0.5"

When logging to a file in /var/log, create the log and give appropriate permissions:

root #touch /var/log/distccd.log
root #chown distcc:root /var/log/distccd.log
Important
Il est important d'utiliser --allow et --listen. Lisez la page de manuel de distccd (distccd manpage) ou le document sur la sécurité cité précédemment pour en savoir plus.

Maintenant démarrez votre daemon distccd sur tous les ordinateurs participants :

root #rc-update add distccd default
root #rc-service distccd start

systemd

Éditez le fichier /etc/systemd/system/distccd.service.d/00gentoo.conf afin d'ajouter les clients au format CIDR. Voici un exemple ajoutant toutes les adresses IP du bloc 192.168.1.xxx :

FILE /etc/systemd/system/distccd.service.d/00gentoo.confConfiguration d'ALLOWED_SERVERS
Environment="ALLOWED_SERVERS=192.168.1.0/24"

Or an example with multiple clients and a manually specified log-level

FILE /etc/systemd/system/distccd.service.d/00gentoo.confSetting ALLOWED_SERVERS
Environment="ALLOWED_SERVERS=127.0.0.1 --allow 192.168.1.0/24 --allow 10.1.1.1/24 --log-level error"
Note
Le nom "ALLOWED_SERVERS" peut porter à confusion, étant donné qu'il indique quels clients ont le droit de se connecter au serveur distccd local. Quoi qu'il en soit, c'est la variable dont la valeur est utilisée par le service distccd pour l'option --allow – se référer au fichier /usr/lib/systemd/system/distccd.service pour plus d'informations.
Important
In contrast to OpenRC, environment variables put in /etc/env.d/* will not take effect for systemd users even after running env-update and restarting the distccd service. This is because /etc/environment.d generated by env-update is only sourced by systemd user instance. Whereas, distccd is spawned by systemd system instance.

To set the proper environment variables for distccd, place them into /etc/systemd/system/distccd.service.d/00gentoo.conf. For example,

FILE /etc/systemd/system/distccd.service.d/00gentoo.conf
[Service]
Environment="ALLOWED_SERVERS=192.168.121.0/24"
Environment="DISTCC_VERBOSE=1"
Environment="DISTCC_SAVE_TEMPS=1"
Environment="CCACHE_DIR=/var/cache/ccache"
Warning
The Environment= directive in /etc/systemd/system/distccd.service.d/00gentoo.conf file does not support variable expansion. Environment="PATH=/usr/lib/ccache/bin:$PATH" will be treated as is, therefore will not work as intended.

For workaround, you need to edit distccd.service by running the following command.

root #systemctl edit --full distccd.service

This will open up an editor. Change the line with ExecStart= directive to

CODE Workaround for appending to PATH
ExecStart=/bin/bash -c "PATH=/usr/lib/ccache/bin:$PATH exec /usr/bin/distccd --no-detach --daemon --port 3632 -N 15 --allow $ALLOWED_SERVERS --log-level debug"

Alternatively, you could also write a shell script wrapper for /usr/bin/distccd.

Recharger les nouvelles configurations:

root #systemctl daemon-reload

Activer le démarrage automatique de distccd et démarrer le service :

root #systemctl enable distccd
root #systemctl start distccd

Spécification des hôtes participants

Utilisez la commande distcc-config pour définir la liste des participants.

Voici quelques exemples de définition d’hôtes. Dans la plupart des cas, des variations des lignes 1 et 2 suffisent. Cette dernière inclue la syntaxe /limit afin d'informer distcc du nombre maximal de taches à lancer sur le nœud. Plus d'informations sur la syntaxe employée aux lignes 3 et 4 sont disponibles sur le manuel de distcc.

CODE Exemples de définition d'hôtes participant
192.168.0.1          192.168.0.2                       192.168.0.3
192.168.0.1/2        192.168.0.2                       192.168.0.3/10
192.168.0.1:4000/2   192.168.0.2/1                     192.168.0.3:3632/4
@192.168.0.1         @192.168.0.2:/usr/bin/distccd     192.168.0.3

Il y a aussi plusieurs autres méthodes pour définir des hôtes. Reportez-vous à la page de manuel de distcc (man distcc) pour plus de détails.

Si la machine locale doit elle aussi compiler, indiquez localhost dans la liste des hôtes participants. À l'inverse, si la machine locale ne participe pas à la compilation (ce qui est souvent le cas), omettez la de la liste. Sur une machine lente, utiliser localhost peut ralentir les choses. Assurez vous de la performance de votre configuration en effectuant des tests.

Configurons distcc afin d'utiliser les hôtes mentionnés par la première ligne de l'exemple :

root #/usr/bin/distcc-config --set-hosts "192.168.0.1 192.168.0.2 192.168.0.3"

Distcc permet également un mode « pump », en invoquant la commande pump. Ce mode peut réduire le temps de compilation de manière significative lorsque plusieurs fichiers sont compilés en parallèle. Cela cache les entêtes pré-traitées sur le serveur et, par conséquent, évite les téléchargements et pré-traitements répétitifs de ces fichiers d’entête.

Pour configurer un hôte pour le mode « pump », ajoutez les suffixes ,cpp,lzo à la définition des hôtes. Le mode « pump » requiert les deux options cpp et lzo (que les fichiers soient en C ou C++).

root #/usr/bin/distcc-config --set-hosts "192.168.0.1,cpp,lzo 192.168.0.2,cpp,lzo 192.168.0.3,cpp,lzo"

Hosts also need to be in:

FILE /etc/distcc/hostsShould match --set-hosts
192.168.0.1
192.168.0.2
192.168.0.3

Optionally, to set the maximum number of threads used by a host, add a forward slash "/" after each host:

FILE /etc/distcc/hostsSpecify max number of threads
192.168.0.1/8
192.168.0.2/4
192.168.0.3/16

The same applies to the distcc-config command. If the maximum threads number is not specified, it will default to 4.

Utilisation

Avec Portage

Il est aisé de configurer Portage pour qu'il utilise distcc. Il suffit pour cela d'activer la fonctionnalité distcc et de choisir une valeur décente pour le nombre de taches de compilation simultanées (étant donné que distcc augmente le nombre de ressources disponible pour la compilation).

Définissez les variables MAKEOPTS et FEATURES comme indiqué ci-dessous.

Une stratégie courante consiste à

  • mettre pour valeur de N le double du nombre "total" (locaux + distants) de cœurs du processeur + 1, et
  • mettre pour valeur de M le nombre de cœurs du processeur local.

L'utilisation de -lM dans la variable MAKEOPTS empêchera la création d'un nombre trop élevé de taches lorsque certain hôtes de distcc sont indisponibles (augmentant alors la quantité de taches simultanées sur les autres systèmes) ou lorsqu'un ebuild est configuré de façon à interdire la compilation distante (tel qu'avec gcc). Cela est accompli en refusant le démarrage de taches supplémentaires lorsque la charge du système et égale ou supérieure à la valeur de M

FILE /etc/portage/make.confConfiguration de MAKEOPTS et FEATURES
# Remplacez N et M avec les bonnes valeurs, comme calculé précédemment
MAKEOPTS="-jN -lM"
FEATURES="distcc"

Par exemple, lorsqu'il y à deux hôtes quadruple cœur qui exécute distccd et que le PC local possède un processeur double cœur, la variable MAKEOPTS peut ressembler à ceci :

FILE /etc/portage/make.confexemple de MAKEOPTS pour 2 quad-core (PC distants) et un dual core (PC local)
# 2 remote hosts with 4 cores each = 8 cores remote
# 1 local host with 2 cores = 2 cores local
# total number of cores is 10, so N = 2*10+1 and M=2
MAKEOPTS="-j21 -l2"

CFLAGS et CXXFLAGS

Lors de l’édition de make.conf, assurez vous que les variables CFLAGS et CXXFLAGS ne contiennent pas -march=native. distcc ne distribuera pas de taches aux autres machines si march a pour valeur native. Une valeur approximative de -march= et d’options peut être obtenue en utilisant la commande suivante :

FILE /etc/portage/make.confinlined *FLAGS
# Minimal list of flags is generated with:
#   $ diff -U0 <(LANG=C gcc -Q -O2 -march=sandybridge --help=target) <(LANG=C gcc -Q -O2 -march=native --help=target)
COMMON_FLAGS="-march=sandybridge -mtune=sandybridge -maes" # don't use -march=native!
CFLAGS="${COMMON_FLAGS}"
CXXFLAGS="${COMMON_FLAGS}"

Pour plus d'information, consultez Résolution de -march=native pour distcc

Avec automake

Ceci est, dans certains cas, plus facile que de configurer Portage. Il n'y a besoin que de mettre la variable PATH à jour pour qu'elle inclue /usr/lib/distcc/bin en face du répertoire qui contient gcc (/usr/bin). Prenez garde cependant: si vous utilisez ccache, mettez alors le répertoire contenant distcc après celui de ccache.

root #export PATH="/usr/lib/ccache/bin:/usr/lib/distcc/bin:${PATH}"

Placez ceci dans le fichier ~/.bashrc de l'utilisateur, ou son équivalent, pour une variable PATH définie à chaque entrée dans sa session, ou définissez la de manière globale avec un fichier dans /etc/env.d.

Au lieu de simplement appeler make, ajoutez s'y un paramètre d'invocation -jN (où N est un entier naturel). La valeur de N dépend du réseau et du type des ordinateurs utilisés pour la compilation. Une approche heuristique pour trouver la bonne valeur a été donné plus tôt dans cet article.

With ccache

To make Ccache work with distcc, some prerequisites must be fulfilled:

  • Ccache is successfully set up locally
  • Distcc is successfully set up on the desired hosts

The following setup will work as follows:

CODE Flow diagram
[client]                                                      [remote]
ccache <miss?> → compile it and save cache files,
<hit?>           also distribute other source code → distccccache <miss?> → compile it, save cache files, return cache file to client
  ↓                                                           <hit?>
use the local cache file                                        ↓
                                                 return local cache file to client
Warning
The following configuration must be done on all desired hosts!

Configure distccd

In order to let the daemon distccd use ccache, it must masquerade the path /usr/bin with /usr/lib/ccache/bin. Furthermore, when it uses ccache, ccache should use the prefix distcc:

FILE /etc/conf.d/distccd
PATH="/usr/lib/ccache/bin:${PATH}"
CCACHE_PREFIX="distcc"

Additionally distccd must be aware of the environment variables DISTCC_DIR and CCACHE_DIR:

Warning
These variables must be set somewhere in /etc/env.d/, otherwise ccache tries to put cache files in ${HOME}/.ccache/, which might result in a COMPILE_ERROR, due to insufficient permissions. To pinpoint this, use the testing example mentioned below and export DISTCC_SAVE_TEMPS="1" as mentioned here. This will provide error logs from the remote site in /tmp/ by default. The logs will look like this: distcc_server_stderr_*.txt. Be aware, that these environment variables cannot be set in /etc/conf.d/distccd, since they will not be read from distccd for some reason.
FILE /etc/env.d/03distcc_ccache
CCACHE_DIR="/var/cache/ccache"
DISTCC_DIR="/var/tmp/portage/.distcc"

Next, update the environment variables:

root #env-update
>>> Regenerating /etc/ld.so.cache...

Finally, restart the daemon distccd to adapt all changes:

root #rc-service distccd restart

Configure ccache

Warning
When using distcc with ccache, it is necessary to prepare the cache directories manually, since the daemon distccd only works with the user distcc for some reason and it cannot create directories within /var/cache/ccache/. It is not sufficient to add this user to the group portage. Also be aware, that the variable cache_dir_levels, defined in ccache.conf, specifies how many subdirectories have to be created. The following example uses the default, which is 2.

First, prepare the cache directories:

root #cd "/var/cache/ccache/"
root #mkdir {a..z} {0..9} tmp
root #for first_level_directory in $(find . -maxdepth 1 -type d -not -name "." -and -not -name "tmp"); do pushd "${first_level_directory}" >/dev/null; mkdir {a..z} {0..9}; popd >/dev/null; done

The second command (mkdir) will create the first level directories from a to z, 0 to 9 and tmp. The following for loop will then look for the first level directories (find . -maxdepth 1 -type d), excluding the current directory . and tmp (-not -name "." -and -not -name "tmp"). It then descends into each of them (pushd), creates the second level directories from a to z and 0 to 9 (mkdir) and goes back to the previous directory (popd), which is /var/cache/ccache/.

Important
The current directory . must be excluded with -not -name ".", otherwise the first pushd command will go to the current directory . and then goes back to whatever directory is currently on the stack via popd. It will navigate through the entire stack until it is empty, creating directories, where each pushd command fails. If this happens, one can search for them using find / -type d -name "0" and remove them with rm --recursive [a-z] [0-9]. It is advised to this manually!

When the preparation is done, every directory - including the directory ccache itself - must be owned by the user distcc:

root #find /var/cache/ccache -type d -exec chown distcc:portage "{}" +

Configure portage

To use emerge with distcc and ccache, make sure, that both features are enabled and that CCACHE_DIR is set in /etc/portage/make.conf:

FILE /etc/portage/make.conf
[...]
FEATURES="distcc ccache"
CCACHE_DIR="/var/cache/ccache"

It might be redundant to set CCACHE_DIR here, since it is already defined in /etc/env.d/03distcc_ccache, mentioned here. But to make absolutely sure, configure it like that.

Testing distcc with ccache manually

Remote

First enable verbose logging by setting --log-level to debug in /etc/conf.d/distccd:

FILE /etc/conf.d/distccd
[...]
DISTCCD_OPTS="${DISTCCD_OPTS} --log-level debug"
[...]

After that, restart the daemon to adapt the changes:

root #rc-service distccd restart

Also check, if there are directories in /var/cache/ccache - including the directory ccache itself - which are not owned by the user distcc and correct their owner permissions:

root #chown -R distcc:portage /var/cache/ccache
Client

Make sure, that the following environment variables are present in the current shell:

root #export PATH="/usr/lib/ccache/bin:${PATH}"
root #export CCACHE_DIR="/var/cache/ccache"
root #export DISTCC_DIR="/var/tmp/portage/.distcc"
root #export DISTCC_SAVE_TEMPS="1"
root #export DISTCC_VERBOSE="1"

After that, navigate to a temporary directory within /tmp/ and compile the example mentioned below:

root #cd $(mktemp --directory)
root #distcc gcc -c main.c -o main.o

This will provide a verbose output, while also keeping temporary files receiving from the remote site in /tmp/ by default:

CODE
[...]
distcc[29466] (dcc_cleanup_tempfiles_inner) skip cleanup of /tmp/distcc_9c42f0a6.i
distcc[29466] (dcc_cleanup_tempfiles_inner) skip cleanup of /tmp/distcc_server_stderr_9cc0f0a6.txt
[...]

Any occuring error from the remote site are saved in /tmp/distcc_server_stderr_*.txt.

If the compilation was successful, the following line will be shown.

CODE
[...]
distcc[29466] compile main.c on 192.168.0.4 completed ok
[...]

On the remote site, it will look like this:

CODE
[...]
distccd[13296] (dcc_check_compiler_masq) /usr/lib/ccache/bin/gcc is a safe symlink to /usr/bin/ccache
[...]
distccd[13296] (dcc_job_summary) client: 192.168.0.4:33880 COMPILE_OK exit:0 sig:0 core:0 ret:0 time:20ms gcc main.c

The important part here, is, that any symlink of /usr/lib/ccache/bin/ is a save symlink to /usr/bin/ccache.

Also, on the remote site, there should be the cached file 2beaa22dc2a2873d6869d69411840c-17229.o in /var/cache/ccache/c/0/, assuming, the example with its filename was copied from this wiki article. Generally, one can monitor the ccache size using watch "ccache --show-stats", while compiling.

Testing distcc with ccache using emerge

Check, if necessary environment variables are present for the current shell, see here and that /etc/portage/make.conf was configured properly, see here.

To produce some cached files on the remote site, one can compile small packages like htop and bzip2 on the client:

root #emerge --ask htop bzip2

Future usage

Make sure, that the following environment variables are always set in the desired shell:

CODE
PATH="/usr/lib/ccache/bin:${PATH}"
CCACHE_DIR="/var/cache/ccache"
DISTCC_DIR="/var/tmp/portage/.distcc"

Pour amorcer

Utiliser distcc pour amorcer (c'est à dire construire une chaîne d'outils avant d'installer le reste du système) requiert quelques étapes supplémentaires.

Étape 1: configurer Portage

Démarrez la nouvelle machine avec un LiveCD de Gentoo Linux et suivez les instructions d'installation tout en tenant compte des instructions sur le démarrage présentes dans la FAQ de Gentoo comme source d'information sur l'amorçage. Configurez ensuite Portage pour utiliser distcc:

FILE /etc/portage/make.confConfigurer Portage pour utiliser distcc
FEATURES="distcc"
MAKEOPTS="-jN"

Mettez aussi à jour la variable PATH de votre session d'installation:

root #export PATH="/usr/lib/ccache/bin:/usr/lib/distcc/bin:${PATH}"

Étape 2: obtenir distcc

Installez sys-devel/distcc:

root #USE='-*' emerge --nodeps sys-devel/distcc

Étape 3: configurer distcc

Exécutez la commande distcc-config --install pour configurer distcc; remplacez les host# de l'exemple par les adresses IP ou les noms d'hôte des nœuds participant.

root #/usr/bin/distcc-config --set-hosts "localhost host1 host2 host3 ..."

Distcc est maintenant configuré pour l’amorçage ! Continuez avec les instructions d'installation officielles et n'oubliez pas de lancer emerge distcc après avoir fait emerge @system. Cela permet d'être sûr que toutes les dépendances nécessaires sont installées.

Note
Pendant l’amorçage et lors le l'exécution de emerge @system, distcc peut sembler non utilisé. Ceci est prévisible, car certains ebuilds ne fonctionnent pas bien avec distcc et l'ont intentionnellement désactivé.

Suppléments

L'application distcc a quelques fonctionnalités supplémentaires et des outils pour aider à travailler dans un environnement distcc.

Utilitaires de surveillance

Distcc arrive avec deux utilitaires de surveillance. L'un, à base de texte, est toujours compilé et est appelé distccmon-text. Le lancer pour la première fois peut paraître confus, mais il est en fait facile à utiliser. Si le programme est utilisé sans paramètre, il ne s'actionnera qu'une seule fois. Cependant, s'il lui est passé un nombre N, il se mettra à jour toutes les N secondes (avec N l'argument qui lui a été passé).

user $distccmon-text 10

L'autre utilitaire de surveillance n'est activé qu'à travers l'option gtk de la variable USE. Celui-ci est basé sur GTK+, tourne dans un environnement X et est très agréable. Pour Gentoo, le surveillant graphique a été renommé distccmon-gui pour éviter la confusion. Il était originellement appelé distccmon-gnome.

user $distccmon-gui

Pour surveiller l'utilisation de distcc par Portage:

root #DISTCC_DIR="/var/tmp/portage/.distcc/" distccmon-text 10
root #DISTCC_DIR="/var/tmp/portage/.distcc/" distccmon-gui
Important
Si le répertoire distcc est ailleurs, changez la variable DISTCC_DIR en conséquence.

Une astuce consiste à définir DISTCC_DIR dans les variables d'environnement:

root #echo 'DISTCC_DIR="/var/tmp/portage/.distcc/"' >> /etc/env.d/02distcc
Important
Be aware that DISTCC_DIR must be set somewhere else than /etc/env.d/02distcc, as it gets overwritten everytime, when using distcc-config!. distcc-config --set-env DISTCC_DIR <some_path> does not work.

Mettez maintenant l'environnement à jour:

root #env-update
root #source /etc/profile

Pour finir, démarrez l'application graphique:

root #distccmon-gui

SSH pour les communications

Configurer distcc via SSH demande d'éviter quelques pièges. Tout d'abord, générez une paire de clés SSH sans définir le mot de passe. Restez conscient du fait que Portage compile les programmes en tant que l'utilisateur Portage (ou en tant que root si FEATURES="userpriv" n'est pas défini). Le dossier home de l'utilisateur Portage est /var/tmp/portage/, ce qui veut dire que les clés doivent être stockées dans /var/tmp/portage/.ssh/.

Warning
Home folder of the Portage user changed in recent versions to /var/lib/portage/home, but this folder cannot be used for distcc via SSH because it is out of the accessible path during compilation. You should then update it:
root #usermod -d /var/tmp/portage portage
root #ssh-keygen -b 2048 -t rsa -f /var/tmp/portage/.ssh/id_rsa

Ensuite, créez une section pour chacun des hôtes dans le fichier de configuration SSH :

FILE /var/tmp/portage/.ssh/configAjouter des sections par hôte
Host test1
    HostName 123.456.789.1
    Port 1234
    User UserName
 
Host test2
    HostName 123.456.789.2
    Port 1234
    User UserName

Envoyez la clef publique à chaque nœud de compilation:

root #ssh-copy-id -i /var/tmp/portage/.ssh/id_rsa.pub UserName@CompilationNode

Assurez-vous également que chaque hôte est disponible dans le fichier known_hosts:

root #ssh-keyscan -t rsa <compilation-node-1> <compilation-node-2> [...] > /var/tmp/portage/.ssh/known_hosts

Réparez les permissions de fichiers:

root #chown -R portage:portage /var/tmp/portage/.ssh/

Pour mettre en place les hôtes test1 et test2, lancez:

root #/usr/bin/distcc-config --set-hosts "@test1 @test2"

Notez le signe @ (symbole @) qui spécifie les hôtes SSH à distcc.

Pour finir, indiquez à distcc quel binaire SSH utiliser"

FILE /etc/portage/make.conf
DISTCC_SSH="ssh"

Il n'est pas nécessaire de lancer le script d'initialisation (initscript) sur les hôtes lorsque distcc communique via SSH.

Reverse SSH

As an alternative to distcc's built-in SSH solution, a compiling server can connect to the distcc client via SSH, redirecting the client's distcc TCP port to the compiling server. There is no need for password-less SSH keys on the client.

user $ssh -R3632:127.0.0.1:3632 root@distcc-client

Note that distcc uses localhost as a literal keyword for special purpose so that 127.0.0.1 has to be used instead. For multiple compiling servers each needs its own port redirection on the client (e.g. 127.0.0.1:4000, 127.0.0.1:4001 etc). Assert that IP addresses and ports are listed in /etc/distcc/hosts on the client.

Testing

To test distcc, write a simple Hello distcc program and run distcc in verbose mode to see if it communicates properly.

FILE main.c
#include <stdio.h>
 
int main() {
    printf("Hello distcc!\n");
    return 0;
}

Next, turn on verbose mode, compile the program using distcc and link the generated object file into an executable:

user $export DISTCC_VERBOSE=1
user $distcc gcc -c main.c -o main.o # or 'pump distcc <...>'
user $gcc main.o -o main
Note
Replace distcc command with pump distcc for use pump mode.

There should be a bunch of output about distcc finding its configuration, selecting the host to connect to, starting to connect to it, and ultimately compile main.c. If the output does not list the desired distcc hosts, check the configuration.

Finally, ensure the compiled program works properly. To test each host, enumerate each compile host in the hosts file.

user $./main
Hello distcc!

Dépannage

Si un problème apparaît lors de l'utilisation de distcc, cette section pourra peut être aider à le résoudre.

ERROR: failed to open /var/log/distccd.log

Au jour du 22 Janvier 2015, la création du fichier distccd.log dans /var/log/ echoue lors de l'emergement. Ceci semble n'affecter que la version 3.1-r8 de distcc. Ce bug est en cours de correction (plus plus d'information, voir bug #477630). Il est possible de contourner le problème en créant manuellement le fichier de log, lui assigner un propriétaire convenable et redémarrer le daemon de distcc.

root #mkdir -p /var/log/distcc
root #touch /var/log/distcc/distccd.log
root #chown distcc:daemon /var/log/distcc/distccd.log

Continuez par mettre à jour le chemin de /var/log présent dans le fichier de configuration de distcc /etc/conf.d/distccd afin de pointer vers le dossier distcc créé dans l’étape précédente.

FILE /etc/conf.d/distccdUpdating log path
DISTCCD_OPTS="--port 3632 --log-level notice --log-file /var/log/distcc/distccd.log -N 15

Pour finir, redémarrez le service distccd:

root #/etc/init.d/distccd restart

Quelques paquets n'utilisent pas distcc

Lorsque certains paquets sont installés, les utilisateurs remarqueront que la compilation de certain d'entre-eux n'est pas répartie (et ils ne sont pas compilés en parallèle). Ceci peut survenir du fait que le Makefile du paquet ne prenne pas en charge les opérations en parallèle, ou que le mainteneur du ebuild les ai explicitement désactivées suite à un problème connu.

Parfois distcc peut faire échouer la compilation d'un paquet. Si cela arrive, ayez s'il vous plaît l’amabilité de le rapporter.

Rust package is known to cause excessive IO utilization as --local-load is ignored and --jobs is usually too high for local build resources. A package.env needs to be provisioned with non-distcc MAKEOPTS values to workaround this behaviour.

Versions mélangées de GCC

Si l'environnement héberge plusieurs versions différentes de GCC, il est probable que des problèmes étranges se produisent. La solution est alors de faire en sorte que tous les hôtes aient la même version de GCC.

De récentes mises à jour de Portage ont fait que Portage utilise ${CHOST}-gcc (tiret gcc) au lieu de gcc . Ceci veut dire que si des machines i686 sont mélangées avec d'autres types (i386, i586), des soucis de compilation se présenteront. Un contournement à cela peut consister à lancer :

root #export CC='gcc' CXX='c++'

Il est aussi possible de définir les variables CC et CXX de /etc/portage/make.conf avec la liste de valeurs indiquée plus haut.

Important
Faire cela redéfinit explicitement quelques comportements de Portage et peut conduire à des résultats étranges dans le futur. Ne faites cela que si mélanger les CHOSTs est inévitable.
Note
Having the right version of gcc as a slot on a server isn’t enough. Portage uses distcc as a replacement for the compiler referenced by the CHOST variable (i.e. x86_64-pc-linux-gnu) and distccd invokes it by exactly same name. The right version of gcc should be a default system’s compiler on all involved compilation hosts.

-march=native

À partir de GCC 4.3.0, le compilateur prend en charge l'option -march=native, qui active l’auto-détection des processeurs et les optimisations qui valent la peine d’être activées sur le processeur faisant tourner GCC. Cela pose un problème lors de l'utilisation de distcc, car cela engendre le mélange de codes optimisés pour différents processeurs. Par exemple, faire tourner distcc avec -march=native sur un réseau de nœuds contenant un système utilisant un AMD Athlon et un système utilisant un Intel Pentium mélangera du code compilé sur chacun des hôtes. Une partie du code compilé sera alors optimisée pour AMD Athlon tandis qu'une autre sera optimisée pour Intel Pentium.

Prenez garde à cette avertissement:

Warning
N'utilisez PAS -march=native ou -mtune=native dans les variables CFLAGS et CXXFLAGS de make.conf lors d'une compilation avec distcc.

See the CFLAGS and CXXFLAGS section and Inlining -march=native for distcc for more information.

Network is unreachable

Note
When using SSH connection, you may also face the error: ssh: Could not resolve hostname: Temporary failure in name resolution.

Due to network restrictions introduced by the feature network-sandbox, you may run into this issue. Since distcc contradicts with this security feature, you have to disable it:

FILE /etc/portage/make.confDisabling network-sandbox feature
FEATURES="${FEATURES} -network-sandbox"

Get more output from emerge logs

It is possible to obtain more logging by enabling verbose mode. This is accomplished by adding DISTCC_VERBOSE to /etc/portage/bashrc:

FILE /etc/portage/bashrcEnabling verbose logging
export DISTCC_VERBOSE=1

The verbose logging can then be found in /var/tmp/portage/$CATEGORY/$PF/temp/build.log.

Keep in mind that the first distcc invocation visible in build.log isn’t necessary the first distcc call during a build process. For example a build server can get a one-minute backoff period during the configuration stage when some checks are performed using a compiler (distcc sets a backoff period when compilation on a remote server failed, it doesn’t matter whether it failed on local machine or not).

Dig into the /var/tmp/portage/$CATEGORY/$PF/work/ directory to investigate such situations. Find other logs, or call make explicitly from within the working directory.

Another interesting variable to use is DISTCC_SAVE_TEMPS. When set, it saves the standard output/error from a remote compiler which, for Portage builds, results in files in the /var/tmp/portage/$CATEGORY/$PF/temp/ directory.

FILE /etc/portage/bashrcSaving temporary output
export DISTCC_SAVE_TEMPS=1

Failed to create directory /dev/null/.cache/ccache/tmp: Not a directory

This error can be discovered from the standard error output file in the server if you set DISTCC_SAVE_TEMPS. It only occurs when using distccd with ccache.

Likely, it is because CCACHE_DIR is not properly set, or not passed correctly to distccd. ccache will then default to $HOME/.cache/ccache as its cache folder. However, ccache is run by distccd under user distcc, which is a non-login account. See systemd section and With ccache section for setting CCACHE_DIR.

Portage build failing with errors that are apparently not connected with distcc at all

When builds are failing with errors that do not seem to be connected to distcc, but the build works with FEATURES="-distcc", it has been reported that builds sometimes fail because of DISTCC_VERBOSE=1. Try the build with DISTCC_VERBOSE=0.

Articles connexes

Ressources externes


This page is based on a document formerly found on our main website gentoo.org.
The following people contributed to the original document: Lisa Seelye, Mike Gilbert (floppym) , Erwin, Sven Vermeulen (SwifT) , Lars Weiler, Tiemo Kieft, and
They are listed here because wiki history does not allow for any external attribution. If you edit the wiki article, please do not add yourself here; your contributions are recorded on each article's associated history page.