en to fr translation catalogue (143 entries)

note: type: Content of: <sect1><title>
en: Notes on Building Software
fr: Remarques sur la construction de logiciels

note: type: Content of: <sect1><para>
en: Those people who have built an LFS system may be aware of the general principles of downloading and unpacking software. Some of that information is repeated here for those new to building their own software.
fr: Celles et ceux qui ont construit un système LFS connaissent sans doute les principes généraux du téléchargement et de l'extraction de logiciel. Certaines de ces informations sont répétées ici pour les nouveaux qui construisent leurs propres logiciels.

note: type: Content of: <sect1><para>
en: Each set of installation instructions contains a URL from which you can download the package.  The patches; however, are stored on the LFS servers and are available via HTTP.  These are referenced as needed in the installation instructions.
fr: Chaque ensemble d'instructions d'installation contient une URL sur laquelle laquelle vous pouvez télécharger le paquet. Cependant, les correctifs sont enregistrés sur les serveurs LFS et disponibles via HTTP. Ces derniers sont référencés, si besoin, dans les instructions d'installation.

note: type: Content of: <sect1><para>
en: While you can keep the source files anywhere you like, we assume that you have unpacked the package and changed into the directory created by the unpacking process (the source directory).  We also assume you have uncompressed any required patches and they are in the directory immediately above the source directory.
fr: Même si vous pouvez placer les fichiers sources où vous voulez, nous supposons que vous avez extrait le paquet et êtes allé dans le répertoire créé par le processus de décompression (le répertoire des sources). Nous supposons aussi que vous avez décompressé les correctifs requis et qu'ils sont dans le répertoire directement au-dessus du répertoire des sources.

note: type: Content of: <sect1><para>
en: We can not emphasize strongly enough that you should start from a <emphasis>clean source tree</emphasis> each time. This means that if you have had an error during configuration or compilation, it's usually best to delete the source tree and re-unpack it <emphasis>before</emphasis> trying again. This obviously doesn't apply if you're an advanced user used to hacking <filename>Makefile</filename>s and C code, but if in doubt, start from a clean tree.
fr: Nous ne saurions que trop vous recommander de démarrer à partir d'une <emphasis>arborescence de sources propre</emphasis> à chaque fois.  Cela veut dire que si vous avez eu une erreur lors de la configuration ou de la compilation, il est généralement préférable de supprimer l'arborescence des sources et de l'extraire de nouveau <emphasis>avant</emphasis> de réessayer. Cela ne s'applique évidemment pas si vous êtes un utilisateur avancé habitué à modifier les <filename>Makefile</filename>s et le code C. Si vous avez un doute cependant, commencez à partir d'une arborescence propre.

note: type: Content of: <sect1><sect2><title>
en: Building Software as an Unprivileged (non-root) User
fr: Construction de logiciels en tant qu'utilisateur non privilégié (non root)

note: type: Content of: <sect1><sect2><para>
en: The golden rule of Unix System Administration is to use your superpowers only when necessary. Hence, BLFS recommends that you build software as an unprivileged user and only become the <systemitem class='username'>root</systemitem> user when installing the software. This philosophy is followed in all the packages in this book.  Unless otherwise specified, all instructions should be executed as an unprivileged user. The book will advise you on instructions that need <systemitem class='username'>root</systemitem> privileges.
fr: La règle d'or de l'administration d'un système Unix est de n'utiliser vos super-pouvoirs que si nécessaire. D'où la recommandation de BLFS de construire les logiciels en tant qu'utilisateur non privilégié et de ne devenir l'utilisateur <systemitem class='username'>root</systemitem> que lors de l'installation du logiciel. On suit cette philosophie dans tous les paquets de ce livre. Sauf spécifications contraires, toutes les instructions devraient être exécutées en tant qu'utilisateur non privilégié. Le livre vous conseillera sur les instructions qui ont besoin des privilèges <systemitem class='username'>root</systemitem>.

note: type: Content of: <sect1><sect2><title>
en: Unpacking the Software
fr: Décompresser le logiciel

note: type: Content of: <sect1><sect2><para>
en: If a file is in <filename class='extension'>.tar</filename> format and compressed, it is unpacked by running one of the following commands:
fr: S'il y a un fichier compressé au format <filename class='extension'>.tar</filename>, on le décompresse en utilisant une des commandes suivantes&nbsp;:

note: type: Content of: <sect1><sect2><note><para>
en: You may omit using the <option>v</option> parameter in the commands shown above and below if you wish to suppress the verbose listing of all the files in the archive as they are extracted. This can help speed up the extraction as well as make any errors produced during the extraction more obvious to you.
fr: Vous pouvez ne pas utiliser le paramètre <option>v</option> dans les commandes décrites ci-dessus et ci-dessous si vous souhaitez supprimer le listage verbeux de tous les fichiers de l'archive au fur et à mesure qu'ils sont extraits. Cela peut aider à accélérer l'extraction mais aussi rendre plus évidentes les erreurs produites durant le processus.

note: type: Content of: <sect1><sect2><para>
en: You can also use a slightly different method:
fr: Vous pouvez aussi utiliser une méthode légèrement différente&nbsp;:

note: type: Content of: <sect1><sect2><para>
en: Finally, sometimes we have a compressed patch file in <filename class='extension'>.patch.gz</filename> or <filename class='extension'>.patch.bz2</filename> format.  The best way to apply the patch is piping the output of the decompressor to the <command>patch</command> utility.  For example:
fr: Enfin, nous avons parfois un fichier de correctif compressé au format <filename class='extension'>.patch.gz</filename> ou <filename class='extension'>.patch.bz2</filename>. La meilleure manière d'applique le correctif est de passer la sortie du décompresseur à l'utilitaire <command>patch</command> via un pipe. Par exemple&nbsp;:

note: type: Content of: <sect1><sect2><para>
en: Or for a patch compressed with <command>bzip2</command>:
fr: Ou pour un correctif compressé avec <command>bzip2</command>&nbsp;:

note: type: Content of: <sect1><sect2><title>
en: Verifying File Integrity
fr: Vérifier l'intégrité des fichiers

note: type: Content of: <sect1><sect2><para>
en: Generally, to verify that the downloaded file is complete, many package maintainers also distribute md5sums of the files. To verify the md5sum of the downloaded files, download both the file and the corresponding md5sum file to the same directory (preferably from different on-line locations), and (assuming <filename>file.md5sum</filename> is the md5sum file downloaded) run the following command:
fr: En général, pour vérifier que le fichier téléchargé est complet, de nombreux mainteneurs de paquets distribuent aussi les sommes md5 des fichiers. Pour vérifier la somme md5 des fichiers téléchargés, téléchargez à la fois le fichier et le fichier md5sum correspondant dans le même répertoire (de préférence à partir d'emplacements différents en ligne)  et (en supposant que <filename>file.md5sum</filename> est le fichier md5sum téléchargé), lancez la commande suivante&nbsp;:

note: type: Content of: <sect1><sect2><para>
en: If there are any errors, they will be reported. Note that the BLFS book includes md5sums for all the source files also. To use the BLFS supplied md5sums, you can create a <filename>file.md5sum</filename> (place the md5sum data and the exact name of the downloaded file on the same line of a file, separated by white space) and run the command shown above.  Alternately, simply run the command shown below and compare the output to the md5sum data shown in the BLFS book.
fr: S'il y a une erreur, elle sera signalée. Remarquez que le livre BLFS contient aussi les sommes md5 de tous les fichiers sources. Pour utiliser les sommes md5 fournies par BLFS, vous pouvez créer un <filename>file.md5sum</filename> (mettez les données md5sum et le nom exact du fichier téléchargé sur la même ligne d'un fichier, séparés par un espace blanc), et lancez la commande montrée ci-dessus. Sinon, lancez simplement la commande décrite ci-dessus et comparez la sortie avec les données de somme md5 inscrites dans le livre BLFS.

note: type: Content of: <sect1><sect2><para>
en: MD5 is not cryptographically secure, so the md5sums are only provided for detecting unmalicious changes to the file content.  For example, an error or truncation introduced during network transfer, or a <quote>stealth</quote> update to the package from the upstream (updating the content of a released tarball instead of making a new release properly).
fr: Le MD5 n'est pas cryptographiquement sûr, donc les sommes md5 ne sont fournies que pour détecter des changements non intentionnels au contenu du fichier. Par exemple, une erreur ou troncation introduite pendant le transfert réseau, ou une mise à jour <quote>furtive</quote> du paquet en amont (mise à jour du contenu d'une archive publiée au lieu de créer directement une nouvelle version).

note: type: Content of: <sect1><sect2><para>
en: There is no <quote>100%</quote> secure way to make sure the genuity of the source files.  Assuming the upstream is managing their website correctly (the private key is not leaked and the domain is not hijacked), and the trust anchors have been set up correctly using <xref linkend="make-ca"/> on the BLFS system, we can reasonably trust download URLs to the upstream official website <emphasis role="bold">with https protocol</emphasis>.  Note that BLFS book itself is published on a website with https, so you should already have some confidence in https protocol or you wouldn't trust the book content.
fr: Il n'y a pas de manière sure à <quote>100 %</quote> pour s'assurer de l'authenticité des fichiers sources. En supposant que les développeurs en amont gèrent leur site correctement (la clé privée n'est pas communiquée et le domaine n'est pas usurpé), et que les ancres de confiance ont été correctement configurées avec <xref linkend="make-ca"/> sur le système BLFS, on peut raisonnablement faire confiance aux URL des site web officiels <emphasis role="bold">avec le protocole https</emphasis>. Remarquez que le livre BLFS lui-même est publié sur un site avec https, donc vous devez déjà avoir un peu confiance en le protocole https ou vous ne pourriez pas faire confiance au contenu de ce livre.

note: type: Content of: <sect1><sect2><para>
en: If the package is downloaded from an unofficial location (for example a local mirror), checksums generated by cryptographically secure digest algorithms (for example SHA256) can be used to verify the genuity of the package.  Download the checksum file from the upstream <emphasis role="bold">official</emphasis> website (or somewhere <emphasis role="bold">you can trust</emphasis>) and compare the checksum of the package from unofficial location with it.  For example, SHA256 checksum can be checked with the command:
fr: Si le paquet est téléchargé à partir d'un emplacement non officiel (par exemple un miroir local), vous pouvez utiliser des sommes de contrôles générées par un algorithme cryptographiquement sûr (par exemple SHA256) pour vérifier l'authenticité du paquet. Téléchargez le fichier de somme de contrôle depuis le site <emphasis role="bold">officiel</emphasis> des développeurs en amont (ou depuis un endroit <emphasis role="bold">auquel vous faites confiance</emphasis>) et comparez la somme de contrôle du paquet de l'emplacement non officiel. Par exemple, vous pouvez vérifier une somme de contrôle SHA256 avec la commande&nbsp;:

note: type: Content of: <sect1><sect2><note><para>
en: If the checksum and the package are downloaded from the same untrusted location, you won't gain security enhancement by verifying the package with the checksum. The attacker can fake the checksum as well as compromising the package itself.
fr: Si la somme de contrôle et le paquet sont téléchargés à partir de la même source non fiable, vous ne gagnerez rien à vérifier le paquet avec la somme de contrôle. L'attaquant peut présenter une fausse somme de contrôle en plus de compromettre le paquet en lui-même.

note: type: Content of: <sect1><sect2><para>
en: If <xref linkend="gnupg2"/> is installed, you can also verify the genuity of the package with a GPG signature.  Import the upstream GPG public key with:
fr: Si <xref linkend="gnupg2"/> est installé, vous pouvez aussi vérifier l'authenticité du paquet avec une signature GPG. Importez la clé publique GPG amont avec&nbsp;:

