pthread_getattr_np(3) Library Functions Manual pthread_getattr_np(3) NOM pthread_getattr_np - Obtenir les attributs d'un thread cree BIBLIOTHEQUE Bibliotheque de threads POSIX (libpthread, -lpthread) SYNOPSIS #define _GNU_SOURCE /* Consultez feature_test_macros(7) */ #include 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 reference de telle sorte qu'il contienne les valeurs reelles 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. - 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 choisie 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 RENVOYEE 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 au thread principal, alors pthread_getattr_np() peut echouer a cause d'erreurs 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. ATTRIBUTS Pour une explication des termes utilises dans cette section, consulter attributes(7). +---------------------------------+--------------------------+---------+ |Interface | Attribut | Valeur | +---------------------------------+--------------------------+---------+ |pthread_getattr_np(). | Securite 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 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 un systeme x86-32, un thread est cree en utilisant les attributs par defaut : $ ulimit -s # Pas de limite de pile ==> taille de pile par defaut : 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 a la valeur superieure du 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 ignore. $ ./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 /* To get pthread_getattr_np() declaration */ #include #include #include #include #include #include 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 * /* 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; size_t 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 != -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) { 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; /* 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) 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(); /* 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) TRADUCTION La traduction francaise de cette page de manuel a ete creee par Christophe Blaess , Stephan Rafin , Thierry Vignaud , Francois Micaux, Alain Portal , Jean-Philippe Guerard , Jean-Luc Coulon (f5ibh) , Julien Cristau , Thomas Huriaux , Nicolas Francois , Florentin Duneau , Simon Paillard , Denis Barbier , David Prevot , Frederic Hantrais et Jean- Pierre Giraud Cette traduction est une documentation libre ; veuillez vous reporter a la GNU General Public License version 3 concernant les conditions de copie et de distribution. Il n'y a aucune RESPONSABILITE LEGALE. Si vous decouvrez un bogue dans la traduction de cette page de manuel, veuillez envoyer un message a . Pages du manuel de Linux 6.06 31 octobre 2023 pthread_getattr_np(3)