perkamon - en to fr translation catalogue (560 entries)

note: type: TH
en: 2014-04-08
fr: 8 avril 2014

note: type: TH
en: Linux Programmer's Manual
fr: Manuel du programmeur Linux

note: type: SH
en: NAME
fr: NOM

note: type: Plain text
en: getcontext, setcontext - get or set the user context
fr: getcontext, setcontext - Lire ou écrire le contexte utilisateur

note: type: Plain text
en: In a System V-like environment, one has the two types I<mcontext_t> and I<ucontext_t> defined in I<E<lt>ucontext.hE<gt>> and the four functions B<getcontext>(), B<setcontext>(), B<makecontext>(3)  and B<swapcontext>(3)  that allow user-level context switching between multiple threads of control within a process.
fr: Dans un environnement de type System V, il existe deux types I<mcontext_t> et I<ucontext_t> définis dans I<E<lt>ucontext.hE<gt>> et les quatre fonctions B<getcontext>(), B<setcontext>(), B<makecontext>(3) et B<swapcontext>(3), qui permettent le changement de contexte au niveau utilisateur entre plusieurs fils de contrôle au sein du même processus (threads).

note: type: Plain text
en: The I<mcontext_t> type is machine-dependent and opaque.  The I<ucontext_t> type is a structure that has at least the following fields:
fr: Le type I<mcontext_t> est opaque et dépend de la machine. Le type I<ucontext_t> est une structure ayant au moins les champs suivants\ :

note: type: Plain text
en: with I<sigset_t> and I<stack_t> defined in I<E<lt>signal.hE<gt>>.  Here I<uc_link> points to the context that will be resumed when the current context terminates (in case the current context was created using B<makecontext>(3)), I<uc_sigmask> is the set of signals blocked in this context (see B<sigprocmask>(2)), I<uc_stack> is the stack used by this context (see B<sigaltstack>(2)), and I<uc_mcontext> is the machine-specific representation of the saved context, that includes the calling thread's machine registers.
fr: Les types I<sigset_t> et I<stack_t> sont définis dans I<E<lt>signal.hE<gt>>. Ici, I<uc_link> pointe sur le contexte qui doit être restauré lorsque le contexte courant se terminera (si le contexte en cours a été créé par B<makecontext>(3)), I<uc_sigmask> est l'ensemble des signaux bloqués dans ce contexte (consultez B<sigprocmask>(2)), I<uc_stack> est la pile utilisée par ce contexte (consultez B<sigaltstack>(2)), et I<uc_mcontext> est la représentation \(em dépendant de la machine \(em du contexte sauvegardé, qui inclut les registres du processeur pour le thread appelant.

note: type: Plain text
en: The function B<getcontext>()  initializes the structure pointed at by I<ucp> to the currently active context.
fr: La fonction B<getcontext>() remplit la structure pointée par I<ucp> avec le contexte actuellement actif.

note: type: Plain text
en: The function B<setcontext>()  restores the user context pointed at by I<ucp>.  A successful call does not return.  The context should have been obtained by a call of B<getcontext>(), or B<makecontext>(3), or passed as third argument to a signal handler.
fr: La fonction B<setcontext>() restaure le contexte utilisateur pointé par I<ucp>. Un appel réussi ne revient pas. Le contexte doit avoir été obtenu par un appel B<getcontext>(), ou B<makecontext>(3), ou passé en troisième argument à un gestionnaire de signal.

note: type: Plain text
en: If the context was obtained by a call of B<getcontext>(), program execution continues as if this call just returned.
fr: Si le contexte a été obtenu par un appel B<getcontext>(), l'exécution du programme reprend comme si cet appel venait juste de se terminer.

note: type: Plain text
en: If the context was obtained by a call of B<makecontext>(3), program execution continues by a call to the function I<func> specified as the second argument of that call to B<makecontext>(3).  When the function I<func> returns, we continue with the I<uc_link> member of the structure I<ucp> specified as the first argument of that call to B<makecontext>(3).  When this member is NULL, the thread exits.
fr: Si le contexte a été obtenu par un appel B<makecontext>(3), l'exécution du programme continue par l'appel de la fonction I<func> indiquée en second argument de B<makecontext>(3). Quand la fonction I<func> se termine, on continue avec le membre I<uc_link> de la structure I<ucp> spécifiée en premier argument de l'appel B<makecontext>(3). Si ce membre est NULL, le thread se termine.

note: type: Plain text
en: If the context was obtained by a call to a signal handler, then old standard text says that "program execution continues with the program instruction following the instruction interrupted by the signal".  However, this sentence was removed in SUSv2, and the present verdict is "the result is unspecified".
fr: Si le contexte a été obtenu lors d'un appel à un gestionnaire de signal, alors le texte des anciens standards dit que «\ l'exécution du programme continue avec l'instruction suivant celle qui a été interrompue par le signal\ ». Toutefois cette phrase a été supprimée de SUSv2, et remplacée par "«\ le résultat n'est pas spécifié\ ».

note: type: SH
en: RETURN VALUE
fr: VALEUR RENVOYÉE

note: type: Plain text
en: When successful, B<getcontext>()  returns 0 and B<setcontext>()  does not return.  On error, both return -1 and set I<errno> appropriately.
fr: Lorsqu'ils réussissent, B<getcontext>() renvoie zéro et B<setcontext>() ne revient pas. En cas d'erreur, ils retournent -1 et remplissent I<errno> avec le code d'erreur adéquat.

note: type: SH
en: ERRORS
fr: ERREURS

note: type: Plain text
en: None defined.
fr: Aucune définie.

note: type: SH
en: ATTRIBUTES
fr: ATTRIBUTS

note: type: SS
en: Multithreading (see pthreads(7))
fr: Multithreading (voir pthreads(7))

note: type: Plain text
en: The B<getcontext>()  and B<setcontext>()  functions are thread-safe.
fr: Les fonctions B<getcontext>() et B<setcontext>() sont sûres dans un contexte multithread.

note: type: SH
en: CONFORMING TO
fr: CONFORMITÉ

note: type: Plain text
en: SUSv2, POSIX.1-2001.  POSIX.1-2008 removes the specification of B<getcontext>(), citing portability issues, and recommending that applications be rewritten to use POSIX threads instead.
fr: SUSv2, POSIX.1-2001. POSIX.1-2008 supprime la spécification de B<getcontext>(), en citant des problèmes de portabilité et en recommandant à la place que les applications soient récrites en utilisant les threads POSIX.

note: type: Plain text
en: The earliest incarnation of this mechanism was the B<setjmp>(3)/B<longjmp>(3)  mechanism.  Since that does not define the handling of the signal context, the next stage was the B<sigsetjmp>(3)/B<siglongjmp>(3)  pair.  The present mechanism gives much more control.  On the other hand, there is no easy way to detect whether a return from B<getcontext>()  is from the first call, or via a B<setcontext>()  call.  The user has to invent her own bookkeeping device, and a register variable won't do since registers are restored.
fr: L'incarnation la plus ancienne de ce mécanisme était constituée de la paire B<setjmp>(3)/B<longjmp>(3). Comme ils ne précisent pas la gestion des signaux, l'étape suivante fut B<sigsetjmp>(3)/B<siglongjmp>(3). Le mécanisme actuel donne plus de contrôle. En revanche, il n'y a pas de moyen simple pour savoir si le retour de B<getcontext>() se fait depuis son premier appel ou par l'intermédiaire d'un appel B<setcontext>(). L'utilisateur doit inventer son propre système de comptabilisation, et pas dans un registre car il serait restauré.

note: type: Plain text
en: When a signal occurs, the current user context is saved and a new context is created by the kernel for the signal handler.  Do not leave the handler using B<longjmp>(3): it is undefined what would happen with contexts.  Use B<siglongjmp>(3)  or B<setcontext>()  instead.
fr: Lorsqu'un signal arrive, le contexte utilisateur courant est sauvegardé et un nouveau contexte est créé par le noyau pour exécuter le gestionnaire. N'utilisez pas B<longjmp>(3) dans le gestionnaire, le comportement est indéfini. Utilisez B<siglongjmp>(3) ou B<setcontext>().

note: type: SH
en: SEE ALSO
fr: VOIR AUSSI

note: type: Plain text
en: This page is part of release 3.65 of the Linux I<man-pages> project.  A description of the project, and information about reporting bugs, can be found at \%http://www.kernel.org/doc/man-pages/.
fr: Cette page fait partie de la publication 3.65 du projet I<man-pages> Linux. Une description du projet et des instructions pour signaler des anomalies peuvent être trouvées à l'adresse \%http://www.kernel.org/doc/man-pages/.

note: type: TH
en: 2014-04-14
fr: 14 avril 2014

note: type: Plain text
en: makecontext, swapcontext - manipulate user context
fr: makecontext, swapcontext - Manipulation du contexte utilisateur

note: type: Plain text
en: In a System V-like environment, one has the type I<ucontext_t> defined in I<E<lt>ucontext.hE<gt>> and the four functions B<getcontext>(3), B<setcontext>(3), B<makecontext>()  and B<swapcontext>()  that allow user-level context switching between multiple threads of control within a process.
fr: Dans un environnement de type System V, on dispose du type I<ucontext_t> défini dans I<E<lt>ucontext.hE<gt>> et des quatre fonctions B<getcontext>(3), B<setcontext>(2), B<makecontext>() et B<swapcontext>() qui permettent, au niveau utilisateur, des permutations de contextes entre plusieurs threads de contrôle au sein d'un processus.

note: type: Plain text
en: For the type and the first two functions, see B<getcontext>(3).
fr: Pour le type et les deux premières fonctions, consultez B<getcontext>(3).

note: type: Plain text
en: The B<makecontext>()  function modifies the context pointed to by I<ucp> (which was obtained from a call to B<getcontext>(3)).  Before invoking B<makecontext>(), the caller must allocate a new stack for this context and assign its address to I<ucp-E<gt>uc_stack>, and define a successor context and assign its address to I<ucp-E<gt>uc_link>.
fr: La fonction B<makecontext>() modifie le contexte pointé par I<ucp> (qui a été obtenu par un appel à B<getcontext>(3)). Avant d'appeler B<makecontext>(), l'appelant doit allouer une nouvelle pile pour ce contexte et l'affecter à I<ucp-E<gt>uc_stack> et définir un contexte successeur et l'affecter à I<ucp-E<gt>uc_link>.

note: type: Plain text
en: When this context is later activated (using B<setcontext>(3)  or B<swapcontext>())  the function I<func> is called, and passed the series of integer (I<int>)  arguments that follow I<argc>; the caller must specify the number of these arguments in I<argc>.  When this function returns, the successor context is activated.  If the successor context pointer is NULL, the thread exits.
fr: Lorsque ce contexte est activé par la suite (avec B<setcontext>(3) ou B<swapcontext>()), alors la fonction I<func>() est tout d'abord appelée avec la série  d'arguments de type I<int> spécifiés à la suite de I<argc>\ ; l'appelant doit préciser le nombre de ces arguments dans I<argc>. Lorsque cette fonction s'achève, le contexte successeur est activé. Lorsque le pointeur sur le contexte successeur vaut NULL, le thread se termine.

note: type: Plain text
en: The B<swapcontext>()  function saves the current context in the structure pointed to by I<oucp>, and then activates the context pointed to by I<ucp>.
fr: La fonction B<swapcontext>() sauvegarde le contexte actuel dans la structure pointée par I<oucp> et active ensuite le contexte pointé par I<ucp>.

note: type: Plain text
en: When successful, B<swapcontext>()  does not return.  (But we may return later, in case I<oucp> is activated, in which case it looks like B<swapcontext>()  returns 0.)  On error, B<swapcontext>()  returns -1 and sets I<errno> appropriately.
fr: En cas de succès, B<swapcontext>() ne rend pas la main à l'appelant (on peut toutefois revenir à l'appelant en cas d'activation de I<oucp>\ ; dans un tel cas, B<swapcontext> se comporte comme si elle renvoyait 0). En cas d'erreur, B<swapcontext>() renvoie -1 et positionne I<errno> de façon appropriée.

note: type: Plain text
en: Insufficient stack space left.
fr: Espace de pile disponible insuffisant.

note: type: Plain text
en: B<makecontext>()  and B<swapcontext>()  are provided in glibc since version 2.1.
fr: B<makecontext>() et B<swapcontext>() sont fournies par la glibc depuis la version 2.1.

note: type: Plain text
en: The B<makecontext>()  and B<swapcontext>()  functions are thread-safe.
fr: Les fonctions B<makecontext>() et B<swapcontext>() sont sûres dans un contexte multithread.

note: type: Plain text
en: SUSv2, POSIX.1-2001.  POSIX.1-2008 removes the specifications of B<makecontext>()  and B<swapcontext>(), citing portability issues, and recommending that applications be rewritten to use POSIX threads instead.
fr: SUSv2, POSIX.1-2001. POSIX.1-2008 supprime les spécifications de B<makecontext>() et B<swapcontext>() à cause de problèmes de portabilité, et recommande que les applications soient réécrites avec des processus légers POSIX à la place.

note: type: Plain text
en: The interpretation of I<ucp-E<gt>uc_stack> is just as in B<sigaltstack>(2), namely, this struct contains the start and length of a memory area to be used as the stack, regardless of the direction of growth of the stack.  Thus, it is not necessary for the user program to worry about this direction.
fr: L'interprétation de I<ucp-E<gt>uc_stack> est exactement la même que pour B<sigaltstack>(2), à savoir, cette structure contient l'adresse de départ et la longueur d'une zone mémoire destinée à être utilisée comme pile, et ce, sans considération sur le sens d'expansion de la pile. Il n'est donc pas nécessaire pour le programme utilisateur de se soucier de ce sens.

note: type: Plain text
en: On architectures where I<int> and pointer types are the same size (e.g., x86-32, where both types are 32 bits), you may be able to get away with passing pointers as arguments to B<makecontext>()  following I<argc>.  However, doing this is not guaranteed to be portable, is undefined according to the standards, and won't work on architectures where pointers are larger than I<int>s.  Nevertheless, starting with version 2.8, glibc makes some changes to B<makecontext>(), to permit this on some 64-bit architectures (e.g., x86-64).
fr: Sur les architectures où le type I<int> et les types « pointeur » sont de même taille (par exemple, pour x86-32, leur taille est de 32 bits), vous pouvez passer outre en passant des pointeurs comme paramètres à B<makecontext>() suivi de I<argc>. Cependant, sachez que cela n'est pas forcément portable, et indéfini selon les standards, et ne fonctionnera pas sur les architectures où la taille des pointeurs est supérieure à la taille des entiers I<int>. Néanmoins, avec la version 2.8, la glibc a effectué quelques changements à B<makecontext>(), afin de permettre cela sur certaines architecture 64 bits (par exemple, x86-64).

note: type: SH
en: EXAMPLE
fr: EXEMPLE

note: type: Plain text
en: The example program below demonstrates the use of B<getcontext>(3), B<makecontext>(), and B<swapcontext>().  Running the program produces the following output:
fr: Le programme d'exemple ci-dessous décrit l'utilisation de B<getcontext>(3), B<makecontext>() et B<swapcontext>(). Ce programme produit la sortie suivante\ :

note: type: SS
en: Program source
fr: Source du programme

note: type: TH
en: 2008-11-11
fr: 11 novembre 2008

note: type: Plain text
en: pthread_attr_init, pthread_attr_destroy - initialize and destroy thread attributes object
fr: pthread_attr_init, pthread_attr_destroy - Initialiser et détruire un objet d'attributs de thread

note: type: Plain text
en: Compile and link with I<-pthread>.
fr: Compilez et effectuez l'édition des liens avec l'option I<-pthread>.

note: type: Plain text
en: The B<pthread_attr_init>()  function initializes the thread attributes object pointed to by I<attr> with default attribute values.  After this call, individual attributes of the object can be set using various related functions (listed under SEE ALSO), and then the object can be used in one or more B<pthread_create>(3)  calls that create threads.
fr: La fonction B<pthread_attr_init>() initialise l'objet d'attributs de thread pointé par I<attr> avec des valeurs d'attributs par défaut. Après cet appel, les attributs individuels de cet objet peuvent être modifiés en utilisant diverses fonctions (listées dans la section VOIR AUSSI), et l'objet peut alors être utilisé dans un ou plusieurs appels de B<pthread_create>(3) pour créer des threads.

note: type: Plain text
en: Calling B<pthread_attr_init>()  on a thread attributes object that has already been initialized results in undefined behavior.
fr: Appeler B<pthread_attr_init>() sur un objet d'attributs de thread qui a déjà été initialisé résulte en un comportement indéfini.

note: type: Plain text
en: When a thread attributes object is no longer required, it should be destroyed using the B<pthread_attr_destroy>()  function.  Destroying a thread attributes object has no effect on threads that were created using that object.
fr: Quand un objet d'attributs de thread n'est plus nécessaire, il devrait être détruit en appelant la fonction B<pthread_attr_destroy>(). Détruire un objet d'attributs de thread n'a aucun effet sur les threads qui ont été créés en utilisant cet objet.

note: type: Plain text
en: Once a thread attributes object has been destroyed, it can be reinitialized using B<pthread_attr_init>().  Any other use of a destroyed thread attributes object has undefined results.
fr: Dès qu'un objet d'attributs de thread a été détruit, il peut être réinitialisé en appelant B<pthread_attr_init>(). Toute autre utilisation d'un objet d'attributs de thread entraîne des résultats indéfinis.

note: type: Plain text
en: On success, these functions return 0; on error, they return a nonzero error number.
fr: En cas de réussite, ces fonctions renvoient 0 ; en cas d'erreur elles renvoient un numéro d'erreur non nul.

note: type: Plain text
en: POSIX.1-2001 documents an B<ENOMEM> error for B<pthread_attr_init>(); on Linux these functions always succeed (but portable and future-proof applications should nevertheless handle a possible error return).
fr: POSIX.1-2001 documente une erreur B<ENOMEM> pour B<pthread_attr_init>(). Sous Linux, ces fonctions réussissent toujours (mais les applications portables et à l'épreuve du temps devraient néanmoins prendre en charge une possible valeur de retour).

note: type: Plain text
en: The I<pthread_attr_t> type should be treated as opaque: any access to the object other than via pthreads functions is nonportable and produces undefined results.
fr: Le type I<pthread_attr_t> doit être traité comme opaque\ ; tout accès à l'objet en dehors des fonctions pthreads n'est pas portable et peut produire des résultats indéfinis.

note: type: Plain text
en: The program below optionally makes use of B<pthread_attr_init>()  and various related functions to initialize a thread attributes object that is used to create a single thread.  Once created, the thread uses the B<pthread_getattr_np>(3)  function (a nonstandard GNU extension) to retrieve the thread's attributes, and then displays those attributes.
fr: Le programme ci-dessous fait un appel optionnel à B<pthread_attr_init>() et à d'autres fonctions similaires pour initialiser un objet d'attributs de thread afin de l'utiliser pour créer un thread unique. Une fois créé, le thread utilise la fonction B<pthread_getattr_np>(3) (une extension GNU non standard) pour récupérer les attributs de threads, et les afficher.

note: type: Plain text
en: If the program is run with no command-line argument, then it passes NULL as the I<attr> argument of B<pthread_create>(3), so that the thread is created with default attributes.  Running the program on Linux/x86-32 with the NPTL threading implementation, we see the following:
fr: Si le programme est exécuté sans argument sur la ligne de commande, alors il passe NULL comme valeur de l'argument I<attr> de B<pthread_create>(3), si bien que le thread est créé avec les attributs par défaut. En exécutant ce programme sur Linux/x86-32 avec l'implémentation NPTL, l'affichage sera\ :

note: type: Plain text
en: When we supply a stack size as a command-line argument, the program initializes a thread attributes object, sets various attributes in that object, and passes a pointer to the object in the call to B<pthread_create>(3).  Running the program on Linux/x86-32 with the NPTL threading implementation, we see the following:
fr: Quand une taille de pile est passée sur la ligne de commande, le programme initialise un objet d'attributs de thread, modifie divers attributs de cet objet, et passe un pointeur sur cet objet dans l'appel à B<pthread_create>(3). En exécutant ce programme sur Linux/x86-32 avec l'implémentation NPTL, l'affichage sera\ :

note: type: Plain text
en: #define _GNU_SOURCE     /* To get pthread_getattr_np() declaration */
    #include E<lt>pthread.hE<gt>
    #include E<lt>stdio.hE<gt>
    #include E<lt>stdlib.hE<gt>
    #include E<lt>unistd.hE<gt>
    #include E<lt>errno.hE<gt>
fr: #define _GNU_SOURCE     /* Pour la déclaration de pthread_getattr_np() */
    #include E<lt>pthread.hE<gt>
    #include E<lt>stdio.hE<gt>
    #include E<lt>stdlib.hE<gt>
    #include E<lt>unistd.hE<gt>
    #include E<lt>errno.hE<gt>

note: type: TH
en: 2010-09-10
fr: 10 septembre 2010

note: type: Plain text
en: pthread_attr_setaffinity_np, pthread_attr_getaffinity_np - set/get CPU affinity attribute in thread attributes object
fr: pthread_attr_setaffinity_np, pthread_attr_getaffinity_np - Définir ou obtenir l'attribut d'affinité CPU d'un objet d'attributs de thread

note: type: Plain text
en: B<#define _GNU_SOURCE>             /* See feature_test_macros(7) */
    B<#include E<lt>pthread.hE<gt>>
fr: B<#define _GNU_SOURCE>             /* Consultez feature_test_macros(7) */
    B<#include E<lt>pthread.hE<gt>>

note: type: Plain text
en: The B<pthread_attr_setaffinity_np>()  function sets the CPU affinity mask attribute of the thread attributes object referred to by I<attr> to the value specified in I<cpuset>.  This attribute determines the CPU affinity mask of a thread created using the thread attributes object I<attr>.
fr: La fonction B<pthread_attr_setaffinity_np>() définit l'attribut du masque d'affinité CPU de l'objet d'attributs de thread auquel I<attr> fait référence à la valeur indiquée par I<cpuset>. Cet attribut détermine le masque d'affinité CPU d'un thread créé en utilisant l'objet d'attributs de thread I<attr>.

note: type: Plain text
en: The B<pthread_attr_getaffinity_np>()  function returns the CPU affinity mask attribute of the thread attributes object referred to by I<attr> in the buffer pointed to by I<cpuset>.
fr: La fonction B<pthread_attr_getaffinity_np>() renvoie, dans le tampon pointé par I<cpuset>, l'attribut du masque d'affinité CPU de l'objet d'attributs de thread auquel I<attr> fait référence.

note: type: Plain text
en: The argument I<cpusetsize> is the length (in bytes) of the buffer pointed to by I<cpuset>.  Typically, this argument would be specified as I<sizeof(cpu_set_t)>.
fr: Le paramètre I<cpusetsize> est la longueur (en octets) du tampon pointé par I<cpuset>. Typiquement, ce paramètre sera I<sizeof (cpu_set_t)>.

note: type: Plain text
en: For more details on CPU affinity masks, see B<sched_setaffinity>(2).  For a description of a set of macros that can be used to manipulate and inspect CPU sets, see B<CPU_SET>(3).
fr: Pour plus de détails sur les masques d'affinité CPU, consultez B<sched_setaffinity>(2). Pour une description d'un jeu de macros qui peuvent être utilisées pour manipuler et inspecter des ensembles de CPU, consultez B<CPU_SET>(3).

note: cpumask_t The raw sched_getaffinity() system call returns the size (in bytes) of the cpumask_t type. type: Plain text
en: (B<pthread_attr_setaffinity_np>())  I<cpuset> specified a CPU that was outside the set supported by the kernel.  (The kernel configuration option B<CONFIG_NR_CPUS> defines the range of the set supported by the kernel data type used to represent CPU sets.)
fr: (B<pthread_attr_setaffinity_np>()) Le I<cpuset> indiquait un CPU en dehors de l'ensemble pris en charge par le noyau (l'option de configuration B<CONFIG_NR_CPUS> du noyau définit l'intervalle de l'ensemble pris en charge par le type de données du noyau pour représenter les ensembles de CPU).

