Provided by: manpages-fr-extra_20080618_all bug

NOM

       pthread_attr_init,  pthread_attr_destroy,  pthread_attr_setdetachstate,
       pthread_attr_getdetachstate,                pthread_attr_setschedparam,
       pthread_attr_getschedparam,                pthread_attr_setschedpolicy,
       pthread_attr_getschedpolicy,              pthread_attr_setinheritsched,
       pthread_attr_getinheritsched,                    pthread_attr_setscope,
       pthread_attr_getscope - Attributs de création de thread

SYNOPSIS

       #include <pthread.h>

       int pthread_attr_init(pthread_attr_t *attr);

       int pthread_attr_destroy(pthread_attr_t *attr);

       int pthread_attr_setdetachstate(pthread_attr_t *attr, int detachstate);

       int   pthread_attr_getdetachstate(const   pthread_attr_t   *attr,   int
       *detachstate);

       int pthread_attr_setschedpolicy(pthread_attr_t *attr, int policy);

       int   pthread_attr_getschedpolicy(const   pthread_attr_t   *attr,   int
       *policy);

       int   pthread_attr_setschedparam(pthread_attr_t   *attr,  const  struct
       sched_param *param);

       int  pthread_attr_getschedparam(const  pthread_attr_t   *attr,   struct
       sched_param *param);

       int pthread_attr_setinheritsched(pthread_attr_t *attr, int inherit);

       int   pthread_attr_getinheritsched(const   pthread_attr_t   *attr,  int
       *inherit);

       int pthread_attr_setscope(pthread_attr_t *attr, int scope);

       int pthread_attr_getscope(const pthread_attr_t *attr, int *scope);

DESCRIPTION

       Pour modifier les attributs des threads, il faut remplir  la  structure
       des  attributs de threads attr, qui est du type pthread_attr_t, puis la
       passer en tant que second argument à pthread_create(3).  Si  l’argument
       est  égal à NULL, cela revient à choisir les paramètres par défaut pour
       tous les attributs.

       pthread_attr_init() initialise la structure d’attributs de thread  attr
       et  la remplit avec les valeurs par défaut pour tous les attributs (les
       valeurs par défaut de chaque attribut sont données plus bas).

       Chaque attribut attrname (la liste de tous les attributs se trouve plus
       bas)  peut  être  individuellement  modifié  en  utilisant  la fonction
       pthread_attr_setattrname  et  récupéré  à   l’aide   de   la   fonction
       pthread_attr_getattrname.

       pthread_attr_destroy()  détruit  une structure d’attribut de thread qui
       ne  doit  plus  jamais  être  réutilisée  jusqu’à   ce   qu’elle   soit
       réinitialisée.     pthread_attr_destroy()    ne    fait    rien    dans
       l’implémentation LinuxThreads.

       Les structures d’attributs ne sont consultées que lors de  la  création
       d’un nouveau thread. La même structure d’attributs peut être réutilisée
       pour créer plusieurs threads. Modifier une structure d’attributs  après
       un  appel  à  pthread_create()  ne  modifie pas les attributs du thread
       précédemment créé.

       Les attributs de thread disponibles sont les suivants :

   detachstate
       Indique  si  le  thread  est  créé  dans   l’état   joignable   (valeur
       PTHREAD_CREATE_JOINABLE)       ou       dans       l’état       détaché
       (PTHREAD_CREATE_DETACHED).

       Valeur par défaut : PTHREAD_CREATE_JOINABLE.

       Dans l’état joignable, un autre thread peut se synchroniser sur la  fin
       du   thread   et   récupérer  son  code  de  terminaison  en  utilisant
       pthread_join(3), mais certaines ressources du thread resteront allouées
       après sa fin et ne seront libérées que lorsqu’un autre thread appellera
       pthread_join(3) sur ce thread.

       Dans l’état  détaché,  les  ressources  du  thread  sont  immédiatement
       libérées quand il se termine, mais pthread_join(3) ne peut être utilisé
       pour se synchroniser sur la fin du thread.

       Un thread créé dans l’état  joignable  peut  ensuite  être  placé  dans
       l’état détaché avec pthread_detach(3).

   schedpolicy
       Change  la  politique  d’ordonnancement  du  thread  pour  l’une  parmi
       SCHED_OTHER (processus normal, non temps réel), SCHED_RR  (temps  réel,
       « round-robin »)   ou  SCHED_FIFO  (temps  réel,  « fifo »).  Consultez
       sched_setpolicy(2)  pour  plus  d’informations   sur   les   politiques
       d’ordonnancement.

       Valeur par défaut : SCHED_OTHER.

       Les  politiques  d’ordonnancement  temps réel SCHED_RR et SCHED_FIFO ne
       sont disponibles que pour les processus  possédant  les  privilèges  du
       superutilisateur.

       La  politique  d’ordonnancement d’un thread peut être modifiée après sa
       création avec pthread_setschedparam(3).

   schedparam
       Contient les paramètres d’ordonnancement (essentiellement, la  priorité
       d’ordonnancement)   du   thread.   Voyez  sched_setparam(2)  pour  plus
       d’informations sur les paramètres d’ordonnancement.

       Valeur par défaut : priorité à 0.

       Cet attribut est sans signification si  la  politique  d’ordonnancement
       est  SCHED_OTHER ;  il  n’a  d’importance  que pour les ordonnancements
       temps réel SCHED_RR et SCHED_FIFO.

       La priorité d’ordonnancement d’un thread peut être  modifiée  après  sa
       création avec pthread_setschedparam(3).

   inheritsched
       Indique  si  la politique et les paramètres d’ordonnancement du nouveau
       thread sont déterminés par les valeurs  des  attributs  schedpolicy  et
       schedparam  (valeur  PTHREAD_EXPLICIT_SCHED)  ou sont hérités du thread
       parent (valeur PTHREAD_INHERIT_SCHED).

       Valeur par défaut : PTHREAD_EXPLICIT_SCHED.

   scope
       Définit comment sont interprétés  les  paramètres  d’ordonnancement  du
       nouveau  thread.  Une  seule valeur est supportée dans l’implémentation
       LinuxThreads : PTHREAD_SCOPE_SYSTEM, qui signifie que tous les  threads
       sont  en  compétition avec tous les processus en cours d’exécution pour
       le temps processeur. En particulier, les  priorités  des  threads  sont
       interprétées relativement aux priorités de tous les autres processus de
       la   machine.   L’autre   valeur    spécifiée    par    le    standard,
       PTHREAD_SCOPE_PROCESS,  signifie que les threads ne sont en compétition
       qu’avec les autres  threads  du  même  processus :  les  priorités  des
       threads  sont  interprétées relativement à celles des autres threads du
       processus,  quelle  que  soit  la  priorité   des   autres   processus.
       PTHREAD_SCOPE_PROCESS n’est pas supportée dans LinuxThreads.

       Valeur par défaut : PTHREAD_SCOPE_SYSTEM.

