Provided by: manpages-fr-dev_3.27fr1.4-1_all bug

NOM

       pthread_setschedparam,  pthread_getschedparam  -  Definir ou obtenir la
       politique et les parametres d'ordonnancement d'un thread

SYNOPSIS

       #include <pthread.h>

       pthread_setschedparam(pthread_t thread, int policy,
                             const struct sched_param *param);
       pthread_getschedparam(pthread_t thread, int *policy,
                             struct sched_param *param);

       Compilez et effectuez l'edition des liens avec l'option -pthread.

DESCRIPTION

       La  fonction  pthread_setschedparam()  definit  la  politique  et   les
       parametres d'ordonnancement du thread thread.

       L'argument  policy  specifie la politique d'ordonnancement pour thread.
       Les valeurs possibles, ainsi que leur signification, sont decrites dans
       sched_setscheduler(2).

       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 supporte.
       Veuillez consulter sched_setscheduler(2) 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  policy  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 RENVOY'EE

       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 thread avec pour identifiant thread n'a pu etre trouve.

       pthread_setschedparam()   peut   egalement  echouer  avec  les  erreurs
       suivantes :

       EINVAL policy n'est pas une politique reconnue, ou  param  n'a  pas  de
              sens pour cette valeur de policy.

       EPERM  L'appelant  n'a  pas  les  privileges suffisants pour definir la
              politique et les parametres d'ordonnancement indiques.

       POSIX.1-2001 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().

CONFORMIT'E

       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_setscheduler(2).

EXEMPLE

       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 <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
       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<policy><prio> Set scheduling policy and priority in\n");
           fpe("                 thread attributes object\n");
           fpe("                 <policy> 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|s}         Set inherit scheduler attribute to\n");
           fpe("                 'explicit' or 'inherit'\n");
           fpe("-m<policy><prio> Set scheduling policy and priority on\n");
           fpe("                 main thread before pthread_create() call\n");
           exit(EXIT_FAILURE);
       } /* usage */

       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;
           }
       } /* get_policy */

       static void
       display_sched_attr(int policy, 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);
       } /* display_sched_attr */

       static void
       display_thread_sched_attr(char *msg)
       {
           int policy, s;
           struct sched_param param;

           s = pthread_getschedparam(pthread_self(), &policy, &param);
           if (s != 0)
               handle_error_en(s, "pthread_getschedparam");

           printf("%s\n", msg);
           display_sched_attr(policy, &param);
       } /* display_thread_sched_attr */

       static void *
       thread_start(void *arg)
       {
           display_thread_sched_attr("Scheduler attributes of new thread");

           return NULL;
       } /* thread_start */

       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 (-s)\n");
               param.sched_priority = strtol(&main_sched_str[1], NULL, 0);

               s = pthread_setschedparam(pthread_self(), policy, &param);
               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, &param);
               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, &param);
               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, &param);

               s = 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 */

           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);
       } /* main */

VOIR AUSSI

       getrlimit(2),     sched_get_priority_min(2),     sched_setscheduler(2),
       pthread_attr_init(3),                  pthread_attr_setinheritsched(3),
       pthread_attr_setschedparam(3),          pthread_attr_setschedpolicy(3),
       pthread_setschedprio(3),       pthread_create(3),      pthread_self(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/>.

       Denis Barbier (2010).

       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> >>.