Provided by: manpages-fr-dev_4.21.0-2_all bug

NOM

       pthread_getattr_np - Obtenir les attributs d'un thread créé

BIBLIOTHÈQUE

       Bibliothèque de threads POSIX (libpthread, -lpthread)

SYNOPSIS

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

       int pthread_getattr_np(pthread_t thread, pthread_attr_t *attr);

DESCRIPTION

       La fonction pthread_getattr_np() initialise l'objet d'attributs de thread auquel attr fait
       référence de telle sorte qu'il contienne les valeurs réelles d'attributs qui décrivent  le
       thread thread en cours d'exécution.

       Les   valeurs  d'attribut  renvoyées  peuvent  être  différentes  des  valeurs  d'attribut
       correspondantes  fournies  dans  l'objet  attr  utilisé  pour   créer   le   thread   avec
       pthread_create(3). En particulier, les attributs suivants peuvent changer :

       -  l'état  détaché ou non, puisqu'un thread fusionné peut s'être détaché lui-même après sa
          création ;

       -  la taille de la pile, que l'implémentation peut aligner sur une limite plus appropriée.

       -  la taille de garde, que l'implémentation peut arrondir  au  multiple  supérieur  de  la
          taille  de  page  ou ignorer (c'est-à-dire, considérer qu'elle vaut 0) si l'application
          alloue sa propre pile.

       De plus, si l'attribut contenant l'adresse de la pile  n'était  pas  défini  dans  l'objet
       d'attributs  de  thread  utilisé pour créer le thread, alors l'objet d'attributs de thread
       renvoyé contiendra l'adresse effective de la pile que l'implémentation a choisie  pour  le
       thread.

       Quand   l'objet   d'attributs  de  thread  renvoyé  par  pthread_getattr_np()  n'est  plus
       nécessaire, il devrait être détruit à l'aide de pthread_attr_destroy(3).

VALEUR RENVOYÉE

       En cas de réussite, cette fonction renvoie 0 ; en cas d'erreur,  elle  renvoie  un  numéro
       d'erreur différent de zéro.

ERREURS

       ENOMEM Mémoire insuffisante.

       De  plus, si thread se réfère au thread principal, alors pthread_getattr_np() peut échouer
       à cause d'erreurs de différents appels sous-jacents : fopen(3) si /proc/self/maps ne  peut
       être  ouvert,  et  getrlimit(2) si la limite de ressources RLIMIT_STACK n'est pas prise en
       charge.

VERSIONS

       Cette fonction est disponible depuis la glibc 2.2.3.

ATTRIBUTS

       Pour une explication des termes utilisés dans cette section, consulter attributes(7).

       ┌────────────────────────────────────────────────────────┬──────────────────────┬─────────┐
       │InterfaceAttributValeur  │
       ├────────────────────────────────────────────────────────┼──────────────────────┼─────────┤
       │pthread_getattr_np().                                   │ Sécurité des threads │ MT-Safe │
       └────────────────────────────────────────────────────────┴──────────────────────┴─────────┘

STANDARDS

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