note: type: Content of: <sect1><sect2><para>
en: <replaceable>keyID</replaceable> should be replaced with the key ID from somewhere <emphasis role="bold">you can trust</emphasis> (for example, copy it from the upstream official website using https).  Now you can verify the signature with:
fr: <replaceable>keyID</replaceable> devrait être remplacée par l'identifiant de la clé fournie par un site <emphasis role="bold">fiable</emphasis> (par exemple, copiez-la depuis le site officiel en utilisant https). Maintenant vous pouvez vérifier la signature avec&nbsp;:

note: type: Content of: <sect1><sect2><para>
en: The advantage of <application>GnuPG</application> signature is, once you imported a public key which can be trusted, you can download both the package and its signature from the same unofficial location and verify them with the public key.  So you won't need to connect to the official upstream website to retrieve a checksum for each new release.  You only need to update the public key if it's expired or revoked.
fr: L'avantage de la signature <application>GnuPG</application> est que, une fois une clé publique de confiance importée, vous pouvez télécharger à la fois le paquet et sa signature à partir du même emplacement non officiel et les vérifier avec la clé publique. Donc vous n'avez pas besoin de vous connecter au site officiel en amont pour récupérer une somme de contrôle pour chaque nouvelle version. Vous n'aurez besoin de mettre à jour la clé publique que si elle est révoquée ou expirée.

note: type: Content of: <sect1><sect2><title>
en: Creating Log Files During Installation
fr: Créer des fichiers journaux pendant l'installation

note: type: Content of: <sect1><sect2><para>
en: For larger packages, it is convenient to create log files instead of staring at the screen hoping to catch a particular error or warning. Log files are also useful for debugging and keeping records. The following command allows you to create an installation log. Replace <replaceable>&lt;command&gt;</replaceable> with the command you intend to execute.
fr: Pour les gros paquets, il est commode de créer des fichiers journaux plutôt que de fixer indéfiniment l'écran en espérant trouver une erreur ou un avertissement particulier. Les fichiers journaux sont aussi utiles pour déboguer et garder des enregistrements. La commande suivante vous permet de créer un journal d'installation. Remplacez <replaceable>&lt;commande&gt;</replaceable> par la commande que vous cherchez à exécuter.

note: type: Content of: <sect1><sect2><para>
en: <option>2&gt;&amp;1</option> redirects error messages to the same location as standard output. The <command>tee</command> command allows viewing of the output while logging the results to a file. The parentheses around the command run the entire command in a subshell and finally the <command>exit $PIPESTATUS</command> command ensures the result of the <replaceable>&lt;command&gt;</replaceable> is returned as the result and not the result of the <command>tee</command> command.
fr: <option>2&gt;&amp;1</option> redirige les messages d'erreur vers le même endroit que la sortie standard. La commande <command>tee</command> vous permet de voir la sortie en journalisant les résultats dans un fichier. Les parenthèses autour de la commande exécutent toute la commande dans un sous-shell. Enfin, la commande <command>exit $PIPESTATUS</command> s'assure que c'est bien le résultat de <replaceable>&lt;commande&gt;</replaceable> qui est retourné et pas le résultat de la commande <command>tee</command>.

note: type: Content of: <sect1><sect2><title>
en: Using Multiple Processors
fr: Utilisation de processeurs multiples

note: type: Content of: <sect1><sect2><para>
en: For many modern systems with multiple processors (or cores) the compilation time for a package can be reduced by performing a "parallel make" by either setting an environment variable or telling the make program to simultaneously execute multiple jobs.
fr: Pour la plupart des systèmes modernes avec des processeurs multiples (ou cœurs) le temps de compilation pour un paquet peut être réduit en effectuant une «&nbsp;construction parallèle&nbsp;» soit en initialisant une variable d'environnement, soit en disant au programme make d'exécuter plusieurs tâches en même temps.

note: type: Content of: <sect1><sect2><para>
en: For instance, an Intel Core i9-13900K CPU contains 8 performance (P) cores and 16 efficiency (E) cores, and the P cores support SMT (Simultaneous MultiThreading, also known as <quote>Hyper-Threading</quote>) so each P core can run two threads simultaneously and the Linux kernel will treat each P core as two logical cores.  As the result, there are 32 logical cores in total.  To utilize all these logical cores running <command>make</command>, we can set an environment variable to tell <command>make</command> to run 32 jobs simultaneously:
fr: Par exemple, un CPU Intel Core i9-13900K contient 8 cœurs performants (P) et 16 cœurs efficaces (E). Les cœurs P prennent en charge SMT (Simultaneous MultiThreading, aussi appelé <quote>Hyper-Threading</quote>) donc chaque cœur P peut exécuter deux tâches en même temps et le noyau Linux traitera chaque cœur P comme deux cœurs logiques. En conséquence, il y a 32 cœurs logiques en tout. Pour utiliser tous ces cœurs logiques en exécutant <command>make</command>, il est possible de configurer une variable d'environnement pour dire à <command>make</command> d'exécuter 32 tâches en parallèle&nbsp;:

note: type: Content of: <sect1><sect2><para>
en: or just building with:
fr: ou en compilant simplement avec&nbsp;:

note: type: Content of: <sect1><sect2><para>
en: If you have applied the optional <command>sed</command> when building <application>ninja</application> in LFS, you can use:
fr: Si vous avez appliqué le <command>sed</command> facultatif pendant la construction de <application>ninja</application> dans LFS, vous pouvez utiliser&nbsp;:

note: type: Content of: <sect1><sect2><para>
en: when a package uses <command>ninja</command>, or just:
fr: quand un paquet utilise <command>ninja</command>, ou simplement&nbsp;:

note: type: Content of: <sect1><sect2><para>
en: If you are not sure about the number of logical cores, run the <command>nproc</command> command.
fr: Si vous n'êtes pas sûr de connaître le nombre de cœurs logiques, exécutez la commande <command>nproc</command>.

note: type: Content of: <sect1><sect2><para>
en: For <command>make</command>, the default number of jobs is 1.  But for <command>ninja</command>, the default number of jobs is N + 2 if the number of logical cores N is greater than 2; or N + 1 if N is 1 or 2.  The reason to use a number of jobs slightly greater than the number of logical cores is keeping all logical processors busy even if some jobs are performing I/O operations.
fr: Pour <command>make</command>, le nombre de tâches par défaut est 1. Mais pour <command>ninja</command>, le nombre de travaux par défaut est N + 2, si le nombre de cœurs logiques N est plus grand que 2. Sinon, N + 1 si N vaut 1 ou 2. La raison pour laquelle cet outil utilise un nombre de tâches plus grand que le nombre de cœurs logiques est de faire travailler tous les processeurs logiques même si certaines tâches effectuent des opérations mémoires.

note: type: Content of: <sect1><sect2><para>
en: Note that the <option>-j</option> switches only limits the parallel jobs started by <command>make</command> or <command>ninja</command>, but each job may still spawn its own processes or threads.  For example, <command>ld.gold</command> will use multiple threads for linking, and some tests of packages can spawn multiple threads for testing thread safety properties.  There is no generic way for the building system to know the number of processes or threads spawned by a job. So generally we should not consider the value passed with <option>-j</option> a hard limit of the number of logical cores to use.  Read <xref linkend='build-in-cgroup'/> if you want to set such a hard limit.
fr: Remarquez que les options <option>-j</option> ne limitent que les tâche parallèles démarrées par <command>make</command> ou <command>ninja</command>, mais chaque tâche peut encore générer ses propres processus ou threads. Par exemple, <command>ld.gold</command> utilisera plusieurs threads pour l'édition des liens, et certains tests des paquets peuvent créer plusieurs threads pour tester les propriétés de sûreté en parallèle. Il n'y a pas de manière générique pour un système de construction de connaître le nombre de processus ou de threads générés par une tâche. En général, il ne faut pas considérer la valeur passée avec <option>-j</option> comme une limite en dur sur le nombre de cœurs logiques à utiliser. Consultez <xref linkend='build-in-cgroup'/> si vous voulez mettre en place ce genre de limite.

note: type: Content of: <sect1><sect2><para>
en: Generally the number of processes should not exceed the number of cores supported by the CPU too much.  To list the processors on your system, issue: <userinput>grep processor /proc/cpuinfo</userinput>.
fr: Généralement le nombre de processus ne doit pas trop dépasser le nombre de cœurs supportés par le CPU. Pour lister les processeurs de votre système, tapez&nbsp;: <userinput>grep processor /proc/cpuinfo</userinput>.

note: type: Content of: <sect1><sect2><para>
en: In some cases, using multiple processes may result in a race condition where the success of the build depends on the order of the commands run by the <command>make</command> program.  For instance, if an executable needs File A and File B, attempting to link the program before one of the dependent components is available will result in a failure.  This condition usually arises because the upstream developer has not properly designated all the prerequisites needed to accomplish a step in the Makefile.
fr: Dans certains cas, l'utilisation de processeurs multiples peut amener dans une situation de compétition où le succès de la construction dépend de l'ordre des commandes lancées par le programme <command>make</command>. Par exemple, si un exécutable demande un fichier A et un fichier B, essayer de lier le programme avant qu'un des composants dépendants ne soit disponible aboutira à un échec.  Cela arrive en général quand les développeurs n'ont pas correctement désigné tous les prérequis utiles pour accomplir une étape du Makefile.

note: type: Content of: <sect1><sect2><para>
en: If this occurs, the best way to proceed is to drop back to a single processor build.  Adding <option>-j1</option> to a make command will override the similar setting in the <envar>MAKEFLAGS</envar> environment variable.
fr: Si cela arrive, la meilleure chose à faire est de recommencer la construction avec un seul processeur. En ajoutant <option>-j1</option> à une commande make, cela écrasera l'initialisation similaire dans une variable d'environnement <envar>MAKEFLAGS</envar>.

note: type: Content of: <sect1><sect2><important><para>
en: Another problem may occur with modern CPU's, which have a lot of cores.  Each job started consumes memory, and if the sum of the needed memory for each job exceeds the available memory, you may encounter either an OOM (Out of Memory) kernel interrupt or intense swapping that will slow the build beyond reasonable limits.
fr: Un autre problème peut survenir avec les CPU modernes avec beaucoup de cœurs. Chaque tâche démarrée consomme de la mémoire, et si la somme de la mémoire requise par chaque tâche dépasse la quantité de mémoire disponible, vous aurez soit une interruption noyau OOM (plus de mémoire) ou une utilisation de l'espace d'échange qui ralentira excessivement la construction.

note: type: Content of: <sect1><sect2><important><para>
en: Some compilations with <command>g++</command> may consume up to 2.5 GB of memory, so to be safe, you should restrict the number of jobs to (Total Memory in GB)/2.5, at least for big packages such as LLVM, WebKitGtk, QtWebEngine, or libreoffice.
fr: Comme certaines compilation avec <command>g++</command> peuvent consommer jusqu'à 2,5 Go de mémoire, pour être sûr, vous devriez restreindre le nombre de tâches à (mémoire totale en Go)/2,5, au moins pour les gros paquets comme LLVM, WebKitGtk, QtWebEngine ou libreoffice.

note: type: Content of: <sect1><sect2><title>
en: Use Linux Control Group to Limit the Resource Usage
fr: Utiliser les groups de contrôle Linux pour limiter l'utilisation des ressources

note: type: Content of: <sect1><sect2><para>
en: Sometimes we want to limit the resource usage when we build a package.  For example, when we have 8 logical cores, we may want to use only 6 cores for building the package and reserve another 2 cores for playing a movie.  The Linux kernel provides a feature called control groups (cgroup) for such a need.
fr: Parfois nous voulons limiter l'utilisation des ressources lors de la construction d'un paquet. Par exemple, lorsqu'on a 8 cœurs logiques, nous pourrions vouloir utiliser seulement 6 cœurs pour construire le paquet et réserver les deux autres cœurs à la lecture d'un film. Le noyau Linux fournit une fonctionnalité appelée les groupes de contrôle (cgroup) pour ce besoin.

