pthread_setschedparam(3) Library Functions Manual pthread_setschedparam(3) NOM pthread_setschedparam, pthread_getschedparam -- Definir ou obtenir la politique et les parametres d'ordonnancement d'un thread BIBLIOTHEQUE Bibliotheque de threads POSIX (libpthread, -lpthread) SYNOPSIS #include int pthread_setschedparam(pthread_t thread, int politique, const struct sched_param *param); int pthread_getschedparam(pthread_t thread, int *restrict politique, struct sched_param *restrict param); DESCRIPTION La fonction pthread_setschedparam() definit la politique et les parametres d'ordonnancement du thread thread. L'argument politique specifie la politique d'ordonnancement pour thread. Les valeurs possibles, ainsi que leur signification, sont decrites dans sched(7). La structure vers laquelle pointe param specifie les nouveaux parametres d'ordonnancement pour thread. Les parametres d'ordonnancement sont geres dans la structure suivante : struct sched_param { int sched_priority; /* Priorite d'ordonnancement */ }; Comme on peut le voir, un seul parametre d'ordonnancement est pris en charge. Veuillez consulter sched(7) pour plus de details sur les valeurs possibles des priorites d'ordonnancement en fonction de chaque politique d'ordonnancement. La fonction pthread_getschedparam() renvoie, dans les tampons pointes par politique et param, respectivement la politique et les parametres d'ordonnancement du thread thread. La valeur de priorite renvoyee est celle utilisee lors de l'appel le plus recent a pthread_setschedparam(), pthread_setschedprio(3) ou pthread_create(3) qui touchait thread. La priorite renvoyee ne reflete pas des ajustements de priorite temporaires qui peuvent resulter d'appels a une fonction qui modifie l'heritage ou plafonne la priorite d'ordonnancement (voir, par exemple, pthread_mutexattr_setprioceiling(3) et pthread_mutexattr_setprotocol(3)). VALEUR RENVOYEE En cas de reussite, ces fonctions renvoient 0 ; en cas d'erreur, elles renvoient un numero d'erreur non nul. Si pthread_setschedparam() echoue, la politique et les parametres d'ordonnancement du thread ne sont pas modifies. ERREURS Ces deux fonctions peuvent echouer avec l'erreur suivante : ESRCH Aucun fil d'execution avec pour identifiant thread n'a pu etre trouve. pthread_setschedparam() peut egalement echouer avec les erreurs suivantes : EINVAL politique n'est pas une politique reconnue, ou param n'a pas de sens pour cette valeur de politique. EPERM L'appelant n'a pas les privileges suffisants pour definir la politique et les parametres d'ordonnancement indiques. POSIX.1 documente egalement une erreur ENOTSUP (tentative de definition de la politique ou de parametres d'ordonnancement a une valeur non prise en charge) pour pthread_setschedparam(). ATTRIBUTS Pour une explication des termes utilises dans cette section, consulter attributes(7). +---------------------------------+--------------------------+---------+ |Interface | Attribut | Valeur | +---------------------------------+--------------------------+---------+ |pthread_setschedparam(), | Securite des threads | MT-Safe | |pthread_getschedparam() | | | +---------------------------------+--------------------------+---------+ STANDARDS POSIX.1-2008. HISTORIQUE glibc 2.0 POSIX.1-2001. NOTES Pour une description des permissions necessaires pour modifier la politique et la priorite d'ordonnancement d'un thread (et leur effet), et les details sur les valeurs possibles de priorites pour chacune des politiques d'ordonnancement, consultez sched(7). EXEMPLES Le programme ci-dessous montre l'utilisation de pthread_setschedparam() et pthread_getschedparam(), ainsi que d'un certain nombre d'autres fonctions de pthreads relatives a l'ordonnancement. Lors de l'execution suivante, le thread principal definit sa politique d'ordonnancement a SCHED_FIFO avec une priorite de 10 et initialise un objet d'attributs de thread avec un attribut de politique d'ordonnancement mis a SCHED_RR et un attribut de priorite d'ordonnancement de 20. Le programme appelle alors pthread_attr_setinheritsched(3) pour definir a PTHREAD_EXPLICIT_SCHED l'attribut d'heritage de l'ordonnancement de l'objets d'attributs de thread, ce qui signifie que les threads crees avec cet objet d'attributs prendront les attributs d'ordonnancement dans l'objet d'attributs de thread. Le programme cree alors un thread en utilisant l'objets d'attributs de thread et ce thread affiche sa politique et sa priorite d'ordonnancement. $ su # Need privilege to set real-time scheduling policies Password: # ./a.out -mf10 -ar20 -i e Scheduler settings of main thread policy=SCHED_FIFO, priority=10 Scheduler settings in 'attr' policy=SCHED_RR, priority=20 inheritsched is EXPLICIT Scheduler attributes of new thread policy=SCHED_RR, priority=20 Nous pouvons voir dans l'affichage ci-dessus que les politique et priorite d'ordonnancement ont pris comme valeurs celles de l'objets d'attributs de thread. L'execution suivante est identique, sauf que l'attribut d'heritage d'ordonnancement est mis a PTHREAD_INHERIT_SCHED, ce qui signifie que les threads crees avec cet objet d'attributs devront ignorer les attributs d'ordonnancement de l'objets d'attributs de thread et prendre a la place les valeurs heritees du thread appelant. # ./a.out -mf10 -ar20 -i i Scheduler settings of main thread policy=SCHED_FIFO, priority=10 Scheduler settings in 'attr' policy=SCHED_RR, priority=20 inheritsched is INHERIT Scheduler attributes of new thread policy=SCHED_FIFO, priority=10 Nous pouvons voir dans l'affichage ci-dessus que les politique et priorite d'ordonnancement ont pris comme valeurs celles du thread appelant et non de l'objets d'attributs de thread. Veuillez noter que si l'option -i i n'avait pas ete presente, l'affichage aurait ete identique, car PTHREAD_INHERIT_SCHED est la valeur par defaut pour l'attribut d'heritage d'ordonnancement. Source du programme /* pthreads_sched_test.c */ #include #include #include #include #include #define handle_error_en(en, msg) \ do { errno = en; perror(msg); exit(EXIT_FAILURE); } while (0) [[noreturn]] static void usage(char *prog_name, char *msg) { if (msg != NULL) fputs(msg, stderr); fprintf(stderr, "Usage: %s [options]\n", prog_name); fprintf(stderr, "Options are:\n"); #define fpe(msg) fprintf(stderr, "\t%s", msg) /* Shorter */ fpe("-a Set scheduling policy and priority in\n"); fpe(" thread attributes object\n"); fpe(" can be\n"); fpe(" f SCHED_FIFO\n"); fpe(" r SCHED_RR\n"); fpe(" o SCHED_OTHER\n"); fpe("-A Use default thread attributes object\n"); fpe("-i {e|i} Set inherit scheduler attribute to\n"); fpe(" 'explicit' or 'inherit'\n"); fpe("-m Set scheduling policy and priority on\n"); fpe(" main thread before pthread_create() call\n"); exit(EXIT_FAILURE); } static int get_policy(char p, int *policy) { switch (p) { case 'f': *policy = SCHED_FIFO; return 1; case 'r': *policy = SCHED_RR; return 1; case 'o': *policy = SCHED_OTHER; return 1; default: return 0; } } static void display_sched_attr(int policy, const struct sched_param *param) { printf(" policy=%s, priority=%d\n", (policy == SCHED_FIFO) ? "SCHED_FIFO" : (policy == SCHED_RR) ? "SCHED_RR" : (policy == SCHED_OTHER) ? "SCHED_OTHER" : "???", param->sched_priority); } static void display_thread_sched_attr(char *msg) { int policy, s; struct sched_param param; s = pthread_getschedparam(pthread_self(), &policy, ¶m); if (s != 0) handle_error_en(s, "pthread_getschedparam"); printf("%s\n", msg); display_sched_attr(policy, ¶m); } static void * thread_start(void *arg) { display_thread_sched_attr("Scheduler attributes of new thread"); return NULL; } int main(int argc, char *argv[]) { int s, opt, inheritsched, use_null_attrib, policy; pthread_t thread; pthread_attr_t attr; pthread_attr_t *attrp; char *attr_sched_str, *main_sched_str, *inheritsched_str; struct sched_param param; /* Process command-line options. */ use_null_attrib = 0; attr_sched_str = NULL; main_sched_str = NULL; inheritsched_str = NULL; while ((opt = getopt(argc, argv, "a:Ai:m:")) != -1) { switch (opt) { case 'a': attr_sched_str = optarg; break; case 'A': use_null_attrib = 1; break; case 'i': inheritsched_str = optarg; break; case 'm': main_sched_str = optarg; break; default: usage(argv[0], "Unrecognized option\n"); } } if (use_null_attrib && (inheritsched_str != NULL || attr_sched_str != NULL)) { usage(argv[0], "Can't specify -A with -i or -a\n"); } /* Optionally set scheduling attributes of main thread, and display the attributes. */ if (main_sched_str != NULL) { if (!get_policy(main_sched_str[0], &policy)) usage(argv[0], "Bad policy for main thread (-m)\n"); param.sched_priority = strtol(&main_sched_str[1], NULL, 0); s = pthread_setschedparam(pthread_self(), policy, ¶m); if (s != 0) handle_error_en(s, "pthread_setschedparam"); } display_thread_sched_attr("Scheduler settings of main thread"); printf("\n"); /* Initialize thread attributes object according to options. */ attrp = NULL; if (!use_null_attrib) { s = pthread_attr_init(&attr); if (s != 0) handle_error_en(s, "pthread_attr_init"); attrp = &attr; } if (inheritsched_str != NULL) { if (inheritsched_str[0] == 'e') inheritsched = PTHREAD_EXPLICIT_SCHED; else if (inheritsched_str[0] == 'i') inheritsched = PTHREAD_INHERIT_SCHED; else usage(argv[0], "Value for -i must be 'e' or 'i'\n"); s = pthread_attr_setinheritsched(&attr, inheritsched); if (s != 0) handle_error_en(s, "pthread_attr_setinheritsched"); } if (attr_sched_str != NULL) { if (!get_policy(attr_sched_str[0], &policy)) usage(argv[0], "Bad policy for 'attr' (-a)\n"); param.sched_priority = strtol(&attr_sched_str[1], NULL, 0); s = pthread_attr_setschedpolicy(&attr, policy); if (s != 0) handle_error_en(s, "pthread_attr_setschedpolicy"); s = pthread_attr_setschedparam(&attr, ¶m); if (s != 0) handle_error_en(s, "pthread_attr_setschedparam"); } /* If we initialized a thread attributes object, display the scheduling attributes that were set in the object. */ if (attrp != NULL) { s = pthread_attr_getschedparam(&attr, ¶m); if (s != 0) handle_error_en(s, "pthread_attr_getschedparam"); s = pthread_attr_getschedpolicy(&attr, &policy); if (s != 0) handle_error_en(s, "pthread_attr_getschedpolicy"); printf("Scheduler settings in 'attr'\n"); display_sched_attr(policy, ¶m); pthread_attr_getinheritsched(&attr, &inheritsched); printf(" inheritsched is %s\n", (inheritsched == PTHREAD_INHERIT_SCHED) ? "INHERIT" : (inheritsched == PTHREAD_EXPLICIT_SCHED) ? "EXPLICIT" : "???"); printf("\n"); } /* Create a thread that will display its scheduling attributes. */ s = pthread_create(&thread, attrp, &thread_start, NULL); if (s != 0) handle_error_en(s, "pthread_create"); /* Destroy unneeded thread attributes object. */ if (!use_null_attrib) { s = pthread_attr_destroy(&attr); if (s != 0) handle_error_en(s, "pthread_attr_destroy"); } s = pthread_join(thread, NULL); if (s != 0) handle_error_en(s, "pthread_join"); exit(EXIT_SUCCESS); } VOIR AUSSI getrlimit(2), sched_get_priority_min(2), pthread_attr_init(3), pthread_attr_setinheritsched(3), pthread_attr_setschedparam(3), pthread_attr_setschedpolicy(3), pthread_create(3), pthread_self(3), pthread_setschedprio(3), pthreads(7), sched(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_setschedparam(3)