note: type: Plain text
en: (B<pthread_attr_getaffinity_np>())  A CPU in the affinity mask of the thread attributes object referred to by I<attr> lies outside the range specified by I<cpusetsize> (i.e., I<cpuset>/I<cpusetsize> is too small).
fr: (B<pthread_attr_getaffinity_np>()) Un CPU du masque d'affinité de l'objet d'attributs de thread auquel I<attr> fait référence réside en dehors de l'intervalle indiqué par I<cpusetsize> (c'est-à-dire, I<cpuset>/I<cpusetsize> est trop petit).

note: type: Plain text
en: (B<pthread_attr_setaffinity_np>())  Could not allocate memory.
fr: (B<pthread_attr_setaffinity_np>()) Impossible d'allouer de la mémoire.

note: type: Plain text
en: These functions are provided by glibc since version 2.3.4.
fr: Ces fonctions sont fournies par la glibc depuis la version 2.3.4.

note: type: Plain text
en: These functions are nonstandard GNU extensions; hence the suffix "_np" (nonportable) in the names.
fr: Ces fonctions sont des extensions non standard GNU ; c'est la raison du suffixe « _np » (non portable) dans leur nom.

note: type: Plain text
en: In glibc 2.3.3 only, versions of these functions were provided that did not have a I<cpusetsize> argument.  Instead the CPU set size given to the underlying system calls was always I<sizeof(cpu_set_t)>.
fr: Dans la glibc 2.3.3, uniquement, les versions de ces fonctions n'avaient pas de paramètre I<cpusetsize>. À la place, la taille de l'ensemble de CPU fourni à l'appel système sous-jacent était toujours I<sizeof(cpu_set_t)>.

note: type: Plain text
en: pthread_attr_setdetachstate, pthread_attr_getdetachstate - set/get detach state attribute in thread attributes object
fr: pthread_attr_setdetachstate, pthread_attr_getdetachstate - Définir ou obtenir l'attribut de l'état de détachement de l'objet d'attributs de thread

note: type: Plain text
en: The B<pthread_attr_setdetachstate>()  function sets the detach state attribute of the thread attributes object referred to by I<attr> to the value specified in I<detachstate>.  The detach state attribute determines whether a thread created using the thread attributes object I<attr> will be created in a joinable or a detached state.
fr: La fonction B<pthread_attr_setdetachstate>() définit l'attribut d'état de détachement de l'objet d'attributs de thread auquel I<attr> fait référence à la valeur indiquée par I<detachstate>. Cet attribut d'état de détachemennt détermine si un thread créé en utilisant l'objet d'attributs de thread I<attr> sera dans un état joignable ou détaché.

note: type: Plain text
en: The following values may be specified in I<detachstate>:
fr: Les valeurs suivantes peuvent être spécifiées dans I<detachstate>\ :

note: type: Plain text
en: Threads that are created using I<attr> will be created in a detached state.
fr: Les threads créés avec I<attr> seront dans un état détaché.

note: type: Plain text
en: Threads that are created using I<attr> will be created in a joinable state.
fr: Les threads créés avec I<attr> seront dans un état joignable.

note: type: Plain text
en: The default setting of the detach state attribute in a newly initialized thread attributes object is B<PTHREAD_CREATE_JOINABLE>.
fr: Par défaut, l'attribut d'état de détachement est initialisé à B<PTHREAD_CREATE_JOINABLE> dans un objet d'attributs de thread.

note: type: Plain text
en: The B<pthread_attr_getdetachstate>()  returns the detach state attribute of the thread attributes object I<attr> in the buffer pointed to by I<detachstate>.
fr: La fonction B<pthread_attr_getdetachstate>() renvoie, dans le tampon pointé par I<detachstate>, l'attribut contenant l'état de détachement de l'objet d'attributs de thread I<attr>.

note: type: Plain text
en: B<pthread_attr_setdetachstate>()  can fail with the following error:
fr: B<pthread_attr_setdetachstate>() peut échouer avec l'erreur suivante\ :

note: type: Plain text
en: An invalid value was specified in I<detachstate>.
fr: Une valeur invalide a été spécifiée dans I<detachstate>.

note: type: Plain text
en: The B<pthread_attr_setdetachstate>()  and B<pthread_attr_getdetachstate>()  functions are thread-safe.
fr: Les fonctions B<pthread_attr_setdetachstate>() et B<pthread_attr_getdetachstate>()  sont sûres dans un contexte multithread.

note: type: Plain text
en: See B<pthread_create>(3)  for more details on detached and joinable threads.
fr: Consultez B<pthread_create>(3)  pour plus de détails sur les threads joignables et détachés.

note: type: Plain text
en: A thread that is created in a joinable state should eventually either be joined using B<pthread_join>(3)  or detached using B<pthread_detach>(3); see B<pthread_create>(3).
fr: Un thread qui est créé dans un état joignable devrait à la fin soit être joint avec B<pthread_join>(3), soit être détaché avec B<pthread_detach>(3)\ ; consultez B<pthread_create>(3).

note: type: Plain text
en: It is an error to specify the thread ID of a thread that was created in a detached state in a later call to B<pthread_detach>(3)  or B<pthread_join>(3).
fr: C'est une erreur de spécifier, lors d'un appel ultérieur à B<pthread_detach>(3) ou B<pthread_join>(3), comme identifiant de thread un thread qui a été créé dans un état détaché.

note: type: Plain text
en: See B<pthread_attr_init>(3).
fr: Consultez B<pthread_attr_init>(3).

note: type: Plain text
en: pthread_attr_setguardsize, pthread_attr_getguardsize - set/get guard size attribute in thread attributes object
fr: pthread_attr_setguardsize, pthread_attr_getguardsize - Définir ou obtenir la taille de garde d'un objet d'attributs de thread

note: type: Plain text
en: The B<pthread_attr_setguardsize>()  function sets the guard size attribute of the thread attributes object referred to by I<attr> to the value specified in I<guardsize>.
fr: La fonction B<pthread_attr_setguardsize>() définit l'attribut de taille de garde de l'objet d'attributs de thread auquel I<thread> fait référence à la valeur indiquée par I<guardsize>.

note: type: Plain text
en: If I<guardsize> is greater than 0, then for each new thread created using I<attr> the system allocates an additional region of at least I<guardsize> bytes at the end of the thread's stack to act as the guard area for the stack (but see BUGS).
fr: Si I<guardsize> est positif, alors, pour chaque thread créé avec I<attr>, le système alloue une région supplémentaire d'au moins I<guardsize> octets à la fin de la pile du thread afin de servir de zone de protection pour la pile (voir la section BOGUES).

note: type: Plain text
en: If I<guardsize> is 0, then new threads created with I<attr> will not have a guard area.
fr: Si I<guardsize> est nul, les nouveaux threads créés avec I<attr> n'auront pas de zone de protection.

note: type: Plain text
en: The default guard size is the same as the system page size.
fr: La taille de garde par défaut est la taille d'une page système.

note: type: Plain text
en: If the stack address attribute has been set in I<attr> (using B<pthread_attr_setstack>(3)  or B<pthread_attr_setstackaddr>(3)), meaning that the caller is allocating the thread's stack, then the guard size attribute is ignored (i.e., no guard area is created by the system): it is the application's responsibility to handle stack overflow (perhaps by using B<mprotect>(2)  to manually define a guard area at the end of the stack that it has allocated).
fr: Si l'adresse de la pile a été définie dans I<attr> (en utilisant B<pthread_attr_setstack>(3) ou B<pthread_attr_setstackaddr>(3)), ce qui signifie que l'appelant alloue la pile du thread, alors l'attribut contenant la taille de garde est ignoré (c'est-à-dire, aucune zone de garde n'est créée par le système) : il est de la responsabilité de l'application de prendre en charge les débordements de pile (peut-être en utilisant B<mprotect>(2) pour définir manuellement une zone de protection à la fin de la pile qui a été allouée).

note: type: Plain text
en: The B<pthread_attr_getguardsize>()  function returns the guard size attribute of the thread attributes object referred to by I<attr> in the buffer pointed to by I<guardsize>.
fr: La fonction B<pthread_attr_getguardsize>() renvoie, dans le tampon pointé par I<guardsize>, l'attribut contenant la taille de garde de l'objet d'attributs de thread auquel I<attr> fait référence.

note: type: Plain text
en: POSIX.1-2001 documents an B<EINVAL> error if I<attr> or I<guardsize> is invalid.  On Linux these functions always succeed (but portable and future-proof applications should nevertheless handle a possible error return).
fr: POSIX.1-2001 documente une erreur B<EINVAL> si I<attr> ou I<guardsize> n'est pas valable. Sous Linux, ces fonctions réussissent toujours (mais les applications portables et à l'épreuve du temps devraient néanmoins prendre en charge une possible valeur de retour).

note: type: Plain text
en: These functions are provided by glibc since version 2.1.
fr: Ces fonctions sont fournies par la glibc depuis la version 2.1.

note: type: Plain text
en: The B<pthread_attr_setguardsize>()  and B<pthread_attr_getguardsize>()  functions are thread-safe.
fr: Les fonctions B<pthread_attr_setguardsize>() et B<pthread_attr_getguardsize>() sont sûres dans un contexte multithread.

note: type: Plain text
en: A guard area consists of virtual memory pages that are protected to prevent read and write access.  If a thread overflows its stack into the guard area, then, on most hard architectures, it receives a B<SIGSEGV> signal, thus notifying it of the overflow.  Guard areas start on page boundaries, and the guard size is internally rounded up to the system page size when creating a thread.  (Nevertheless, B<pthread_attr_getguardsize>()  returns the guard size that was set by B<pthread_attr_setguardsize>().)
fr: Une zone de garde consiste en des pages de mémoire virtuelles qui sont protégées pour empêcher des accès en lecture ou écriture. Si la pile d'un thread déborde dans la zone de garde, alors, pour la plupart des architectures matérielles, il reçoit un signal B<SIGSEGV>, ce qui le prévient du débordement. Les zones de protection démarrent sur des limites de pages, et la taille de garde est arrondie en interne au multiple de taille de pages système supérieur lors de la création d'un thread (cependant, B<pthread_attr_getguardsize>() renvoie la taille de garde qui a été définie par B<pthread_attr_setguardsize>()).

note: type: Plain text
en: Setting a guard size of 0 may be useful to save memory in an application that creates many threads and knows that stack overflow can never occur.
fr: Définir une taille de garde de 0 peut être utile pour économiser de la mémoire dans une application qui crée beaucoup de thread et sait qu'il n'y aura jamais de débordement de la pile.

note: type: Plain text
en: Choosing a guard size larger than the default size may be necessary for detecting stack overflows if a thread allocates large data structures on the stack.
fr: Choisir une taille de garde supérieure à la taille par défaut peut être nécessaire pour détecter des débordements de pile si un thread alloue des structures de données importantes sur la pile.

note: type: SH
en: BUGS
fr: BOGUES

note: type: Plain text
en: As at glibc 2.8, the NPTL threading implementation includes the guard area within the stack size allocation, rather than allocating extra space at the end of the stack, as POSIX.1 requires.  (This can result in an B<EINVAL> error from B<pthread_create>(3)  if the guard size value is too large, leaving no space for the actual stack.)
fr: Au moment de la glibc 2.8, l'implémentation des threads NPTL place la zone de protection dans la taille allouée à la pile, plutôt que d'allouer de l'espace supplémentaire à la fin de la pile, comme exigé par POSIX.1 (ceci peut causer une erreur B<EINVAL> lors de B<pthread_create>(3) si la taille de garde est trop importante, ne laissant en fait pas de place à la pile).

note: glibc includes the guardsize within the allocated stack size, which looks pretty clearly to be in violation of POSIX. Filed bug, 22 Oct 2008: http://sources.redhat.com/bugzilla/show_bug.cgi?id=6973 Older reports: https//bugzilla.redhat.com/show_bug.cgi?id=435337 Reportedly, LinuxThreads did the righ
en: The obsolete LinuxThreads implementation did the right thing, allocating extra space at the end of the stack for the guard area.
fr: L'implémentation obsolète LinuxThreads faisait ce qu'il fallait, en allouant de l'espace supplémentaire à la fin de la pile pour la zone de protection.

note: type: Plain text
en: See B<pthread_getattr_np>(3).
fr: Consultez B<pthread_getattr_np>(3).

note: type: TH
en: 2013-04-19
fr: 19 avril 2013

note: type: Plain text
en: pthread_attr_setinheritsched, pthread_attr_getinheritsched - set/get inherit-scheduler attribute in thread attributes object
fr: pthread_attr_setinheritsched, pthread_attr_getinheritsched - Définir ou obtenir l'attribut d'héritage d'ordonnancement d'un objet d'attributs de thread

note: type: Plain text
en: The B<pthread_attr_setinheritsched>()  function sets the inherit-scheduler attribute of the thread attributes object referred to by I<attr> to the value specified in I<inheritsched>.  The inherit-scheduler attribute determines whether a thread created using the thread attributes object I<attr> will inherit its scheduling attributes from the calling thread or whether it will take them from I<attr>.
fr: La fonction B<pthread_attr_setinheritsched>() définit l'attribut d'héritage d'ordonnancement de l'objet d'attributs de thread auquel I<attr> fait référence à la valeur indiquée par I<inheritsched>. Cet attribut détermine si un thread créé en utilisant l'objet d'attributs de thread I<attr> héritera les paramètres d'ordonnancement du thread appelant, ou prendra la valeur fournie par I<attr>.

note: type: Plain text
en: The following scheduling attributes are affected by the inherit-scheduler attribute: scheduling policy (B<pthread_attr_setschedpolicy>(3)), scheduling priority (B<pthread_attr_setschedparam>(3)), and contention scope (B<pthread_attr_setscope>(3)).
fr: Les attributs d'ordonnancement suivants dépendent de l'attribut d'ordonnancement hérité : la politique d'ordonnancement (B<pthread_attr_setschedpolicy>(3)), la priorité d'ordonnancement (B<pthread_attr_setschedparam>(3)), et l'arbitrage de compétitions (B<pthread_attr_setscope>(3)).

note: type: Plain text
en: The following values may be specified in I<inheritsched>:
fr: Les valeurs suivantes peuvent être spécifiées dans I<inheritsched>\ :

note: type: Plain text
en: Threads that are created using I<attr> inherit scheduling attributes from the creating thread; the scheduling attributes in I<attr> are ignored.
fr: Les threads qui sont créés en utilisant I<attr> héritent des attributs d'ordonnancement du thread appelant. Les attributs d'ordonnancement dans I<attr> sont ignorés.

note: FIXME what are the defaults for scheduler settings? type: Plain text
en: Threads that are created using I<attr> take their scheduling attributes from the values specified by the attributes object.
fr: Les threads qui sont créés en utilisant I<attr> prennent comme attributs d'ordonnancement les valeurs spécifiées dans l'objet d'attributs de thread.

note: type: Plain text
en: The default setting of the inherit-scheduler attribute in a newly initialized thread attributes object is B<PTHREAD_INHERIT_SCHED>.
fr: La valeur par défaut de l'attribut d'ordonnancement pour un nouvel objet d'attributs de thread est B<PTHREAD_INHERIT_SCHED>.

note: type: Plain text
en: The B<pthread_attr_getinheritsched>()  returns the inherit-scheduler attribute of the thread attributes object I<attr> in the buffer pointed to by I<inheritsched>.
fr: La fonction B<pthread_attr_getinheritsched>() renvoie, dans le tampon pointé par I<inheritsched>, l'attribut contenant l'ordonnancement de l'objet d'attributs de thread auquel I<attr> fait référence.

note: type: Plain text
en: B<pthread_attr_setinheritsched>()  can fail with the following error:
fr: B<pthread_attr_setinheritsched>() peut échouer avec les erreurs suivantes :

note: type: Plain text
en: Invalid value in I<inheritsched>.
fr: Valeur invalide pour I<inheritsched>.

note: .SH VERSIONS Available since glibc 2.0. type: Plain text
en: POSIX.1-2001 also documents an optional B<ENOTSUP> error ("attempt was made to set the attribute to an unsupported value") for B<pthread_attr_setinheritsched>().
fr: POSIX.1-2001 documente également une erreur B<ENOTSUP> (tentative de définition de la priorité à une valeur non prise en charge) pour B<pthread_attr_setinheritsched>().

note: FIXME . Track status of the following bug: http://sourceware.org/bugzilla/show_bug.cgi?id=7007 type: Plain text
en: As at glibc 2.8, if a thread attributes object is initialized using B<pthread_attr_init>(3), then the scheduling policy of the attributes object is set to B<SCHED_OTHER> and the scheduling priority is set to 0.  However, if the inherit-scheduler attribute is then set to B<PTHREAD_EXPLICIT_SCHED>, then a thread created using the attribute object wrongly inherits its scheduling attributes from the creating thread.  This bug does not occur if either the scheduling policy or scheduling priority attribute is explicitly set in the thread attributes object before calling B<pthread_create>(3).
fr: Dans glibc 2.8, si un objet d'attributs de thread est initialisé avec B<pthread_attr_init>(3), alors la politique d'ordonnancement de l'objet des attributs est mis à B<SCHED_OTHER> et la priorité d'ordonnancement à 0. Cependant, si l'attribut d'héritage d'ordonnancement est mis à B<PTHREAD_EXPLICIT_SCHED>,un thread créé avec l'objet d'attributs de thread va hériter de manière erronée des attributs d'ordonnancement du thread appelant. Pour éviter cette erreur, il faut positionner soit la politique d'ordonnancement, soit l'attribut de priorité d'ordonnancement, de manière explicite dans l'objet d'attributs de thread avant d'appeler B<pthread_create>(3).

note: type: Plain text
en: See B<pthread_setschedparam>(3).
fr: Consultez B<pthread_setschedparam>(3).

note: type: TH
en: 2013-06-21
fr: 21 juin 2013

note: type: Plain text
en: pthread_attr_setschedparam, pthread_attr_getschedparam - set/get scheduling parameter attributes in thread attributes object
fr: pthread_attr_setschedparam, pthread_attr_getschedparam - Définir ou obtenir les paramètres d'ordonnancement d'un objet d'attributs de thread

note: type: Plain text
en: The B<pthread_attr_setschedparam>()  function sets the scheduling parameter attributes of the thread attributes object referred to by I<attr> to the values specified in the buffer pointed to by I<param>.  These attributes determine the scheduling parameters of a thread created using the thread attributes object I<attr>.
fr: La fonction B<pthread_attr_setschedparam>() définit l'attribut des paramètres d'ordonnancement de l'objet d'attributs de thread auquel I<attr> fait référence à la valeur indiquée par I<param>. Ces attributs déterminent les paramètres d'ordonnancement d'un thread créé en utilisant l'objet d'attributs de thread I<attr>.

note: type: Plain text
en: The B<pthread_attr_getschedparam>()  returns the scheduling parameter attributes of the thread attributes object I<attr> in the buffer pointed to by I<param>.
fr: La fonction B<pthread_attr_getschedparam>() renvoie, dans le tampon pointé par I<param>, l'attribut contenant les paramètres d'ordonnancement de l'objet d'attributs de thread auquel I<attr> fait référence.

note: type: Plain text
en: Scheduling parameters are maintained in the following structure:
fr: Les paramètres d'ordonnancement sont gérés dans la structure suivante\ :

note: type: Plain text
en: struct sched_param {
        int sched_priority;     /* Scheduling priority */
    };
fr: struct sched_param {
        int sched_priority;     /* Priorité d'ordonnancement */
    };

note: type: Plain text
en: As can be seen, only one scheduling parameter is supported.  For details of the permitted ranges for scheduling priorities in each scheduling policy, see B<sched_setscheduler>(2).
fr: Comme on peut le voir, un seul paramètre d'ordonnancement est supporté. Veuillez consulter B<sched_setscheduler>(2) pour plus de détails sur les valeurs possibles des priorités d'ordonnancement en fonction de chaque politique d'ordonnancement.

note: type: Plain text
en: In order for the parameter setting made by B<pthread_attr_setschedparam>()  to have effect when calling B<pthread_create>(3), the caller must use B<pthread_attr_setinheritsched>(3)  to set the inherit-scheduler attribute of the attributes object I<attr> to B<PTHREAD_EXPLICIT_SCHED>.
fr: Pour que les paramètres définis par B<pthread_attr_setschedparam>()  puissent être pris en compte lors de l'appel de B<pthread_create>(3), l'appelant doit définir l'attribut d'ordonnancement hérité de l'objet I<attr> au moyen de B<pthread_attr_setinheritsched>(3), en lui assignant la valeur B<PTHREAD_EXPLICIT_SCHED>.

note: .SH VERSIONS Available since glibc 2.0. type: Plain text
en: POSIX.1 documents B<EINVAL> and B<ENOTSUP> errors for B<pthread_attr_setschedparam>().  On Linux these functions always succeed (but portable and future-proof applications should nevertheless handle a possible error return).
fr: POSIX.1 documente des erreurs B<EINVAL> et B<ENOTSUP> pour B<pthread_attr_setschedparam>(). Sous Linux, ces fonctions réussissent toujours (mais les applications portables et à l'épreuve du temps devraient néanmoins prendre en charge une possible valeur de retour).

note: type: Plain text
en: See B<pthread_attr_setschedpolicy>(3)  for a list of the thread scheduling policies supported on Linux.
fr: Veuillez consulter B<pthread_attr_setschedpolicy>(3) pour avoir la liste des politiques d'ordonnancement des threads supportées sous Linux.

note: type: Plain text
en: pthread_attr_setschedpolicy, pthread_attr_getschedpolicy - set/get scheduling policy attribute in thread attributes object
fr: pthread_attr_setschedpolicy, pthread_attr_getschedpolicy - Définir ou obtenir l'attribut de politique d'ordonnancement d'un objet d'attributs de thread

note: type: Plain text
en: The B<pthread_attr_setschedpolicy>()  function sets the scheduling policy attribute of the thread attributes object referred to by I<attr> to the value specified in I<policy>.  This attribute determines the scheduling policy of a thread created using the thread attributes object I<attr>.
fr: La fonction B<pthread_attr_setschedpolicy>() définit l'attribut de politique d'ordonnancement de l'objet d'attributs de thread auquel I<attr> fait référence à la valeur indiquée par I<policy>. Cet attribut détermine la politique d'ordonnancement d'un thread créé en utilisant l'objet d'attributs de thread I<attr>.

note: FIXME . pthread_setschedparam() places no restriction on the policy, but pthread_attr_setschedpolicy() restricts policy to RR/FIFO/OTHER http://sourceware.org/bugzilla/show_bug.cgi?id=7013 type: Plain text
en: The supported values for I<policy> are B<SCHED_FIFO>, B<SCHED_RR>, and B<SCHED_OTHER>, with the semantics described in B<sched_setscheduler>(2).
fr: Les valeurs possibles pour I<policy> sont B<SCHED_FIFO>, B<SCHED_RR> et B<SCHED_OTHER>, leur signification est décrite dans B<sched_setscheduler>(2).

note: type: Plain text
en: The B<pthread_attr_getschedpolicy>()  returns the scheduling policy attribute of the thread attributes object I<attr> in the buffer pointed to by I<policy>.
fr: La fonction B<pthread_attr_getschedpolicy>() renvoie, dans le tampon pointé par I<policy>, l'attribut contenant l'attribut de politique d'ordonnancement de l'objet d'attributs de thread auquel I<attr> fait référence.

note: type: Plain text
en: In order for the policy setting made by B<pthread_attr_setschedpolicy>()  to have effect when calling B<pthread_create>(3), the caller must use B<pthread_attr_setinheritsched>(3)  to set the inherit-scheduler attribute of the attributes object I<attr> to B<PTHREAD_EXPLICIT_SCHED>.
fr: Pour que la politique définie par B<pthread_attr_setschedpolicy>()  puisse être prise en compte lors de l'appel de B<pthread_create>(3), l'appelant doit définir l'attribut d'ordonnancement hérité de l'objet I<attr> au moyen de B<pthread_attr_setinheritsched>(3), en lui assignant la valeur B<PTHREAD_EXPLICIT_SCHED>.

note: type: Plain text
en: B<pthread_attr_setschedpolicy>()  can fail with the following error:
fr: B<pthread_attr_setschedpolicy>() peut échouer avec l'erreur suivante :

note: type: Plain text
en: Invalid value in I<policy>.
fr: Valeur invalide dans I<policy>.

note: .SH VERSIONS Available since glibc 2.0. type: Plain text
en: POSIX.1-2001 also documents an optional B<ENOTSUP> error ("attempt was made to set the attribute to an unsupported value") for B<pthread_attr_setschedpolicy>().
fr: POSIX.1-2001 documente également une erreur B<ENOTSUP> (tentative de définition de la priorité à une valeur non prise en charge) pour B<pthread_attr_setschedpolicy>().

note: type: Plain text
en: pthread_attr_setscope, pthread_attr_getscope - set/get contention scope attribute in thread attributes object
fr: pthread_attr_setscope, pthread_attr_getscope - Définir ou obtenir la contention d'un objet d'attributs de thread

note: type: Plain text
en: The B<pthread_attr_setscope>()  function sets the contention scope attribute of the thread attributes object referred to by I<attr> to the value specified in I<scope>.  The contention scope attribute defines the set of threads against which a thread competes for resources such as the CPU.  POSIX.1-2001 specifies two possible values for I<scope>:
fr: La fonction B<pthread_attr_setscope>() définit l'attribut de contention de l'objet d'attributs de thread auquel I<attr> fait référence à la valeur indiquée par I<scope>. Cet attribut détermine l'ensemble des threads avec lesquels un thread est en compétition pour les ressources, telles que le CPU. POSIX.1-2001 spécifie deux valeurs possibles pour I<scope>\ :

note: type: Plain text
en: The thread competes for resources with all other threads in all processes on the system that are in the same scheduling allocation domain (a group of one or more processors).  B<PTHREAD_SCOPE_SYSTEM> threads are scheduled relative to one another according to their scheduling policy and priority.
fr: Le thread est en compétition pour les ressources avec tous les threads de tous les processus du système qui sont dans le même domaine d'allocation (un groupe composé d'un ou de plusieurs processeurs). Les threads B<PTHREAD_SCOPE_SYSTEM> sont ordonnancés entre eux en fonction de leur priorité et de la politique d'ordonnancement.

note: type: Plain text
en: The thread competes for resources with all other threads in the same process that were also created with the B<PTHREAD_SCOPE_PROCESS> contention scope.  B<PTHREAD_SCOPE_PROCESS> threads are scheduled relative to other threads in the process according to their scheduling policy and priority.  POSIX.1-2001 leaves it unspecified how these threads contend with other threads in other process on the system or with other threads in the same process that were created with the B<PTHREAD_SCOPE_SYSTEM> contention scope.
fr: Le thread est en compétition pour les ressources avec tous les threads du même processus du système qui ont aussi été créés avec B<PTHREAD_SCOPE_PROCESS>. Les threads B<PTHREAD_SCOPE_PROCESS> sont ordonnancés entre eux à l'intérieur du processus en fonction de leur priorité et de la politique d'ordonnancement. POSIX.1-2001 ne spécifie pas comment régler la compétition entre ces threads et les threads d'autres processus du système, ni avec les threads du même processus qui ont été créés avec B<PTHREAD_SCOPE_SYSTEM>.

note: type: Plain text
en: POSIX.1-2001 requires that an implementation support at least one of these contention scopes.  Linux supports B<PTHREAD_SCOPE_SYSTEM>, but not B<PTHREAD_SCOPE_PROCESS>.
fr: POSIX.1-2001 impose qu'une implémentation doit accepter au moins l'une de ces résolutions de compétition. Linux accepte B<PTHREAD_SCOPE_SYSTEM>, mais pas B<PTHREAD_SCOPE_PROCESS>.

