Provided by: manpages-fr-dev_4.23.1-1_all 
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 non nul.
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.
ATTRIBUTS
Pour une explication des termes utilisés dans cette section, consulter attributes(7).
┌────────────────────────────────────────────────────────┬──────────────────────┬─────────┐
│Interface │ Attribut │ Valeur │
├────────────────────────────────────────────────────────┼──────────────────────┼─────────┤
│pthread_getattr_np(). │ Sécurité des threads │ MT-Safe │
└────────────────────────────────────────────────────────┴──────────────────────┴─────────┘
STANDARDS
GNU ; c'est la raison du suffixe « _np » (non portable) dans son nom.
HISTORIQUE
glibc 2.2.3.
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
Attributs du thread créé :
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
Objet d'attributs de thread après initialisations :
Guard size = 4097 bytes
Stack address = (nil)
Stack size = 0x0 (0) bytes
Attributs du thread créé :
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
Objet d'attributs de thread après initialisations :
Guard size = 4096 bytes
Stack address = 0x804d000 (EOS = 0x8055000)
Stack size = 0x8000 (32768) bytes
Attributs du thread créé :
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("Attributs du thread créé :\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, "Utilisation : %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 != -1 || guard_size > 0) {
ret_attrp = attrp;
s = pthread_attr_init(attrp);
if (s != 0)
errc(EXIT_FAILURE, s, "pthread_attr_init");
}
if (stack_size != -1) {
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 !1= -1) {
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("Objet d'attributs de thread après initialisations :\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⟩.