NOM¶
pthread_getattr_np - Obtenir les attributs d'un thread créé
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'édition des liens avec l'option -pthread.
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 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 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 à à 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.
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 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.44 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¶
Depuis 2010, cette traduction est maintenue à l'aide de l'outil po4a
<
http://po4a.alioth.debian.org/> par l'équipe de traduction
francophone au sein du projet perkamon
<
http://perkamon.alioth.debian.org/>.
Nicolas François et l'équipe francophone de traduction de
Debian (2006-2009).
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> ».