note: type: Plain text
en: On systems that support multiple contention scopes, then, in order for the parameter setting made by B<pthread_attr_setscope>()  to have effect when calling B<pthread_create>(3), the caller must use B<pthread_attr_setinheritsched>(3)  to set the inherit-scheduler attribute of the attributes object I<attr> to B<PTHREAD_EXPLICIT_SCHED>.
fr: Sur les systèmes qui acceptent plusieurs arbitrages de compétition, pour que la politique définie par B<pthread_attr_setscope>()  puisse être prise en compte lors de l'appel de B<pthread_create>(3), l'appelant doit définir l'attribut d'ordonnancement hérité de l'objet I<attr> au moyen de B<pthread_attr_setinheritsched>(3), en lui assignant la valeur B<PTHREAD_EXPLICIT_SCHED>.

note: type: Plain text
en: The B<pthread_attr_getscope>()  function returns the contention scope attribute of the thread attributes object referred to by I<attr> in the buffer pointed to by I<scope>.
fr: La fonction B<pthread_attr_getscope>() renvoie, dans le tampon pointé par I<scope>, l'attribut contenant le mode de résolution de compétition de l'objet d'attributs de thread I<attr>.

note: type: Plain text
en: B<pthread_attr_setscope>()  can fail with the following errors:
fr: B<pthread_attr_setscope>() peut échouer avec les erreurs suivantes :

note: type: Plain text
en: An invalid value was specified in I<scope>.
fr: Une valeur invalide a été spécifiée dans I<scope>.

note: type: Plain text
en: I<scope> specified the value B<PTHREAD_SCOPE_PROCESS>, which is not supported on Linux.
fr: La valeur B<PTHREAD_SCOPE_PROCESS> est spécifiée dans I<scope>, or elle n'est pas supportée sous Linux.

note: type: Plain text
en: The B<PTHREAD_SCOPE_SYSTEM> contention scope typically indicates that a user-space thread is bound directly to a single kernel-scheduling entity.  This is the case on Linux for the obsolete LinuxThreads implementation and the modern NPTL implementation, which are both 1:1 threading implementations.
fr: La valeur B<PTHREAD_SCOPE_SYSTEM> indique typiquement qu'un thread dans l'espace utilisateur est rattaché directement à une entité unique d'ordonnancement du noyau. C'est le cas sous Linux avec l'implémentation obsolète LinuxThreads, mais aussi avec l'implémentation moderne NPTL, qui sont toutes les deux des implémentations de threads 1:1.

note: type: Plain text
en: POSIX.1-2001 specifies that the default contention scope is implementation-defined.
fr: POSIX.1-2001 spécifie que chaque implémentation est libre de définir la valeur par défaut.

note: type: TH
en: 2008-10-24
fr: 24 octobre 2008

note: type: Plain text
en: pthread_attr_setstack, pthread_attr_getstack - set/get stack attributes in thread attributes object
fr: pthread_attr_setstack, pthread_attr_getstack - Définir ou obtenir les attributs de pile d'un objet d'attributs de thread

note: type: Plain text
en: Feature Test Macro Requirements for glibc (see B<feature_test_macros>(7)):
fr: Exigences de macros de test de fonctionnalités pour la glibc (consultez B<feature_test_macros>(7)) :

note: type: Plain text
en: B<pthread_attr_getstack>(), B<pthread_attr_setstack>():
fr: B<pthread_attr_getstack>(), B<pthread_attr_setstack>() :

note: type: Plain text
en: The B<pthread_attr_setstack>()  function sets the stack address and stack size attributes of the thread attributes object referred to by I<attr> to the values specified in I<stackaddr> and I<stacksize>, respectively.  These attributes specify the location and size of the stack that should be used by a thread that is created using the thread attributes object I<attr>.
fr: La fonction B<pthread_attr_setstack>() définit l'adresse et la taille de la pile dans l'objet d'attributs de thread auquel I<attr> fait référence, à partir des valeurs indiquées par I<stackaddr> et I<stacksize> respectivement. Ces attributs indique l'emplacement et la taille de la pile qui doit être utilisée par un thread qui est créé en utilisant I<attr>.

note: type: Plain text
en: I<stackaddr> should point to the lowest addressable byte of a buffer of I<stacksize> bytes that was allocated by the caller.  The pages of the allocated buffer should be both readable and writable.
fr: I<stackaddr> devrait pointer vers l'octet adressable d'adresse la plus basse d'un tampon de I<stacksize> octets, alloué par l'appelant. Les pages du tampon alloué devraient être accessibles en lecture et écriture.

note: type: Plain text
en: The B<pthread_attr_getstack>()  function returns the stack address and stack size attributes of the thread attributes object referred to by I<attr> in the buffers pointed to by I<stackaddr> and I<stacksize>, respectively.
fr: La fonction B<pthread_attr_getstack>() renvoie, respectivement dans les tampons pointé par I<stackaddr> et I<stacksize>, l'adresse et la taille de la pile d'un objet d'attributs de thread auquel I<attr> fait référence.

note: type: Plain text
en: B<pthread_attr_setstack>()  can fail with the following error:
fr: B<pthread_attr_setstack>() peut échouer avec les erreurs suivantes :

note: type: Plain text
en: I<stacksize> is less than B<PTHREAD_STACK_MIN> (16384) bytes.  On some systems, this error may also occur if I<stackaddr> or I<stackaddr\ +\ stacksize> is not suitably aligned.
fr: I<stacksize> est inférieur à B<PTHREAD_STACK_MIN> (16384) octets. Sur certains systèmes, cette erreur peut également se produire si I<stackaddr> ou I<stackaddr\ +\ stacksize> n'est pas aligné correctement.

note: type: Plain text
en: POSIX.1-2001 also documents an B<EACCES> error if the stack area described by I<stackaddr> and I<stacksize> is not both readable and writable by the caller.
fr: POSIX.1-2001 documente également une erreur B<EACCES> si la zone de pile décrite par I<stackaddr> et I<stacksize> n'est pas accessible en lecture ou écriture par l'appelant.

note: type: Plain text
en: These functions are provided by glibc since version 2.2.
fr: Ces fonctions sont fournies par la glibc depuis la version 2.1.

note: type: Plain text
en: These functions are provided for applications that must ensure that a thread's stack is placed in a particular location.  For most applications, this is not necessary, and the use of these functions should be avoided.  (Use B<pthread_attr_setstacksize>(3)  if an application simply requires a stack size other than the default.)
fr: Ces fonctions sont fournies pour les applications qui doivent assurer que la pile d'un thread se trouve à un emplacement particulier. Pour la plupart des applications, ce n'est pas nécessaire, et l'utilisation de cette fonction devrait être évitée. (Utilisez B<pthread_attr_setstacksize>(3) si une application a juste besoin d'une pile de taille différente de la taille par défaut.)

note: type: Plain text
en: When an application employs B<pthread_attr_setstack>(), it takes over the responsibility of allocating the stack.  Any guard size value that was set using B<pthread_attr_setguardsize>(3)  is ignored.  If deemed necessary, it is the application's responsibility to allocate a guard area (one or more pages protected against reading and writing)  to handle the possibility of stack overflow.
fr: Quand une application utilise B<pthread_attr_setstack>(), elle prend la responsabilité d'allouer la pile. Si une taille de garde a été définie en utilisant B<pthread_attr_setguardsize>(3), elle est ignorée. Si c'est nécessaire, l'application est responsable de l'allocation d'une zone de protection (une page ou plus protégées en lecture et écriture) pour prendre en charge la possibilité d'un débordement de pile.

note: type: Plain text
en: The address specified in I<stackaddr> should be suitably aligned: for full portability, align it on a page boundary (I<sysconf(_SC_PAGESIZE)>).  B<posix_memalign>(3)  may be useful for allocation.  Probably, I<stacksize> should also be a multiple of the system page size.
fr: L'adresse indiquée par I<stackaddr> devrait être alignée correctement : pour une compatibilité complète, il faut l'aligner sur une limite de page (I<sysconf(_SC_PAGESIZE)>). B<posix_memalign>(3) peut être utile pour l'allocation. I<stacksize> devrait probablement aussi être un multiple de la taille des pages système.

note: type: Plain text
en: If I<attr> is used to create multiple threads, then the caller must change the stack address attribute between calls to B<pthread_create>(3); otherwise, the threads will attempt to use the same memory area for their stacks, and chaos will ensue.
fr: Si I<attr> est utilisé pour créer plusieurs threads, alors l'appelant doit changer l'attribut de l'adresse de la pile entre les appels à B<pthread_create>(3) ; sinon, les threads vont chercher à utiliser la même zone mémoire pour leurs piles, ce qui ne pourra que créer du chaos.

note: type: Plain text
en: pthread_attr_setstackaddr, pthread_attr_getstackaddr - set/get stack address attribute in thread attributes object
fr: pthread_attr_setstackaddr, pthread_attr_getstackaddr - Définir ou obtenir l'adresse de la pile de l'objet d'attributs de thread

note: type: Plain text
en: These functions are obsolete: B<do not use them.> Use B<pthread_attr_setstack>(3)  and B<pthread_attr_getstack>(3)  instead.
fr: Ces fonctions sont obsolètes : B<ne les utilisez pas>. Utilisez B<pthread_attr_setstack>(3) et B<pthread_attr_getstack>(3) à la place.

note: type: Plain text
en: The B<pthread_attr_setstackaddr>()  function sets the stack address attribute of the thread attributes object referred to by I<attr> to the value specified in I<stackaddr>.  This attribute specifies the location of the stack that should be used by a thread that is created using the thread attributes object I<attr>.
fr: La fonction B<pthread_attr_setstackaddr>() définit, à la valeur indiquée dans I<stackaddr>, l'attribut d'adresse de la pile de l'objet d'attributs de thread I<attr>. Cet attribut indique l'emplacement de la pile qui devrait être utilisée par un thread créé en utilisant l'objet d'attributs de thread I<attr>.

note: type: Plain text
en: I<stackaddr> should point to a buffer of at least B<PTHREAD_STACK_MIN> bytes that was allocated by the caller.  The pages of the allocated buffer should be both readable and writable.
fr: I<stackaddr> devrait pointer vers un tampon d'au moins B<PTHREAD_STACK_MIN> octets, alloué par l'appelant. Les pages du tampon alloué devraient être accessibles à la fois en lecture et en écriture.

note: type: Plain text
en: The B<pthread_attr_getstackaddr>()  function returns the stack address attribute of the thread attributes object referred to by I<attr> in the buffer pointed to by I<stackaddr>.
fr: La fonction B<pthread_attr_getstackaddr>() renvoie, dans le tampon pointé par I<stackaddr>, l'attribut d'adresse de la pile de l'objet d'attributs de thread I<attr>.

note: type: Plain text
en: No errors are defined (but applications should nevertheless handle a possible error return).
fr: Aucune erreur n'est définie (mais les applications devraient néanmoins prendre en charge un possible code d'erreur).

note: type: Plain text
en: POSIX.1-2001 specifies these functions but marks them as obsolete.  POSIX.1-2008 removes the specification of these functions.
fr: POSIX.1-2001 spécifie ces fonctions, mais les marque comme étant obsolètes. POSIX.1-2008 supprime la spécification de ces fonctions.

note: type: Plain text
en: I<Do not use these functions!> They cannot be portably used, since they provide no way of specifying the direction of growth or the range of the stack.  For example, on architectures with a stack that grows downward, I<stackaddr> specifies the next address past the I<highest> address of the allocated stack area.  However, on architectures with a stack that grows upward, I<stackaddr> specifies the I<lowest> address in the allocated stack area.  By contrast, the I<stackaddr> used by B<pthread_attr_setstack>(3)  and B<pthread_attr_getstack>(3), is always a pointer to the lowest address in the allocated stack area (and the I<stacksize> argument specifies the range of the stack).
fr: I<N'utilisez pas ces fonction !> Elles ne peuvent pas être utilisées de façon portable, puisqu'elle ne fournissent aucun moyen d'indiquer la direction ni l'intervalle de la pile. Par exemple, sur une architecture où la pile croit vers le bas, I<stackaddr> indique l'adresse après l'adresse I<la plus haute> de la zone de pile. Mais sur les architectures dont la pile croit vers le haut, I<stackaddr> indique l'adresse I<la plus basse> de la zone de pile allouée. A l'opposé, le paramètre I<stackaddr> utilisé par B<pthread_attr_setstack>(3) et B<pthread_attr_getstack>(3) est toujours un pointeur vers l'adresse la plus basse de la zone de pile allouée (et le paramètre I<stacksize> indique l'intervalle de la pile).

note: type: TH
en: 2012-03-15
fr: 15 mars 2012

note: type: Plain text
en: pthread_attr_setstacksize, pthread_attr_getstacksize - set/get stack size attribute in thread attributes object
fr: pthread_attr_setstacksize, pthread_attr_getstacksize - Définir ou obtenir la taille de la pile de l'objet d'attributs de thread

note: type: Plain text
en: The B<pthread_attr_setstacksize>()  function sets the stack size attribute of the thread attributes object referred to by I<attr> to the value specified in I<stacksize>.
fr: La fonction B<pthread_attr_setstacksize>() définit, à la valeur indiquée par I<stacksize>, l'attribut contenant la taille de la pile dans l'objet d'attributs de thread auquel I<attr> fait référence.

note: type: Plain text
en: The stack size attribute determines the minimum size (in bytes) that will be allocated for threads created using the thread attributes object I<attr>.
fr: L'attribut contenant la taille de la pile détermine la taille minimale (en octets) de la pile qui sera allouée pour les threads créés en utilisant l'objet d'attributs de thread I<attr>.

note: type: Plain text
en: The B<pthread_attr_getstacksize>()  function returns the stack size attribute of the thread attributes object referred to by I<attr> in the buffer pointed to by I<stacksize>.
fr: La fonction B<pthread_attr_getstacksize>() renvoie, dans le tampon pointé par I<stacksize>, l'attribut contenant la taille de la pile de l'objet d'attributs de thread I<attr>.

note: type: Plain text
en: B<pthread_attr_setstacksize>()  can fail with the following error:
fr: B<pthread_attr_setstacksize>() peut échouer avec les erreurs suivantes :

note: type: Plain text
en: The stack size is less than B<PTHREAD_STACK_MIN> (16384) bytes.
fr: La taille de la pile est inférieure à B<PTHREAD_STACK_MIN> (16384) octets.

note: e.g., MacOS type: Plain text
en: On some systems, B<pthread_attr_setstacksize>()  can fail with the error B<EINVAL> if I<stacksize> is not a multiple of the system page size.
fr: Sur certains systèmes, B<pthread_attr_setstacksize>() peut échouer avec l'erreur B<EINVAL> si I<stacksize> n'est pas un multiple de la taille des pages système.

note: type: Plain text
en: For details on the default stack size of new threads, see B<pthread_create>(3).
fr: Pour des détails sur la taille par défaut de la pile des nouveaux threads, consultez B<pthread_create>(3).

note: type: Plain text
en: A thread's stack size is fixed at the time of thread creation.  Only the main thread can dynamically grow its stack.
fr: La taille de la pile d'un thread est définie au moment de la création d'un thread. Seul le thread principal peut dynamiquement agrandir sa pile.

note: type: Plain text
en: The B<pthread_attr_setstack>(3)  function allows an application to set both the size and location of a caller-allocated stack that is to be used by a thread.
fr: La fonction B<pthread_attr_setstack>(3) permet à une application de définir à la fois la taille et l'emplacement d'une pile allouée par l'appelant qui doit être utilisée par un thread.

note: type: Plain text
en: As at glibc 2.8, if the specified I<stacksize> is not a multiple of B<STACK_ALIGN> (16 bytes on most architectures), it may be rounded I<downward>, in violation of POSIX.1-2001, which says that the allocated stack will be at least I<stacksize> bytes.
fr: Au moment de la glibc 2.8, si le paramètre I<stacksize> n'est pas un multiple de B<STACK_ALIGN> (16 octets sur la plupart des architectures), la taille peut être I<réduite>, ce qui est contraire à POSIX.1-2001, qui indique que la pile allouée doit être d'au moins I<stacksize> octets.

note: type: Plain text
en: See B<pthread_create>(3).
fr: Consultez B<pthread_create>(3).

note: type: TH
en: 2008-11-17
fr: 17 novembre 2008

note: type: Plain text
en: pthread_cancel - send a cancellation request to a thread
fr: pthread_cancel - Envoyer une requête d'annulation à un thread

note: type: Plain text
en: The B<pthread_cancel>()  function sends a cancellation request to the thread I<thread>.  Whether and when the target thread reacts to the cancellation request depends on two attributes that are under the control of that thread: its cancelability I<state> and I<type>.
fr: La fonction B<pthread_cancel>() envoie une requête d'annulation au thread I<thread>. Si et quand le thread ciblé réagit à la requête d'annulation dépend de deux attributs qui sont sous le contrôle de ce thread\ : son état d'annulation (I<state>) et son mode d'annulation (I<type>).

note: type: Plain text
en: A thread's cancelability state, determined by B<pthread_setcancelstate>(3), can be I<enabled> (the default for new threads) or I<disabled>.  If a thread has disabled cancellation, then a cancellation request remains queued until the thread enables cancellation.  If a thread has enabled cancellation, then its cancelability type determines when cancellation occurs.
fr: L'état d'annulation d'un thread, déterminé par B<pthread_setcancelstate>(3), peut être activé (I<enabled>), c'est le défaut pour les nouveaux threads, ou désactivé (I<disabled>). Si un thread désactive l'annulation, alors une demande d'annulation restera dans la file d'attente jusqu'à ce que le thread active l'annulation. Si un thread active l'annulation, alors son mode d'annulation va déterminer le moment où cette annulation est effectuée.

note: type: Plain text
en: A thread's cancellation type, determined by B<pthread_setcanceltype>(3), may be either I<asynchronous> or I<deferred> (the default for new threads).  Asynchronous cancelability means that the thread can be canceled at any time (usually immediately, but the system does not guarantee this).  Deferred cancelability means that cancellation will be delayed until the thread next calls a function that is a I<cancellation point>.  A list of functions that are or may be cancellation points is provided in B<pthreads>(7).
fr: Le mode d'annulation d'un thread, déterminé par B<pthread_setcanceltype>(3), peut être asynchrone (I<asynchronous>) ou retardée (I<deferred>), qui est le mode par défaut pour les nouveaux threads. Un mode d'annulation asynchrone signifie que le thread peut être annulé à tout moment (d'ordinaire immédiatement, mais ce n'est pas garanti). Un mode d'annulation retardé signifie que l'annulation peut être retardée jusqu'à ce que le thread appelle une fonction qui est un point d'annulation (I<cancellation point>). Une liste des fonctions qui sont ou peuvent être des points d'annulation est donnée dans B<pthreads>(7).

note: type: Plain text
en: When a cancellation requested is acted on, the following steps occur for I<thread> (in this order):
fr: Quand une requête d'annulation est traitée, les étapes suivantes sont effectuées pour I<thread> (dans cet ordre)\ :