note: type: Content of: <sect1><sect2><para>
en: Enable control group in the kernel configuration, then rebuild the kernel and reboot if necessary:
fr: Activez les groupes de contrôle dans la configuration du noyau, puis reconstruisez le noyau et redémarrez si nécessaire&nbsp;:

note: type: Content of: <sect1><sect2><para>
en: Ensure <xref linkend='systemd'/> and <xref linkend='shadow'/> have been rebuilt with <xref linkend='linux-pam'/> support (if you are interacting via a SSH or graphical session, also ensure the <xref linkend='openssh'/> server or the desktop manager has been built with <xref linkend='linux-pam'/>).  As the &root; user, create a configuration file to allow resource control without &root; privilege, and instruct <command>systemd</command> to reload the configuration:
fr: Assurez-vous que <xref linkend='systemd'/> et <xref linkend='shadow'/> ont été reconstruits avec la prise en charge de <xref linkend='linux-pam'/> (si vous interagissez à travers une session SSH ou graphique, assurez-vous également que le serveur <xref linkend='openssh'/> ou le gestionnaire de bureau a été construit avec <xref linkend='linux-pam'/>). En tant qu'utilisateur &root;, créez un fichier de configuration pour permettre le contrôle des ressources sans privilège &root;, et dites à <command>systemd</command> de recharger la configuration&nbsp;:

note: type: Content of: <sect1><sect2><para>
en: Then logout and login again.  Now to run <command>make -j5</command> with the first 4 logical cores and 8 GB of system memory, issue:
fr: Ensuite, déconnectez-vous et reconnectez-vous. Maintenant pour exécuter <command>make -j5</command> avec les 4 premiers cœurs logiques et 8&nbsp;Go de mémoire système, exécutez&nbsp;:

note: type: Content of: <sect1><sect2><para>
en: Ensure <xref linkend='sudo'/> is installed.  To run <command>make -j5</command> with the first 4 logical cores and 8 GB of system memory, issue:
fr: Assurez-vous que <xref linkend='sudo'/> est installé. Pour exécuter <command>make -j5</command> avec les 4 premiers cœurs logiques et 8&nbsp;Go de mémoire système, exécutez&nbsp;:

note: type: Content of: <sect1><sect2><para>
en: With <phrase revision='systemd'> <parameter>MemoryHigh=8G</parameter> </phrase> <phrase revision='sysv'> <literal>8589934592</literal> (the output of <userinput>bc -e '8*2^30'</userinput>, 2^30 represents 2<superscript>30</superscript>, i.e. a Gigabyte) in the <filename>memory.high</filename> entry </phrase>, a soft limit of memory usage is set.  If the processes in the cgroup (<command>make</command> and all the descendants of it) uses more than 8 GB of system memory in total, the kernel will throttle down the processes and try to reclaim the system memory from them.  But they can still use more than 8 GB of system memory.  If you want to make a hard limit instead, replace <phrase revision='systemd'> <parameter>MemoryHigh</parameter> with <parameter>MemoryMax</parameter>.  </phrase> <phrase revision='sysv'> <filename>memory.high</filename> with <filename>memory.max</filename>.  </phrase> But doing so will cause the processes killed if 8 GB is not enough for them.
fr: Avec <phrase revision='systemd'><parameter>MemoryHigh=8G</parameter></phrase><phrase revision='sysv'><literal>8589934592</literal> (la sortie de <userinput>bc -e '8*2^30'</userinput>, 2^30 représentant 2<superscript>30</superscript>, c.-à-d. un gigaoctet) dans l'entrée <filename>memory.high</filename></phrase>, une limite souple pour l'utilisation de la mémoire est mise en place. Si les processus du cgroup (<command>make</command> et tous ses descendants) utilisent plus de 8&nbsp;Go de mémoire système en tout, le noyau va les ralentir et essayer de récupérer la mémoire système qui leur a alloué. Mais ils peuvent toujours utiliser plus de 8&nbsp;Go de mémoire système. Si vous voulez plutôt donner une limite nette, remplacez <phrase revision='systemd'><parameter>MemoryHigh</parameter> par <parameter>MemoryMax</parameter>.</phrase><phrase revision='sysv'><filename>memory.high</filename> par <filename>memory.max</filename>.</phrase> Mais cela fera tuer les processus si 8&nbsp;Go n'est pas suffisant pour eux.

note: type: Content of: <sect1><sect2><para>
en: <phrase revision='systemd'> <parameter>AllowedCPUs=0-3</parameter> </phrase> <phrase revision='sysv'> <literal>0-3</literal> in the <filename>cpuset.cpus</filename> entry </phrase> makes the kernel only run the processes in the cgroup on the logical cores with numbers 0, 1, 2, or 3.  You may need to adjust this setting based the mapping between the logical cores and the physical cores.  For example, with an Intel Core i9-13900K CPU, the logical cores 0, 2, 4, ..., 14 are mapped to the first threads of the eight physical P cores, the logical cores 1, 3, 5, ..., 15 are mapped to the second threads of the physical P cores, and the logical cores 16, 17, ..., 31 are mapped to the 16 physical E cores.  So if we want to use four threads from four different P cores, we need to specify <literal>0,2,4,6</literal> instead of <literal>0-3</literal>.  Note that the other CPU models may use a different mapping scheme.  If you are not sure about the mapping between the logical cores and the physical cores, run <command>grep -E '^processor|^core' /proc/cpuinfo</command> which will output logical core IDs in the <computeroutput>processor</computeroutput> lines, and physical core IDs in the <computeroutput>core id</computeroutput> lines.
fr: <phrase revision='systemd'><parameter>AllowedCPUs=0-3</parameter></phrase><phrase revision='sysv'><literal>0-3</literal> dans l'entrée <filename>cpuset.cpus</filename></phrase> fait en sorte que le noyau ne lance les processus dans le cgroup que sur les cœurs logiques avec les numéros 0, 1, 2 ou 3. Vous aurez peut-être besoin d'ajuster ce paramètre en fonction de la correspondance entre les cœurs logiques et physiques. Par exemple, avec un CPU Intel Core i9-13900K, les cœurs logiques 0, 2, 4, …, 14 correspondent au premier thread des huit cœurs physiques P, les cœurs logiques 1, 3, 5, …, 15 correspondent au second thread des cœurs physiques P, et les cœurs logiques 16, 17, …, 31 correspondent aux cœurs physiques E. Donc si vous voulez utiliser quatre threads de différents cœurs P, nous devons spécifier <literal>0,2,4,6</literal> au lieu de <literal>0-3</literal>. Remarquez que les autres modèles de CPU peuvent avoir une autre correspondance. Si vous ne connaissez pas la correspondance entre cœurs logiques et physiques, exécutez <command>grep -E '^processor|^core' /proc/cpuinfo</command> qui affichera les ID de cœurs logique dans les lignes <computeroutput>processor</computeroutput> et les ID de cœurs physiques dans les lignes <computeroutput>core id</computeroutput>.

note: type: Content of: <sect1><sect2><para>
en: When the <command>nproc</command> or <command>ninja</command> command runs in a cgroup, it will use the number of logical cores assigned to the cgroup as the <quote>system logical core count</quote>.  For example, in a cgroup with logical cores 0-3 assigned, <command>nproc</command> will print <computeroutput>4</computeroutput>, and <command>ninja</command> will run 6 (4 + 2) jobs simultaneously if no <option>-j</option> setting is explicitly given.
fr: Lorsque la commande <command>nproc</command> ou <command>ninja</command> est exécutée dans un cgroup, elle utilisera le nombre de cœurs logiques assignés au cgroup comme <quote>nombre de cœurs logiques du système</quote>. Par exemple, dans un cgroup avec les cœurs logiques 0-3 assignés, <command>nproc</command> affichera <computeroutput>4</computeroutput> et <command>ninja</command> exécutera 6 (4 + 2) tâche simultanées sans option <option>-j</option> explicite.

note: type: Content of: <sect1><sect2><para>
en: Read the man pages <ulink role='man' url='&man;systemd-run.1'>systemd-run(1)</ulink> and <ulink role='man' url='&man;systemd.resource-control.5'>systemd.resource-control(5)</ulink> for the detailed explanation of parameters in the command.
fr: Consultez les pages de manuel <ulink role='man' url='&man;systemd-run.1'>systemd-run(1)</ulink> et <ulink role='man' url='&man;systemd.resource-control.5'>systemd.resource-control(5)</ulink> pour des explications détaillées des paramètre de la commande.

note: type: Content of: <sect1><sect2><para>
en: Read the <filename>Documentation/admin-guide/cgroup-v2.rst</filename> file in the Linux kernel source tree for the detailed explanation of <systemitem class="filesystem">cgroup2</systemitem> pseudo file system entries referred in the command.
fr: Consultez le fichier <filename>Documentation/admin-guide/cgroup-v2.rst</filename> dans les sources du noyau Linux pour des explications détaillées sur les entrées pseudo-système de fichiers <systemitem class="filesystem">cgroup2</systemitem> auxquelles la commande se réfère.

note: type: Content of: <sect1><sect2><title>
en: Automated Building Procedures
fr: Procédures de construction automatique

note: type: Content of: <sect1><sect2><para>
en: There are times when automating the building of a package can come in handy. Everyone has their own reasons for wanting to automate building, and everyone goes about it in their own way. Creating <filename>Makefile</filename>s, <application>Bash</application> scripts, <application>Perl</application> scripts or simply a list of commands used to cut and paste are just some of the methods you can use to automate building BLFS packages. Detailing how and providing examples of the many ways you can automate the building of packages is beyond the scope of this section. This section will expose you to using file redirection and the <command>yes</command> command to help provide ideas on how to automate your builds.
fr: Automatiser la construction d'un paquet peut parfois s'avérer utile. On a tous des raisons différentes pour automatiser la construction, et on le fait par nos propres moyens. Soit en créant des <filename>Makefile</filename>s, des scripts <application>Bash</application>, des scripts <application>Perl</application> ou simplement une liste de commandes utilisées à copier-coller. Ce sont toutes des méthodes que vous pouvez utiliser pour automatiser la construction de paquets BLFS. Détailler et donner des exemples sur les nombreuses manières d'automatiser la construction de paquets va au-delà des objectifs de cette section. Cette section vous présentera l'utilisation de la redirection de fichiers et de la commande <command>yes</command> pour vous donner des idées sur la façon d'automatiser vos constructions.

note: type: Content of: <sect1><sect2><bridgehead>
en: File Redirection to Automate Input
fr: Redirection de fichier pour automatiser l'entrée

note: type: Content of: <sect1><sect2><para>
en: You will find times throughout your BLFS journey when you will come across a package that has a command prompting you for information. This information might be configuration details, a directory path, or a response to a license agreement. This can present a challenge to automate the building of that package. Occasionally, you will be prompted for different information in a series of questions. One method to automate this type of scenario requires putting the desired responses in a file and using redirection so that the program uses the data in the file as the answers to the questions.
fr: Il y aura des moments, tout au long de votre aventure BLFS, où vous tomberez sur un paquet ayant une invite de commande vous demandant des informations. Ces informations peuvent être des détails de configuration, un chemin de répertoire ou une réponse à un accord de licence. Cela peut être un challenge pour automatiser la construction de ce paquet. On vous demandera occasionnellement différentes informations via une série de questions. Une méthode pour automatiser ce type de scénario est de mettre les réponses désirées dans un fichier et d'utiliser la redirection pour que le programme utilise les données du fichier comme réponses aux questions.

