Provided by:
manpages-fr-dev_3.27fr1.4-1_all 
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> >>.