pthread_attr_init

PTHREAD_ATTR_INIT(3)      Manuel du programmeur Linux     PTHREAD_ATTR_INIT(3)



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 (Les
       valeurs par défauts de chaque attribut sont données plus bas).

       Chaque attribut attrname (voir plus bas la liste de tous les attributs)
       peut être individuellement modifié en utilisant la fonction
       pthread_attr_set(attrname) et récupéré à l'aide de la fonction
       pthread_attr_get(attrname).

       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 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(3) ne modifie pas les
       attributs du thread précédemment 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é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 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ée 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
       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
       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éfinit 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_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 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 le code
              d'erreur suivant 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 super-utilisateur.

              La fonction pthread_attr_setinheritsched() renvoie le code
              d'erreur suivant 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 DOT Leroy AT inria DOT fr>

VOIR AUSSI
       pthread_create(3), pthread_join(3), pthread_detach(3),
       pthread_setschedparam(3)

TRADUCTION
       Ce document est une traduction réalisée par Thierry Vignaud <tvignaud
       AT mandriva DOT com> en 2000 et révisée le 25 avril 2008.

       L'équipe de traduction a fait le maximum pour réaliser une adaptation
       française de qualité. La version anglaise la plus à jour de ce
       document est toujours consultable via la commande :
       « LANG=C man 3 pthread_attr_init ».  N'hésitez pas à  signaler Ã
       l'auteur ou au traducteur, selon le cas, toute erreur dans cette page
       de manuel.



LinuxThreads                     11 mars 1998             PTHREAD_ATTR_INIT(3)