VALEUR RENVOYÉE

       Toutes  ces  fonctions renvoient 0 en cas de succès et un code d’erreur
       non  nul  en  cas  d’erreur.  En   cas   de   succès,   les   fonctions
       pthread_attr_get(attrname) sauvegardent également la valeur courante de
       l’attribut attrname à l’emplacement pointé par leur second argument.

ERREURS

       La fonction  pthread_attr_setdetachstate()  renvoie  le  code  d’erreur
       suivant lors d’une erreur :

              EINVAL Le    paramètre    detachstate    spécifié    n’est    ni
                     PTHREAD_CREATE_JOINABLE ni PTHREAD_CREATE_DETACHED.

       La  fonction  pthread_attr_setschedparam()  renvoie  le  code  d’erreur
       suivant lors d’une erreur :

              EINVAL La   priorité   indiquée   par   param   n’est  pas  dans
                     l’intervalle autorisé par la  politique  d’ordonnancement
                     actuellement  dans  attr  (1  à  99  pour  SCHED_FIFO  et
                     SCHED_RR ; 0 pour SCHED_OTHER).

       La  fonction  pthread_attr_setschedpolicy()  renvoie  l’un  des   codes
       d’erreur lors d’une erreur :

              EINVAL Le  paramètre  policy  spécifié  n’est ni SCHED_OTHER, ni
                     SCHED_FIFO, ni SCHED_RR.

              ENOTSUP
                     policy  est  SCHED_FIFO  ou  SCHED_RR,  et  l’utilisateur
                     effectif    du    processus   appelant   n’est   pas   le
                     superutilisateur.

       La fonction pthread_attr_setinheritsched()  renvoie  le  code  d’erreur
       lors d’une erreur :

              EINVAL Le     paramètre     inherit     spécifié     n’est    ni
                     PTHREAD_INHERIT_SCHED ni PTHREAD_EXPLICIT_SCHED.

       En cas d’erreur, la fonction pthread_attr_setscope() renvoie  l’un  des
       codes d’erreur :

              EINVAL Le paramètre scope spécifié n’est ni PTHREAD_SCOPE_SYSTEM
                     ni PTHREAD_SCOPE_PROCESS.

              ENOTSUP
                     Le paramètre  scope  spécifié  est  PTHREAD_SCOPE_PROCESS
                     (non géré).

AUTEUR

       Xavier Leroy <Xavier.Leroy@inria.fr>

VOIR AUSSI

       pthread_create(3),          pthread_join(3),         pthread_detach(3),
       pthread_setschedparam(3).

TRADUCTION

       Cette page de manuel a été traduite par Thierry  Vignaud  <tvignaud  AT
       mandriva  DOT  com>  en  2000  et  révisée par Alain Portal <aportal AT
       univ-montp2 DOT fr> en 2006.   La  version  présente  dans  Debian  est
       maintenue  par les membres de la liste <debian-l10n-french AT lists DOT
       debian DOT org>.  Veuillez signaler toute erreur de traduction  par  un
       rapport de bogue sur le paquet manpages-fr-extra.

                                 LinuxThreads             PTHREAD_ATTR_INIT(3)