note: type: Plain text
en: Cancellation clean-up handlers are popped (in the reverse of the order in which they were pushed) and called.  (See B<pthread_cleanup_push>(3).)
fr: Les gestionnaires de nettoyage sont dépilés (dans l'ordre inverse dans lequel ils ont été empilés) et appelés (consultez B<pthread_cleanup_push>(3)).

note: type: Plain text
en: Thread-specific data destructors are called, in an unspecified order.  (See B<pthread_key_create>(3).)
fr: Les destructeurs de données spécifiques aux threads sont appelés, dans un ordre non déterminé (consultez B<pthread_key_create>(3)).

note: type: Plain text
en: The thread is terminated.  (See B<pthread_exit>(3).)
fr: Le thread s'est terminé (consultez B<pthread_exit>(3)).

note: type: Plain text
en: The above steps happen asynchronously with respect to the B<pthread_cancel>()  call; the return status of B<pthread_cancel>()  merely informs the caller whether the cancellation request was successfully queued.
fr: Les étapes ci-dessus sont effectuées de manière asynchrone par rapport à l'appel à B<pthread_cancel>(). La valeur de retour de B<pthread_cancel>() ne fait qu'informer l'appelant si une requête d'annulation a été correctement mise en file d'attente.

note: type: Plain text
en: After a canceled thread has terminated, a join with that thread using B<pthread_join>(3)  obtains B<PTHREAD_CANCELED> as the thread's exit status.  (Joining with a thread is the only way to know that cancellation has completed.)
fr: Après qu'un thread annulé s'est terminé, une demande de jointure par B<pthread_join>(3) renvoie B<PTHREAD_CANCELED> comme état de sortie du thread. Il faut noter que joindre un thread est la seule manière de savoir si une annulation a terminé.

note: type: Plain text
en: On success, B<pthread_cancel>()  returns 0; on error, it returns a nonzero error number.
fr: En cas de réussite, B<pthread_cancel>() renvoie 0 ; en cas d'erreur, elle renvoie un numéro d'erreur non nul.

note: type: Plain text
en: No thread with the ID I<thread> could be found.
fr: Aucun thread avec pour identifiant I<thread> n'a pu être trouvé.

note: type: Plain text
en: On Linux, cancellation is implemented using signals.  Under the NPTL threading implementation, the first real-time signal (i.e., signal 32) is used for this purpose.  On LinuxThreads, the second real-time signal is used, if real-time signals are available, otherwise B<SIGUSR2> is used.
fr: Sous Linux, l'annulation est implémentée par des signaux. Avec l'implémentation NPTL, le premier signal temps-réel (c'est-à-dire le signal 32) est utilisé dans ce but. Avec LinuxThreads, le second signal temps-réel est utilisé, si les signaux temps-réels sont disponibles, sinon B<SIGUSR2> est utilisé à la place.

note: type: Plain text
en: The program below creates a thread and then cancels it.  The main thread joins with the canceled thread to check that its exit status was B<PTHREAD_CANCELED>.  The following shell session shows what happens when we run the program:
fr: Le programme ci-dessous crée un thread puis l'annule. Le thread principal joint le thread annulé pour vérifier que son état de sortie était bien B<PTHREAD_CANCELED>. La session suivante montre un exemple d'exécution\ :

note: type: TH
en: 2008-11-24
fr: 24 novembre 2008

note: type: Plain text
en: pthread_cleanup_push, pthread_cleanup_pop - push and pop thread cancellation clean-up handlers
fr: pthread_cleanup_push, pthread_cleanup_pop - Empiler et dépiler des gestionnaires de nettoyage de threads

note: type: Plain text
en: These functions manipulate the calling thread's stack of thread-cancellation clean-up handlers.  A clean-up handler is a function that is automatically executed when a thread is canceled (or in various other circumstances described below); it might, for example, unlock a mutex so that it becomes available to other threads in the process.
fr: Ces fonctions manipulent la pile de gestionnaires de nettoyage du thread appelant. Un gestionnaire de nettoyage est une fonction qui est automatiquement exécutée quand un thread est annulé (ou dans d'autres circonstances, décrites ci-dessous). Il peut, par exemple, déverrouiller un mutex pour le rendre disponible aux autres threads du processus.

note: type: Plain text
en: The B<pthread_cleanup_push>()  function pushes I<routine> onto the top of the stack of clean-up handlers.  When I<routine> is later invoked, it will be given I<arg> as its argument.
fr: La fonction B<pthread_cleanup_push>() empile I<routine> au sommet de la pile des gestionnaires de nettoyage. Quand I<routine> sera appelée ultérieurement, I<arg> sera passé en argument.

note: type: Plain text
en: The B<pthread_cleanup_pop>()  function removes the routine at the top of the stack of clean-up handlers, and optionally executes it if I<execute> is nonzero.
fr: La fonction B<pthread_cleanup_pop>() dépile la routine au sommet de la pile des gestionnaires de nettoyage, et éventuellement l'exécute si l'argument I<execute> est non nul.

note: type: Plain text
en: A cancellation clean-up handler is popped from the stack and executed in the following circumstances:
fr: Un gestionnaire de nettoyage est dépilé et exécuté dans les circonstances suivantes\ :

note: type: Plain text
en: When a thread is canceled, all of the stacked clean-up handlers are popped and executed in the reverse of the order in which they were pushed onto the stack.
fr: Quand un thread est annulé, tous les gestionnaires de nettoyage empilés sont dépilés et exécutés dans l'ordre inverse dans lequel ils ont été empilés.

note: type: Plain text
en: When a thread terminates by calling B<pthread_exit>(3), all clean-up handlers are executed as described in the preceding point.  (Clean-up handlers are I<not> called if the thread terminates by performing a I<return> from the thread start function.)
fr: Quand un thread se termine en appelant B<pthread_exit>(3), tous les gestionnaires de nettoyage sont exécutés comme décrit dans le point précédent. Il faut noter que les gestionnaires de nettoyage ne sont I<pas> appelés si le thread se termine par un I<return> depuis la fonction de démarrage du thread.

note: type: Plain text
en: When a thread calls B<pthread_cleanup_pop>()  with a nonzero I<execute> argument, the top-most clean-up handler is popped and executed.
fr: Quand un thread appelle B<pthread_cleanup_pop>() avec un argument I<execute> non nul, le gestionnaire de nettoyage au sommet de la pile est dépilé et exécuté.

note: type: Plain text
en: POSIX.1 permits B<pthread_cleanup_push>()  and B<pthread_cleanup_pop>()  to be implemented as macros that expand to text containing \(aqB<{>\(aq and \(aqB<}>\(aq, respectively.  For this reason, the caller must ensure that calls to these functions are paired within the same function, and at the same lexical nesting level.  (In other words, a clean-up handler is established only during the execution of a specified section of code.)
fr: POSIX.1 autorise B<pthread_cleanup_push>()  et B<pthread_cleanup_pop>()  à être implémentées comme des macros qui sont développées en du texte contenant «\ B<{>\ » et «\ B<}>\ » respectivement. Pour cette raison, l'appelant doit s'assurer que les appels à ces fonctions sont appariés à l'intérieur d'une même fonction, et au même niveau d'imbriquement lexical. En d'autres termes, un gestionnaire de nettoyage n'est établi que pendant l'exécution d'une partie spécifique de code.

note: type: Plain text
en: Calling B<longjmp>(3)  (B<siglongjmp>(3))  produces undefined results if any call has been made to B<pthread_cleanup_push>()  or B<pthread_cleanup_pop>()  without the matching call of the pair since the jump buffer was filled by B<setjmp>(3)  (B<sigsetjmp>(3)).  Likewise, calling B<longjmp>(3)  (B<siglongjmp>(3))  from inside a clean-up handler produces undefined results unless the jump buffer was also filled by B<setjmp>(3)  (B<sigsetjmp>(3))  inside the handler.
fr: Un appel à B<longjmp>(3)  (resp. B<siglongjmp>(3))  produit des résultats indéfinis si un appel à B<pthread_cleanup_push>()  ou B<pthread_cleanup_pop>()  a été réalisé sans l'appel correspondant de la paire si le tampon de saut a été rempli par B<setjmp>(3)  (resp. B<sigsetjmp>(3)). De la même manière, un appel à B<longjmp>(3)  (resp. B<siglongjmp>(3))  depuis un gestionnaire de nettoyage entraine des résultats indéfinis, sauf si le tampon de saut a lui aussi été rempli dans B<setjmp>(3)  (resp. B<sigsetjmp>(3))  à l'intérieur du gestionnaire.

note: type: Plain text
en: These functions do not return a value.
fr: Ces fonctions ne renvoient pas de valeur.

note: SH VERSIONS Available since glibc 2.0 type: Plain text
en: There are no errors.
fr: Il n'y a pas d'erreur.

note: type: Plain text
en: On Linux, the B<pthread_cleanup_push>()  and B<pthread_cleanup_pop>()  functions I<are> implemented as macros that expand to text containing \(aqB<{>\(aq and \(aqB<}>\(aq, respectively.  This means that variables declared within the scope of paired calls to these functions will be visible within only that scope.
fr: Sous Linux, les fonctions B<pthread_cleanup_push>()  et B<pthread_cleanup_pop>()  I<sont> implémentées comme des macros qui sont développées en du texte contenant «\ B<{>\ » et «\ B<}>\ » respectivement. Cela signifie que les variables déclarées entre les appels appariés à ces fonctions ne seront visible qu'à l'intérieur de cet intervalle.

note: The text was actually added in the 2004 TC2 type: Plain text
en: POSIX.1 says that the effect of using I<return>, I<break>, I<continue>, or I<goto> to prematurely leave a block bracketed B<pthread_cleanup_push>()  and B<pthread_cleanup_pop>()  is undefined.  Portable applications should avoid doing this.
fr: POSIX.1 indique qu'utiliser I<return>, I<break>, I<continue>, ou I<goto> pour quitter prématurément un bloc compris entre B<pthread_cleanup_push>()  et B<pthread_cleanup_pop>()  entraine un comportement indéfini. Les applications portables doivent l'éviter.

note: type: Plain text
en: The program below provides a simple example of the use of the functions described in this page.  The program creates a thread that executes a loop bracketed by B<pthread_cleanup_push>()  and B<pthread_cleanup_pop>().  This loop increments a global variable, I<cnt>, once each second.  Depending on what command-line arguments are supplied, the main thread sends the other thread a cancellation request, or sets a global variable that causes the other thread to exit its loop and terminate normally (by doing a I<return>).
fr: Le programme ci-dessous fournit un exemple simple de l'utilisation des fonctions décrites dans cette page. Le programme crée un thread qui exécute une boucle comprise entre des appels à B<pthread_cleanup_push>()  et B<pthread_cleanup_pop>(). Cette boucle incrémente une variable globale, I<cnt>, à chaque seconde. En fonction des arguments fournis sur la ligne de commande,, le thread principal envoie une requête d'annulation à l'autre thread, ou définit une variable globale qui fait que l'autre thread quitte sa boucle et se termine normalement (avec un I<return>).

note: type: Plain text
en: In the following shell session, the main thread sends a cancellation request to the other thread:
fr: Dans la session d'interpréteur de commande ci-dessous, le thread principal envoie une requête d'annulation à l'autre thread\ :

note: type: Plain text
en: From the above, we see that the thread was canceled, and that the cancellation clean-up handler was called and it reset the value of the global variable I<cnt> to 0.
fr: Dans la sortie, nous voyons que le thread a été annulé, et que le gestionnaire de nettoyage a été appelé et a remis la valeur de la variable globale I<cnt> à 0.

note: type: Plain text
en: In the next run, the main program sets a global variable that causes other thread to terminate normally:
fr: Lors de l'exécution suivante, le programme principal définit une variable globale qui fait que l'autre thread se termine normalement\ :

note: type: Plain text
en: From the above, we see that the clean-up handler was not executed (because I<cleanup_pop_arg> was 0), and therefore the value of I<cnt> was not reset.
fr: Dans la sortie, nous voyons que le gestionnaire de nettoyage n'a pas été appelé (car I<cleanup_pop_arg> vaut 0), et la variable I<cnt> n'a pas été réinitialisée.

note: type: Plain text
en: In the next run, the main program sets a global variable that causes the other thread to terminate normally, and supplies a nonzero value for I<cleanup_pop_arg>:
fr: Lors de l'exécution suivante, le programme principal définit une variable globale qui fait que l'autre thread se termine normalement, et fournit une valeur non-nulle à I<cleanup_pop_arg>\ :

note: type: Plain text
en: In the above, we see that although the thread was not canceled, the clean-up handler was executed, because the argument given to B<pthread_cleanup_pop>()  was nonzero.
fr: Dans la sortie, nous voyons que bien que le thread n'ait pas été annulé, le gestionnaire de nettoyage a été appelé, car l'argument fourni à B<pthread_cleanup_pop> n'était pas nul.

note: type: Plain text
en:     s = pthread_create(&thr, NULL, thread_start, NULL);
        if (s != 0)
            handle_error_en(s, "pthread_create");
fr:     s = pthread_create(&thread, NULL, thread_start, NULL);
        if (s != 0)
            handle_error_en(s, "pthread_create");

note: type: TH
en: 2008-12-04
fr: 4 décembre 2008

note: type: Plain text
en: pthread_cleanup_push_defer_np, pthread_cleanup_pop_restore_np - push and pop thread cancellation clean-up handlers while saving cancelability type
fr: pthread_cleanup_push_defer_np, pthread_cleanup_pop_restore_np - Empiler et dépiler les gestionnaires de nettoyage tout en préservant le mode d'annulation

note: type: Plain text
en: Compile and link with I<-pthread>.
fr: Compilez et effectuez l'édition des liens avec l'option I<-pthread>.

note: type: Plain text
en: These functions are the same as B<pthread_cleanup_push>(3)  and B<pthread_cleanup_pop>(3), except for the differences noted on this page.
fr: Ces fonctions opèrent de la même façon que B<pthread_cleanup_push>(3) et B<pthread_cleanup_pop>(3), à l'exception des différences décrites dans cette page.

note: type: Plain text
en: Like B<pthread_cleanup_push>(3), B<pthread_cleanup_push_defer_np>()  pushes I<routine> onto the thread's stack of cancellation clean-up handlers.  In addition, it also saves the thread's current cancelability type, and sets the cancelability type to "deferred" (see B<pthread_setcanceltype>(3)); this ensures that cancellation clean-up will occur even if the thread's cancelability type was "asynchronous" before the call.
fr: Comme B<pthread_cleanup_push>(3), B<pthread_cleanup_push_defer_np>() empile I<routine> sur la pile des gestionnaires de nettoyage du thread. De plus, elle sauvegarde le mode actuel d'annulation, et le change en «\ deferred\ » (retardé), consultez B<pthread_setcanceltype>(3). Cela garantit que le nettoyage à l'annulation sera appelé même si le mode d'annulation était à «\ asynchronous\ » (asynchrone) avant l'appel.

note: type: Plain text
en: Like B<pthread_cleanup_pop>(3), B<pthread_cleanup_pop_restore_np>()  pops the top-most clean-up handler from the thread's stack of cancellation clean-up handlers.  In addition, it restores the thread's cancelability type to its value at the time of the matching B<pthread_cleanup_push_defer_np>().
fr: Comme B<pthread_cleanup_pop>(3), B<pthread_cleanup_pop_restore_np>() dépile le gestionnaire de nettoyage depuis la pile des gestionnaires de nettoyage du thread. De plus, elle remet le mode d'annulation à la valeur qu'il avait lors de l'appel à B<pthread_cleanup_push_defer_np>() correspondant.

note: type: Plain text
en: The caller must ensure that calls to these functions are paired within the same function, and at the same lexical nesting level.  Other restrictions apply, as described in B<pthread_cleanup_push>(3).
fr: L'appelant doit vérifier que les appels à ces fonctions sont appariés à l'intérieur de la même fonction, et au même niveau d'imbriquement lexical. D'autres restrictions s'appliquent, comme expliqué dans B<pthread_cleanup_push>(3).

note: type: Plain text
en: This sequence of calls:
fr: Cette séquence d'appels\ :

note: type: Plain text
en: is equivalent to (but shorter and more efficient than):
fr: est équivalente à (mais en plus court et plus efficace)\ :

note: type: TH
en: 2012-08-03
fr: 3 août 2012

note: type: Plain text
en: pthread_create - create a new thread
fr: pthread_create - Créer un nouveau thread

note: type: Plain text
en: The B<pthread_create>()  function starts a new thread in the calling process.  The new thread starts execution by invoking I<start_routine>(); I<arg> is passed as the sole argument of I<start_routine>().
fr: La fonction B<pthread_create>()  démarre un nouveau thread dans le processus appelant. Le nouveau thread commence par appeler I<start_routine>()\ ; I<arg> est passé comme unique argument de I<start_routine>().

note: type: Plain text
en: The new thread terminates in one of the following ways:
fr: Le nouveau thread se termine d'une des manières suivantes\ :

note: type: Plain text
en: It calls B<pthread_exit>(3), specifying an exit status value that is available to another thread in the same process that calls B<pthread_join>(3).
fr: Il appelle B<pthread_exit>(3), en indiquant une valeur de sortie qui sera disponible pour pour un autre thread du même processus qui appelle B<pthread_join>(3).

note: type: Plain text
en: It returns from I<start_routine>().  This is equivalent to calling B<pthread_exit>(3)  with the value supplied in the I<return> statement.
fr: Il sort de la routine I<start_routine>(). C'est équivalent à appeler B<pthread_exit>(3)  avec la valeur fournie à l'instruction I<return>.

note: type: Plain text
en: It is canceled (see B<pthread_cancel>(3)).
fr: Il est annulé (voir  B<pthread_cancel>(3)).

note: type: Plain text
en: Any of the threads in the process calls B<exit>(3), or the main thread performs a return from I<main>().  This causes the termination of all threads in the process.
fr: Un des threads du processus appelle B<exit>(3), ou le thread principal sort de la routine I<main>(). Cela entraine l'arrêt de tous les threads du processus.

note: type: Plain text
en: The I<attr> argument points to a I<pthread_attr_t> structure whose contents are used at thread creation time to determine attributes for the new thread; this structure is initialized using B<pthread_attr_init>(3)  and related functions.  If I<attr> is NULL, then the thread is created with default attributes.
fr: L'argument I<attr> pointe sur une structure I<pthread_attr_t> dont le contenu est utilisé pendant la création des threads pour déterminer les attributs du nouveau thread. Cette structure est initialisée avec B<pthread_attr_init>(3) et les fonctions similaires. Si I<attr> est NULL, alors le thread est créé avec les attributs par défaut.

note: type: Plain text
en: Before returning, a successful call to B<pthread_create>()  stores the ID of the new thread in the buffer pointed to by I<thread>; this identifier is used to refer to the thread in subsequent calls to other pthreads functions.
fr: Avant de revenir, un appel réussi à B<pthread_create>()  stocke l'identifiant du nouveau thread dans le tampon pointé par I<thread>. Cet identifiant est utilisé pour se référer à ce thread dans les appels ultérieurs aux autres fonctions de pthreads.

note: type: Plain text
en: The new thread inherits a copy of the creating thread's signal mask (B<pthread_sigmask>(3)).  The set of pending signals for the new thread is empty (B<sigpending>(2)).  The new thread does not inherit the creating thread's alternate signal stack (B<sigaltstack>(2)).
fr: Le nouveau thread hérite d'une copie du masque de signal du thread créateur (B<pthread_sigmask>(3)). L'ensemble des signaux en attente pour le nouveau thread est vide (B<sigpending>(2)). Le nouveau thread n'hérite pas de la pile spécifique de signaux (B<sigaltstack>(2)) du thread appelant.

note: type: Plain text
en: The new thread inherits the calling thread's floating-point environment (B<fenv>(3)).
fr: Le nouveau thread hérite de l'environnement en virgule flottante (B<fenv>(3)) du thread appelant.

note: CLOCK_THREAD_CPUTIME_ID in clock_gettime(2) type: Plain text
en: The initial value of the new thread's CPU-time clock is 0 (see B<pthread_getcpuclockid>(3)).
fr: La valeur initiale de l'horloge CPU du nouveau thread est 0 (voir B<pthread_getcpuclockid>(3)).

note: type: SS
en: Linux-specific details
fr: Détails spécifiques à Linux

note: type: Plain text
en: The new thread inherits copies of the calling thread's capability sets (see B<capabilities>(7))  and CPU affinity mask (see B<sched_setaffinity>(2)).
fr: Le nouveau thread hérite de copies des ensembles des capacités (voir B<capabilities>(7))  et des masques d'affinité CPU (consultez B<sched_setaffinity>(2)).

note: type: Plain text
en: On success, B<pthread_create>()  returns 0; on error, it returns an error number, and the contents of I<*thread> are undefined.
fr: En cas de réussite, B<pthread_create>() renvoie 0 ; en cas d'erreur, elle renvoie un numéro d'erreur, et le contenu de I<*thread> est indéfini.

note: type: Plain text
en: Insufficient resources to create another thread, or a system-imposed limit on the number of threads was encountered.  The latter case may occur in two ways: the B<RLIMIT_NPROC> soft resource limit (set via B<setrlimit>(2)), which limits the number of process for a real user ID, was reached; or the kernel's system-wide limit on the number of threads, I</proc/sys/kernel/threads-max>, was reached.
fr: Ressources insuffisantes pour créer un nouveau thread, ou une limite sur le nombre de threads imposée par le système a été atteinte. Ce dernier cas peut arriver de deux façons\ : la limite souple B<RLIMIT_NPROC> (changée par B<setrlimit>(2)), qui limite le nombre de processus pour un identifiant d'utilisateur réel, a été atteinte\ ; ou alors la limite imposée par le noyau sur le nombre total de threads, I</proc/sys/kernel/threads-max>, a été atteinte.

note: type: Plain text
en: Invalid settings in I<attr>.
fr: Paramètres invalides dans I<attr>.

note: type: Plain text
en: No permission to set the scheduling policy and parameters specified in I<attr>.
fr: Permissions insuffisantes pour définir la politique d'ordonnancement et les paramètres spécifiés dans I<attr>.

note: type: Plain text
en: See B<pthread_self>(3)  for further information on the thread ID returned in I<*thread> by B<pthread_create>().  Unless real-time scheduling policies are being employed, after a call to B<pthread_create>(), it is indeterminate which thread\(emthe caller or the new thread\(emwill next execute.
fr: Consultez B<pthread_self>(3)  pour des informations plus détaillées sur l'identifiant de thread renvoyé dans I<*thread> par B<pthread_create>(). Sauf si une politique d'ordonnancement temps-réel est employée, après un appel à B<pthread_create>(), on ne sait pas quel thread \(em l'appelant ou le nouveau thread \(em sera exécuté ensuite.

note: type: Plain text
en: A thread may either be I<joinable> or I<detached>.  If a thread is joinable, then another thread can call B<pthread_join>(3)  to wait for the thread to terminate and fetch its exit status.  Only when a terminated joinable thread has been joined are the last of its resources released back to the system.  When a detached thread terminates, its resources are automatically released back to the system: it is not possible to join with the thread in order to obtain its exit status.  Making a thread detached is useful for some types of daemon threads whose exit status the application does not need to care about.  By default, a new thread is created in a joinable state, unless I<attr> was set to create the thread in a detached state (using B<pthread_attr_setdetachstate>(3)).
fr: Un thread peut être dans un état soit joignable (I<joinable>), soit détaché (I<detached>). Si un thread est joignable, un autre thread peut appeler B<pthread_join>(3)  pour attendre que ce thread se termine, et récupérer sa valeur de sortie. Ce n'est que quand un thread terminé et joignable a été joint que ses ressources sont rendues au système. Quand un thread détaché se termine, ses ressources sont automatiquement rendues au système\ ; il n'est pas possible de joindre un tel thread afin d'en obtenir la valeur de sortie. Mettre un thread dans l'état détaché est pratique pour certains types de démons qui ne se préoccupent pas de la valeur de sortie de ses threads. Par défaut, un nouveau thread est créé dans l'état joignable, à moins qu'I<attr> n'ait été modifié (avec B<pthread_attr_setdetachstate>(3)) pour créer le thread dans un état détaché.

note: FIXME . Perhaps some of the following detail should be in a future pthread_attr_setstacksize(3) page. type: Plain text
en: On Linux/x86-32, the default stack size for a new thread is 2 megabytes.  Under the NPTL threading implementation, if the B<RLIMIT_STACK> soft resource limit I<at the time the program started> has any value other than "unlimited", then it determines the default stack size of new threads.  Using B<pthread_attr_setstacksize>(3), the stack size attribute can be explicitly set in the I<attr> argument used to create a thread, in order to obtain a stack size other than the default.
fr: Sous Linux/x86-32, la taille de la pile par défaut pour un nouveau thread est de 2 mégaoctets. Avec l'implémentation NPTL, si la limite souple B<RLIMIT_STACK> a une valeur autre qu'«\ unlimited\ » I<au moment où le programme a démarré>, alors elle détermine la taille de la pile par défaut pour les nouveaux threads. Afin d'obtenir une taille de pile différente de la valeur par défaut, il faut appeler B<pthread_attr_setstacksize>(3) avec la valeur souhaitée sur l'argument I<attr> utilisé pour créer un thread.

note: type: Plain text
en: In the obsolete LinuxThreads implementation, each of the threads in a process has a different process ID.  This is in violation of the POSIX threads specification, and is the source of many other nonconformances to the standard; see B<pthreads>(7).
fr: Dans l'implémentation obsolète LinuxThreads, chacun des threads dans un processus a un identifiant de processus différent. Ceci est en violation des spécifications POSIX sur les threads, et est la cause de beaucoup de non conformité au standard. Consultez B<pthreads>(7).

note: type: Plain text
en: The program below demonstrates the use of B<pthread_create>(), as well as a number of other functions in the pthreads API.
fr: Le programme ci-dessous montre l'utilisation de B<pthread_create>(), ainsi qu'un certain nombre d'autres fonctions de l'API pthreads.

note: type: Plain text
en: In the following run, on a system providing the NPTL threading implementation, the stack size defaults to the value given by the "stack size" resource limit:
fr: Lors de l'exécution suivante, sur un système avec l'implémentation NPTL, la taille de la pile vaut par défaut la valeur renvoyée par la limite de la ressource «\ stack size\ » (taille de la pile)\ :

note: type: Plain text
en: In the next run, the program explicitly sets a stack size of 1MB (using B<pthread_attr_setstacksize>(3))  for the created threads:
fr: Lors de l'exécution suivante, le programme définit explicitement une taille de pile de 1\ Mo (avec B<pthread_attr_setstacksize>(3))  pour les threads créés\ :

note: type: TH
en: 2008-11-27
fr: 27 novembre 2008

note: type: Plain text
en: pthread_detach - detach a thread
fr: pthread_detach - Détacher un thread

note: type: Plain text
en: The B<pthread_detach>()  function marks the thread identified by I<thread> as detached.  When a detached thread terminates, its resources are automatically released back to the system without the need for another thread to join with the terminated thread.
fr: La fonction B<pthread_detach>()  marque l'identifiant de thread identifié par I<thread> comme détaché. Quand un thread détaché se termine, ses ressources sont automatiquement rendues au système sans avoir besoin d'un autre thread pour joindre le thread terminé.

note: type: Plain text
en: Attempting to detach an already detached thread results in unspecified behavior.
fr: Essayer de détacher un thread qui est déjà détaché résulte en un comportement indéfini.

note: type: Plain text
en: On success, B<pthread_detach>()  returns 0; on error, it returns an error number.
fr: En cas de réussite, B<pthread_detach>() renvoie 0 ; en cas d'erreur, elle renvoie un numéro d'erreur.

note: type: Plain text
en: I<thread> is not a joinable thread.
fr: I<thread> n'est pas un thread joignable.

note: type: Plain text
en: Once a thread has been detached, it can't be joined with B<pthread_join>(3)  or be made joinable again.
fr: Une fois qu'un thread est détaché, il ne peut plus être joint avec B<pthread_join>(3) ou être fait de nouveau joignable.

note: type: Plain text
en: A new thread can be created in a detached state using B<pthread_attr_setdetachstate>(3)  to set the detached attribute of the I<attr> argument of B<pthread_create>(3).
fr: Un nouveau thread peut être créé dans un état détaché en utilisant B<pthread_attr_setdetachstate>(3)  pour positionner l'attribut détaché de l'argument I<attr> de B<pthread_create>(3).

note: type: Plain text
en: The detached attribute merely determines the behavior of the system when the thread terminates; it does not prevent the thread from being terminated if the process terminates using B<exit>(3)  (or equivalently, if the main thread returns).
fr: L'attribut d'état de détachement détermine principalement le comportement du système quand le thread se termine. Il n'empêche pas le thread de terminer si le processus se termine avec B<exit>(3)  (ou, de manière équivalente, si le thread principal sort de sa routine d'appel).

note: type: Plain text
en: Either B<pthread_join>(3)  or B<pthread_detach>()  should be called for each thread that an application creates, so that system resources for the thread can be released.  (But note that the resources of all threads are freed when the process terminates.)
fr: Soit B<pthread_join>(3), soit B<pthread_detach>() devrait être appelé pour chaque thread créé par une application, afin que les ressources système du thread puissent être libérées. Notez cependant que les ressources de tous les threads sont libérées quand le processus se termine.

note: type: Plain text
en: The following statement detaches the calling thread:
fr: L'expression suivante détache le thread appelant\ :

note: type: TH
en: 2009-03-30
fr: 30 mars 2009

note: type: Plain text
en: pthread_equal - compare thread IDs
fr: pthread_equal - Comparer des identifiants de threads

note: type: Plain text
en: The B<pthread_equal>()  function compares two thread identifiers.
fr: La fonction B<pthread_equal>() compare deux identifiants de threads.

note: type: Plain text
en: If the two thread IDs are equal, B<pthread_equal>()  returns a nonzero value; otherwise, it returns 0.
fr: Si les deux identifiants de threads sont égaux, B<pthread_equal>() renvoie une valeur non nulle. Autrement, elle renvoie 0.

note: SH VERSIONS Available since glibc 2.0 type: Plain text
en: This function always succeeds.
fr: Cette fonction réussit toujours.

note: type: Plain text
en: The B<pthread_equal>()  function is necessary because thread IDs should be considered opaque: there is no portable way for applications to directly compare two I<pthread_t> values.
fr: La fonction B<pthread_equal>() est nécessaire car les identifiants de threads devraient être considérés comme étant opaques. Il n'existe pas de façon portable de comparer directement deux valeurs de I<pthread_t>.

note: type: Plain text
en: pthread_exit - terminate calling thread
fr: pthread_exit - Terminer le thread appelant

note: type: Plain text
en: The B<pthread_exit>()  function terminates the calling thread and returns a value via I<retval> that (if the thread is joinable)  is available to another thread in the same process that calls B<pthread_join>(3).
fr: La fonction B<pthread_exit>() termine le thread appelant et renvoie une valeur à travers I<retval> qui, si le thread est joignable, est rendue disponible à un autre thread dans le même processus s'il appelle B<pthread_join>(3).

note: type: Plain text
en: Any clean-up handlers established by B<pthread_cleanup_push>(3)  that have not yet been popped, are popped (in the reverse of the order in which they were pushed)  and executed.  If the thread has any thread-specific data, then, after the clean-up handlers have been executed, the corresponding destructor functions are called, in an unspecified order.
fr: Tous les gestionnaires de nettoyage ajoutés par B<pthread_cleanup_push>(3) \em qui n'ont pas encore été dépilés \em  sont dépilés (dans l'ordre inverse dans lequel ils ont été empilés) et exécutés. Si le thread contient des données spécifiques au thread, alors les destructeurs de ces données sont appelées, dans un ordre indéfini, une fois que tous les gestionnaires de nettoyage ont été exécutés.

note: type: Plain text
en: When a thread terminates, process-shared resources (e.g., mutexes, condition variables, semaphores, and file descriptors) are not released, and functions registered using B<atexit>(3)  are not called.
fr: Quand un thread se termine, les ressources partagées au niveau du processus (comme les verrous mutuellement exclusifs, des variables de condition, des sémaphores et des descripteurs de fichiers) ne sont pas libérées, et les fonctions enregistrées avec B<atexit>(3)  ne sont pas appelées.

note: type: Plain text
en: After the last thread in a process terminates, the process terminates as by calling B<exit>(3)  with an exit status of zero; thus, process-shared resources are released and functions registered using B<atexit>(3)  are called.
fr: Quand le dernier thread d'un processus se termine, le processus s'arrête en appelant B<exit>(3) avec une valeur de sortie de zéro. Ainsi, les ressources partagées au niveau du processus sont libérées, et les fonctions enregistrées avec B<atexit>(3)  sont appelées.

note: type: Plain text
en: This function does not return to the caller.
fr: Cette fonction ne retourne jamais vers l'appelant.

note: type: Plain text
en: Performing a return from the start function of any thread other than the main thread results in an implicit call to B<pthread_exit>(), using the function's return value as the thread's exit status.
fr: Tout thread autre que le thread principal qui sort de la fonction initiale entraîne un appel implicite à B<pthread_exit>(), en utilisant la valeur de retour de la fonction comme état de sortie du thread.

note: type: Plain text
en: To allow other threads to continue execution, the main thread should terminate by calling B<pthread_exit>()  rather than B<exit>(3).
fr: Afin de permettre aux autres threads de continuer l'exécution, le thread principal devrait se terminer en appelant B<pthread_exit>()  plutôt que B<exit>(3).

note: type: Plain text
en: The value pointed to by I<retval> should not be located on the calling thread's stack, since the contents of that stack are undefined after the thread terminates.
fr: La valeur pointée par I<retval> ne devrait pas être placée sur la pile du thread appelant, puisque le contenu de cette pile devient indéfini quand le thread se termine.

note: Linux 2.6.27 FIXME . review a later kernel to see if this gets fixed http://thread.gmane.org/gmane.linux.kernel/611611 http://marc.info/?l=linux-kernel&m=122525468300823&w=2 type: Plain text
en: Currently, there are limitations in the kernel implementation logic for B<wait>(2)ing on a stopped thread group with a dead thread group leader.  This can manifest in problems such as a locked terminal if a stop signal is sent to a foreground process whose thread group leader has already called B<pthread_exit>().
fr: Il y a actuellement des limitations dans la logique d'implémentation du noyau si on attend (avec B<wait>(2)) un groupe de thread dont le chef de groupe a terminé. Cela peut entraîner des problèmes comme un terminal bloqué si le signal d'arrêt est envoyé à un processus en avant-plan dont le thread chef de groupe a déjà appelé B<pthread_exit>().

note: type: Plain text
en: pthread_getattr_np - get attributes of created thread
fr: pthread_getattr_np - Obtenir les attributs d'un thread créé

note: type: Plain text
en: The B<pthread_getattr_np>()  function initializes the thread attributes object referred to by I<attr> so that it contains actual attribute values describing the running thread I<thread>.
fr: La fonction B<pthread_getattr_np>() initialise l'objet d'attributs de thread auquel I<attr> fait référence de telle sorte qu'il contienne les valeurs d'attributs qui décrivent le thread I<thread> en cours d'exécution.

note: type: Plain text
en: The returned attribute values may differ from the corresponding attribute values passed in the I<attr> object that was used to create the thread using B<pthread_create>(3).  In particular, the following attributes may differ:
fr: Les valeurs d'attribut renvoyées peuvent être différentes des valeurs d'attribut correspondantes fournies dans l'objet I<attr> utilisé pour créer le thread avec B<pthread_create>(3). En particulier, les attributs suivants peuvent changer :

note: type: Plain text
en: the detach state, since a joinable thread may have detached itself after creation;
fr: l'état détaché ou non, puisqu'un thread fusionné peut s'être détaché lui même après sa création ;

note: type: Plain text
en: the stack size, which the implementation may align to a suitable boundary.
fr: la taille de la pile, que l'implémentation peut aligner sur une limite plus appropriée.

note: type: Plain text
en: and the guard size, which the implementation may round upward to a multiple of the page size, or ignore (i.e., treat as 0), if the application is allocating its own stack.
fr: et la taille de garde, que l'implémentation peut arrondir au multiple supérieur de la taille de page ou ignorer (c'est-à-dire, considérer qu'elle vaut 0) si l'application alloue sa propre pile.

note: type: Plain text
en: Furthermore, if the stack address attribute was not set in the thread attributes object used to create the thread, then the returned thread attributes object will report the actual stack address that the implementation selected for the thread.
fr: De plus, si l'attribut contenant l'adresse de la pile n'était pas défini dans l'objet d'attributs de thread utilisé pour créer le thread, alors l'objet d'attributs de thread renvoyé contiendra l'adresse effective de la pile que l'implémentation a choisit pour le thread.

note: type: Plain text
en: When the thread attributes object returned by B<pthread_getattr_np>()  is no longer required, it should be destroyed using B<pthread_attr_destroy>(3).
fr: Quand l'objet d'attributs de thread renvoyé par B<pthread_getattr_np>() n'est plus nécessaire, il devrait être détruit à l'aide de B<pthread_attr_destroy>(3).

note: type: Plain text
en: On success, this function returns 0; on error, it returns a nonzero error number.
fr: En cas de réussite, cette fonction renvoie 0 ; en cas d'erreur, elle renvoie un numéro d'erreur non nul.

note: Can happen (but unlikely) while trying to allocate memory for cpuset type: Plain text
en: Insufficient memory.
fr: Mémoire insuffisante.

note: type: Plain text
en: In addition, if I<thread> refers to the main thread, then B<pthread_getattr_np>()  can fail because of errors from various underlying calls: B<fopen>(3), if I</proc/self/maps> can't be opened; and B<getrlimit>(2), if the B<RLIMIT_STACK> resource limit is not supported.
fr: De plus, si I<thread> se réfère à à un thread principal, alors B<pthread_getattr_np>() peut échouer à cause de différents appels sous-jacents : B<fopen>(3), si I</proc/self/maps> ne peut être ouvert, et B<getrlimit>(2), si la limite de ressources B<RLIMIT_STACK> n'est pas prise en charge.

note: type: Plain text
en: This function is available in glibc since version 2.2.3.
fr: Cette fonction est disponible dans la glibc depuis la version 2.2.3.

note: type: Plain text
en: This function is a nonstandard GNU extension; hence the suffix "_np" (nonportable) in the name.
fr: Cette fonction est une extension GNU non standard ; c'est la raison du suffixe « _np » (non portable) dans son nom.

note: type: Plain text
en: The program below demonstrates the use of B<pthread_getattr_np>().  The program creates a thread that then uses B<pthread_getattr_np>()  to retrieve and display its guard size, stack address, and stack size attributes.  Command-line arguments can be used to set these attributes to values other than the default when creating the thread.  The shell sessions below demonstrate the use of the program.
fr: Le programme ci-dessous démontre l'utilisation de B<pthread_getattr_np>(). Le programme crée un thread qui utilise ensuite B<pthread_getattr_np>() pour récupérer et afficher les attributs contenant la taille de la garde, l'adresse de la pile et la taille de la pile. Des paramètres en ligne de commande peuvent être utilisés pour définir les attributs qui seront utilisés pour créer le thread à des valeurs autres que les valeurs par défaut. Les sessions d'interpréteur de commande ci-dessous démontrent l'utilisation du programme.

note: type: Plain text
en: In the first run, on an x86-32 system, a thread is created using default attributes:
fr: Lors de la première exécution, sur une système x86-32, un thread est créé en utilisant les attributs par défaut :

note: type: Plain text
en: $B< ulimit -s>      # No stack limit ==E<gt> default stack size is 2MB
    unlimited
    $B< ./a.out>
    Attributes of created thread:
            Guard size          = 4096 bytes
            Stack address       = 0x40196000 (EOS = 0x40397000)
            Stack size          = 0x201000 (2101248) bytes
fr: $B< ulimit -s> # Pas de limite de pile
                # ==E<gt> la taille de pile par défaut est de 2 Mo
    unlimited
    $B< ./a.out>
    Attributes of created thread:
            Guard size          = 4096 bytes
            Stack address       = 0x40196000 (EOS = 0x40397000)
            Stack size          = 0x201000 (2101248) bytes

note: type: Plain text
en: In the following run, we see that if a guard size is specified, it is rounded up to the next multiple of the system page size (4096 bytes on x86-32):
fr: Lors de l'exécution suivante, nous voyons que si la taille de la garde est fournie, elle est arrondie (vers le haut) au prochain multiple de la taille de page système (4096 octets sous x86-32) :

note: .in +4n .nf $ ./a.out \-s 0x8000 Thread attributes object after initializations: Guard size          = 4096 bytes Stack address       = 0xffff8000 (EOS = (nil)) Stack size          = 0x8000 (32768) bytes Attributes of created thread: Stack address       = 0x4001e000 (EOS = 0x40026000) .fi .in type: 
en: In the last run, the program manually allocates a stack for the thread.  In this case, the guard size attribute is ignored.
fr: Lors de la dernière exécution, le programme alloue manuellement une pile pour le thread. Dans ce cas, l'attribut contenant la taille de la garde est ignorée.

note: type: TH
en: 2009-02-08
fr: 8 février 2009

note: type: Plain text
en: pthread_getcpuclockid - retrieve ID of a thread's CPU time clock
fr: pthread_getcpuclockid - Récupérer l'identifiant d'horloge de temps CPU d'un thread

note: The clockid is constructed as follows: *clockid = CLOCK_THREAD_CPUTIME_ID | (pd->tid << CLOCK_IDFIELD_SIZE) where CLOCK_IDFIELD_SIZE is 3. type: Plain text
en: The B<pthread_getcpuclockid>()  function returns the clock ID for the CPU time clock of the thread I<thread>.
fr: La fonction B<pthread_getcpuclockid>() renvoie l'identifiant d'horloge pour l'horloge de temps CPU du thread I<thread>.

note: CLOCK_THREAD_CPUTIME_ID not defined Looking at nptl/pthread_getcpuclockid.c an ERANGE error would be possible if kernel thread IDs took more than 29 bits (which they currently cannot). type: Plain text
en: Per-thread CPU time clocks are not supported by the system.
fr: Les horloges de temps CPU par thread ne sont pas pris en charge par le système.

note: type: Plain text
en: This function is available in glibc since version 2.2.
fr: Cette fonction est disponible dans la glibc depuis la version\ 2.2.

note: type: Plain text
en: When I<thread> refers to the calling thread, this function returns an identifier that refers to the same clock manipulated by B<clock_gettime>(2)  and B<clock_settime>(2)  when given the clock ID B<CLOCK_THREAD_CPUTIME_ID>.
fr: Quand I<thread> se rapporte au thread appelant, cette fonction renvoie un identifiant qui indique la même horloge que celle manipulée par B<clock_gettime>(2) et B<clock_settime>(2) avec l'identifiant d'horloge B<CLOCK_THREAD_CPUTIME_ID>.

note: type: Plain text
en: The program below creates a thread and then uses B<clock_gettime>(2)  to retrieve the total process CPU time, and the per-thread CPU time consumed by the two threads.  The following shell session shows an example run:
fr: Le programme ci-dessous crée un thread puis utilise B<clock_gettime>(2) pour récupérer le temps CPU total du processus et le temps CPU utilisé par chacun des deux threads. La session suivante montre un exemple d'exécution :

note: type: Plain text
en: /* Link with "-lrt" */
fr: /* Effectuez l'édition des liens avec l'option "-lrt" */

note: type: Plain text
en: pthread_join - join with a terminated thread
fr: pthread_join - Joindre un thread terminé

note: type: Plain text
en: The B<pthread_join>()  function waits for the thread specified by I<thread> to terminate.  If that thread has already terminated, then B<pthread_join>()  returns immediately.  The thread specified by I<thread> must be joinable.
fr: La fonction B<pthread_join>()  attend que le thread spécifié par I<thread> se termine. Si ce thread s'est déjà terminé, B<pthread_join>() revient tout de suite. Le thread spécifié par I<thread> doit être joignable.

note: type: Plain text
en: If I<retval> is not NULL, then B<pthread_join>()  copies the exit status of the target thread (i.e., the value that the target thread supplied to B<pthread_exit>(3))  into the location pointed to by I<*retval>.  If the target thread was canceled, then B<PTHREAD_CANCELED> is placed in I<*retval>.
fr: Si I<retval> n'est pas NULL, B<pthread_join>() copie la valeur de sortie du thread cible (c'est-à-dire la valeur que le thread cible a fournie à B<pthread_exit>(3))  dans l'emplacement pointé par I<*retval>. Si le thread cible est annulé, B<PTHREAD_CANCELED> est placé dans I<*retval>.

note: type: Plain text
en: If multiple threads simultaneously try to join with the same thread, the results are undefined.  If the thread calling B<pthread_join>()  is canceled, then the target thread will remain joinable (i.e., it will not be detached).
fr: Si plusieurs threads essaient simultanément de joindre le même thread, le résultat est indéfini. Si le thread appelant B<pthread_join>()  est annulé, le thread cible reste joignable (c'est-à-dire qu'il ne sera pas détaché).

note: type: Plain text
en: On success, B<pthread_join>()  returns 0; on error, it returns an error number.
fr: En cas de réussite, B<pthread_join>() renvoie 0 ; en cas d'erreur, elle renvoie un numéro d'erreur.

note: The following verified by testing on glibc 2.8/NPTL: type: Plain text
en: A deadlock was detected (e.g., two threads tried to join with each other); or I<thread> specifies the calling thread.
fr: Un verrou perpétuel (I<deadlock>) a été détecté, par exemple deux threads essaient de se joindre mutuellement\ ; ou bien I<thread> est aussi le thread appelant.

note: POSIX.1-2001 does not specify this error case. type: Plain text
en: Another thread is already waiting to join with this thread.
fr: Un autre thread attend déjà de joindre ce thread.

note: type: Plain text
en: After a successful call to B<pthread_join>(), the caller is guaranteed that the target thread has terminated.
fr: Après un appel réussi à B<pthread_join>(), l'appelant est sûr que le thread cible s'est terminé.

note: type: Plain text
en: Joining with a thread that has previously been joined results in undefined behavior.
fr: Joindre un thread qui avait préalablement été joint résulte en un comportement indéfini.

note: type: Plain text
en: Failure to join with a thread that is joinable (i.e., one that is not detached), produces a "zombie thread".  Avoid doing this, since each zombie thread consumes some system resources, and when enough zombie threads have accumulated, it will no longer be possible to create new threads (or processes).
fr: Un échec à joindre un thread qui est joignable (c'est-à-dire non détaché) produit un «\ thread zombie\ ». Il faut l'éviter, car chaque thread zombie consomme des ressources du système, et si trop de threads zombies s'accumulent, il ne sera plus possible de créer de nouveaux threads (ou de nouveaux processus).

note: type: Plain text
en: There is no pthreads analog of I<waitpid(-1,\ &status,\ 0)>, that is, "join with any terminated thread".  If you believe you need this functionality, you probably need to rethink your application design.
fr: Il n'existe pas d'analogue pthreads à I<waitpid(-1,\ &status,\ 0)> pour joindre tout thread non terminé. Si vous pensez avoir besoin de cette fonctionnalité, vous devez probablement repenser la conception de votre application.

note: type: Plain text
en: All of the threads in a process are peers: any thread can join with any other thread in the process.
fr: Tous les threads dans un processus sont au même niveau\ : tout thread peut joindre tout autre thread du processus.

note: type: TH
en: 2014-02-04
fr: 4 février 2014

note: type: Plain text
en: pthread_kill - send a signal to a thread
fr: pthread_kill - Envoyer un signal à un thread

note: type: Plain text
en: B<pthread_kill>():
fr: B<pthread_kill>() :

note: type: Plain text
en: The B<pthread_kill>()  function sends the signal I<sig> to I<thread>, a thread in the same process as the caller.  The signal is asynchronously directed to I<thread>.
fr: La fonction B<pthread_kill>() envoie le signal I<sig> à I<thread>, un thread du même processus que l'appelant. Le signal est dirigé de manière asynchrone vers I<thread>.

note: type: Plain text
en: If I<sig> is 0, then no signal is sent, but error checking is still performed.
fr: Si I<sig> est 0, aucun signal n'est envoyé, mais la détection d'erreur est quand même effectuée.

note: type: Plain text
en: On success, B<pthread_kill>()  returns 0; on error, it returns an error number, and no signal is sent.
fr: En cas de réussite, B<pthread_kill>() renvoie 0 ; en cas d'erreur, elle renvoie un numéro d'erreur, et aucun signal n'est envoyé.

note: type: Plain text
en: An invalid signal was specified.
fr: Un signal invalide a été spécifié.

note: type: Plain text
en: Signal dispositions are process-wide: if a signal handler is installed, the handler will be invoked in the thread I<thread>, but if the disposition of the signal is "stop", "continue", or "terminate", this action will affect the whole process.
fr: Les dispositions d'un signal sont définies au niveau du processus. Si un gestionnaire de signal est installé, le gestionnaire sera invoqué dans le thread I<thread>, mais si la disposition du signal est « stop », « continue » ou « terminate », cette action affectera le processus entier.

note: type: Plain text
en: POSIX.1-2008 recommends that if an implementation detects the use of a thread ID after the end of its lifetime, B<pthread_kill>()  should return the error B<ESRCH>.  The glibc implementation returns this error in the cases where an invalid thread ID can be detected.  But note also that POSIX says that an attempt to use a thread ID whose lifetime has ended produces undefined behavior, and an attempt to use an invalid thread ID in a call to B<pthread_kill>()  can, for example, cause a segmentation fault.
fr: La norme POSIX.1-2008 recommande que lorsqu'une implémentation détecte l'utilisation de l'identifiant d'un thread qui n'est plus en vie, l'appel B<pthread_kill>() renvoie le message d'erreur B<ESRCH>. L'implémentation de glibc renvoie cette erreur dans les cas où un identifiant de thread non valide est détecté. Il est à noter que POSIX précise également que l'utilisation d'un identifiant de thread dont l'exécution est terminée produit des effets indéfinis, et que l'utilisation d'un identifiant de thread invalide dans l'appel à B<pthread_kill>() peut, par exemple, provoquer une erreur de segmentation (segmentation fault).

note: type: TH
en: 2010-09-09
fr: 9 septembre 2010

note: type: Plain text
en: pthread_kill_other_threads_np - terminate all other threads in process
fr: pthread_kill_other_threads_np - Terminer tous les autres threads du processus

note: .SH VERSIONS Available since glibc 2.0 type: Plain text
en: B<pthread_kill_other_threads_np>()  has an effect only in the LinuxThreads threading implementation.  On that implementation, calling this function causes the immediate termination of all threads in the application, except the calling thread.  The cancellation state and cancellation type of the to-be-terminated threads are ignored, and the cleanup handlers are not called in those threads.
fr: B<pthread_kill_other_threads_np>()  n'a d'effet qu'avec l'implémentation LinuxThreads. Avec cette implémentation, l'appel de cette fonction entraîne l'arrêt de tous les threads de l'application, à l'exception du thread appelant. L'état et le mode d'annulation des threads à terminer seront ignorés, et les gestionnaires de nettoyage de ces threads ne seront pas appelés.

note: type: Plain text
en: B<pthread_kill_other_threads_np>()  is intended to be called just before a thread calls B<execve>(2)  or a similar function.  This function is designed to address a limitation in the obsolete LinuxThreads implementation whereby the other threads of an application are not automatically terminated (as POSIX.1-2001 requires) during B<execve>(2).
fr: La fonction B<pthread_kill_other_threads_np>() est prévue pour être appelée juste avant qu'un thread n'appelle B<execve>(2) ou une fonction similaire. Le but de cette fonction est de contourner une limitation de l'implémentation obsolète LinuxThreads, où les autres threads d'une application ne sont pas automatiquement terminés (comme le requiert POSIX.1-2001) pendant B<execve>(2).

note: type: Plain text
en: In the NPTL threading implementation, B<pthread_kill_other_threads_np>()  exists, but does nothing.  (Nothing needs to be done, because the implementation does the right thing during an B<execve>(2).)
fr: Dans l'implémentation NPTL, B<pthread_kill_other_threads_np>() existe, mais ne fait rien ; il n'y a rien à faire, car l'implémentation fait ce qu'il faut pendant B<execve>(2).

note: type: Plain text
en: pthread_self - obtain ID of the calling thread
fr: pthread_self - Obtenir l'identifiant du thread appelant

note: type: Plain text
en: The B<pthread_self>()  function returns the ID of the calling thread.  This is the same value that is returned in I<*thread> in the B<pthread_create>(3)  call that created this thread.
fr: La fonction B<pthread_self>() renvoie l'identifiant du thread appelant. C'est la même valeur qui est renvoyée dans I<*thread> dans l'appel à B<pthread_create>(3)  qui a créé ce thread.

note: type: Plain text
en: This function always succeeds, returning the calling thread's ID.
fr: Cette fonction réussit toujours, et renvoie l'identifiant du thread appelant.

note: type: Plain text
en: POSIX.1 allows an implementation wide freedom in choosing the type used to represent a thread ID; for example, representation using either an arithmetic type or a structure is permitted.  Therefore, variables of type I<pthread_t> can't portably be compared using the C equality operator (B<==>); use B<pthread_equal>(3)  instead.
fr: POSIX.1 laisse la liberté aux implémentations de choisir le type utilisé pour représenter l'identifiant des threads\ ; par exemple, une représentation par un type arithmétique ou par une structure est permise. Cependant, des variables de type I<pthread_t> ne peuvent pas être comparées de manière portable en utilisant l'opérateur d'égalité C (B<==>). Il faut utiliser B<pthread_equal>(3) à la place.

note: type: Plain text
en: Thread identifiers should be considered opaque: any attempt to use a thread ID other than in pthreads calls is nonportable and can lead to unspecified results.
fr: Les identifiants de threads doivent être considérés comme opaques. Toute tentative pour utiliser un identifiant de thread autre part que dans des appels à pthreads n'est pas portable et peut entraîner des résultats indéfinis.

note: type: Plain text
en: Thread IDs are guaranteed to be unique only within a process.  A thread ID may be reused after a terminated thread has been joined, or a detached thread has terminated.
fr: Les identifiants de threads ne sont garantis d'être uniques qu'à l'intérieur d'un processus. Un identifiant de thread peut être réutilisé après qu'un thread terminé a été rejoint, ou après qu'un thread détaché s'est terminé.

note: type: Plain text
en: The thread ID returned by B<pthread_self>()  is not the same thing as the kernel thread ID returned by a call to B<gettid>(2).
fr: L'identifiant de thread renvoyé par B<pthread_self>() n'est pas la même chose que l'identifiant de thread du noyau renvoyé par B<gettid>(2).

note: type: Plain text
en: pthread_setaffinity_np, pthread_getaffinity_np - set/get CPU affinity of a thread
fr: pthread_setaffinity_np, pthread_getaffinity_np - Définir et obtenir l'affinité CPU d'un thread

note: type: Plain text
en: The B<pthread_setaffinity_np>()  function sets the CPU affinity mask of the thread I<thread> to the CPU set pointed to by I<cpuset>.  If the call is successful, and the thread is not currently running on one of the CPUs in I<cpuset>, then it is migrated to one of those CPUs.
fr: La fonction B<pthread_setaffinity_np>() définit le masque d'affinité CPU du thread I<thread> comme étant l'ensemble de CPU pointé par I<cpuset>. Si l'appel réussit et que le thread n'est pas en cours d'exécution sur un des CPU de I<cpuset>, alors il est déplacé sur un de ces CPU.

note: type: Plain text
en: The B<pthread_getaffinity_np>()  function returns the CPU affinity mask of the thread I<thread> in the buffer pointed to by I<cpuset>.
fr: La fonction B<pthread_getaffinity_np>() renvoie, dans le tampon pointé par I<cpuset>, le masque d'affinité CPU du thread I<thread>.

note: type: Plain text
en: The argument I<cpusetsize> is the length (in bytes) of the buffer pointed to by I<cpuset>.  Typically, this argument would be specified as I<sizeof(cpu_set_t)>.  (It may be some other value, if using the macros described in B<CPU_SET>(3)  for dynamically allocating a CPU set.)
fr: Le paramètre I<cpusetsize> est la longueur (en octets) du tampon pointé par I<cpuset>. Typiquement, ce paramètre sera I<sizeof (cpu_set_t)> (il peut prendre d'autres valeurs, si on utilise les macros décrites dans B<CPU_SET>(3) pour allouer dynamiquement un ensemble de CPU).

note: type: Plain text
en: A supplied memory address was invalid.
fr: Une adresse mémoire fournie n'est pas correcte.

note: type: Plain text
en: (B<pthread_setaffinity_np>())  The affinity bit mask I<mask> contains no processors that are currently physically on the system and permitted to the thread according to any restrictions that may be imposed by the "cpuset" mechanism described in B<cpuset>(7).
fr: (B<pthread_setaffinity_np>()) Le masque de bits d'affinité I<mask> ne contient pas de processeurs qui soit actuellement physiquement sur le système et autorisé pour le thread d'après les restrictions imposées par le mécanisme d'ensembles de CPU décrit dans B<cpuset>(7).

note: FIXME . ? Loic Domaigne commented: it seems that in the future the kernel developers want to make cpumask_t dynamic, so CONFIG_NR_CPUS might become obsolete in the future. cpumask_t The raw sched_getaffinity() system call returns the size (in bytes) of the cpumask_t type. type: Plain text
en: (B<pthread_setaffinity_np>())  I<cpuset> specified a CPU that was outside the set supported by the kernel.  (The kernel configuration option B<CONFIG_NR_CPUS> defines the range of the set supported by the kernel data type used to represent CPU sets.)
fr: (B<pthread_setaffinity_np>()) Le I<cpuset> indique un CPU en dehors de l'ensemble pris en charge par le noyau (l'option de configuration du noyau B<CONFIG_NR_CPUS> définie l'intervalle de l'ensemble pris en charge par le type de données du noyau utilisé pour représenter les ensembles de CPU).

note: type: Plain text
en: (B<pthread_getaffinity_np>())  I<cpusetsize> is smaller than the size of the affinity mask used by the kernel.
fr: (B<pthread_getaffinity_np>()) I<cpusetsize> est plus petit que le taille du masque d'affinité utilisé par le noyau.

note: type: Plain text
en: After a call to B<pthread_setaffinity_np>(), the set of CPUs on which the thread will actually run is the intersection of the set specified in the I<cpuset> argument and the set of CPUs actually present on the system.  The system may further restrict the set of CPUs on which the thread runs if the "cpuset" mechanism described in B<cpuset>(7)  is being used.  These restrictions on the actual set of CPUs on which the thread will run are silently imposed by the kernel.
fr: Après un appel à B<pthread_setaffinity_np>(), l'ensemble de CPU sur lesquels le processus s'exécutera est l'intersection de l'ensemble spécifié dans le paramètre I<cpuset> et l'ensemble des CPU actuellement présents sur le système. Le système peut restreindre encore plus l'ensemble des CPU sur lesquels le processus peut tourner si le mécanisme « cpuset », décrit dans B<cpuset>(7), est utilisé. Ces restrictions sur le véritable ensemble de CPU sur lesquels le processus peut tourner sont imposées sans avertissement par le noyau.

note: type: Plain text
en: These functions are implemented on top of the B<sched_setaffinity>(2)  and B<sched_getaffinity>(2)  system calls.
fr: Ces fonctions sont implémentées en utilisant les appels système B<sched_setaffinity>(2) et B<sched_getaffinity>(2).

note: type: Plain text
en: A new thread created by B<pthread_create>(3)  inherits a copy of its creator's CPU affinity mask.
fr: Un nouveau thread créé avec B<pthread_create>(3) hérite d'une copie du masque d'affinité CPU de son créateur.

note: type: Plain text
en: In the following program, the main thread uses B<pthread_setaffinity_np>()  to set its CPU affinity mask to include CPUs 0 to 7 (which may not all be available on the system), and then calls B<pthread_getaffinity_np>()  to check the resulting CPU affinity mask of the thread.
fr: Dans le programme suivant, le thread principal utilise B<pthread_setaffinity_np>() pour définir son masque d'affinité CPU incluant les CPU 0 à 7 (qui peuvent ne pas être tous présents sur le système), puis appelle B<pthread_getaffinity_np>() pour vérifier le masque d'affinité CPU finalement utilisé pour le thread.

note: type: Plain text
en: pthread_setcancelstate, pthread_setcanceltype - set cancelability state and type
fr: pthread_setcancelstate, pthread_setcanceltype - Définir l'état et le type d'annulation

note: type: Plain text
en: The B<pthread_setcancelstate>()  sets the cancelability state of the calling thread to the value given in I<state>.  The previous cancelability state of the thread is returned in the buffer pointed to by I<oldstate>.  The I<state> argument must have one of the following values:
fr: La fonction B<pthread_setcancelstate>() définit l'état d'annulation du thread appelant à la valeur indiquée par I<state>. L'ancien état d'annulation du thread est renvoyé dans le tampon pointé par I<oldstate>. L'argument I<state> doit avoir une des valeurs suivantes\ :

note: type: Plain text
en: The thread is cancelable.  This is the default cancelability state in all new threads, including the initial thread.  The thread's cancelability type determines when a cancelable thread will respond to a cancellation request.
fr: Le thread peut être annulé. C'est l'état d'annulation par défaut pour tous les nouveaux threads, y compris le thread initial. Le type d'annulation du thread détermine quand un thread annulable répondra à une requête d'annulation.

note: type: Plain text
en: The thread is not cancelable.  If a cancellation request is received, it is blocked until cancelability is enabled.
fr: Le thread n'est pas annulable. Si une requête d'annulation arrive, elle est bloquée jusqu'à ce que l'annulation soit activée.

note: type: Plain text
en: The B<pthread_setcanceltype>()  sets the cancelability type of the calling thread to the value given in I<type>.  The previous cancelability type of the thread is returned in the buffer pointed to by I<oldtype>.  The I<type> argument must have one of the following values:
fr: La fonction B<pthread_setcanceltype>() définit le type d'annulation du thread appelant à la valeur indiquée par I<type>. L'ancien type d'annulation du thread est renvoyé dans le tampon pointé par I<oldtype>. L'argument I<type> doit avoir une des valeurs suivantes\ :

note: type: Plain text
en: A cancellation request is deferred until the thread next calls a function that is a cancellation point (see B<pthreads>(7)).  This is the default cancelability type in all new threads, including the initial thread.
fr: Une requête d'annulation est retardé jusqu'à ce que le thread appelle une fonction qui est un point d'annulation (consultez B<pthreads>(7)). C'est le type d'annulation par défaut pour tous les nouveaux threads, y compris le thread initial.

note: type: Plain text
en: The thread can be canceled at any time.  (Typically, it will be canceled immediately upon receiving a cancellation request, but the system doesn't guarantee this.)
fr: Le thread peut être annulé à tout moment. Typiquement, il sera annulé dès réception de la requête d'annulation, mais ce n'est pas garanti par le système.

note: type: Plain text
en: The set-and-get operation performed by each of these functions is atomic with respect to other threads in the process calling the same function.
fr: Les opérations I<set>/I<get> effectuées par ces fonctions sont atomiques, eu égard aux autres threads du processus qui appellent la même fonction.

note: type: Plain text
en: The B<pthread_setcancelstate>()  can fail with the following error:
fr: B<pthread_setcancelstate>() peut échouer avec l'erreur suivante :

note: type: Plain text
en: Invalid value for I<state>.
fr: Valeur invalide pour I<state>.

note: type: Plain text
en: The B<pthread_setcanceltype>()  can fail with the following error:
fr: B<pthread_setcanceltype>() peut échouer avec l'erreur suivante :

note: .SH VERSIONS Available since glibc 2.0 type: Plain text
en: Invalid value for I<type>.
fr: Valeur invalide pour I<type>.

note: type: Plain text
en: For details of what happens when a thread is canceled, see B<pthread_cancel>(3).
fr: Pour des détails sur ce qui se passe quand un thread est annulé, voyez B<pthread_cancel>(3).

note: type: Plain text
en: Briefly disabling cancelability is useful if a thread performs some critical action that must not be interrupted by a cancellation request.  Beware of disabling cancelability for long periods, or around operations that may block for long periods, since that will render the thread unresponsive to cancellation requests.
fr: Désactiver brièvement l'annulation peut être pratique si un thread effectue une action critique qui ne doit pas être interrompue par une requête d'annulation. Mais attention de ne pas désactiver l'annulation sur de longues périodes, ou autour d'opérations qui peuvent ploquer pendant un long moment, car cela empêcherait le thread de répondre aux requêtes d'annulation.

note: type: Plain text
en: Setting the cancelability type to B<PTHREAD_CANCEL_ASYNCHRONOUS> is rarely useful.  Since the thread could be canceled at I<any> time, it cannot safely reserve resources (e.g., allocating memory with B<malloc>(3)), acquire mutexes, semaphores, or locks, and so on.  Reserving resources is unsafe because the application has no way of knowing what the state of these resources is when the thread is canceled; that is, did cancellation occur before the resources were reserved, while they were reserved, or after they were released? Furthermore, some internal data structures (e.g., the linked list of free blocks managed by the B<malloc>(3)  family of functions) may be left in an inconsistent state if cancellation occurs in the middle of the function call.  Consequently, clean-up handlers cease to be useful.  Functions that can be safely asynchronously canceled are called I<async-cancel-safe functions>.  POSIX.1-2001 requires only that B<pthread_cancel>(3), B<pthread_setcancelstate>(), and B<pthread_setcanceltype>()  be async-cancel-safe.  In general, other library functions can't be safely called from an asynchronously cancelable thread.  One of the few circumstances in which asynchronous cancelability is useful is for cancellation of a thread that is in a pure compute-bound loop.
fr: Le type d'annulation est rarement mis à B<PTHREAD_CANCEL_ASYNCHRONOUS>. Comme le thread pourrait être annulé n'importe quand, il ne pourrait pas réserver de ressources (par exemple en allouant de la mémoire avec B<malloc>(3)) de manière sûre, acquérir des verrous exclusifs (I<mutex>), des sémaphores, des verrous, etc. Réserver des ressources n'est pas sûr, car l'application n'a aucun moyen de connaître l'état de ces ressources quand le thread est annulé\ ; en d'autres termes, l'annulation arrive-t-elle avant que les ressources n'aient été réservées, pendant qu'elles sont réservées, ou après qu'elles ont été libérées\ ? De plus, certaines structures de données internes (par exemple la liste chaînée des blocs libres gérée par la famille de fonctions B<malloc>(3)) pourraient se retrouver dans un état incohérent si l'annulation se passe au milieu d'un appel de fonction. En conséquence de quoi les gestionnaires de nettoyage perdent toute utilité. Les fonctions qui peuvent sans risque être annulées de manière asynchrone sont appelées des I<fonctions async-cancel-safe>. POSIX.1-2001 nécessite seulement que B<pthread_cancel>(3), B<pthread_setcancelstate>() et B<pthread_setcanceltype>()  soient async-cancel-safe. En général, les autres fonctions de la bibliothèque ne peuvent pas être appelées de manière sûre depuis un thread annulable immédiatement. Une des rares circonstances dans lesquelles une annulation immédiate est utile est pour l'annulation d'un thread qui est dans une boucle qui ne fait que des calculs.

note: It looks like at least Solaris, FreeBSD and Tru64 support this. type: Plain text
en: The Linux threading implementations permit the I<oldstate> argument of B<pthread_setcancelstate>()  to be NULL, in which case the information about the previous cancelability state is not returned to the caller.  Many other implementations also permit a NULL I<oldstat> argument, but POSIX.1-2001 does not specify this point, so portable applications should always specify a non-NULL value in I<oldstate>.  A precisely analogous set of statements applies for the I<oldtype> argument of B<pthread_setcanceltype>().
fr: Les implémentations de Linux autorisent l'argument I<oldstate> de B<pthread_setcancelstate>()  à être NULL, auquel cas l'information au sujet de l'état antérieur d'annulation n'est pas renvoyé à l'appelant. Beaucoup d'autres implémentations autorisent aussi un argument I<oldstat> NULL, mais POSIX.1-2001 ne spécifie pas ce point, si bien que les applications portables devraient toujours donner une valeur non NULL à I<oldstate>. Le même type de raisonnement s'applique à l'argument I<oldtype> de B<pthread_setcanceltype>().

note: type: Plain text
en: See B<pthread_cancel>(3).
fr: Consultez B<pthread_cancel>(3).

note: type: TH
en: 2009-04-10
fr: 10 avril 2009

note: type: Plain text
en: pthread_setconcurrency, pthread_getconcurrency - set/get the concurrency level
fr: pthread_setconcurrency, pthread_getconcurrency - Définir ou récupérer le niveau de concurrence

note: type: Plain text
en: The B<pthread_setconcurrency>()  function informs the implementation of the application's desired concurrency level, specified in I<new_level>.  The implementation takes this only as a hint: POSIX.1 does not specify the level of concurrency that should be provided as a result of calling B<pthread_setconcurrency>().
fr: La fonction B<pthread_setconcurrency>() informe l'implémentation du niveau de concurrence (nombre de threads exécutés en parallèle indiqué par I<new_level>) souhaité par l'application. Ce n'est qu'une indication pour l'implémentation : POSIX.1 ne spécifie pas le niveau de concurrence qui doit résulter d'un appel à B<pthread_setconcurrency>().

note: type: Plain text
en: Specifying I<new_level> as 0 instructs the implementation to manage the concurrency level as it deems appropriate.
fr: Une valeur de 0 pour I<new_level> indique à l'implémentation qu'elle peut gérer le niveau de concurrence au niveau qu'elle juge approprié.

note: type: Plain text
en: B<pthread_getconcurrency>()  returns the current value of the concurrency level for this process.
fr: B<pthread_getconcurrency>() renvoie le niveau de concurrence du processus.

note: type: Plain text
en: On success, B<pthread_setconcurrency>()  returns 0; on error, it returns a nonzero error number.
fr: En cas de réussite, B<pthread_setconcurrency>() renvoie 0 ; en cas d'erreur, elle renvoie un numéro d'erreur non nul.

note: type: Plain text
en: B<pthread_getconcurrency>()  always succeeds, returning the concurrency level set by a previous call to B<pthread_setconcurrency>(), or 0, if B<pthread_setconcurrency>()  has not previously been called.
fr: B<pthread_getconcurrency>() ne peut pas échouer et renvoie le niveau de concurrence défini par l'appel précédent à B<pthread_setconcurrency>() ou 0 si B<pthread_setconcurrency>() n'a pas été appelé auparavant.

note: type: Plain text
en: B<pthread_setconcurrency>()  can fail with the following error:
fr: B<pthread_setconcurrency>() peut échouer avec les erreurs suivantes :

note: type: Plain text
en: I<new_level> is negative.
fr: I<new_level> est négatif.

note: type: Plain text
en: POSIX.1-2001 also documents an B<EAGAIN> error ("the value specified by I<new_level> would cause a system resource to be exceeded").
fr: POSIX.1-2001 documente également une erreur B<EAGAIN> (« la valeur indiquée par I<new_level> entraînerait un dépassement des ressources du système »).

note: type: Plain text
en: These functions are available in glibc since version 2.1.
fr: Ces fonctions sont disponibles dans la glibc depuis la version 2.1.

note: type: Plain text
en: The default concurrency level is 0.
fr: Le niveau de concurrence par défaut est de 0.

note: type: Plain text
en: Concurrency levels are meaningful only for M:N threading implementations, where at any moment a subset of a process's set of user-level threads may be bound to a smaller number of kernel-scheduling entities.  Setting the concurrency level allows the application to give the system a hint as to the number of kernel-scheduling entities that should be provided for efficient execution of the application.
fr: Les niveaux de concurrence n'ont de sens que pour les implémentations des threads M:N, pour lesquelles à un moment donné un sous-ensemble de threads d'un processus peut être associé à un plus petit nombre d'entités ordonnançable du noyau. Définir le niveau de concurrence permet à une application de donner une indication au noyau pour qu'il fournisse le bon nombre d'entités ordonnançable pour une exécution efficace de l'application.

note: type: Plain text
en: Both LinuxThreads and NPTL are 1:1 threading implementations, so setting the concurrency level has no meaning.  In other words, on Linux these functions merely exist for compatibility with other systems, and they have no effect on the execution of a program.
fr: A la fois LinuxThreads et NPTL sont des implémentations des threads 1:1, donc définir le niveau de concurrence n'a pas de signification. En d'autres termes, sous Linux ces fonctions existent essentiellement pour la compatibilité avec d'autres systèmes et elles n'ont aucun effet sur l'exécution d'un programme.

note: type: Plain text
en: pthread_setname_np, pthread_getname_np - set/get the name of a thread
fr: pthread_setname_np, pthread_getname_np - Définir ou obtenir le nom d'un thread

note: type: Plain text
en: B<#define _GNU_SOURCE>             /* See feature_test_macros(7) */
    B<#include E<lt>pthread.hE<gt>>
    B<int pthread_setname_np(pthread_t >I<thread>B<, const char *>I<name>B<);>
    B<int pthread_getname_np(pthread_t >I<thread>B<,>
    B<                       const char *>I<name>B<, size_t >I<len>B<);>
fr: B<#define _GNU_SOURCE>             /* Consultez feature_test_macros(7) */
    B<#include E<lt>pthread.hE<gt>>
    B<int pthread_setname_np(pthread_t >I<thread>B<, const char *>I<name>B<);>
    B<int pthread_getname_np(pthread_t >I<thread>B<,>
    B<                       const char *>I<name>B<, size_t >I<len>B<);>

note: type: Plain text
en: By default, all the threads created using B<pthread_create>()  inherit the program name.  The B<pthread_setname_np>()  function can be used to set a unique name for a thread, which can be useful for debugging multithreaded applications.  The thread name is a meaningful C language string, whose length is restricted to 16 characters, including the terminating null byte (\(aq\e0\(aq).  The I<thread> argument specifies the thread whose name is to be changed; I<name> specifies the new name.
fr: Par défaut, tous les threads créés par B<pthread_create>() héritent du nom de programme. La fonction B<pthread_setname_np>() permet d'affecter un nom propre à un thread, ce qui peut être utile pour déboguer une application multithread. Le nom du thread est une chaîne de langage C significative, dont la longueur ne peut dépasser 16 caractères, caractère nul final (\(aq\e0\(aq) inclus. L'argument I<thread> indique le thread dont le nom doit être changé ; le nouveau nom est précisé dans I<name>.

note: type: Plain text
en: The B<pthread_getname_np>()  function can be used to retrieve the name of the thread.  The I<thread> argument specifies the thread whose name is to be retrieved.  The buffer I<name> is used to return the thread name; I<len> specifies the number of bytes available in I<name>.  The buffer specified by I<name> should be at least 16 characters in length.  The returned thread name in the output buffer will be null terminated.
fr: La fonction B<pthread_getname_np>() permet de récupérer le nom du thread. L'argument I<thread> indique le thread dont le nom doit être récupéré. Le tampon I<name> est utilisé pour renvoyer le nom du thread ; I<len> indique le nombre d'octets disponibles dans I<name>. La longueur du tampon indiqué dans I<name> doit être d'au moins 16 caractères. Le nom du thread renvoyé dans le tampon de retour est terminé par caractère nul.

note: type: Plain text
en: The B<pthread_setname_np>()  function can fail with the following error:
fr: La fonction B<pthread_setname_np>() peut échouer avec l'erreur suivante :

note: type: Plain text
en: The length of the string specified pointed to by I<name> exceeds the allowed limit.
fr: La longueur de la chaîne vers laquelle pointe I<name> dépasse la limite autorisée.

note: type: Plain text
en: The B<pthread_getname_np>()  function can fail with the following error:
fr: La fonction B<pthread_getname_np>() peut échouer avec l'erreur suivante :

note: type: Plain text
en: The buffer specified by I<name> and I<len> is too small to hold the thread name.
fr: Le tampon indiqué par I<name> et I<len> a une taille insuffisante pour contenir le nom du thread.

note: type: Plain text
en: If either of these functions fails to open I</proc/self/task/[tid]/comm>, then the call may fail with one of the errors described in B<open>(2).
fr: Si l'une de ces fonctions ne parvient pas à ouvrir I</proc/self/task/[tid]/comm>, alors l'appel peut échouer en retournant l'une des erreurs décrites dans B<open>(2)

note: type: Plain text
en: These functions first appeared in glibc in version 2.12.
fr: Ces fonctions ont été introduites dans la glibc dans sa version 2.12.

note: type: Plain text
en: These functions are nonstandard GNU extensions.
fr: Ces fonctions sont des extension GNU non standard.

note: type: Plain text
en: B<pthread_setname_np>()  internally writes to the thread-specific I<comm> file under the I</proc> filesystem: I</proc/self/task/[tid]/comm>.  B<pthread_getname_np>()  retrieves it from the same location.
fr: B<pthread_setname_np>() écrit en interne dans le fichier I<comm> du thread (dans le système de fichiers I</proc>) : I</proc/self/task/[tid]/comm>. B<pthread_getname_np>() récupère le nom du thread à ce même endroit.

note: type: Plain text
en: The program below demonstrates the use of B<pthread_setname_np>()  and B<pthread_getname_np>().
fr: Le programme ci-dessous illustre l'utilisation de B<pthread_setname_np>() et de B<pthread_getname_np>().

note: type: Plain text
en: The following shell session shows a sample run of the program:
fr: La session d'interpréteur de commande ci-dessous montre l'exécution du programme :

note: type: Plain text
en: $B< ./a.out>
    Created a thread. Default name is: a.out
    The thread name after setting it is THREADFOO.
    B<^Z>                           # Suspend the program
    [1]+  Stopped           ./a.out
    $ B<ps H -C a.out -o 'pid tid cmd comm'>
      PID   TID CMD                         COMMAND
     5990  5990 ./a.out                     a.out
     5990  5991 ./a.out                     THREADFOO
    $ B<cat /proc/5990/task/5990/comm>
    a.out
    $ B<cat /proc/5990/task/5991/comm>
    THREADFOO
fr: $B< ./a.out>
    Thread créé. Le nom par défaut est : a.out
    Le nom du thread après nommage est THREADFOO.
    B<^Z>                           # Suspendre l'exécution du programme
    [1]+  Stoppé            ./a.out
    $ B<ps H -C a.out -o 'pid tid cmd comm'>
      PID   TID CMD                         COMMAND
     5990  5990 ./a.out                     a.out
     5990  5991 ./a.out                     THREADFOO
    $ B<cat /proc/5990/task/5990/comm>
    a.out
    $ B<cat /proc/5990/task/5991/comm>
    THREADFOO

note: type: Plain text
en: static void *
    threadfunc(void *parm)
    {
        sleep(5);          // allow main program to set the thread name
        return NULL;
    }
fr: static void *
    threadfunc(void *parm)
    {
        sleep(5);          // permet au programme principal de définir
                           // le nom du thread
        return NULL;
    }

note: type: Plain text
en:     printf("Created a thread. Default name is: %s\en", thread_name);
        rc = pthread_setname_np(thread, (argc E<gt> 1) ? argv[1] : "THREADFOO");
        if (rc != 0)
            errExitEN(rc, "pthread_setname_np");
fr:     printf("Thread créé. Le nom par défaut est : %s\en", thread_name);
        rc = pthread_setname_np(thread, (argc E<gt> 1) ? argv[1] : "THREADFOO");
        if (rc != 0)
            errExitEN(rc, "pthread_setname_np");

note: type: Plain text
en:     rc = pthread_getname_np(thread, thread_name,
                                (argc E<gt> 2) ? atoi(argv[1]) : NAMELEN);
        if (rc != 0)
            errExitEN(rc, "pthread_getname_np");
        printf("The thread name after setting it is %s.\en", thread_name);
fr:     rc = pthread_getname_np(thread, thread_name,
                                (argc E<gt> 2) ? atoi(argv[1]) : NAMELEN);
        if (rc != 0)
            errExitEN(rc, "pthread_getname_np");
        printf("Le nom du thread après nommage est %s.\en", thread_name);

note: type: Plain text
en:     printf("Done\en");
        exit(EXIT_SUCCESS);
    }
fr:     printf("Terminé\en");
        exit(EXIT_SUCCESS);
    }

note: type: Plain text
en: pthread_setschedparam, pthread_getschedparam - set/get scheduling policy and parameters of a thread
fr: pthread_setschedparam, pthread_getschedparam - Définir ou obtenir la politique et les paramètres d'ordonnancement d'un thread

note: type: Plain text
en: The B<pthread_setschedparam>()  function sets the scheduling policy and parameters of the thread I<thread>.
fr: La fonction B<pthread_setschedparam>() définit la politique et les paramètres d'ordonnancement du thread I<thread>.

note: FIXME . pthread_setschedparam() places no restriction on the policy, but pthread_attr_setschedpolicy() restricts policy to RR/FIFO/OTHER http://sourceware.org/bugzilla/show_bug.cgi?id=7013 type: Plain text
en: I<policy> specifies the new scheduling policy for I<thread>.  The supported values for I<policy>, and their semantics, are described in B<sched_setscheduler>(2).
fr: L'argument I<policy>  spécifie la politique d'ordonnancement pour I<thread>. Les valeurs possibles, ainsi que leur signification, sont décrites dans B<sched_setscheduler>(2).

note: type: Plain text
en: The structure pointed to by I<param> specifies the new scheduling parameters for I<thread>.  Scheduling parameters are maintained in the following structure:
fr: La structure vers laquelle pointe I<param> spécifie les nouveaux paramètres d'ordonnancement pour I<thread>. Les paramètres d'ordonnancement sont gérés dans la structure suivante\ :

note: FIXME . nptl/pthread_setschedparam.c has the following /* If the thread should have higher priority because of some PTHREAD_PRIO_PROTECT mutexes it holds, adjust the priority. */ Eventually (perhaps after writing the mutexattr pages), we may want to add something on the topic to this page. type: Pla
en: The B<pthread_getschedparam>()  function returns the scheduling policy and parameters of the thread I<thread>, in the buffers pointed to by I<policy> and I<param>, respectively.  The returned priority value is that set by the most recent B<pthread_setschedparam>(), B<pthread_setschedprio>(3), or B<pthread_create>(3)  call that affected I<thread>.  The returned priority does not reflect any temporary priority adjustments as a result of calls to any priority inheritance or priority ceiling functions (see, for example, B<pthread_mutexattr_setprioceiling>(3)  and B<pthread_mutexattr_setprotocol>(3)).
fr: La fonction B<pthread_getschedparam>() renvoie, dans les tampons pointés par I<policy> et I<param>, respectivement la politique et les paramètres d'ordonnancement du thread I<thread>. La valeur de priorité renvoyée est celle utilisée lors de l'appel le plus récent à B<pthread_setschedparam>(), B<pthread_setschedprio>(3) ou B<pthread_create>(3)  qui touchait I<thread>. La priorité renvoyée ne reflète pas des ajustements de priorité temporaires qui peuvent résulter d'appels à une fonction qui modifie l'héritage ou plafonne la priorité d'ordonnancement (voir, par exemple, B<pthread_mutexattr_setprioceiling>(3)  et B<pthread_mutexattr_setprotocol>(3)).

note: type: Plain text
en: On success, these functions return 0; on error, they return a nonzero error number.  If B<pthread_setschedparam>()  fails, the scheduling policy and parameters of I<thread> are not changed.
fr: En cas de réussite, ces fonctions renvoient 0 ; en cas d'erreur, elles renvoient un numéro d'erreur non nul. Si B<pthread_setschedparam>() échoue, la politique et les paramètres d'ordonnancement du thread ne sont pas modifiés.

note: type: Plain text
en: Both of these functions can fail with the following error:
fr: Ces deux fonctions peuvent échouer avec l'erreur suivante :

note: type: Plain text
en: B<pthread_setschedparam>()  may additionally fail with the following errors:
fr: B<pthread_setschedparam>() peut également échouer avec les erreurs suivantes\ :

note: type: Plain text
en: I<policy> is not a recognized policy, or I<param> does not make sense for the I<policy>.
fr: I<policy> n'est pas une politique reconnue, ou I<param> n'a pas de sens pour cette valeur de I<policy>.

note: type: Plain text
en: The caller does not have appropriate privileges to set the specified scheduling policy and parameters.
fr: L'appelant n'a pas les privilèges suffisants pour définir la politique et les paramètres d'ordonnancement indiqués.

note: .SH VERSIONS Available since glibc 2.0 type: Plain text
en: POSIX.1-2001 also documents an B<ENOTSUP> ("attempt was made to set the policy or scheduling parameters to an unsupported value") error for B<pthread_setschedparam>().
fr: POSIX.1-2001 documente également une erreur B<ENOTSUP> (tentative de définition de la politique ou de paramètres d'ordonnancement à une valeur non prise en charge) pour B<pthread_setschedparam>().

note: type: Plain text
en: For a description of the permissions required to, and the effect of, changing a thread's scheduling policy and priority, and details of the permitted ranges for priorities in each scheduling policy, see B<sched_setscheduler>(2).
fr: Pour une description des permissions nécessaires pour modifier la politique et la priorité d'ordonnancement d'un thread (et leur effet), et les détails sur les valeurs possibles de priorités pour chacune des politiques d'ordonnancement, consultez B<sched_setscheduler>(2).

note: type: Plain text
en: The program below demonstrates the use of B<pthread_setschedparam>()  and B<pthread_getschedparam>(), as well as the use of a number of other scheduling-related pthreads functions.
fr: Le programme ci-dessous montre l'utilisation de B<pthread_setschedparam>()  et B<pthread_getschedparam>(), ainsi que d'un certain nombre d'autres fonctions de pthreads relatives à l'ordonnancement.

note: type: Plain text
en: In the following run, the main thread sets its scheduling policy to B<SCHED_FIFO> with a priority of 10, and initializes a thread attributes object with a scheduling policy attribute of B<SCHED_RR> and a scheduling priority attribute of 20.  The program then sets (using B<pthread_attr_setinheritsched>(3))  the inherit scheduler attribute of the thread attributes object to B<PTHREAD_EXPLICIT_SCHED>, meaning that threads created using this attributes object should take their scheduling attributes from the thread attributes object.  The program then creates a thread using the thread attributes object, and that thread displays its scheduling policy and priority.
fr: Lors de l'exécution suivante, le thread principal définit sa politique d'ordonnancement à B<SCHED_FIFO> avec une priorité de 10, et initialise un objet d'attributs de thread avec un attribut de politique d'ordonnancement mis à B<SCHED_RR>, et un attribut de priorité d'ordonnancement de 20. Le programme appelle alors B<pthread_attr_setinheritsched>(3) pour définir à B<PTHREAD_EXPLICIT_SCHED> l'attribut d'héritage de l'ordonnancement de l'objets d'attributs de thread, ce qui signifie que les threads créés avec cet objet d'attributs prendront les attributs d'ordonnancement dans l'objet d'attributs de thread. Le programme crée alors un thread en utilisant l'objets d'attributs de thread, et ce thread affiche sa politique et sa priorité d'ordonnancement.

note: type: Plain text
en: In the above output, one can see that the scheduling policy and priority were taken from the values specified in the thread attributes object.
fr: Nous pouvons voir dans l'affichage ci-dessus que les politique et priorité d'ordonnancement ont pris comme valeurs celles de l'objets d'attributs de thread.

note: type: Plain text
en: The next run is the same as the previous, except that the inherit scheduler attribute is set to B<PTHREAD_INHERIT_SCHED>, meaning that threads created using the thread attributes object should ignore the scheduling attributes specified in the attributes object and instead take their scheduling attributes from the creating thread.
fr: L'exécution suivante est identique, sauf que l'attribut d'héritage d'ordonnancement est mis à B<PTHREAD_INHERIT_SCHED>, ce qui signifie que les threads créés avec cet objet d'attributs devront ignorer les attributs d'ordonnancement de l'objets d'attributs de thread, et prendre à la place les valeurs héritées du thread appelant.

note: type: Plain text
en: In the above output, one can see that the scheduling policy and priority were taken from the creating thread, rather than the thread attributes object.
fr: Nous pouvons voir dans l'affichage ci-dessus que les politique et priorité d'ordonnancement ont pris comme valeurs celles du thread appelant, et non de l'objets d'attributs de thread.

note: type: Plain text
en: Note that if we had omitted the I<-i\ i> option, the output would have been the same, since B<PTHREAD_INHERIT_SCHED> is the default for the inherit scheduler attribute.
fr: Veuillez noter que si l'option I<-i\ i> n'avait pas été présente, l'affichage aurait été identique, car B<PTHREAD_INHERIT_SCHED> est la valeur par défaut pour l'attribut d'héritage d'ordonnancement.

note: type: TH
en: 2008-11-06
fr: 6 novembre 2008

note: type: Plain text
en: pthread_setschedprio - set scheduling priority of a thread
fr: pthread_setschedprio - Définir la priorité d'ordonnancement d'un thread

note: FIXME . nptl/pthread_setschedprio.c has the following /* If the thread should have higher priority because of some PTHREAD_PRIO_PROTECT mutexes it holds, adjust the priority. */ Eventually (perhaps after writing the mutexattr pages), we may want to add something on the topic to this page. nptl/pthre
en: The B<pthread_setschedprio>()  function sets the scheduling priority of the thread I<thread> to the value specified in I<prio>.  (By contrast B<pthread_setschedparam>(3)  changes both the scheduling policy and priority of a thread.)
fr: La fonction B<pthread_setschedprio>() définit la priorité d'ordonnancement du thread I<thread> à la valeur indiquée par I<prio> (à l'inverse, B<pthread_setschedparam>(3) modifie à la fois la priorité et la politique d'ordonnancement d'un thread).

note: type: Plain text
en: On success, this function returns 0; on error, it returns a nonzero error number.  If B<pthread_setschedprio>()  fails, the scheduling priority of I<thread> is not changed.
fr: En cas de réussite, cette fonction renvoie 0 ; en cas d'erreur, elle renvoie un numéro d'erreur non nul. Si B<pthread_setschedprio>() échoue, la priorité d'ordonnancement du thread n'est pas modifiée.

note: type: Plain text
en: I<prio> is not valid for the scheduling policy of the specified thread.
fr: I<prio> n'est pas valable pour une priorité d'ordonnancement du thread indiqué.

note: type: Plain text
en: The caller does not have appropriate privileges to set the specified priority.
fr: L'appelant n'a pas les privilèges suffisants pour définir la priorité indiquée.

note: type: Plain text
en: POSIX.1-2001 also documents an B<ENOTSUP> ("attempt was made to set the priority to an unsupported value") error for B<pthread_setschedparam>(3).
fr: POSIX.1-2001 documente également une erreur B<ENOTSUP> (tentative de définition de la priorité à une valeur non prise en charge) pour B<pthread_setschedparam>(3).

note: type: Plain text
en: This function is available in glibc since version 2.3.4.
fr: Cette fonction est disponible dans la glibc depuis la version 2.3.4.

note: type: Plain text
en: For a description of the permissions required to, and the effect of, changing a thread's scheduling priority, and details of the permitted ranges for priorities in each scheduling policy, see B<sched_setscheduler>(2).
fr: Pour une description des permissions nécessaires pour modifier la priorité d'ordonnancement d'un thread (et son effet), et les détails sur les valeurs possibles de priorités pour chacune des politiques d'ordonnancement, consultez B<sched_setscheduler>(2).

note: type: Plain text
en: pthread_sigmask - examine and change mask of blocked signals
fr: pthread_sigmask - Examiner et modifier le masque des signaux bloqués

note: type: Plain text
en: B<pthread_sigmask>():
fr: B<pthread_sigmask>() :

note: type: Plain text
en: The B<pthread_sigmask>()  function is just like B<sigprocmask>(2), with the difference that its use in multithreaded programs is explicitly specified by POSIX.1-2001.  Other differences are noted in this page.
fr: La fonction B<pthread_sigmask>() est identique à B<sigprocmask>(2), à la différence près que son utilisation dans des programmes multithread est explicitement spécifié dans POSIX.1-2001. D'autres différences sont indiquées dans cette page.

note: type: Plain text
en: For a description of the arguments and operation of this function, see B<sigprocmask>(2).
fr: Pour une description des arguments et du mode d'opération de cette fonction, consultez B<sigprocmask>(2).

note: type: Plain text
en: On success, B<pthread_sigmask>()  returns 0; on error, it returns an error number.
fr: En cas de réussite, B<pthread_sigmask>() renvoie 0 ; en cas d'erreur, elle renvoie un numéro d'erreur.

note: type: Plain text
en: See B<sigprocmask>(2).
fr: Consultez B<sigprocmask>(2).

note: type: Plain text
en: A new thread inherits a copy of its creator's signal mask.
fr: Un nouveau thread hérite d'une copie du masque de signaux de son créateur.

note: type: Plain text
en: The program below blocks some signals in the main thread, and then creates a dedicated thread to fetch those signals via B<sigwait>(3).  The following shell session demonstrates its use:
fr: Le programme ci-dessous bloque certains signaux dans le thread principal, puis crée un thread dédié pour récupérer ces signaux avec B<sigwait>(3). La session d'interpréteur de commande ci-dessous démontre l'utilisation du programme.

note: type: TH
en: 2012-08-19
fr: 19 août 2012

note: type: Plain text
en: pthread_sigqueue - queue a signal and data to a thread
fr: pthread_sigqueue - Enregistrer un signal et des données pour un thread

note: type: Plain text
en: B<pthread_sigqueue>(): _GNU_SOURCE
fr: B<pthread_sigqueue>() : _GNU_SOURCE

note: type: Plain text
en: The B<pthread_sigqueue>()  function performs a similar task to B<sigqueue>(3), but, rather than sending a signal to a process, it sends a signal to a thread in the same process as the calling thread.
fr: La fonction B<pthread_exit>() effectue une tâche semblable à B<sigqueue>(3), mais, au lieu d'envoyer un signal à un processus, elle envoie le signal à un thread du même processus que le thread appelant.

note: type: Plain text
en: The I<thread> argument is the ID of a thread in the same process as the caller.  The I<sig> argument specifies the signal to be sent.  The I<value> argument specifies data to accompany the signal; see B<sigqueue>(3)  for details.
fr: Le paramètre I<thread> est l'identifiant d'un thread du même processus que l'appelant. Le paramètre I<sig> indique le signal à envoyer. Le paramètre I<value> indique les données à envoyer avec le signal ; consultez B<sigqueue>(3)  pour plus de détails.

note: type: Plain text
en: On success, B<pthread_sigqueue>()  returns 0; on error, it returns an error number.
fr: En cas de réussite, B<pthread_sigqueue>() renvoie 0 ; en cas d'erreur, elle renvoie un numéro d'erreur.

note: type: Plain text
en: The limit of signals which may be queued has been reached.  (See B<signal>(7)  for further information.)
fr: La limite du nombre de signaux en file a été atteinte (consultez B<signal>(7) pour plus d'informations).

note: type: Plain text
en: I<sig> was invalid.
fr: I<sig> est invalide.

note: type: Plain text
en: B<pthread_sigqueue>()  is not supported on this system.
fr: B<pthread_sigqueue>()  n'est pas pris en charge par ce système.

note: type: Plain text
en: I<thread> is not valid.
fr: I<thread> n'est pas valide.

note: type: Plain text
en: The B<pthread_sigqueue>()  function first appeared in glibc 2.11.
fr: La fonction B<pthread_sigqueue>() a été introduite dans la glibc dans sa version 2.11.

note: type: Plain text
en: This function is a GNU extension.
fr: Cette fonction est une extension GNU.

note: type: TH
en: 2012-04-14
fr: 14 avril 2012

note: type: Plain text
en: pthread_testcancel - request delivery of any pending cancellation request
fr: pthread_testcancel - Demander la délivrance de toute requête d'annulation en cours

note: type: Plain text
en: Calling B<pthread_testcancel>()  creates a cancellation point within the calling thread, so that a thread that is otherwise executing code that contains no cancellation points will respond to a cancellation request.
fr: Appeler B<pthread_testcancel>() crée un point d'annulation à l'intérieur du thread appelant, si bien qu'un thread qui ne contient normalement pas de points d'annulation sera en mesure de répondre à une requête d'annulation.

note: type: Plain text
en: If cancelability is disabled (using B<pthread_setcancelstate>(3)), or no cancellation request is pending, then a call to B<pthread_testcancel>()  has no effect.
fr: Si la possibilité d'annulation est désactivée (avec B<pthread_setcancelstate>(3)), ou si aucune requête d'annulation est en cours, un appel à B<pthread_testcancel>() n'aura aucun effet.

note: type: Plain text
en: This function does not return a value.  If the calling thread is canceled as a consequence of a call to this function, then the function does not return.
fr: Cette fonction ne renvoie aucune valeur. Si le thread appelant est annulé en conséquence d'un appel à cette fonction, alors cette fonction ne retourne pas.

note: type: Plain text
en: See B<pthread_cleanup_push>(3).
fr: Consultez B<pthread_cleanup_push>(3).

note: type: Plain text
en: pthread_tryjoin_np, pthread_timedjoin_np - try to join with a terminated thread
fr: pthread_tryjoin_np, pthread_timedjoin_np - Essayer de fusionner avec un thread ayant terminé son exécution

note: type: Plain text
en: These functions operate in the same way as B<pthread_join>(3), except for the differences described on this page.
fr: Ces fonctions opèrent de la même façon que B<pthread_join>(3), à l'exception des différences décrites dans cette page.

note: type: Plain text
en: The B<pthread_tryjoin_np>()  function performs a nonblocking join with the thread I<thread>, returning the exit status of the thread in I<*retval>.  If I<thread> has not yet terminated, then instead of blocking, as is done by B<pthread_join>(3), the call returns an error.
fr: La fonction B<pthread_tryjoin_np>() essaie de fusionner avec le thread I<thread> si cela est possible sans attendre et renvoie le code de retour du thread dans I<*retval>. Si le I<thread> ne s'est toujours pas terminé, alors au lieu d'être bloquée (comme le fait B<pthread_join>(3)), l'appel renvoie une erreur.

note: type: Plain text
en: The B<pthread_timedjoin_np>()  function performs a join-with-timeout.  If I<thread> has not yet terminated, then the call blocks until a maximum time, specified in I<abstime>.  If the timeout expires before I<thread> terminates, the call returns an error.  The I<abstime> argument is a structure of the following form, specifying an absolute time measured since the Epoch (see B<time>(2)):
fr: La fonction B<pthread_timedjoin_np>() essaie de fusionner avec un thread avec une limite de temps. Si le I<thread> ne s'est toujours pas terminé, alors l'appel est bloqué pendant un temps maximum de I<abstime>. Si le délai expire avant que I<thread> ne se termine, l'appel renvoie une erreur. Le paramètre I<abstime> est une structure de la forme suivante, qui indique un temps absolu mesuré depuis l'époque (consultez B<time>(2)) :

note: type: Plain text
en: struct timespec {
        time_t tv_sec;     /* seconds */
        long   tv_nsec;    /* nanoseconds */
    };
fr: struct timespec {
        time_t tv_sec;      /* Secondes */
        long   tv_nsec;     /* Nanosecondes */
    };

note: type: Plain text
en: On success, these functions return 0; on error, they return an error number.
fr: En cas de réussite, ces fonction renvoient 0 ; en cas d'erreur, elles renvoient un numéro d'erreur.

note: type: Plain text
en: These functions can fail with the same errors as B<pthread_join>(3).  B<pthread_tryjoin_np>()  can in addition fail with the following error:
fr: Ces fonction peuvent échouer avec les mêmes erreurs que B<pthread_join>(3). B<pthread_tryjoin_np>() peut de plus échouer avec l'erreur suivante :

note: type: Plain text
en: I<thread> had not yet terminated at the time of the call.
fr: L'exécution du I<thread> n'était pas terminée au moment de l'appel.

note: type: Plain text
en: B<pthread_timedjoin_np>()  can in addition fail with the following error:
fr: B<pthread_timedjoin_np>() peut également échouer avec les erreurs suivantes\ :

note: type: Plain text
en: The call timed out before I<thread> terminated.
fr: Le délai a expiré avant que I<thread> ne se soit terminé.

note: type: Plain text
en: B<pthread_timedjoin_np>()  never returns the error B<EINTR>.
fr: B<pthread_timedjoin_np>() ne renvoie jamais d'erreur B<EINTR>.

note: type: Plain text
en: These functions first appeared in glibc in version 2.3.3.
fr: Ces fonctions ont été introduites dans la glibc dans sa version 2.3.3.

note: type: Plain text
en: The following code waits to join for up to 5 seconds:
fr: Le code suivant attend la fin d'exécution d'un thread pour fusionner pendant au plus 5 seconde :

note: type: TH
en: 2013-03-05
fr: 5 mars 2013

note: type: Plain text
en: pthread_yield - yield the processor
fr: pthread_yield - Libérer le processeur

note: type: Plain text
en: B<pthread_yield>()  causes the calling thread to relinquish the CPU.  The thread is placed at the end of the run queue for its static priority and another thread is scheduled to run.  For further details, see B<sched_yield>(2)
fr: B<pthread_yield>() libère le CPU du thread appelant. Le thread est déplacé à la fin de la queue d'exécution pour sa priorité statique et un autre thread sera exécuté. Pour plus de détails, consultez B<sched_yield>(2).

note: type: Plain text
en: On success, B<pthread_yield>()  returns 0; on error, it returns an error number.
fr: En cas de réussite, B<pthread_yield>() renvoie 0 ; en cas d'erreur, elle renvoie un numéro d'erreur.

note: type: Plain text
en: On Linux, this call always succeeds (but portable and future-proof applications should nevertheless handle a possible error return).
fr: Sous Linux, ces fonctions réussissent toujours (mais les applications portables et à l'épreuve du temps devraient néanmoins prendre en charge une possible valeur de retour).

note: e.g., the BSDs, Tru64, AIX, and Irix. type: Plain text
en: This call is nonstandard, but present on several other systems.  Use the standardized B<sched_yield>(2)  instead.
fr: Cet appel n'est pas standard mais est présent sur plusieurs autres systèmes. Utilisez plutôt B<sched_yield>(2) qui est standard.

note: type: Plain text
en: On Linux, this function is implemented as a call to B<sched_yield>(2).
fr: Sous Linux, cette fonction est implémentée comme un appel à B<sched_yield>(2).

note: type: TH
en: 2010-11-14
fr: 14 novembre 2010

note: type: Plain text
en: pthreads - POSIX threads
fr: pthreads - Threads POSIX

note: type: Plain text
en: POSIX.1 specifies a set of interfaces (functions, header files) for threaded programming commonly known as POSIX threads, or Pthreads.  A single process can contain multiple threads, all of which are executing the same program.  These threads share the same global memory (data and heap segments), but each thread has its own stack (automatic variables).
fr: POSIX.1 décrit une série d'interfaces (fonctions et fichiers d'en\(hytêtes) pour la programmation multithread, couramment appelée threads POSIX, ou pthreads. Un unique processus peut contenir plusieurs threads, qui exécutent tous le même programme. Ces threads partagent la même mémoire globale (segments de données et tas), mais chaque thread a sa propre pile (variables automatiques).

note: type: Plain text
en: POSIX.1 also requires that threads share a range of other attributes (i.e., these attributes are process-wide rather than per-thread):
fr: POSIX.1 requiert aussi que les threads partagent une série d'autres attributs (ces attributs sont par processus, plutôt que par thread)\ :

note: type: Plain text
en: process ID
fr: identifiant de processus (PID)

note: type: Plain text
en: parent process ID
fr: identifiant de processus père (PPID)

note: type: Plain text
en: process group ID and session ID
fr: identifiant de groupe de processus (PGID) et identifiant de session (SID)

note: type: Plain text
en: controlling terminal
fr: terminal de contrôle

note: type: Plain text
en: user and group IDs
fr: identifiants d'utilisateur et de groupe

note: type: Plain text
en: open file descriptors
fr: descripteurs de fichier ouverts

note: type: Plain text
en: record locks (see B<fcntl>(2))
fr: verrouillages d'enregistrements (consultez B<fcntl>(2))

note: type: Plain text
en: signal dispositions
fr: gestion de signaux

note: type: Plain text
en: file mode creation mask (B<umask>(2))
fr: masque de création de fichier (B<umask>(2))

note: type: Plain text
en: current directory (B<chdir>(2))  and root directory (B<chroot>(2))
fr: répertoire de travail (B<chdir>(2)) et répertoire racine (B<chroot>(2))

note: type: Plain text
en: interval timers (B<setitimer>(2))  and POSIX timers (B<timer_create>(2))
fr: temporisations d'intervalle (B<setitimer>(2)) et temporisations POSIX (B<timer_create>(2))

note: type: Plain text
en: nice value (B<setpriority>(2))
fr: valeur de politesse (B<setpriority>(2))

note: type: Plain text
en: resource limits (B<setrlimit>(2))
fr: limites de ressources (B<setrlimit>(2))

note: type: Plain text
en: measurements of the consumption of CPU time (B<times>(2))  and resources (B<getrusage>(2))
fr: mesures de consommation de temps CPU (B<times>(2)) et de ressources (B<getrusage>(2))

note: type: Plain text
en: As well as the stack, POSIX.1 specifies that various other attributes are distinct for each thread, including:
fr: En plus de la pile, POSIX.1 indique que plusieurs autres attributs sont distincts pour chaque thread, dont les suivants\ :

note: type: Plain text
en: thread ID (the I<pthread_t> data type)
fr: identifiant de thread (le type de donnée I<pthread_t>)

note: type: Plain text
en: signal mask (B<pthread_sigmask>(3))
fr: masque de signaux (B<pthread_sigmask>(3))

note: type: Plain text
en: the I<errno> variable
fr: la variable I<errno>

note: type: Plain text
en: alternate signal stack (B<sigaltstack>(2))
fr: pile spécifique de signal (B<sigaltstack>(2))

note: type: Plain text
en: real-time scheduling policy and priority (B<sched_setscheduler>(2)  and B<sched_setparam>(2))
fr: politique et priorité d'ordonnancement temps-réel (B<sched_setscheduler>(2) et B<sched_setparam>(2))

note: type: Plain text
en: The following Linux-specific features are also per-thread:
fr: Les caractéristiques spécifiques à Linux suivantes sont également distinctes pour chaque thread\ :

note: type: Plain text
en: capabilities (see B<capabilities>(7))
fr: capacités (consultez B<capabilities>(7))

note: type: Plain text
en: CPU affinity (B<sched_setaffinity>(2))
fr: affinité CPU (B<sched_setaffinity>(2))

note: type: SS
en: Pthreads function return values
fr: Valeurs de retour des fonctions pthreads

note: type: Plain text
en: Most pthreads functions return 0 on success, and an error number of failure.  Note that the pthreads functions do not set I<errno>.  For each of the pthreads functions that can return an error, POSIX.1-2001 specifies that the function can never fail with the error B<EINTR>.
fr: La plupart des fonctions pthreads renvoient 0 en cas de succès et un numéro d'erreur en cas d'échec. Notez que les fonctions pthreads ne positionnent pas I<errno>. Pour chacune des fonctions pthreads qui peuvent produire une erreur, POSIX.1-2001 spécifie que la fonction ne peut pas échouer avec l'erreur B<EINTR>.

note: type: SS
en: Thread IDs
fr: Identifiants de thread

note: type: Plain text
en: Each of the threads in a process has a unique thread identifier (stored in the type I<pthread_t>).  This identifier is returned to the caller of B<pthread_create>(3), and a thread can obtain its own thread identifier using B<pthread_self>(3).  Thread IDs are guaranteed to be unique only within a process.  A thread ID may be reused after a terminated thread has been joined, or a detached thread has terminated.  In all pthreads functions that accept a thread ID as an argument, that ID by definition refers to a thread in the same process as the caller.
fr: Chacun des threads d'un processus a un unique identifiant de thread (stocké dans le type I<pthread_t>). Cet identifiant est renvoyé à l'appelant de B<pthread_create>(3) et un thread peut obtenir son propre identifiant de thread en utilisant B<pthread_self>(3). Les identifiants de thread n'ont la garantie d'être uniques qu'à l'intérieur d'un processus. Un identifiant de thread peut être réutilisé après qu'un thread qui s'est terminé a été rejoint ou qu'un thread détaché se soit terminé. Pour toutes les fonctions qui acceptent un identifiant de thread en paramètre, cet identifiant de thread se réfère par définition à un thread du même processus que l'appelant.

note: type: SS
en: Thread-safe functions
fr: Fonctions sûres du point de vue des threads

note: type: Plain text
en: A thread-safe function is one that can be safely (i.e., it will deliver the same results regardless of whether it is)  called from multiple threads at the same time.
fr: Une fonction sûre du point de vue des threads est une fonction qui peut être appelée en toute sûreté (c'est-à-dire qu'elle renverra le même résultat d'où qu'elle soit appelée) par plusieurs threads en même temps.

note: type: Plain text
en: POSIX.1-2001 and POSIX.1-2008 require that all functions specified in the standard shall be thread-safe, except for the following functions:
fr: POSIX.1-2001 et POSIX.1-2008 exigent que toutes les fonctions indiquées dans la norme soient sûres du point de vue des threads, excepté les fonctions suivantes :

note: type: Plain text
en: asctime()
    basename()
    catgets()
    crypt()
    ctermid() if passed a non-NULL argument
    ctime()
    dbm_clearerr()
    dbm_close()
    dbm_delete()
    dbm_error()
    dbm_fetch()
    dbm_firstkey()
    dbm_nextkey()
    dbm_open()
    dbm_store()
    dirname()
    dlerror()
    drand48()
    ecvt() [POSIX.1-2001 only (function removed in POSIX.1-2008)]
    encrypt()
    endgrent()
    endpwent()
    endutxent()
    fcvt() [POSIX.1-2001 only (function removed in POSIX.1-2008)]
    ftw()
    gcvt() [POSIX.1-2001 only (function removed in POSIX.1-2008)]
    getc_unlocked()
    getchar_unlocked()
    getdate()
    getenv()
    getgrent()
    getgrgid()
    getgrnam()
    gethostbyaddr() [POSIX.1-2001 only (function removed in POSIX.1-2008)]
    gethostbyname() [POSIX.1-2001 only (function removed in POSIX.1-2008)]
    gethostent()
    getlogin()
    getnetbyaddr()
    getnetbyname()
    getnetent()
    getopt()
    getprotobyname()
    getprotobynumber()
    getprotoent()
    getpwent()
    getpwnam()
    getpwuid()
    getservbyname()
    getservbyport()
    getservent()
    getutxent()
    getutxid()
    getutxline()
    gmtime()
    hcreate()
    hdestroy()
    hsearch()
    inet_ntoa()
    l64a()
    lgamma()
    lgammaf()
    lgammal()
    localeconv()
    localtime()
    lrand48()
    mrand48()
    nftw()
    nl_langinfo()
    ptsname()
    putc_unlocked()
    putchar_unlocked()
    putenv()
    pututxline()
    rand()
    readdir()
    setenv()
    setgrent()
    setkey()
    setpwent()
    setutxent()
    strerror()
    strsignal() [Added in POSIX.1-2008]
    strtok()
    system() [Added in POSIX.1-2008]
    tmpnam() if passed a non-NULL argument
    ttyname()
    unsetenv()
    wcrtomb() if its final argument is NULL
    wcsrtombs() if its final argument is NULL
    wcstombs()
    wctomb()
fr: asctime()
    basename()
    catgets()
    crypt()
    ctermid() avec un paramètre non NULL
    ctime()
    dbm_clearerr()
    dbm_close()
    dbm_delete()
    dbm_error()
    dbm_fetch()
    dbm_firstkey()
    dbm_nextkey()
    dbm_open()
    dbm_store()
    dirname()
    dlerror()
    drand48()
    ecvt() [POSIX.1-2001 uniquement (fonction supprimée dans POSIX.1-2008)]
    encrypt()
    endgrent()
    endpwent()
    endutxent()
    fcvt() [POSIX.1-2001 uniquement (fonction supprimée dans POSIX.1-2008)]
    ftw()
    gcvt() [POSIX.1-2001 uniquement (fonction supprimée dans POSIX.1-2008)]
    getc_unlocked()
    getchar_unlocked()
    getdate()
    getenv()
    getgrent()
    getgrgid()
    getgrnam()
    gethostbyaddr() [POSIX.1-2001 uniquement (fonction supprimée dans POSIX.1-2008)]
    gethostbyname() [POSIX.1-2001 uniquement (fonction supprimée dans POSIX.1-2008)]
    gethostent()
    getlogin()
    getnetbyaddr()
    getnetbyname()
    getnetent()
    getopt()
    getprotobyname()
    getprotobynumber()
    getprotoent()
    getpwent()
    getpwnam()
    getpwuid()
    getservbyname()
    getservbyport()
    getservent()
    getutxent()
    getutxid()
    getutxline()
    gmtime()
    hcreate()
    hdestroy()
    hsearch()
    inet_ntoa()
    l64a()
    lgamma()
    lgammaf()
    lgammal()
    localeconv()
    localtime()
    lrand48()
    mrand48()
    nftw()
    nl_langinfo()
    ptsname()
    putc_unlocked()
    putchar_unlocked()
    putenv()
    pututxline()
    rand()
    readdir()
    setenv()
    setgrent()
    setkey()
    setpwent()
    setutxent()
    strerror()
    strsignal() [Ajoutée dans POSIX.1-2008]
    strtok()
    system() [Ajoutée dans POSIX.1-2008]
    tmpnam() avec un paramètre non NULL
    ttyname()
    unsetenv()
    wcrtomb() si son dernier paramètre est NULL
    wcsrtombs() si son dernier paramètre est NULL
    wcstombs()
    wctomb()

note: type: SS
en: Async-cancel-safe functions
fr: Fonctions pour annulations sûres asynchrones

note: type: Plain text
en: An async-cancel-safe function is one that can be safely called in an application where asynchronous cancelability is enabled (see B<pthread_setcancelstate>(3)).
fr: Une fonction pour annulations sûres asynchrones peut être appelée sans risque dans une application où l'état d'annulation est activé (consultez B<pthread_setcancelstate>(3)).

note: type: Plain text
en: Only the following functions are required to be async-cancel-safe by POSIX.1-2001 and POSIX.1-2008:
fr: POSIX.1-2001 et POSIX.1-2008 exigent que seules les fonctions suivantes soient pour annulations sûres asynchrones :

note: type: SS
en: Cancellation points
fr: Points d'annulation

note: type: Plain text
en: POSIX.1 specifies that certain functions must, and certain other functions may, be cancellation points.  If a thread is cancelable, its cancelability type is deferred, and a cancellation request is pending for the thread, then the thread is canceled when it calls a function that is a cancellation point.
fr: POSIX.1 spécifie que certaines fonctions doivent, et certaines autres fonctions peuvent, être des points d'annulation. Si un thread est annulable, que son type d'annulation est retardé (« deferred ») et qu'une demande d'annulation est en cours pour ce thread, alors le thread est annulé quand il appelle une fonction qui est un point d'annulation.

note: type: Plain text
en: The following functions are required to be cancellation points by POSIX.1-2001 and/or POSIX.1-2008:
fr: POSIX.1-2001 et/ou POSIX.1-2008 exigent que les fonctions suivantes soient des points d'annulation :

note: type: Plain text
en: accept()
    aio_suspend()
    clock_nanosleep()
    close()
    connect()
    creat()
    fcntl() F_SETLKW
    fdatasync()
    fsync()
    getmsg()
    getpmsg()
    lockf() F_LOCK
    mq_receive()
    mq_send()
    mq_timedreceive()
    mq_timedsend()
    msgrcv()
    msgsnd()
    msync()
    nanosleep()
    open()
    openat() [Added in POSIX.1-2008]
    pause()
    poll()
    pread()
    pselect()
    pthread_cond_timedwait()
    pthread_cond_wait()
    pthread_join()
    pthread_testcancel()
    putmsg()
    putpmsg()
    pwrite()
    read()
    readv()
    recv()
    recvfrom()
    recvmsg()
    select()
    sem_timedwait()
    sem_wait()
    send()
    sendmsg()
    sendto()
    sigpause() [POSIX.1-2001 only (moves to "may" list in POSIX.1-2008)]
    sigsuspend()
    sigtimedwait()
    sigwait()
    sigwaitinfo()
    sleep()
    system()
    tcdrain()
    usleep() [POSIX.1-2001 only (function removed in POSIX.1-2008)]
    wait()
    waitid()
    waitpid()
    write()
    writev()
fr: accept()
    aio_suspend()
    clock_nanosleep()
    close()
    connect()
    creat()
    fcntl() F_SETLKW
    fdatasync()
    fsync()
    getmsg()
    getpmsg()
    lockf() F_LOCK
    mq_receive()
    mq_send()
    mq_timedreceive()
    mq_timedsend()
    msgrcv()
    msgsnd()
    msync()
    nanosleep()
    open()
    openat() [Ajoutée dans POSIX.1-2008]
    pause()
    poll()
    pread()
    pselect()
    pthread_cond_timedwait()
    pthread_cond_wait()
    pthread_join()
    pthread_testcancel()
    putmsg()
    putpmsg()
    pwrite()
    read()
    readv()
    recv()
    recvfrom()
    recvmsg()
    select()
    sem_timedwait()
    sem_wait()
    send()
    sendmsg()
    sendto()
    sigpause() [POSIX.1-2001 uniquement (dans la liste des fonctions pouvant être un point d'annulation dans POSIX.1-2008)]
    sigsuspend()
    sigtimedwait()
    sigwait()
    sigwaitinfo()
    sleep()
    system()
    tcdrain()
    usleep() [POSIX.1-2001 uniquement (fonction supprimée dans POSIX.1-2008)]
    wait()
    waitid()
    waitpid()
    write()
    writev()

note: type: Plain text
en: The following functions may be cancellation points according to POSIX.1-2001 and/or POSIX.1-2008:
fr: POSIX.1-2001 et/ou POSIX.1-2008 indiquent que les fonctions suivantes peuvent être des points d'annulation :

note: So, scanning "cancellation point" comments in the glibc 2.8 header files, it looks as though at least the following nonstandard functions are cancellation points: endnetgrent endspent epoll_pwait epoll_wait fcloseall fdopendir fflush_unlocked fgetc_unlocked fgetgrent fgetgrent_r fgetpwent fgetpwent_
en: An implementation may also mark other functions not specified in the standard as cancellation points.  In particular, an implementation is likely to mark any nonstandard function that may block as a cancellation point.  (This includes most functions that can touch files.)
fr: Une implémentation peut également indiquer d'autres fonctions non spécifiées dans la norme comme étant des points d'annulation. En particulier, une implémentation marquera probablement toute fonction non standard qui peut bloquer comme étant un point d'annulation (ceci inclus la plupart des fonctions qui peuvent toucher des fichiers).

note: type: SS
en: Compiling on Linux
fr: Compiler sous Linux

note: type: Plain text
en: On Linux, programs that use the Pthreads API should be compiled using I<cc -pthread>.
fr: Sous Linux, les programmes utilisant l'API pthreads doivent être compilés avec I<cc -pthread>.

note: type: SS
en: Linux implementations of POSIX threads
fr: Implémentations des threads POSIX sous Linux

note: type: Plain text
en: Over time, two threading implementations have been provided by the GNU C library on Linux:
fr: Deux implémentations différentes des threads ont été fournies par la bibliothèque C de GNU sous Linux\ :

note: type: Plain text
en: This is the original Pthreads implementation.  Since glibc 2.4, this implementation is no longer supported.
fr: Il s'agit de l'implémentation des Pthreads originelle. Depuis la glibc\ 2.4, cette implémentation n'est plus prise en charge.

note: type: Plain text
en: This is the modern Pthreads implementation.  By comparison with LinuxThreads, NPTL provides closer conformance to the requirements of the POSIX.1 specification and better performance when creating large numbers of threads.  NPTL is available since glibc 2.3.2, and requires features that are present in the Linux 2.6 kernel.
fr: Il s'agit de l'implémentation moderne des Pthreads. Par rapport à LinuxThreads, NPTL se conforme mieux aux exigences de la norme POSIX.1, et une meilleure performance lors de la création d'un grand nombre de threads. NPTL est disponible depuis la glibc\ 2.3.2, et nécessite des fonctionnalités présentes dans le noyau Linux\ 2.6.

note: type: Plain text
en: Both of these are so-called 1:1 implementations, meaning that each thread maps to a kernel scheduling entity.  Both threading implementations employ the Linux B<clone>(2)  system call.  In NPTL, thread synchronization primitives (mutexes, thread joining, and so on) are implemented using the Linux B<futex>(2)  system call.
fr: Ces deux implémentation sont dit de type 1:1, ce qui veut dire que chaque thread correspond à une entité d'ordonnancement du noyau. Les deux implémentations utilisent l'appel système B<clone>(2) de Linux. Dans NPTL, les primitives de synchronisation de threads (mutexes, jonction de thread, etc.) sont implémentées avec l'appel système B<futex>(2) de Linux.

note: type: Plain text
en: The notable features of this implementation are the following:
fr: Les fonctionnalités importantes de cette implémentation sont les suivantes\ :

note: type: Plain text
en: In addition to the main (initial) thread, and the threads that the program creates using B<pthread_create>(3), the implementation creates a "manager" thread.  This thread handles thread creation and termination.  (Problems can result if this thread is inadvertently killed.)
fr: En plus du thread principal (initial) et des threads créés par le programme avec B<pthread_create>(3), l'implémentation crée un thread de gestion. Ce thread s'occupe de la création et de la terminaison des threads. Des problèmes peuvent survenir si ce thread est tué de façon imprévue.

note: type: Plain text
en: Signals are used internally by the implementation.  On Linux 2.2 and later, the first three real-time signals are used (see also B<signal>(7)).  On older Linux kernels, B<SIGUSR1> and B<SIGUSR2> are used.  Applications must avoid the use of whichever set of signals is employed by the implementation.
fr: Les signaux sont utilisés en interne par l'implémentation. Sous Linux 2.2 et suivants, les trois premiers signaux temps-réel sont utilisés (voir aussi B<signal>(7)). Sous les noyaux plus anciens, LinuxThreads utilise B<SIGUSR1> et B<SIGUSR2>. Les applications doivent éviter d'utiliser les signaux utilisés par l'implémentation.

note: type: Plain text
en: Threads do not share process IDs.  (In effect, LinuxThreads threads are implemented as processes which share more information than usual, but which do not share a common process ID.)  LinuxThreads threads (including the manager thread)  are visible as separate processes using B<ps>(1).
fr: Les threads ne partagent pas leur identifiant de processus. (En fait, les threads LinuxThreads sont implémentés comme des processus partageant plus d'informations qu'à l'habitude, mais pas leur identifiant de processus.) Les threads LinuxThreads (y compris le thread de gestion) sont visibles comme des processus différents avec B<ps>(1).

note: type: Plain text
en: The LinuxThreads implementation deviates from the POSIX.1 specification in a number of ways, including the following:
fr: L'implémentation LinuxThreads s'écarte de la spécification POSIX.1 par plusieurs aspects, dont les suivants\ :

note: type: Plain text
en: Calls to B<getpid>(2)  return a different value in each thread.
fr: Les appels à B<getpid>(2) renvoient une valeur distincte dans chaque thread.

note: type: Plain text
en: Calls to B<getppid>(2)  in threads other than the main thread return the process ID of the manager thread; instead B<getppid>(2)  in these threads should return the same value as B<getppid>(2)  in the main thread.
fr: Les appels à B<getppid>(2) dans les threads autres que le thread principal renvoient l'identifiant de processus du thread de gestion\ ; B<getppid>(2) dans ces threads devrait renvoyer la même valeur que dans le thread principal.

note: type: Plain text
en: When one thread creates a new child process using B<fork>(2), any thread should be able to B<wait>(2)  on the child.  However, the implementation only allows the thread that created the child to B<wait>(2)  on it.
fr: Lorsqu'un thread crée un nouveau processus fils avec B<fork>(2), n'importe quel thread devrait pouvoir utiliser B<wait>(2) pour attendre la terminaison de ce fils. Cependant, l'implémentation ne permet qu'au thread ayant créé le fils d'appeler B<wait>(2) pour l'attendre.

note: type: Plain text
en: When a thread calls B<execve>(2), all other threads are terminated (as required by POSIX.1).  However, the resulting process has the same PID as the thread that called B<execve>(2): it should have the same PID as the main thread.
fr: Lorsqu'un thread appelle B<execve>(2), tous les autres threads sont terminés (comme le prescrit POSIX.1). Cependant, le processus résultant a le même PID que le thread ayant appelé B<execve>(2)\ : il devrait avoir le même PID que le thread principal.

note: type: Plain text
en: Threads do not share user and group IDs.  This can cause complications with set-user-ID programs and can cause failures in Pthreads functions if an application changes its credentials using B<seteuid>(2)  or similar.
fr: Les threads ne partagent pas leurs identifiants d'utilisateur et de groupe. Ceci peut causer des complications pour les programmes setuid et provoquer des erreurs dans les fonctions pthreads si une application change d'identifiant avec B<seteuid>(2) et consorts.

note: type: Plain text
en: Threads do not share a common session ID and process group ID.
fr: Les threads ne partagent pas l'identifiant de session et de groupe de processus.

note: type: Plain text
en: Threads do not share record locks created using B<fcntl>(2).
fr: Les threads ne partagent pas les verrouillages d'enregistrements créés avec B<fcntl>(2).

note: type: Plain text
en: The information returned by B<times>(2)  and B<getrusage>(2)  is per-thread rather than process-wide.
fr: L'information renvoyée par B<times>(2) et B<getrusage>(2) est par thread au lieu d'être par processus.

note: type: Plain text
en: Threads do not share semaphore undo values (see B<semop>(2)).
fr: Les threads ne partagent pas les valeurs «\ undo\ » de sémaphores (voir B<semop>(2)).

note: type: Plain text
en: Threads do not share interval timers.
fr: Les threads ne partagent pas les temporisations d'intervalles.

note: FIXME . bug report filed for NPTL nice nonconformance http://bugzilla.kernel.org/show_bug.cgi?id=6258 Sep 08: there is a patch by Denys Vlasenko to address this "make setpriority POSIX compliant; introduce PRIO_THREAD extension" Monitor this to see if it makes it into mainline. type: Plain text
en: Threads do not share a common nice value.
fr: Les threads ne partagent pas leur valeur de politesse.

note: type: Plain text
en: POSIX.1 distinguishes the notions of signals that are directed to the process as a whole and signals that are directed to individual threads.  According to POSIX.1, a process-directed signal (sent using B<kill>(2), for example) should be handled by a single, arbitrarily selected thread within the process.  LinuxThreads does not support the notion of process-directed signals: signals may be sent only to specific threads.
fr: POSIX.1 distingue les notions de signal envoyé au processus dans son ensemble, et de signal envoyé à un thread individuellement. Selon POSIX.1, un signal envoyé au processus (par exemple avec B<kill>(2)) sera géré par un thread choisi arbitrairement au sein du processus. LinuxThreads ne permet pas d'envoyer un signal au processus, mais seulement à un thread spécifique.

note: type: Plain text
en: Threads have distinct alternate signal stack settings.  However, a new thread's alternate signal stack settings are copied from the thread that created it, so that the threads initially share an alternate signal stack.  (A new thread should start with no alternate signal stack defined.  If two threads handle signals on their shared alternate signal stack at the same time, unpredictable program failures are likely to occur.)
fr: Les threads ont des paramètres de pile spécifique de signal distincts. Cependant, les paramètres de pile spécifique d'un nouveau thread sont copiés à partir du thread qui l'a créé, ce qui veut dire que les threads partagent initialement une même pile spécifique de signaux. (Un nouveau thread devrait démarrer sans pile spécifique de signaux. Si deux threads gèrent un signal sur leur pile spécifique au même moment, des échecs imprévisibles du programme risquent de se produire.)

note: type: Plain text
en: With NPTL, all of the threads in a process are placed in the same thread group; all members of a thread group share the same PID.  NPTL does not employ a manager thread.  NPTL makes internal use of the first two real-time signals (see also B<signal>(7)); these signals cannot be used in applications.
fr: Avec NPTL, tous les threads d'un processus sont placés dans le même groupe de threads. Tous les membres d'un groupe de threads partagent le même PID. NPTL n'utilise pas de thread de gestion. NPTL utilise en interne les deux premiers signaux temps\(hyréel (voir aussi B<signal>(7))\ ; ces signaux ne peuvent pas être utilisés dans les applications.

note: type: Plain text
en: NPTL still has at least one nonconformance with POSIX.1:
fr: NPTL a encore au moins une non conformité à POSIX.1\ :

note: type: Plain text
en: Some NPTL nonconformances occur only with older kernels:
fr: Certaines non conformités n'apparaissent qu'avec des noyaux plus anciens\ :

note: type: Plain text
en: The information returned by B<times>(2)  and B<getrusage>(2)  is per-thread rather than process-wide (fixed in kernel 2.6.9).
fr: L'information renvoyée par B<times>(2) et B<getrusage>(2) est par thread au lieu d'être globale au processus (corrigé dans le noyau 2.6.9).

note: type: Plain text
en: Threads do not share resource limits (fixed in kernel 2.6.10).
fr: Les threads ne partagent pas les limites de ressources (corrigé dans le noyau 2.6.10).

note: type: Plain text
en: Threads do not share interval timers (fixed in kernel 2.6.12).
fr: Les threads ne partagent pas les temporisations d'intervalles (corrigé dans le noyau 2.6.12).

note: type: Plain text
en: Only the main thread is permitted to start a new session using B<setsid>(2)  (fixed in kernel 2.6.16).
fr: Seul le thread principal est autorisé à démarrer une nouvelle session avec B<setsid>(2) (corrigé dans le noyau 2.6.16).

note: type: Plain text
en: Only the main thread is permitted to make the process into a process group leader using B<setpgid>(2)  (fixed in kernel 2.6.16).
fr: Seul le thread principal est autorisé à rendre le processus leader de son groupe de processus avec B<setpgid>(2) (corrigé dans le noyau 2.6.16).

note: type: Plain text
en: Threads have distinct alternate signal stack settings.  However, a new thread's alternate signal stack settings are copied from the thread that created it, so that the threads initially share an alternate signal stack (fixed in kernel 2.6.16).
fr: Les threads ont des paramètres de pile spécifique de signaux distincts. Cependant, les paramètres de pile spécifique d'un nouveau thread sont copiés sur ceux du thread qui l'a créé, et les threads partagent donc initialement leur pile spécifique de signaux (corrigé dans le noyau 2.6.16).

note: type: Plain text
en: Note the following further points about the NPTL implementation:
fr: Veuillez noter les points suivants à propos de l'implémentation NPTL\ :

note: type: Plain text
en: If the stack size soft resource limit (see the description of B<RLIMIT_STACK> in B<setrlimit>(2))  is set to a value other than I<unlimited>, then this value defines the default stack size for new threads.  To be effective, this limit must be set before the program is executed, perhaps using the I<ulimit -s> shell built-in command (I<limit stacksize> in the C shell).
fr: Si la limite souple de taille de pile (voir dans B<setrlimit>(2) la description de B<RLIMIT_STACK>) est différente de I<unlimited>, cette valeur détermine la taille de pile par défaut pour les nouveaux threads. Pour avoir un effet, cette limite doit être définie avant le démarrage du programme, par exemple en utilisant la commande I<ulimit -s> du shell (I<limit stacksize> dans csh).

note: type: SS
en: Determining the threading implementation
fr: Déterminer l'implémentation des threads utilisée

note: type: Plain text
en: Since glibc 2.3.2, the B<getconf>(1)  command can be used to determine the system's threading implementation, for example:
fr: Depuis glibc 2.3.2, la commande B<getconf>(1) peut être utilisée pour déterminer l'implémentation de threads du système, par exemple\ :

note: type: Plain text
en: With older glibc versions, a command such as the following should be sufficient to determine the default threading implementation:
fr: Avec des versions plus anciennes de la glibc, une commande comme la suivante devrait être suffisante pour déterminer l'implémentation de threads par défaut\ :

note: type: SS
en: Selecting the threading implementation: LD_ASSUME_KERNEL
fr: Choisir l'implémentation des threads\ : LD_ASSUME_KERNEL

note: type: Plain text
en: On systems with a glibc that supports both LinuxThreads and NPTL (i.e., glibc 2.3.I<x>), the B<LD_ASSUME_KERNEL> environment variable can be used to override the dynamic linker's default choice of threading implementation.  This variable tells the dynamic linker to assume that it is running on top of a particular kernel version.  By specifying a kernel version that does not provide the support required by NPTL, we can force the use of LinuxThreads.  (The most likely reason for doing this is to run a (broken) application that depends on some nonconformant behavior in LinuxThreads.)  For example:
fr: Sur les systèmes avec une glibc fournissant à la fois LinuxThreads et NPTL (i.e. glibc\ 2.3.I<x>), la variable d'environnement B<LD_ASSUME_KERNEL> peut être utilisée pour écraser le choix par défaut d'implémentation de threads fait par l'éditeur de liens dynamique. Cette variable indique à l'éditeur de liens dynamique qu'il doit faire comme s'il était exécuté avec une version particulière du noyau. En indiquant une version du noyau ne fournissant pas les fonctionnalités nécessitées par NPTL, on peut forcer l'utilisation de LinuxThreads. (La raison la plus probable pour cela est d'exécuter une application (boguée) qui dépend d'un comportement de LinuxThreads non conforme à la spécification.) Par exemple\ :

note: type: Plain text
en: Various Pthreads manual pages, for example: B<pthread_attr_init>(3), B<pthread_atfork>(3), B<pthread_cancel>(3), B<pthread_cleanup_push>(3), B<pthread_cond_signal>(3), B<pthread_cond_wait>(3), B<pthread_create>(3), B<pthread_detach>(3), B<pthread_equal>(3), B<pthread_exit>(3), B<pthread_key_create>(3), B<pthread_kill>(3), B<pthread_mutex_lock>(3), B<pthread_mutex_unlock>(3), B<pthread_once>(3), B<pthread_setcancelstate>(3), B<pthread_setcanceltype>(3), B<pthread_setspecific>(3), B<pthread_sigmask>(3), B<pthread_sigqueue>(3), and B<pthread_testcancel>(3)
fr: Diverses pages de manuel Pthreads, par exemple\ : B<pthread_attr_init>(3), B<pthread_atfork>(3), B<pthread_cancel>(3), B<pthread_cleanup_push>(3), B<pthread_cond_signal>(3), B<pthread_cond_wait>(3), B<pthread_create>(3), B<pthread_detach>(3), B<pthread_equal>(3), B<pthread_exit>(3), B<pthread_key_create>(3), B<pthread_kill>(3), B<pthread_mutex_lock>(3), B<pthread_mutex_unlock>(3), B<pthread_once>(3), B<pthread_setcancelstate>(3), B<pthread_setcanceltype>(3), B<pthread_setspecific>(3), B<pthread_sigmask>(3), B<pthread_sigqueue>(3) et B<pthread_testcancel>(3)
