Provided by: manpages-fr_1.67.0-1_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).   Un  paramètre
       égal  à  NULL 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 (voir
       plus bas).

       Chaque attribut attrname (voir 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 un objet attribut_de_thread, qui  ne  doit
       plus   jamais  être  réutilisé  jusqu’à  ce  qu’il  soit  réinitialisé.
       pthread_attr_destroy ne fait rien dans l’implémentation LinuxThreads.

       Les structureis 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écedemment créé.

       Les attributs de thread supportés 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ésupé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 appelera
       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 mis dans  l’état
       détaché en utilisant pthread_detach(3).

   schedpolicy
       change  la  politique et les paramètres d’ordonnancement pour le 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).
       Voir sched_setpolicy(2) pour plus d’informations sur ces politiques.

       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
       super-utilisateur.

       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) pour le  thread.  Voir  sched_setparam(2)  pour  plus
       d’informations sur les paramètres d’ordonnancement.

       Valeur par défaut: priorité à 0.

       Cet  attribut  est  sans significtion 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  pour  le
       nouveau   thread   sont   déterminés  par  les  valeurs  des  attributs
       schedpolicy  et  schedparam  (valeur  PTHREAD_EXPLICIT_SCHED)  ou  sont
       héritées du thread parent (valeur PTHREAD_INHERIT_SCHED).

       Valeur par défaut : PTHREAD_EXPLICIT_SCHED.

   scope
       Défini comment sont interprétés les paramètres d’ordonnancement pour le
       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 de threads sont
       interprétées relativement aux priorités de tous  les  autres  processus
       sur   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 de threads
       sont  interprétées  relativement  à  celles  des  autres   threads   du
       processus,   quel   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_getattrname sauvegardent également la valeur  courante  de
       l’attribut attrname à l’emplacement pointé par leur second argument.

ERREURS

       La fonction pthread_attr_setdetachstate renvoie l’un des codes d’erreur
       suivants en cas de problème :

              EINVAL l’argument     detachstate     spécifié     n’est      ni
                     PTHREAD_CREATE_JOINABLE ni PTHREAD_CREATE_DETACHED.

       La  fonction pthread_attr_setschedparam renvoie l’un des codes d’erreur
       suivants en cas de problème :

              EINVAL la  priorité  indiquée   par   param   n’est   pas   dans
                     l’intervalle  autorisé pour 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
       suivants en cas de problème :

              EINVAL l’argument  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   supe-
                     utilisateur.

       La   fonction   pthread_attr_setinheritsched  renvoie  l’un  des  codes
       d’erreur suivants en cas de problème :

              EINVAL l’argument      inherit      spécifié      n’est       ni
                     PTHREAD_INHERIT_SCHED ni PTHREAD_EXPLICIT_SCHED.

       La  fonction  pthread_attr_setscope  renvoie  l’un  des  codes d’erreur
       suivants en cas de problème :

              EINVAL l’argument scope spécifié n’est  ni  PTHREAD_SCOPE_SYSTEM
                     ni PTHREAD_SCOPE_PROCESS.

              ENOTSUP
                     l’argument  scope spécifié est PTHREAD_SCOPE_PROCESS (non
                     supporté).

AUTEUR

       Xavier Leroy <Xavier.Leroy@inria.fr>

VOIR AUSSI

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

TRADUCTION

       Thierry Vignaud <tvignaud@mandrakesoft.com>, 2000
       Christophe Blaess, 2003.