Provided by: manpages-fr-dev_3.27fr1.4-1_all bug

NOM

       pthread_getattr_np - Obtenir les attributs d'un thread cree

SYNOPSIS

       #define _GNU_SOURCE             /* Consultez feature_test_macros(7) */
       #include <pthread.h>

       int pthread_getattr_np(pthread_t thread, pthread_attr_t *attr);

       Compilez et effectuez l'edition des liens avec l'option -pthread.

DESCRIPTION

       La  fonction  pthread_getattr_np()  initialise  l'objet  d'attributs de
       thread auquel attr fait reference de telle sorte  qu'il  contienne  les
       valeurs   d'attributs   qui   decrivent   le  thread  thread  en  cours
       d'execution.

       Les valeurs d'attribut renvoyees peuvent etre differentes  des  valeurs
       d'attribut  correspondantes  fournies  dans  l'objet  attr utilise pour
       creer le thread avec pthread_create(3). En particulier,  les  attributs
       suivants peuvent changer :

       * l'etat  detache ou non, puisqu'un thread fusionne peut s'etre detache
         lui meme apres sa creation ;

       * la taille de la pile,  que  l'implementation  peut  aligner  sur  une
         limite plus appropriee.

       * et la taille de garde, que l'implementation peut arrondir au multiple
         superieur de la taille de page ou ignorer  (c'est-a-dire,  considerer
         qu'elle vaut 0) si l'application alloue sa propre pile.

       De  plus,  si  l'attribut  contenant  l'adresse  de la pile n'etait pas
       defini dans l'objet d'attributs de thread utilise pour creer le thread,
       alors  l'objet  d'attributs  de  thread  renvoye  contiendra  l'adresse
       effective de la pile que l'implementation a choisit pour le thread.

       Quand l'objet d'attributs de thread  renvoye  par  pthread_getattr_np()
       n'est   plus   necessaire,   il   devrait  etre  detruit  a  l'aide  de
       pthread_attr_destroy(3).

VALEUR RENVOY'EE

       En cas de reussite, cette fonction renvoie 0 ; en  cas  d'erreur,  elle
       renvoie un numero d'erreur non nul.

ERREURS

       ENOMEM Memoire insuffisante.

       De   plus,  si  thread  se  refere  a  a  un  thread  principal,  alors
       pthread_getattr_np()  peut  echouer  a  cause  de   differents   appels
       sous-jacents :  fopen(3),  si  /proc/self/maps  ne peut etre ouvert, et
       getrlimit(2), si la limite de ressources RLIMIT_STACK n'est  pas  prise
       en charge.

VERSIONS

       Cette fonction est disponible dans la glibc depuis la version 2.2.3.

CONFORMIT'E

       Cette  fonction est une extension GNU non standard ; c'est la raison du
       suffixe << _np >> (non portable) dans son nom.

EXEMPLE

       Le programme ci-dessous demontre l'utilisation de pthread_getattr_np().
       Le  programme  cree  un thread qui utilise ensuite pthread_getattr_np()
       pour recuperer et afficher les attributs  contenant  la  taille  de  la
       garde,  l'adresse de la pile et la taille de la pile. Des parametres en
       ligne de commande peuvent etre utilises pour definir les attributs  qui
       seront  utilises  pour  creer  le  thread  a des valeurs autres que les
       valeurs par defaut. Les sessions d'interpreteur de commande  ci-dessous
       demontrent l'utilisation du programme.

       Lors  de  la  premiere execution, sur une systeme x86-32, un thread est
       cree en utilisant les attributs par defaut :

           $ ulimit -s # Pas de limite de pile
                       # ==> la taille de pile par defaut est de 2 Mo
           unlimited
           $ ./a.out
           Attributes of created thread:
                   Guard size          = 4096 bytes
                   Stack address       = 0x40196000 (EOS = 0x40397000)
                   Stack size          = 0x201000 (2101248) bytes

       Lors de l'execution 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 systeme (4096 octets sous x86-32) :

           $ ./a.out -g 4097
           Thread attributes object after initializations:
                   Guard size          = 4097 bytes
                   Stack address       = (nil)
                   Stack size          = 0x0 (0) bytes

           Attributes of created thread:
                   Guard size          = 8192 bytes
                   Stack address       = 0x40196000 (EOS = 0x40397000)
                   Stack size          = 0x201000 (2101248) bytes

       Lors de la derniere execution, le  programme  alloue  manuellement  une
       pile  pour le thread. Dans ce cas, l'attribut contenant la taille de la
       garde est ignoree.

           $ ./a.out -g 4096 -s 0x8000 -a
           Allocated thread stack at 0x804d000

           Thread attributes object after initializations:
                   Guard size          = 4096 bytes
                   Stack address       = 0x804d000 (EOS = 0x8055000)
                   Stack size          = 0x8000 (32768) bytes

           Attributes of created thread:
                   Guard size          = 0 bytes
                   Stack address       = 0x804d000 (EOS = 0x8055000)
                   Stack size          = 0x8000 (32768) bytes

   Source du programme

       #define _GNU_SOURCE     /* Pour la declaration de pthread_getattr_np() */
       #include <pthread.h>
       #include <stdio.h>
       #include <stdlib.h>
       #include <unistd.h>
       #include <errno.h>

       #define handle_error_en(en, msg) \
               do { errno = en; perror(msg); exit(EXIT_FAILURE); } while (0)

       static void
       display_stack_related_attributes(pthread_attr_t *attr, char *prefix)
       {
           int s;
           size_t stack_size, guard_size;
           void *stack_addr;

           s = pthread_attr_getguardsize(attr, &guard_size);
           if (s != 0)
               handle_error_en(s, "pthread_attr_getguardsize");
           printf("%sGuard size          = %d bytes\n", prefix, guard_size);

           s = pthread_attr_getstack(attr, &stack_addr, &stack_size);
           if (s != 0)
               handle_error_en(s, "pthread_attr_getstack");
           printf("%sStack address       = %p", prefix, stack_addr);
           if (stack_size > 0)
               printf(" (EOS = %p)", (char *) stack_addr + stack_size);
           printf("\n");
           printf("%sStack size          = 0x%x (%d) bytes\n",
                   prefix, stack_size, stack_size);
       }

       static void
       display_thread_attributes(pthread_t thread, char *prefix)
       {
           int s;
           pthread_attr_t attr;

           s = pthread_getattr_np(thread, &attr);
           if (s != 0)
               handle_error_en(s, "pthread_getattr_np");

           display_stack_related_attributes(&attr, prefix);

           s = pthread_attr_destroy(&attr);
           if (s != 0)
               handle_error_en(s, "pthread_attr_destroy");
       }

       static void *           /* Start function for thread we create */
       thread_start(void *arg)
       {
           printf("Attributes of created thread:\n");
           display_thread_attributes(pthread_self(), "\t");

           exit(EXIT_SUCCESS);         /* Terminate all threads */
       }

       static void
       usage(char *pname, char *msg)
       {
           if (msg != NULL)
               fputs(msg, stderr);
           fprintf(stderr, "Usage: %s [-s stack-size [-a]]"
                   " [-g guard-size]\n", pname);
           fprintf(stderr, "\t\t-a means program should allocate stack\n");
           exit(EXIT_FAILURE);
       }

       static pthread_attr_t *   /* Get thread attributes from command line */
       get_thread_attributes_from_cl(int argc, char *argv[],
                                     pthread_attr_t *attrp)
       {
           int s, opt, allocate_stack;
           long stack_size, guard_size;
                   void *stack_addr;
           pthread_attr_t *ret_attrp = NULL;   /* Set to attrp if we initialize
                                                  a thread attributes object */
           allocate_stack = 0;
           stack_size = -1;
           guard_size = -1;

           while ((opt = getopt(argc, argv, "ag:s:")) != -1) {
               switch (opt) {
               case 'a':   allocate_stack = 1;                     break;
               case 'g':   guard_size = strtoul(optarg, NULL, 0);  break;
               case 's':   stack_size = strtoul(optarg, NULL, 0);  break;
               default:    usage(argv[0], NULL);
               }
           }

           if (allocate_stack && stack_size == -1)
               usage(argv[0], "Specifying -a without -s makes no sense\n");

           if (argc > optind)
               usage(argv[0], "Extraneous command-line arguments\n");

           if (stack_size >= 0 || guard_size > 0) {
               ret_attrp = attrp;

               s = pthread_attr_init(attrp);
               if (s != 0)
                   handle_error_en(s, "pthread_attr_init");
           }

           if (stack_size >= 0) {
               if (!allocate_stack) {
                   s = pthread_attr_setstacksize(attrp, stack_size);
                   if (s != 0)
                       handle_error_en(s, "pthread_attr_setstacksize");
               } else {
                   s = posix_memalign(&stack_addr, sysconf(_SC_PAGESIZE),
                                      stack_size);
                   if (s != 0)
                       handle_error_en(s, "posix_memalign");
                   printf("Allocated thread stack at %p\n\n", stack_addr);

                   s = pthread_attr_setstack(attrp, stack_addr, stack_size);
                   if (s != 0)
                       handle_error_en(s, "pthread_attr_setstacksize");
               }
           }

           if (guard_size >= 0) {
               s = pthread_attr_setguardsize(attrp, guard_size);
               if (s != 0)
                   handle_error_en(s, "pthread_attr_setstacksize");
           }

           return ret_attrp;
       }

       int
       main(int argc, char *argv[])
       {
           int s;
           pthread_t thr;
           pthread_attr_t attr;
           pthread_attr_t *attrp = NULL;    /* Set to &attr if we initialize
                                               a thread attributes object */

           attrp = get_thread_attributes_from_cl(argc, argv, &attr);

           if (attrp != NULL) {
               printf("Thread attributes object after initializations:\n");
               display_stack_related_attributes(attrp, "\t");
               printf("\n");
           }

           s = pthread_create(&thr, attrp, &thread_start, NULL);
           if (s != 0)
               handle_error_en(s, "pthread_create");

           if (attrp != NULL) {
               s = pthread_attr_destroy(attrp);
               if (s != 0)
                   handle_error_en(s, "pthread_attr_destroy");
           }

           pause();    /* Terminates when other thread calls exit() */
       }

VOIR AUSSI

       pthread_attr_getaffinity_np(3),         pthread_attr_getdetachstate(3),
       pthread_attr_getguardsize(3),          pthread_attr_getinheritsched(3),
       pthread_attr_getschedparam(3),          pthread_attr_getschedpolicy(3),
       pthread_attr_getscope(3),                     pthread_attr_getstack(3),
       pthread_attr_getstackaddr(3),             pthread_attr_getstacksize(3),
       pthread_attr_init(3), pthread_create(3), pthreads(7)

COLOPHON

       Cette  page  fait  partie  de  la  publication 3.27 du projet man-pages
       Linux. Une description du projet et des instructions pour signaler  des
       anomalies       peuvent       etre       trouvees      a      l'adresse
       <URL:http://www.kernel.org/doc/man-pages/>.

TRADUCTION

       Depuis 2010, cette traduction est maintenue a l'aide  de  l'outil  po4a
       <URL:http://po4a.alioth.debian.org/>   par   l'equipe   de   traduction
       francophone       au       sein        du        projet        perkamon
       <URL:http://perkamon.alioth.debian.org/>.

       Nicolas   Francois   et   l'equipe   francophone   de   traduction   de
       Debian (2006-2009).

       Veuillez  signaler  toute  erreur   de   traduction   en   ecrivant   a
       <debian-l10n-french@lists.debian.org> ou par un rapport de bogue sur le
       paquet manpages-fr.

       Vous pouvez toujours avoir acces a la version anglaise de  ce  document
       en utilisant la commande << man -L C <section> <page_de_man> >>.