NOM
pthread_getattr_np - Obtenir les attributs d’un thread créé
SYNOPSIS
#define _GNU_SOURCE
#include <pthread.h>
int pthread_getattr_np(pthread_t thread, pthread_attr_t *attr);
Compilez et effectuez l’édition des liens avec l’option -pthread.
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 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.
* et 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 choisit 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 succès, 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 à à un thread principal, alors
pthread_getattr_np() peut échouer à cause 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 dans la glibc depuis la version 2.2.3.
CONFORMITÉ
Cette fonction est une extension GNU non standard. C’est la raison du
suffixe « _np » (non portable) dans leur nom.
EXEMPLE
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 une système x86-32, un thread est
créé en utilisant les attributs par défaut :
$ ulimit -s # Pas de limite de pile
# ==> la taille de pile par défaut 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’exécution 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 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ée.
$ ./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 <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.23 du projet man-pages
Linux. Une description du projet et des instructions pour signaler des
anomalies peuvent être trouvées à l’adresse
http://www.kernel.org/doc/man-pages/.
TRADUCTION
Cette page de manuel a été traduite et est maintenue par Nicolas
François <nicolas.francois@centraliens.net> et l’équipe francophone de
traduction de Debian.
Veuillez signaler toute erreur de traduction en écrivant à
<debian-l10n-french@lists.debian.org> ou par un rapport de bogue sur le
paquet manpages-fr.
Vous pouvez toujours avoir accès à la version anglaise de ce document
en utilisant la commande « man -L C <section> <page_de_man> ».