perkamon - en to fr translation catalogue (88 entries)

note: type: TH
en: 2019-10-10
fr: 10 octobre 2019

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: 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>(7))
fr: politique et priorité d'ordonnancement temps-réel (B<sched>(7))

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: SS
en: Thread IDs
fr: Identifiants de thread

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: #-#-#-#-#  archlinux: pthreads.7.pot (PACKAGE VERSION)  #-#-#-#-# type: Plain text #-#-#-#-#  debian-buster: pthreads.7.pot (PACKAGE VERSION)  #-#-#-#-# So, scanning "cancellation point" comments in the glibc 2.8 header files, it looks as though at least the following nonstandard functions are cance
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 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: 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: SH
en: SEE ALSO
fr: VOIR AUSSI

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

note: type: TH
en: 2019-03-06
fr: 6 mars 2019

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

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