EXEMPLES

       Le  programme ci-dessous démontre l'utilisation de pthread_getattr_np(). Le programme crée
       un thread  qui  utilise  ensuite  pthread_getattr_np()  pour  récupérer  et  afficher  les
       attributs  contenant  la taille de la garde, l'adresse de la pile et la taille de la pile.
       Des paramètres en ligne de commande peuvent être utilisés pour définir les  attributs  qui
       seront  utilisés pour créer le thread à des valeurs autres que les valeurs par défaut. Les
       sessions d'interpréteur de commande ci-dessous démontrent l'utilisation du programme.

       Lors de la première exécution, sur un système x86-32, un thread est créé en utilisant  les
       attributs par défaut :

           $ ulimit -s   # Pas de limite de pile ==> taille de pile par défaut : 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'exécution suivante, nous voyons que si la taille de la garde est fournie, elle
       est arrondie à la valeur supérieure du prochain multiple de  la  taille  de  page  système
       (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 dernière exécution, le programme alloue manuellement une pile pour le thread.
       Dans ce cas, l'attribut contenant la taille de la garde est ignoré.

           $ ./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 déclaration de pthread_getattr_np() */
       #include <err.h>
       #include <errno.h>
       #include <pthread.h>
       #include <stdio.h>
       #include <stdlib.h>
       #include <unistd.h>

       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)
               errc(EXIT_FAILURE, s, "pthread_attr_getguardsize");
           printf("%sGuard size          = %zu bytes\n", prefix, guard_size);

           s = pthread_attr_getstack(attr, &stack_addr, &stack_size);
           if (s != 0)
               errc(EXIT_FAILURE, 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          = %#zx (%zu) 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)
               errc(EXIT_FAILURE, s, "pthread_getattr_np");

           display_stack_related_attributes(&attr, prefix);

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

       static void *           /* Démarrage de la fonction pour le thread créé */
       thread_start(void *arg)
       {
           printf("Attributes of created thread:\n");
           display_thread_attributes(pthread_self(), "\t");

           exit(EXIT_SUCCESS);         /* Termine tous les 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 *   /* Obtenir les attributs de thread en ligne de commande */
       get_thread_attributes_from_cl(int argc, char *argv[],
                                     pthread_attr_t *attrp)
       {
           int s, opt, allocate_stack;
           size_t stack_size, guard_size;
           void *stack_addr;
           pthread_attr_t *ret_attrp = NULL;   /* définir à attrp si un objet d'attributs
                                                  de thread est initialisé */
           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)
                   errc(EXIT_FAILURE, s, "pthread_attr_init");
           }

           if (stack_size >= 0) {
               if (!allocate_stack) {
                   s = pthread_attr_setstacksize(attrp, stack_size);
                   if (s != 0)
                       errc(EXIT_FAILURE, s, "pthread_attr_setstacksize");
               } else {
                   s = posix_memalign(&stack_addr, sysconf(_SC_PAGESIZE),
                                      stack_size);
                   if (s != 0)
                       errc(EXIT_FAILURE, 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)
                       errc(EXIT_FAILURE, s, "pthread_attr_setstacksize");
               }
           }

           if (guard_size >= 0) {
               s = pthread_attr_setguardsize(attrp, guard_size);
               if (s != 0)
                   errc(EXIT_FAILURE, 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;    /* Définir à &attr si un objet d'attributs
                                               de thread est initialisé */

           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)
               errc(EXIT_FAILURE, s, "pthread_create");

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

           pause();    /* Termine quand un autre thread appelle 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)

TRADUCTION

       La traduction française de cette page de manuel a été créée par Christophe Blaess
       <https://www.blaess.fr/christophe/>, Stéphan Rafin <stephan.rafin@laposte.net>, Thierry
       Vignaud <tvignaud@mandriva.com>, François Micaux, Alain Portal <aportal@univ-montp2.fr>,
       Jean-Philippe Guérard <fevrier@tigreraye.org>, Jean-Luc Coulon (f5ibh) <jean-
       luc.coulon@wanadoo.fr>, Julien Cristau <jcristau@debian.org>, Thomas Huriaux
       <thomas.huriaux@gmail.com>, Nicolas François <nicolas.francois@centraliens.net>, Florentin
       Duneau <fduneau@gmail.com>, Simon Paillard <simon.paillard@resel.enst-bretagne.fr>, Denis
       Barbier <barbier@debian.org>, David Prévot <david@tilapin.org>, Frédéric Hantrais
       <fhantrais@gmail.com> et Jean-Pierre Giraud <jean-pierregiraud@neuf.fr>

       Cette traduction est une documentation libre ; veuillez vous reporter à la GNU General
       Public License version 3 ⟨https://www.gnu.org/licenses/gpl-3.0.html⟩ concernant les
       conditions de copie et de distribution. Il n'y a aucune RESPONSABILITÉ LÉGALE.

       Si vous découvrez un bogue dans la traduction de cette page de manuel, veuillez envoyer un
       message à ⟨debian-l10n-french@lists.debian.org⟩.