note: type: Content of: <sect1><sect2><para>
en: This effectively makes the test suite use the responses in the file as the input to the questions. Occasionally you may end up doing a bit of trial and error determining the exact format of your input file for some things, but once figured out and documented you can use this to automate building the package.
fr: Cela fait logiquement utilise les réponses du fichier comme entrée pour les questions de la suite de tests. Vous aurez parfois à faire des séries d'essais et erreurs pour déterminer le format exact de votre fichier d'entrée pour certaines choses, mais une fois expérimenté et documenté, vous pouvez utiliser cela pour automatiser la construction du paquet.

note: type: Content of: <sect1><sect2><bridgehead>
en: Using <command>yes</command> to Automate Input
fr: Utiliser <command>yes</command> pour automatiser l'entrée

note: type: Content of: <sect1><sect2><para>
en: Sometimes you will only need to provide one response, or provide the same response to many prompts. For these instances, the <command>yes</command> command works really well. The <command>yes</command> command can be used to provide a response (the same one) to one or more instances of questions. It can be used to simulate pressing just the <keycap>Enter</keycap> key, entering the <keycap>Y</keycap> key or entering a string of text. Perhaps the easiest way to show its use is in an example.
fr: Vous n'aurez parfois besoin de ne fournir qu'une réponse ou alors la même réponse à de nombreuses invites. Dans ces cas-là, la commande <command>yes</command> fonctionne vraiment bien.  On peut utiliser la commande <command>yes</command> pour fournir une réponse (la même) à une ou plusieurs questions. On peut l'utiliser pour simuler un simple appui sur la touche <keycap>Entrée</keycap>, l'entrée de la touche <keycap>Y</keycap> ou l'entrée d'une chaîne de texte. La manière la plus facile de montrer son utilisation est peut-être de prendre un exemple.

note: type: Content of: <sect1><sect2><para>
en: First, create a short <application>Bash</application> script by entering the following commands:
fr: Créez tout d'abord un petit script <application>Bash</application> en entrant les commandes suivantes&nbsp;:

note: type: Content of: <sect1><sect2><para>
en: Now run the script by issuing <command>./blfs-yes-test1</command> from the command line. It will wait for a response, which can be anything (or nothing) followed by the <keycap>Enter</keycap> key. After entering something, the result will be echoed to the screen. Now use the <command>yes</command> command to automate the entering of a response:
fr: Maintenant, lancez le script en exécutant <command>./blfs-yes-test1</command> depuis la ligne de commande. Il attendra une réponse, qui peut être n'importe quoi (ou rien) suivi de la touche <keycap>Entrée</keycap>. Après avoir entré quelque chose, le résultat sera affiché à l'écran. Utilisez maintenant la commande <command>yes</command> pour automatiser l'entrée d'une réponse&nbsp;:

note: type: Content of: <sect1><sect2><para>
en: Notice that piping <command>yes</command> by itself to the script results in <keycap>y</keycap> being passed to the script. Now try it with a string of text:
fr: Remarquez que la redirection (le piping) de <command>yes</command> en lui-même vers le script aboutit à ce que <keycap>y</keycap> est passé au script. Essayez-la maintenant avec une chaîne de texte&nbsp;:

note: type: Content of: <sect1><sect2><para>
en: The exact string was used as the response to the script. Finally, try it using an empty (null) string:
fr: La chaîne exacte était utilisée comme réponse au script. Enfin, essayez-la en utilisant une chaîne vide (null)&nbsp;:

note: type: Content of: <sect1><sect2><para>
en: Notice this results in passing just the press of the <keycap>Enter</keycap> key to the script. This is useful for times when the default answer to the prompt is sufficient. This syntax is used in the <xref linkend="net-tools-automate-example"/> instructions to accept all the defaults to the many prompts during the configuration step. You may now remove the test script, if desired.
fr: Remarquez que cela aboutit à ne passer au script que l'appui sur la touche <keycap>Entrée</keycap>. C'est utile parfois quand la réponse par défaut à l'invite est suffisante. Cette syntaxe est utilisée dans les instructions de <xref linkend="net-tools-automate-example"/> pour accepter tous les réglages par défaut à toutes les invites lors de l'étape de configuration.  Vous pouvez maintenant supprimer le script de test si vous le désirez.

note: type: Content of: <sect1><sect2><bridgehead>
en: File Redirection to Automate Output
fr: Redirection de fichiers pour automatiser la sortie

note: type: Content of: <sect1><sect2><para>
en: In order to automate the building of some packages, especially those that require you to read a license agreement one page at a time, requires using a method that avoids having to press a key to display each page.  Redirecting the output to a file can be used in these instances to assist with the automation. The previous section on this page touched on creating log files of the build output. The redirection method shown there used the <command>tee</command> command to redirect output to a file while also displaying the output to the screen. Here, the output will only be sent to a file.
fr: Pour automatiser la construction de certains paquets, surtout ceux qui vous demandent de lire un accord de licence page après page, il faut utiliser une méthode qui évite de devoir appuyer sur une touche pour afficher chaque page. On peut utiliser la redirection de sortie vers un fichier dans ce cas-là pour vous aider à automatiser. La section précédente de cette page a visé à créer des fichiers journaux de la sortie de la construction.  La méthode de redirection qui y est décrite utilisait la commande <command>tee</command> pour rediriger la sortie tout en affichant aussi la sortie à l'écran. Ici on ne verra la sortie que dans un fichier.

note: type: Content of: <sect1><sect2><para>
en: Again, the easiest way to demonstrate the technique is to show an example. First, issue the command:
fr: De nouveau, la manière la plus facile de montrer la technique est de présenter un exemple. Lancez d'abord la commande&nbsp;:

note: type: Content of: <sect1><sect2><para>
en: Of course, you'll be required to view the output one page at a time because the <command>less</command> filter was used. Now try the same command, but this time redirect the output to a file. The special file <filename>/dev/null</filename> can be used instead of the filename shown, but you will have no log file to examine:
fr: Bien entendu, vous devrez voir la sortie page par page car on a utilisé le filtre <command>less</command>. Essayez maintenant la même commande, mais en redirigeant cette fois la sortie vers un fichier. Le fichier spécial <filename>/dev/null</filename> peut être utilisé à la place du fichier indiqué, mais vous n'aurez pas de fichier journal à examiner&nbsp;:

note: type: Content of: <sect1><sect2><para>
en: Notice that this time the command immediately returned to the shell prompt without having to page through the output. You may now remove the log file.
fr: Vous remarquerez que cette fois, la commande est immédiatement revenue à l'invite du shell sans devoir parcourir la sortie page par page. Vous pouvez maintenant supprimer le fichier journal.

note: type: Content of: <sect1><sect2><para>
en: The last example will use the <command>yes</command> command in combination with output redirection to bypass having to page through the output and then provide a <keycap>y</keycap> to a prompt. This technique could be used in instances when otherwise you would have to page through the output of a file (such as a license agreement) and then answer the question of <quote>do you accept the above?</quote>. For this example, another short <application>Bash</application> script is required:
fr: Le dernier exemple utilisera la commande <command>yes</command> associée à la redirection de sortie pour éviter de naviguer page par page dans la sortie, puis de fournir un <keycap>y</keycap> à l'invite. Cette technique peut être utilisée dans les cas où vous devriez, sans elle, naviguer page par page dans la sortie d'un fichier (tel qu'un accord de licence), puis répondre à la question <quote>Acceptez-vous ce qui précède&nbsp;?</quote>.  Pour cet exemple, on a besoin d'un autre petit script <application>Bash</application>&nbsp;:

note: type: Content of: <sect1><sect2><para>
en: This script can be used to simulate a program that requires you to read a license agreement, then respond appropriately to accept the agreement before the program will install anything. First, run the script without any automation techniques by issuing <command>./blfs-yes-test2</command>.
fr: On peut utiliser ce script pour simuler un programme qui demande que vous lisiez un accord de licence et que vous acceptiez le contrat avant que le programme n'installe quoique ce soit. Lancez d'abord le script sans techniques d'automatisation en exécutant <command>./blfs-yes-test2</command>.

note: type: Content of: <sect1><sect2><para>
en: Now issue the following command which uses two automation techniques, making it suitable for use in an automated build script:
fr: Maintenant lancez la commande suivante qui utilise deux techniques d'automatisation, rendant l'utilisation convenable dans un script de construction automatisé&nbsp;:

note: type: Content of: <sect1><sect2><para>
en: If desired, issue <command>tail blfs-yes-test2.log</command> to see the end of the paged output, and confirmation that <keycap>y</keycap> was passed through to the script. Once satisfied that it works as it should, you may remove the script and log file.
fr: Si vous le désirez, lancez <command>tail blfs-yes-test2.log</command> pour voir la fin de la sortie paginée et la confirmation que <keycap>y</keycap> a été passé au script. Une fois que cela marche comme cela devrait, vous pouvez supprimer le script et le fichier journal.

note: type: Content of: <sect1><sect2><para>
en: Finally, keep in mind that there are many ways to automate and/or script the build commands. There is not a single <quote>correct</quote> way to do it. Your imagination is the only limit.
fr: Enfin, gardez à l'esprit qu'il y a de nombreux moyens d'automatiser ou de scripter les commandes de construction. Il n'y a pas <quote>une seule</quote> manière de procéder. Votre imagination est la seule limite.

note: type: Content of: <sect1><sect2><title>
en: Dependencies
fr: Dépendances

note: type: Content of: <sect1><sect2><para>
en: For each package described, BLFS lists the known dependencies.  These are listed under several headings, whose meaning is as follows:
fr: Pour chaque paquet décrit, BLFS liste les dépendances connues. Elles sont listées sous plusieurs en-têtes, dont la signification est la suivante&nbsp;:

note: type: Content of: <sect1><sect2><itemizedlist><listitem><para>
en: <emphasis>Required</emphasis> means that the target package cannot be correctly built without the dependency having first been installed, except if the dependency is said to be <quote>runtime</quote>, which means the target package can be built but cannot function without it.
fr: <emphasis>Requis</emphasis> signifie que le paquet cible ne peut pas se construire correctement sans avoir d'abord installé la dépendance, sauf si la dépendance est dite <quote>à l'exécution</quote>, ce qui signifie que le paquet cible peut être construit mais ne peut pas fonctionner sans elle.

note: type: Content of: <sect1><sect2><itemizedlist><listitem><para>
en: Note that a target package can start to <quote>function</quote> in many subtle ways: an installed configuration file can make the init system, cron daemon, or bus daemon to run a program automatically; another package using the target package as an dependency can run a program from the target package in the building system; and the configuration sections in the BLFS book may also run a program from a just installed package.  So if you are installing the target package without a <emphasis>Required (runtime)</emphasis> dependency installed, You should install the dependency as soon as possible after the installation of the target package.
fr: Remarquez qu'un paquet cible peut commencer à <quote>fonctionner</quote> de plusieurs manières subtiles&nbsp;: un fichier de configuration installé peut le faire exécuter au système d'initialisation, au démon cron ou au démon de bus automatiquement. Ou bien un autre paquet qui utilise le paquet cible en dépendance peut exécuter le programme du paquet cible dans son système de construction. Ou encore, les sections de configuration du livre BLFS peuvent également exécuter un problème du paquet tout juste installé. Si vous installez le paquet cible sans un dépendance <emphasis>Requise (à l'exécution)</emphasis>, vous devriez installer la dépendance aussi vite que possible après l'installation du paquet cible.

note: type: Content of: <sect1><sect2><itemizedlist><listitem><para>
en: <emphasis>Recommended</emphasis> means that BLFS strongly suggests this package is installed first (except if said to be <quote>runtime</quote>, see below) for a clean and trouble-free build, that won't have issues either during the build process, or at run-time.  The instructions in the book assume these packages are installed.  Some changes or workarounds may be required if these packages are not installed. If a recommended dependency is said to be <quote>runtime</quote>, it means that BLFS strongly suggests that this dependency is installed before using the package, for getting full functionality.
fr: <emphasis>Recommandées</emphasis> signifie que BLFS suggère fortement d'installer préalablement ce paquet (sauf si elle est dite <quote>à l'exécution</quote>, voir plus bas) pour une construction propre et sans problème, ni pendant le processus de construction ni au moment de l'exécution. Les instructions dans le livre considèrent que ces paquets sont installés. Des modifications ou contournements peuvent être requis si ces paquets ne sont pas installés. Si une dépendance recommandée est dite <quote>à l'exécution</quote>, cela signifie que BLFS suggère fortement d'installer cette dépendance avant d'utiliser le paquet, pour avoir toutes les fonctionnalités.

note: type: Content of: <sect1><sect2><itemizedlist><listitem><para>
en: <emphasis>Optional</emphasis> means that this package might be installed for added functionality. Often BLFS will describe the dependency to explain the added functionality that will result.  An optional dependency may be automatically pick up by the target package if the dependency is installed, but another some optional dependency may also need additional configuration options to enable them when the target package is built.  Such additional options are often documented in the BLFS book.  If an optional dependency is said to be <quote>runtime</quote>, it means you may install the dependency after installing the target package to support some optional features of the target package if you need these features.
fr: <emphasis>Facultatives</emphasis> signifie que ce paquet peut être installé pour ajouter une fonctionnalité. Souvent BLFS décrira la dépendance pour expliquer la fonctionnalité ajoutée. Une dépendance facultative peut être automatiquement trouvée par le paquet cible si la dépendance est installée, mais d'autres dépendances facultatives peuvent également nécessiter des options de configuration supplémentaires pour les activer à la construction du paquet cible. Ces options seront documentées dans le livre BLFS. Si un dépendance facultative est dite <quote>à l'exécution</quote>, cela signifie que vous pouvez installer la dépendance après l'installation du paquet cible pour prendre en charge des fonctionnalités facultatives du paquet cible si vous en avez besoin.

note: type: Content of: <sect1><sect2><itemizedlist><listitem><para>
en: An optional dependency may be out of BLFS.  If you need such an <emphasis>external</emphasis> optional dependency for some features you need, read <xref linkend='beyond'/> for the general hint about installing an out-of-BLFS package.
fr: Une dépendance facultative peut se trouver en dehors de BLFS. Si vous avez besoin d'une dépendance facultative <emphasis>externe</emphasis> pour des fonctionnalités, consultez <xref linkend='beyond'/> pour trouver l'aide générique sur l'installation des paquets en dehors de BLFS.

note: type: Content of: <sect1><sect2><title>
en: Using the Most Current Package Sources
fr: Utilisation de paquets sources les plus récents

note: type: Content of: <sect1><sect2><para>
en: On occasion you may run into a situation in the book when a package will not build or work properly. Though the Editors attempt to ensure that every package in the book builds and works properly, sometimes a package has been overlooked or was not tested with this particular version of BLFS.
fr: Il peut arriver occasionnellement qu'un paquet ne se construise pas ou ne fonctionne pas correctement dans le livre. Bien que les éditeurs tentent de faire en sorte que chaque paquet dans le livre se construise et fonctionne correctement, il arrive parfois qu'un paquet ait été oublié ou n'ait pas été testé avec cette version particulière de BLFS.

note: type: Content of: <sect1><sect2><para>
en: If you discover that a package will not build or work properly, you should see if there is a more current version of the package. Typically this means you go to the maintainer's web site and download the most current tarball and attempt to build the package. If you cannot determine the maintainer's web site by looking at the download URLs, use Google and query the package's name. For example, in the Google search bar type: 'package_name download' (omit the quotes) or something similar. Sometimes typing: 'package_name home page' will result in you finding the maintainer's web site.
fr: Si vous découvrez un paquet qui ne se construit pas ou ne fonctionne pas correctement, vous pouvez regarder s'il s'agit de la version la plus récente du paquet. En général, cela signifie que vous devez vous rendre sur le site web du responsable, télécharger l'archive la plus récente et tenter de construire le paquet. Si vous ne pouvez pas déterminer le site web du responsable en regardant l'URL de chargement, utilisez Google et cherchez le nom du paquet. Par exemple, dans la barre de recherche de Google tapez&nbsp;: «&nbsp;nom_du_paquet download&nbsp;» (sans les guillemets) ou quelque chose de similaire. Parfois en tapant&nbsp;: «&nbsp;nom_du_paquet home page&nbsp;» vous trouverez le site web du responsable.

note: type: Content of: <sect1><sect2><title>
en: Stripping One More Time
fr: Nettoyage une fois de plus

note: type: Content of: <sect1><sect2><para>
en: In LFS, stripping of debugging symbols and unneeded symbol table entries was discussed a couple of times.  When building BLFS packages, there are generally no special instructions that discuss stripping again. Stripping can be done while installing a package, or afterwards.
fr: Dans LFS, le nettoyage des symboles de débogage et des entrées de la table des symboles inutiles a été abordé plusieurs fois.  Pour la construction des paquets BLFS, il n'y a généralement pas d'instructions qui abordent de nouveau le nettoyage. Le nettoyage peut avoir lieu après l'installation d'un paquet, ou plus tard.

note: type: Content of: <sect1><sect2><bridgehead>
en: Stripping while Installing a Package
fr: Nettoyage à l'installation d'un paquet

note: type: Content of: <sect1><sect2><para>
en: There are several ways to strip executables installed by a package. They depend on the build system used (see below <link linkend="buildsystems">the section about build systems</link>), so only some generalities can be listed here:
fr: Il y a plusieurs manières de nettoyer les exécutables installés par un paquet. Elles dépendent du système de construction utilisé (voir plus bas <link linkend="buildsystems">la section sur les systèmes de construction</link>), c'est pourquoi nous ne listons que quelques généralités ici&nbsp;:

note: type: Content of: <sect1><sect2><note><para>
en: The following methods using the feature of a building system (autotools, meson, or cmake) will not strip static libraries if any is installed.  Fortunately there are not too many static libraries in BLFS, and a static library can always be stripped safely by running <command>strip --strip-unneeded</command> on it manually.
fr: Les méthodes suivantes qui utilisent la fonctionnalité d'un système de construction (autotools, meson ou cmake) ne nettoieront pas les bibliothèques statiques si elles sont installées. Heureusement il n'y a pas tant de bibliothèques statiques dans BLFS et une bibliothèque statique peut toujours être nettoyée sans problème en exécutant <command>strip --strip-unneeded</command> dessus manuellement.

note: type: Content of: <sect1><sect2><itemizedlist><listitem><para>
en: The packages using autotools usually have an <parameter>install-strip</parameter> target in their generated <filename>Makefile</filename> files. So installing stripped executables is just a matter of using <command>make install-strip</command> instead of <command>make install</command>.
fr: Les paquets qui utilisent les autotools ont habituellement une cible <parameter>install-strip</parameter> dans leur fichier <filename>Makefile</filename> généré. Donc installer des exécutables nettoyer est aussi simple qu'utiliser <command>make install-strip</command> au lieu de <command>make install</command>.

note: type: Content of: <sect1><sect2><itemizedlist><listitem><para>
en: The packages using the meson build system can accept <parameter>-Dstrip=true</parameter> when running <command>meson</command>.  If you've forgot to add this option running the <command>meson</command>, you can also run <command>meson install --strip</command> instead of <command>ninja install</command>.
fr: Les paquets qui utilisent le système de construction meson acceptent <parameter>-Dstrip=true</parameter> au lancement de <command>meson</command>. Si vous avez oublié d'ajouter cette option en lançant <command>meson</command>, vous pouvez aussi lancer <command>meson install --strip</command> au lieu de <command>ninja install</command>.

note: type: Content of: <sect1><sect2><itemizedlist><listitem><para>
en: <command>cmake</command> generates <parameter>install/strip</parameter> targets for both the <parameter>Unix Makefiles</parameter> and <parameter>Ninja</parameter> generators (the default is <parameter>Unix Makefiles</parameter> on linux). So just run <command>make install/strip</command> or <command>ninja install/strip</command> instead of the <command>install</command> counterparts.
fr: <command>cmake</command> génère des cibles <parameter>install/strip</parameter> aussi bien pour le générateur de <parameter>Makefiles Unix</parameter> que pour le générateur <parameter>Ninja</parameter> (par défaut c'est le générateur de <parameter>Makefiles Unix</parameter> qui sera utilisé sur linux). Lancez simplement <command>make install/strip</command> ou <command>ninja install/strip</command> au lieu de l'équivalent avec <command>install</command>.

note: type: Content of: <sect1><sect2><itemizedlist><listitem><para>
en: Removing (or not generating) debug symbols can also be achieved by removing the <parameter>-g&lt;something&gt;</parameter> options in C/C++ calls. How to do that is very specific for each package.  And, it does not remove unneeded symbol table entries.  So it will not be explained in detail here. See also below the paragraphs about optimization.
fr: Supprimer (ou éviter de générer) les symboles de débogage peut aussi se faire en supprimant les options <parameter>-g&lt;quelque chose&gt;</parameter> dans les appels au compilateur C/C++. La manière de procéder est spécifique à chaque paquet. En plus, cela ne supprime pas les entrées inutiles de la table des symboles. Nous ne l'expliquons donc pas ici. Voir plus bas les paragraphes sur l'optimisation.

note: type: Content of: <sect1><sect2><bridgehead>
en: Stripping Installed Executables
fr: Nettoyer les exécutables installés

note: type: Content of: <sect1><sect2><para>
en: The <command>strip</command> utility changes files in place, which may break anything using it if it is loaded in memory. Note that if a file is in use but just removed from the disk (i.e. not overwritten nor modified), this is not a problem since the kernel can use <quote>deleted</quote> files.  Look at <filename>/proc/*/maps</filename> and it is likely that you'll see some <emphasis>(deleted)</emphasis> entries. The <command>mv</command> just removes the destination file from the directory but does not touch its content, so that it satisfies the condition for the kernel to use the old (deleted) file.  But this approach can detach hard links into duplicated copies, causing a bloat which is obviously unwanted as we are stripping to reduce system size.  If two files in a same file system share the same inode number, they are hard links to each other and we should reconstruct the link.  The script below is just an example.  It should be run as the &root; user:
fr: L'utilitaire <command>strip</command> modifie les fichiers en place, ce qui peut casser tout ce qui l'utilise s'il est chargé en mémoire. Remarquez que si un fichier est utilisé mais simplement supprimé du disque (c.-à-d. pas écrasé ou modifié), ce n'est pas un problème car le noyau peut utiliser des fichiers <quote>supprimés</quote>. Regardez dans <filename>/proc/*/maps</filename>, et il est probable que vous verrez des entrées <emphasis>(deleted)</emphasis>. La commande <command>mv</command> supprime seulement le fichier de destination du répertoire mais ne change pas son contenu, donc elle satisfait aux conditions pour que le noyau utilise l'ancien fichier supprimé. Mais cette approche peut détacher des liens en dur et créer des copies dupliquées, causant une plus forte utilisation du disque, ce qui n'est évidemment pas souhaitable quand nous nettoyons pour réduire la taille du système. Si deux fichiers du même système de fichiers partage le même numéro d'inœud, ils sont liés en dur et nous devrions reconstruire le lien. Le script ci-dessous est juste un exemple. Il devrait être lancé en &root;&nbsp;:

note: type: Content of: <sect1><sect2><para>
en: If you install programs in other directories such as <filename class="directory">/opt</filename> or <filename class="directory">/usr/local</filename>, you may want to strip the files there too. Just add other directories to scan in the compound list of <command>find</command> commands between the braces.
fr: Si vous installez des programmes dans d'autres répertoires tels que <filename class="directory">/opt</filename> ou <filename class="directory">/usr/local</filename>, vous pouvez vouloir nettoyer les fichiers ici aussi. Ajoutez simplement d'autres répertoires à scanner dans la liste des commandes <command>find</command> entre accolades.

note: type: Content of: <sect1><sect2><para>
en: For more information on stripping, see <ulink url="https://www.technovelty.org/linux/stripping-shared-libraries.html"/>.
fr: Pour plus d'information sur le nettoyage, regardez <ulink url="https://www.technovelty.org/linux/stripping-shared-libraries.html"/>.

note: type: Content of: <sect1><sect2><title>
en: Working with different build systems
fr: Travailler avec différents systèmes de construction

note: type: Content of: <sect1><sect2><para>
en: There are now three different build systems in common use for converting C or C++ source code into compiled programs or libraries and their details (particularly, finding out about available options and their default values) differ. It may be easiest to understand the issues caused by some choices (typically slow execution or unexpected use of, or omission of, optimizations) by starting with the <envar>CFLAGS</envar>, <envar>CXXFLAGS</envar>, and <envar>LDFLAGS</envar> environment variables.  There are also some programs which use Rust.
fr: Il y a maintenant trois systèmes de construction différents utilisés régulièrement pour convertir du code source C ou C++ en un programme compilé ou en une bibliothèque et leur fonctionnement (en particulier, comment trouver les options disponibles et leurs valeurs par défaut) est différent. Il peut être plus facile de comprendre les problèmes causés par certains choix (typiquement une exécution lente ou l'utilisation inattendue, ou l'omission, des optimisations en commençant par les variables d'environnement <envar>CFLAGS</envar>, <envar>CXXFLAGS</envar> et <envar>LDFLAGS</envar>. Certains programmes utilisent aussi Rust.

note: type: Content of: <sect1><sect2><para>
en: Most LFS and BLFS builders are probably aware of the basics of <envar>CFLAGS</envar> and <envar>CXXFLAGS</envar> for altering how a program is compiled. Typically, some form of optimization is used by upstream developers (<option>-O2</option> or <option>-O3</option>), sometimes with the creation of debug symbols (<option>-g</option>), as defaults.
fr: La plupart des lecteurs de LFS et de BLFS connaissent probablement déjà les bases de l'utilisation de <envar>CFLAGS</envar> et <envar>CXXFLAGS</envar> pour altérer la compilation d'un programme. En général, certaines formes d'optimisations sont utilisées par les développeurs en amont (<option>-O2</option> ou <option>-O3</option>), parfois avec la création de symboles de débogage (<option>-g</option>) par défaut.

note: type: Content of: <sect1><sect2><para>
en: If there are contradictory flags (e.g. multiple different <option>-O</option> values), the <emphasis>last</emphasis> value will be used. Sometimes this means that flags specified in environment variables will be picked up before values hardcoded in the Makefile, and therefore ignored.  For example, where a user specifies <option>-O2</option> and that is followed by <option>-O3</option> the build will use <option>-O3</option>.
fr: S'il y a des drapeaux contradictoires (p. ex. plusieurs valeurs différentes de <option>-O</option>), la <emphasis>dernière</emphasis> valeur sera utilisée. Parfois les drapeaux spécifiés dans les variables d'environnement sont insérés avant les valeurs en dur dans le Makefile, ce qui signifie qu'ils sont ignorés. Par exemple, si un utilisateur spécifie <option>-O2</option>et qu'il est suivi de <option>-O3</option>, la construction utilisera <option>-O3</option>.

note: type: Content of: <sect1><sect2><para>
en: There are various other things which can be passed in CFLAGS or CXXFLAGS, such as allowing using the instruction set extensions available with a specific microarchitecture (e.g.  <option>-march=amdfam10</option> or <option>-march=native</option>), tune the generated code for a specific microarchitecture (e. g.  <option>-mtune=tigerlake</option> or <option>-mtune=native</option>, if <option>-mtune=</option> is not used, the microarchitecture from <option>-march=</option> setting will be used), or specifying a specific standard for C or C++ (<option>-std=c++17</option> for example).  But one thing which has now come to light is that programmers might include debug assertions in their code, expecting them to be disabled in releases by using <option>-DNDEBUG</option>.  Specifically, if <xref linkend="mesa"/> is built with these assertions enabled, some activities such as loading levels of games can take extremely long times, even on high-class video cards.
fr: On peut passer divers autres drapeaux dans CFLAGS et CXXFLAGS, comme permettre d'utiliser les extensions des jeux d'instruction disponibles pour une microarchitecture spécifique (p. ex. <option>-march=amdfam10</option> ou <option>-march=native</option>), optimiser le code généré pour une microarchitecture donnée (p. ex. <option>-mtune=tigerlake</option> ou <option>-mtune=native</option>, si <option>-mtune=</option> n'est pas utilisé, la microarchitecture du paramètre <option>-march=</option> sera utilisé) ou pour spécifier un standard C ou C++ particulier (<option>-std=c++17</option> par exemple). Mais ce qui commence à apparaître, c'est l'inclusion par les développeurs d'assertions de débogage dans leur code qui sont généralement désactivés dans les versions publiées avec <option>-DNDEBUG</option>. Plus spécifiquement, si <xref linkend="mesa"/> est construit avec ces assertions, certaines activités comme le chargement de niveaux dans les jeux peuvent prendre très longtemps, même sur des cartes vidéo haut de gamme.

note: type: Content of: <sect1><sect2><bridgehead>
en: Autotools with Make
fr: Autotools avec Make

note: type: Content of: <sect1><sect2><para>
en: This combination is often described as <quote>CMMI</quote> (configure, make, make install) and is used here to also cover the few packages which have a configure script that is not generated by autotools.
fr: Cette combinaison est souvent décrite comme <quote>CMMI</quote> (configure, make, make install) et est utilisée ici pour couvrir aussi certains paquets dont le script configure n'a pas été généré par les autotools.

note: type: Content of: <sect1><sect2><para>
en: Sometimes running <command>./configure --help</command> will produce useful options about switches which might be used.  At other times, after looking at the output from configure you may need to look at the details of the script to find out what it was actually searching for.
fr: Parfois lancer <command>./configure --help</command> affichera les options utiles des paramètres qui peuvent être utilisés. D'autres fois, après avoir regardé la sortie de configure vous pourriez avoir besoin de regarder les détails du script pour comprendre ce qu'il cherchait vraiment.

note: type: Content of: <sect1><sect2><para>
en: Many configure scripts will pick up any CFLAGS or CXXFLAGS from the environment, but CMMI packages vary about how these will be mixed with any flags which would otherwise be used (<emphasis>variously</emphasis>: ignored, used to replace the programmer's suggestion, used before the programmer's suggestion, or used after the programmer's suggestion).
fr: De nombreux scripts configure récupéreront les CFLAGS et CXXFLAGS de l'environnement, mais les paquets CMMI varient dans la manière dont ils seront insérés avec les drapeaux qui sinon seraient utilisés (<emphasis>au choix</emphasis>&nbsp;: ignorés, utilisés à la place de la suggestion des programmeurs, utilisés avant la suggestion des programmeurs ou utilisés après la suggestion des programmeurs).

note: type: Content of: <sect1><sect2><para>
en: In most CMMI packages, running <command>make</command> will list each command and run it, interspersed with any warnings. But some packages try to be <quote>silent</quote> and only show which file they are compiling or linking instead of showing the command line.  If you need to inspect the command, either because of an error, or just to see what options and flags are being used, adding <option>V=1</option> to the make invocation may help.
fr: Dans la plupart des paquets CMMI, <command>make</command> listera les commandes lancées, séparées par des avertissements éventuels. Mais certains paquets essayent d'être <quote>silencieux</quote> et ne montrent que les fichiers qu'ils compilent ou dont ils éditent les liens au lieu de montrer la ligne de commande. Si vous devez inspecter la commande, soit à cause d'une erreur, ou juste pour voir les options et les drapeaux utilisés, ajouter<option>V=1</option> à l'invocation make peut aider.

note: type: Content of: <sect1><sect2><para>
en: CMake works in a very different way, and it has two backends which can be used on BLFS: <command>make</command> and <command>ninja</command>. The default backend is make, but ninja can be faster on large packages with multiple processors. To use ninja, specify <option>-G Ninja</option> in the cmake command.  However, there are some packages which create fatal errors in their ninja files but build successfully using the default of Unix Makefiles.
fr: CMake fonctionne de manière différente et il a deux moteurs qui peuvent être utilisés sur BLFS&nbsp;: <command>make</command> et <command>ninja</command>. Le moteur par défaut est make, mais ninja est plus rapide sur les paquets plus gros avec plusieurs processeurs. Pour utiliser ninja, spécifiez <option>-G Ninja</option> dans la commande cmake. Cependant, certains paquets peuvent avoir des erreurs fatales dans leurs fichiers ninja tout en pouvant être construits sans problème avec les Makefile Unix par défaut.

note: type: Content of: <sect1><sect2><para>
en: The hardest part of using CMake is knowing what options you might wish to specify. The only way to get a list of what the package knows about is to run <command>cmake -LAH</command> and look at the output for that default configuration.
fr: La partie la plus dure de l'utilisation de CMake est de connaître les options que vous voudrez spécifier. La seule manière de récupérer une liste de ce que le paquet connaît est de lancer <command>cmake -LAH</command> et de regarder la sortie pour cette configuration par défaut.

note: type: Content of: <sect1><sect2><para>
en: Perhaps the most-important thing about CMake is that it has a variety of CMAKE_BUILD_TYPE values, and these affect the flags. The default is that this is not set and no flags are generated. Any <envar>CFLAGS</envar> or <envar>CXXFLAGS</envar> in the environment will be used. If the programmer has coded any debug assertions, those will be enabled unless -DNDEBUG is used. The following CMAKE_BUILD_TYPE values will generate the flags shown, and these will come <emphasis>after</emphasis> any flags in the environment and therefore take precedence.
fr: Peut-être que la chose la plus importante à propos de CMake est qu'il a plusieurs valeurs de CMAKE_BUILD_TYPE et qu'elles affectent les drapeaux. La valeur par défaut est vide et aucun drapeau n'est généré. Les <envar>CFLAGS</envar> et <envar>CXXFLAGS</envar> dans l'environnement seront utilisés. Si le programmeur a codé des assertions de débogage, elles seront activées à moins que vous n'utilisiez -DNDEBUG. Les valeurs CMAKE_BUILD_TYPE suivantes généreront les drapeaux associés et ils seront ajoutés <emphasis>après</emphasis> les drapeaux dans l'environnement et prennent donc le pas dessus.

note: type: Content of: <sect1><sect2><para>
en: CMake tries to produce quiet builds. To see the details of the commands which are being run, use <command>make VERBOSE=1</command> or <command>ninja -v</command>.
fr: CMake essaye de produire des constructions silencieuses. Pour voir les détails des commandes lancées, utilisez <command>make VERBOSE=1</command> ou <command>ninja -v</command>.

note: type: Content of: <sect1><sect2><para>
en: By default, CMake treats file installation differently from the other build systems: if a file already exists and is not newer than a file that would overwrite it, then the file is not installed. This may be a problem if a user wants to record which file belongs to a package, either using <envar>LD_PRELOAD</envar>, or by listing files newer than a timestamp. The default can be changed by setting the variable <envar>CMAKE_INSTALL_ALWAYS</envar> to 1 in the <emphasis>environment</emphasis>, for example by <command>export</command>'ing it.
fr: Par défaut, CMake traite l'installation des fichiers différemment des autres systèmes de construction&nbsp;: si un fichier existe déjà et n'est pas plus récent qu'un fichier qui le remplacerait, alors le fichier n'est pas installé. cela peut être un problème si vous voulez enregistrer quels fichiers appartiennent à quel paquet, soit avec <envar>LD_PRELOAD</envar>, soit en listant les fichiers plus récents qu'un certain horodatage. Ce comportement par défaut peut être modifié en paramétrant la variable <envar>CMAKE_INSTALL_ALWAYS</envar> à 1 dans l'<emphasis>environnement</emphasis>, par exemple en l'<command>export</command>ant.

note: type: Content of: <sect1><sect2><para>
en: Meson has some similarities to CMake, but many differences. To get details of the defines that you may wish to change you can look at <filename>meson_options.txt</filename> which is usually in the top-level directory.
fr: Meson ressemble un peu à CMake, mais avec beaucoup de différences. Pour trouver les détails des définitions que vous pourriez avoir besoin de modifier, vous pouvez regarder dans <filename>meson_options.txt</filename> qui est généralement dans le répertoire de plus haut niveau.

note: type: Content of: <sect1><sect2><para>
en: If you have already configured the package by running <command>meson</command> and now wish to change one or more settings, you can either remove the build directory, recreate it, and use the altered options, or within the build directory run <command>meson configure</command>, e.g. to set an option:
fr: Si vous avez déjà configuré le paquet en lançant <command>meson</command> et que vous souhaitez maintenant changer un ou plusieurs paramètres, vous pouvez soit supprimer le répertoire de construction, le recréer et utiliser les options modifiées, soit lancer <command>meson configure</command> dans le répertoire de construction, p. ex. pour ajouter une option&nbsp;:

note: type: Content of: <sect1><sect2><para>
en: If you do that, the file <filename>meson-private/cmd_line.txt</filename> will show the <emphasis>last</emphasis> commands which were used.
fr: Si vous faites cela, le fichier <filename>meson-private/cmd_line.txt</filename> contiendra les <emphasis>dernières</emphasis> commandes qui ont été utilisées.

note: type: Content of: <sect1><sect2><para>
en: Meson provides the following buildtype values, and the flags they enable come <emphasis>after</emphasis> any flags supplied in the environment and therefore take precedence.
fr: Meson fournit les valeurs buildtype suivantes, et les drapeaux qu'elles activent viennent <emphasis>après</emphasis> les drapeaux fournis dans l'environnement et prennent donc le pas.

note: type: Content of: <sect1><sect2><itemizedlist><listitem><para>
en: plain : no added flags. This is for distributors to supply their own <envar>CFLAGS</envar>, <envar>CXXFLAGS</envar> and <envar>LDFLAGS</envar>. There is no obvious reason to use this in BLFS.
fr: plain&nbsp;: pas de drapeau supplémentaire. Cela est utilisé pour spécifier ses propres <envar>CFLAGS</envar>, <envar>CXXFLAGS</envar> et <envar>LDFLAGS</envar>. Il n'y a pas de raison évidente pour utiliser cela dans BLFS.

note: type: Content of: <sect1><sect2><itemizedlist><listitem><para>
en: debug : <option>-g</option> - this is the default if nothing is specified in either <filename>meson.build</filename> or the command line. However it results large and slow binaries, so we should override it in BLFS.
fr: debug&nbsp;: <option>-g</option> — c'est la valeur par défaut si rien n'est spécifié dans <filename>meson.build</filename> ni sur la ligne de commande. Cependant, cela crée des binaires gros et lents, donc vous devez le remplacer dans BLFS.

note: type: Content of: <sect1><sect2><itemizedlist><listitem><para>
en: debugoptimized : <option>-O2 -g</option> - this is the default specified in <filename>meson.build</filename> of some packages.
fr: debugoptimized&nbsp;: <option>-O2 -g</option>&nbsp;: c'est la valeur par défaut spécifiée dans <filename>meson.build</filename> pour certains paquets.

note: type: Content of: <sect1><sect2><itemizedlist><listitem><para>
en: release : <option>-O3</option> (occasionally a package will force <option>-O2</option> here) - this is the buildtype we use for most packages with Meson build system in BLFS.
fr: release&nbsp;: <option>-O3</option> (parfois un paquet forcera <option>-O2</option>) — c'est le type de construction utilisé pour la plupart des paquets avec le système de construction Meson dans BLFS.

note: type: Content of: <sect1><sect2><para>
en: The <option>-DNDEBUG</option> flag is implied by the release buildtype for some packages (for example <xref linkend='mesa'/>).  It can also be provided explicitly by passing <option>-Db_ndebug=true</option>.
fr: Le drapeau <option>-DNDEBUG</option> est sous-entendu par le type de construction release pour certains paquets (par exemple <xref linkend='mesa'/>). Il peut également être fournit en passant <option>-Db_ndebug=true</option>.

note: type: Content of: <sect1><sect2><para>
en: To see the details of the commands which are being run in a package using meson, use <command>ninja -v</command>.
fr: Pour voir les détails des commandes qui sont lancées dans un paquet qui utilise meson, utilisez <command>ninja -v</command>.

note: type: Content of: <sect1><sect2><bridgehead>
en: Rustc and Cargo
fr: Rustc et Cargo

note: type: Content of: <sect1><sect2><para>
en: Most released rustc programs are provided as crates (source tarballs)  which will query a server to check current versions of dependencies and then download them as necessary.  These packages are built using <command>cargo --release</command>. In theory, you can manipulate the RUSTFLAGS to change the optimize-level (default for <option>--release</option> is 3, i. e.  <option>-Copt-level=3</option>, like <option>-O3</option>) or to force it to build for the machine it is being compiled on, using <option>-Ctarget-cpu=native</option> but in practice this seems to make no significant difference.
fr: La plupart des programmes rustc publiés sont fournis dans des archives (ou «&nbsp;crates&nbsp;») qui demanderont à un serveur de vérifier les versions actuelles des dépendances et les téléchargera au besoin. Ces paquets sont construits avec <command>cargo --release</command>. En théorie, on peut manipuler les RUSTFLAGS pour changer le niveau d'optimisation (la valeur par défaut pour <option>--release</option> est 3, c.-à-d. <option>-Copt-level=3</option>, comme <option>-O3</option>) ou pour forcer la construction pour la machine sur laquelle il est compilé, avec <literal>-Ctarget-cpu=native</literal> mais en pratique cela ne semble pas faire de réelle différence.

note: type: Content of: <sect1><sect2><para>
en: If you are compiling a standalone Rust program (as an unpackaged <filename class='extension'>.rs</filename> file) by running <command>rustc</command> directly, you should specify <option>-O</option> (the abbreviation of <option>-Copt-level=2</option>) or <option>-Copt-level=3</option> otherwise it will do an unoptimized compile and run <emphasis>much</emphasis> slower.  If are compiling the program for debugging it, replace the <option>-O</option> or <option>-Copt-level=</option> options with <option>-g</option> to produce an unoptimized program with debug info.
fr: Si vous compilez un programme Rust autonome (en tant que fichier <filename class='extension'>.rs</filename> sans paquet) en exécutant directement <command>rustc</command>, vous devriez spécifier <option>-O</option> (abbreviation de <option>-Copt-level=2</option>) ou <option>-Copt-level=3</option> sinon il effectuera une compilation non optimisée et s'exécutera <emphasis>bien plus</emphasis> lentement. Si vous compilez un programme pour le déboguer, remplacez les options <option>-O</option> ou <option>-Copt-level=</option> par <option>-g</option> pour produire un programme non optimisé avec des informations de débogage.

note: type: Content of: <sect1><sect2><para>
en: Like <command>ninja</command>, by default <command>cargo</command> uses all logical cores.  This can often be worked around, either by exporting <envar>CARGO_BUILD_JOBS=<replaceable>&lt;N&gt;</replaceable></envar> or passing <option>--jobs <replaceable>&lt;N&gt;</replaceable></option> to <command>cargo</command>.  For compiling rustc itself, specifying <option>--jobs <replaceable>&lt;N&gt;</replaceable></option> for invocations of <command>x.py</command> (together with the <envar>CARGO_BUILD_JOBS</envar> environment variable, which looks like a <quote>belt and braces</quote> approach but seems to be necessary) mostly works. The exception is running the tests when building rustc, some of them will nevertheless use all online CPUs, at least as of rustc-1.42.0.
fr: Comme pour <command>ninja</command>, par défaut <command>cargo</command> utilise tous les cœurs logiques. Cela peut souvent être changé, soit en exportant <envar>CARGO_BUILD_JOBS=<replaceable>&lt;N&gt;</replaceable></envar> ou en passant <option>--jobs <replaceable>&lt;N&gt;</replaceable></option> à <command>cargo</command>. Pour compiler rustc lui-même, spécifiez <option>--jobs <replaceable>&lt;N&gt;</replaceable></option> lors de l'invocation de <command>x.py</command> (avec la variable d'environnement <envar>CARGO_BUILD_JOBS</envar>, ce qui ressemble à une approche <quote>ceinture et bretelle</quote> mais a l'air nécessaire). L'exception est le lancement des tests à la construction de rustc, où certains d'entre eux utiliseront tout de même tous les CPU en ligne, au moins à partir de rustc-1.42.0.

note: type: Content of: <sect1><sect2><title>
en: Optimizing the build
fr: Optimisation de la construction

note: type: Content of: <sect1><sect2><para>
en: Many people will prefer to optimize compiles as they see fit, by providing <envar>CFLAGS</envar> or <envar>CXXFLAGS</envar>. For an introduction to the options available with gcc and g++ see <ulink url="https://gcc.gnu.org/onlinedocs/gcc-&gcc-version;/gcc/Optimize-Options.html"/>.  The same content can be also found in <command>info gcc</command>.
fr: De nombreuses personnes préfèrent optimiser la compilation à leur goût, en fournissant <envar>CFLAGS</envar> ou <envar>CXXFLAGS</envar>. Vous trouverez une introduction aux options disponibles avec gcc et g++ sur <ulink url="https://gcc.gnu.org/onlinedocs/gcc-&gcc-version;/gcc/Optimize-Options.html"/>. Ce contenu est également disponible dans <command>info gcc</command>.

note: type: Content of: <sect1><sect2><para>
en: Some packages default to <option>-O2 -g</option>, others to <option>-O3 -g</option>, and if <envar>CFLAGS</envar> or <envar>CXXFLAGS</envar> are supplied they might be added to the package's defaults, replace the package's defaults, or even be ignored.  There are details on some desktop packages which were mostly current in April 2019 at <ulink url="https://www.linuxfromscratch.org/~ken/tuning/"/> - in particular, <filename>README.txt</filename>, <filename>tuning-1-packages-and-notes.txt</filename>, and <filename>tuning-notes-2B.txt</filename>. The particular thing to remember is that if you want to try some of the more interesting flags you may need to force verbose builds to confirm what is being used.
fr: Certains paquets utilisent par défaut<option>-O2 -g</option>, d'autres <option>-O3 -g</option> et si les <envar>CFLAGS </envar>ou <envar>CXXFLAGS</envar> sont fournis ils peuvent être ajoutés aux valeurs par défaut du paquet, remplacer les valeurs par défaut ou même être ignorés. Il y a des détails sur les dernières versions (en avril 2019) de certains paquets graphiques sur <ulink url="https://www.linuxfromscratch.org/~ken/tuning/"/> — en particulier, <filename>README.txt</filename>, <filename>tuning-1-packages-and-notes.txt</filename> et <filename>tuning-notes-2B.txt</filename>. Ce dont il faut se souvenir, c'est que si vous voulez essayer certains des drapeaux les plus intéressants vous devez forcer les constructions à être plus verbeuses pour confirmer qu'elles sont utilisées.

note: type: Content of: <sect1><sect2><para>
en: Clearly, if you are optimizing your own program you can spend time to profile it and perhaps recode some of it if it is too slow. But for building a whole system that approach is impractical. In general, <option>-O3</option> usually produces faster programs than <option>-O2</option>.  Specifying <option>-march=native</option> is also beneficial, but means that you cannot move the binaries to an incompatible machine - this can also apply to newer machines, not just to older machines. For example programs compiled for <literal>amdfam10</literal> run on old Phenoms, Kaveris, and Ryzens : but programs compiled for a Kaveri will not run on a Ryzen because certain op-codes are not present.  Similarly, if you build for a Haswell not everything will run on a SandyBridge.
fr: Clairement, si vous optimisez votre propre programme vous pouvez passer du temps à effectuer des mesures et peut-être recoder certaines parties plutôt lentes. Mais pour construire un système complet cette approche est impossible. En général, <option>-O3</option> produit des programmes plus rapides que <option>-O2</option>. Spécifier <option>-march=native</option> est aussi bénéfique, mais cela signifie que vous ne pouvez pas utiliser les binaires sur une machine incompatible — cela s'applique aussi à des machines plus récentes, pas seulement à des machines plus vieilles. Par exemple les programmes compilés pour <literal>amdfam10</literal> peuvent tourner sur les vieux Phenoms, Kaveris et Ryzens&nbsp;; mais les programmes compilés pour un Kaveri ne tourneront pas sur un Ryzen parce que certains opcodes ne sont pas présents. De même, si vous construisez pour un Haswell tout ne tournera pas sur un SandyBridge.

note: type: Content of: <sect1><sect2><note><para>
en: Be careful that the name of a <option>-march</option> setting does not always match the baseline of the microarchitecture with the same name.  For example, the Skylake-based Intel Celeron processors do not support AVX at all, but <option>-march=skylake</option> assumes AVX and even AVX2.
fr: Soyez conscient que le nom d'un paramètre <option>-march</option> ne correspond pas toujours à la microarchitecture de base du même nom. Par exemple, les processeurs Celeron d'Intel basés sur Skylake ne prennent pas en charge AVX du tout, mais <option>-march=skylake</option> suppose AVX et même AVX2.

note: type: Content of: <sect1><sect2><para>
en: When a shared library is built by GCC, a feature named <quote>semantic interposition</quote> is enabled by default.  When the shared library refers to a symbol name with external linkage and default visibility, if the symbol exists in both the shared library and the main executable, semantic interposition guarantees the symbol in the main executable is always used.  This feature was invented in an attempt to make the behavior of linking a shared library and linking a static library as similar as possible.  Today only a small number of packages still depend on semantic interposition, but the feature is still on by the default of GCC, causing many optimizations disabled for shared libraries because they conflict with semantic interposition.  The <option>-fno-semantic-interposition</option> option can be passed to <command>gcc</command> or <command>g++</command> to disable semantic interposition and enable more optimizations for shared libraries.  This option is used as the default of some packages (for example <xref linkend='python3'/>), and it's also the default of Clang.
fr: Lorsqu'une bibliothèque partagée est construite par GCC, une fonctionnalité nommée <quote>interposition sémantique</quote> est activée par défaut. Lorsque la bibliothèque partagée se réfère à un nom de symbole avec un lien externe et la visibilité par défaut, si le symbole existe à la fois dans la bibliothèque partagée et l'exécutable principal, l'interposition sémantique garanti que le symbole de l'exécutable principal sera toujours utilisé. Cette fonctionnalité a été inventée pour essayer de rendre la liaison d'une bibliothèque partagée et d'une bibliothèque statique aussi proches que possible. Aujourd'hui seul un petit nombre de paquets dépendent toujours de l'interposition sémantique, mais la fonctionnalité est toujours proposée par défaut par GCC, ce qui désactive plusieurs optimisations pour les bibliothèques partagées car elles entrent en conflit avec l'interposition sémantique. L'option <option>-fno-semantic-interposition</option> peut être passée à <command>gcc</command> ou <command>g++</command> pour désactiver l'interposition sémantique et activer plus d'optimisations pour les bibliothèques partagées. Cette option est utilisée par défaut dans certains paquets (par exemple <xref linkend='python3'/>) et elle est activée par défaut dans Clang.

note: type: Content of: <sect1><sect2><para>
en: There are also various other options which some people claim are beneficial. At worst, you get to recompile and test, and then discover that in your usage the options do not provide a benefit.
fr: Il y a aussi diverses autres options que certains pensent bénéfiques. Au pire, vous devez recompiler et tester, pour découvrir que pour votre utilisation ces options ne font rien de spécial.

note: type: Content of: <sect1><sect2><para>
en: If building Perl or Python modules, in general the <envar>CFLAGS</envar> and <envar>CXXFLAGS</envar> used are those which were used by those <quote>parent</quote> packages.
fr: Si vous construisez des modules Perl ou Python, en général les <envar>CFLAGS</envar> et <envar>CXXFLAGS</envar> utilisés sont ceux utilisés pour construire ces paquets <quote>parents</quote>.

note: type: Content of: <sect1><sect2><para>
en: For <envar>LDFLAGS</envar>, there are three options can be used for optimization.  They are quite safe to use and the building system of some packages use some of these options as the default.
fr: Pour <envar>LDFLAGS</envar>, il y a trois options pour l'optimisation. Elles sont relativement sures à utiliser et le système de construction de certains paquets utilisent certaines de ces options par défaut.

note: type: Content of: <sect1><sect2><para>
en: With <option>-Wl,-O1</option>, the linker will optimize the hash table to speed up the dynamic linking.  Note that <option>-Wl,-O1</option> is completely unrelated to the compiler optimization flag <option>-O1</option>.
fr: Avec <option>-Wl,-O1</option>, l'éditeur des liens optimisera la table de hash pour accélérer la liaison dynamique. Remarquez que <option>-Zl,-O1</option> est complètement décorrélée du drapeau d'optimisation du compilateur <option>-O1</option>.

note: type: Content of: <sect1><sect2><para>
en: With <option>-Wl,--as-needed</option>, the linker will disregard unnecessary <option>-l<replaceable>foo</replaceable></option> options from the command line, i. e. the shared library <systemitem class='library'>lib<replaceable>foo</replaceable></systemitem> will only be linked if a symbol in <systemitem class='library'>lib<replaceable>foo</replaceable></systemitem> is really referred from the executable or shared library being linked.  This can sometimes mitigate the <quote>excessive dependencies to shared libraries</quote> issues caused by <application>libtool</application>.
fr: Avec <option>-Wl,--as-needed</option>, l'éditeur des liens ignorera les options <option>-l<replaceable>toto</replaceable></option> inutiles de la ligne de commande, c.-à-d. que la bibliothèque partagée <systemitem class='library'>lib<replaceable>toto</replaceable></systemitem> ne sera liée que si un symbole de <systemitem class='library'>lib<replaceable>toto</replaceable></systemitem> est vraiment demandé par l'exécutable ou la bibliothèque dynamique en train d'être liée. Cela peut parfois éviter des problèmes de <quote>dépendances excessives à des bibliothèques partagées</quote> causés par <application>libtool</application>.

note: type: Content of: <sect1><sect2><para>
en: With <option>-Wl,-z,pack-relative-relocs</option>, the linker generates a more compacted form of the relative relocation entries for PIEs and shared libraries.  It reduces the size of the linked PIE or shared library, and speeds up the loading of the PIE or shared library.
fr: Avec <option>-Wl,-z,-pack-relative-relocs</option>, l'éditeur des liens générera une forme plus compacte des entrées de relocations relatives pour les exécutables repositionnables et les bibliothèques partagées. Cela réduit la taille des exécutables ou des bibliothèques partagées et accélère leur chargement.

note: type: Content of: <sect1><sect2><para>
en: The <option>-Wl,</option> prefix is necessary because despite the variable is named <envar>LDFLAGS</envar>, its content is actually passed to <command>gcc</command> (or <command>g++</command>, <command>clang</command>, etc.) during the link stage, not directly passed to <command>ld</command>.
fr: Le préfixe <option>-Wl,</option> est nécessaire car malgré le nom de la variable <envar>LDFLAGS</envar>, son contenu est en fait passé à <command>gcc</command> (ou <command>g++</command>, <command>clang</command>, etc) pendant l'édition des liens, pas directement à <command>ld</command>.

note: type: Content of: <sect1><sect2><title>
en: Options for hardening the build
fr: Options pour durcir la construction

note: type: Content of: <sect1><sect2><para>
en: Even on desktop systems, there are still a lot of exploitable vulnerabilities. For many of these, the attack comes via javascript in a browser. Often, a series of vulnerabilities are used to gain access to data (or sometimes to pwn, i.e. own, the machine and install rootkits).  Most commercial distros will apply various hardening measures.
fr: Même sur un système de bureau, il y a des vulnérabilités exploitables. Pour beaucoup, l'attaque vient de javascript dans un navigateur. Souvent, une série de vulnérabilités sont utilisées pour récupérer un accès aux données (ou parfois pour powner, c.-à-d. cracker la machine et installer des rootkits). La plupart des distributions commerciales appliqueront diverses mesures de durcissement.

note: type: Content of: <sect1><sect2><para>
en: In the past, there was Hardened LFS where gcc (a much older version)  was forced to use hardening (with options to turn some of it off on a per-package basis).  The current LFS and BLFS books are carrying forward a part of its spirit by enabling PIE (<option>-fPIE -pie</option>) and SSP (<option>-fstack-protector-strong</option>) as the defaults for GCC and clang.  What is being covered here is different - first you have to make sure that the package is indeed using your added flags and not over-riding them.
fr: Par le passé, il existait un Hardened LFS (LFS durci) où gcc (une version beaucoup plus vieille) était forcé à utiliser le durcissement (avec des options pour les désactiver au cas par cas). Les livres LFS et BLFS actuels portent encore une partie de cet esprit en activant PIE (<option>-fPIE -pie</option>) et SSP (<option>-fstack-protector-strong</option>) dans les options par défaut de GCC et de clang. Ce dont on parle ici est différent — vous devrez déjà vous assurer que le paquet utilise bien vos options supplémentaires et qu'il ne les écrase pas.

note: type: Content of: <sect1><sect2><para>
en: The main distros use much more, such as RELRO (Relocation Read Only)  and perhaps <option>-fstack-clash-protection</option>. You may also encounter the so-called <quote>userspace retpoline</quote> (<option>-mindirect-branch=thunk</option> etc.) which is the equivalent of the spectre mitigations applied to the linux kernel in late 2018. The kernel mitigations caused a lot of complaints about lost performance, if you have a production server you might wish to consider testing that, along with the other available options, to see if performance is still sufficient.
fr: Les distros principales utilisent bien plus, comme RELRO (Relocation Read Only) et parfois <option>-fstack-clash-protection</option>. Vous pouvez aussi rencontrer les <quote>retpolines en espace utilisateur</quote> (<option>-mindirect-branch=thunk</option> etc) qui sont équivalents aux atténuations de spectre appliquées au noyau Linux fin 2018. Les atténuations du noyau ont causé de nombreuses plaintes à propos d'une perte de performance, donc si vous avez un serveur en production vous devriez peut-être tester ça ainsi que d'autres options disponibles, pour voir si les performances sont toujours satisfaisantes.

note: type: Content of: <sect1><sect2><para>
en: Whilst gcc has many hardening options, clang/LLVM's strengths lie elsewhere. Some options which gcc provides are said to be less effective in clang/LLVM.
fr: Tandis que gcc a de nombreuses options de durcissement, la force de clang/LLVM se trouve ailleurs. Certaines options fournies par gcc sont dites moins efficaces dans clang/LLVM.
