TP de systèmes d'exploitation

Dci

Description

tp, Supérieur, TP

• cours - matière potentielle : systèmes d
• redaction - matière potentielle : documents
• cours - matière potentielle : exécution
• mémoire
• revision

TP de systèmes d'exploitation - Partage de ressources entre processus et arbitrage par sémaphore - Gestion des processus en C fork() Un processus peut se dupliquer – et donc créer un nouveau processus – par la fonction : pid_t fork(void) qui rend -1 en cas d'échec. En cas de réussite, la fonction retourne 0 dans le processus fils et le n° du processus fils – Process Identifier ou PID – dans le père.

• signification pour la politique pol- icy
• gestion des sémaphores
• politiques d'ordonnancement
• sémaphore
• temps de réponse
• appels système
• appel système
• thread
• linux
• processus
• ressources
• ressource

Sujets

• Documents
• Exécution
• Mémoire
• Révision
• Ward Cunningham
• Processus
• Système
• Sémaphore

Informations

• Publié par: idwe0
• Nombre de lectures: 337
• Langue: Français

Extrait

Ensi de Caen TP 2A instrumentation / microélectronique

TP de systèmes d'exploitation

Page 1 / 6 PhL  18/11/04  tp_se_2a.sxw

- Partage de ressources entre processus et arbitrage par sémaphore -

Gestion des processus en C

fork() Un processus peut se dupliquer – et donc créer un nouveau processus – par la fonction : p i d _ tf o r k ( v o i d ) qui renden cas d’échec. En cas de réussite, la fonction retournedans le processus fils et le n° du processus fils –  10 Process Identifier– dans le père. Cette fonction transmet une partie du contexte du père au fils : les descripteurs desou PID fichiers standards et des autres fichiers, les redirections… Les deux programmes sont sensibles aux mêmes interruptions. À l’issue d’unles deux processus s’exécutent simultanément. f o r k ( )

exit() Un processus se termine lorsqu’il n’a plus d’instructions ou lorsqu’il exécute la fonction : v o i de x i t ( i n ts t a t u t )

wait() L’élimination d’un processus terminé de la table ne peut se faire que par son père, grâce à la fonction : i n tw a i t ( i n t* c o d e _ d e _ s o r t i e ) Avec cette instruction, le père se bloque en attente de la fin d’un fils. Elle rendra le n° PID du premier fils mort trouvé. La valeur du code de sortie est celle du paramètre de la fonctionde ce fils. On peut donc utiliser l’instruction e x i tw a i t pour connaître la valeur éventuelle de retour, fournie par, d’un processus. Ce mode d’utilisation est analogue à e x i t ( ) celui d’une fonction.rend encas d’erreur. w a i t ( ) 1 Si le fils se termine sans que son père l’attende, le fils passe à l’étatdefunctla table. Si, au contraire, le père se dans termine avant le fils, ce dernier est rattaché au processus initial. Le processus initial passe la plupart de son temps à attendre les processus orphelins.

kill() L’instruction : i n tk i l l ( i n tp i d ,i n ts i g n a l ) permet à un processus d’envoyer un signal à un autre processus.est le n° du processus à détruire et, le n° du p i ds i g n a l signal employé. La fonctioncorrespond à des interruptions logicielles. k i l l Par défaut, un signal provoque la destruction du processus récepteur, à condition bien sûr, que le processus émetteur possède ce droit de destruction. Le signal de terminaison normal est 3, et celui de terminaison sans condition est 9. Cette même commande existe aussi en shell.

–Écrire un programme qui va créer un deuxième processus. Le père va afficher les majuscules à l'écran et le fils les minuscules. Ici, le travail effectué par les 2 processus est trop court et il n'y a pas entrelacement des exécutions. Pensez à mettre un "\n" à la fin de chaque écriture afin de vider le buffer ! –programme qui va créer un deuxième processus. Le père et le fils comptent de 0 à 100000 et l'affiche à l'écran.Écrire un Le père place un P devant son comptage et le fils un F. Analysez le travail de l'ordonnanceur. –le programme précédent. Le père ouvre un fichier en écriture avant de créer le fils. Père et fils écrivent leReprenez comptage dans le fichier. –Faites de même avec un fichier ouvert en ajout à la fois par le père et par le fils. Pourquoi cela ne fonctionnetil plus correctement ?

Gestion des threads en C(voir lemande chaque fonction!!) voir aussi en annexe du polycopié.

La création et le lancement du thread se fait par :  pthread_t th1 ;  int ret ;  pthread_create (&th1, NULL, runDuThread, "1") ;

Ensi de CaenPage 2 / 6 TP 2A instrumentation / microélectroniquePhL  18/11/04  tp_se_2a.sxw  if (th1 == NULL) {  fprintf(stderr, "pthread_create error 1\n") ; exit(0) ;  } Le thread exécutera alors la fonctiondont le prototype est : runDuThread  void* runDuthread (void *param) ; Cette fonction est à écrire par le programmeur pour décrire le comportement du thread. Le paramètreparamest un pointeur dont la valeur est celle passée en argument (le 4ième) de la fonctionpthread_create. Il permet de passer des données au thread. Si la fonction main se termine, le programme et tous les threads lancés se terminent aussi. Il faut donc s'assurer avant de terminer le programme que tous les threads ont fini leur travail. L'attente de la terminaison d'un thread se fait comme ceci : (void) pthread_join (th1, (void *)&ret) ; Le paramètreretcontiendra la valeur retournée par la fonctionà exécuter avant de terminer pthread_exit (int val) un thread. –Écrire un proprogramme qui lance 2 threads. L'un écrira les 26 minuscules à l'écran et l'autre les 26 majuscules. –en écriture puis qui crée 2 threads, les attend et ferme le ficher. Le premierÉcrire un programme qui ouvre un ficher thread écrira les nombres de 0 à 100 000 dans le ficher et l'autre de 1 000 000 à 1 100 000. Consultez le fichier ainsi créé et analysez le travail de l'ordonnanceur. –Écrire un programme qui initialise une variable globale à 0 et crée 2 threads. Chacun des threads va incrémenter la variable N fois. Afficher la valeur de la variable à la fin de l'exécution de chacun des threads. –Faites plusieurs executions et augmenter N jusqu'à remarquer que le résultat n'est plus 2xN. Pourquoi ? Vous le saurez en assistant au prochain épisode du cours de Systèmes d 'exploitation et réseaux.

Gestion des sémaphores. Lorsque 2 processus veulent se partager une ressource unique, on met en place un système de sémaphore afin d'arbitrer l'accès à cette ressource. Un sémaphore est une variable gérée par le système d'exploitation dont le test et l'affectation se font de manière atomique ; c’est à dire que le système ne peut pas être interrompu au milieu du traitement de ces 2 opérations. De plus, plusieurs processus peuvent avoir accès à cette variable. En général la prise (décrémente de 1) d'un sémaphore par un processus bloquera un autre processus qui voudrait prendre par la suite ce sémaphore ; ce dernier processus sera débloqué quand le premier rendra (incrémente de 1) le sémaphore. Voyons comment gérer les sémaphores sur un système UNIX (celle ci serait très semblable sur un système window's). Les fonctions C Voici les fonctions qui permettent la gestion des sémaphores. Elles viennent de la librairie Inter Process Communication. Vous pouvez avoir de plus amples renseignements en utilisant la commandeman. D’abord, quelques fichiers de déclaration : #include <unistd.h> #include <sys/ipc.h> #include <sys/sem.h> D'abord, il faut générer une clé unique permettant de repérer de façon univoque la ressource du système (ici un fichier) :  key_t cle;  int er ;  cle=ftok("fichier.txt",0);  if(cle==(key_t) 1) { perror ("erreur ftok\n");exit (1); } Ensuite, les sémaphores sont gérés au niveau du système par ensemble. Ici nous avons besoins de 1 seul sémaphore, donc créons un ensemble contenant 1 sémaphore avec les droits de modifications et de consultation pour tout le monde soit_rw_rw_rw ou 0666 en octal (r=4, w=2 et x=1):  int semid ;  semid=semget(cle,1,IPC_CREAT|0666);  if(semid==1) { perror("erreur semget\n");exit(1); } La fonction semget permet aussi de récupérer un identifiant de sémaphore si il en existe un connu du système associé à la clé. Dans ce cas le troisième argument est 0.

Initialisons à 1 de notre sémaphore (qui est le sémaphore n° 0 de l'ensemble ) :  union semun {  intval;  structsemid_ds *buf;  ushort*array;

Ensi de CaenPage 3 / 6 TP 2A instrumentation / microélectroniquePhL  18/11/04  tp_se_2a.sxw  }arg;  arg.val = 1 ;  er=semctl(semid,0,SETVAL,arg);  if (er==1) {perror("erreur semctl\n");exit(1);} La fonction semctl permet d'effectuer des opérations de contrôle les sémaphores. On peut par exemple effacer un ensemble de sémaphor en passant la valeur IPC_RMID à l'argument 3.

Voilà une fonction permettant de rendre le sémaphore no de l' ensemble semid : void rendre (int semid, int no) {  struct sembuf op[1];  int er ;  op[0].sem_num=no;// semaphore no  op[0].sem_op=1;// libération (à mettre à –1 pour une prise)  op[0].sem_flg=0;// l'operation de prise sera bloquante  er=semop (semid,op,1);  if (er==1) {perror("erreur semop rendre\n");exit(1);} } La fonctionsemop (semid, op, n)permet de réalisernopérations décrites dans le tableau de structureopsur l'ensemble des sémaphores d'identifiantsemid.

Remarques : –Pour consulter les sémaphores du système : ipcs t –Pour effacer un sémaphore d'identifiantsemid: ipcrm s semid

Travail à effectuer :  Écrireune fonctionvoid prendre (int semid, int no) quiprend le sémaphoreno del'ensemblesemid,similaire à la fonction rendre.  Écrireun programme qui va créer un processus fils. Le père et le fils vont écrire simultanément, l’un, les 26 minuscules et l’autre, les 26 majuscules, à l’écran. Ceci devra donner le résultat suivant : A a B b C c D d …

Application On vous propose de réaliser un Wiki allégé (c'est à la mode). Un Wiki est un site web dynamique dont tout visiteur peut modifier les pages à volonté.

Il s'agit d'un concept assez récent, bien que la technologie nécessaire existe depuis plusieurs années. Le nom Wiki provient de l'hawaïen "WikiWiki" qui signifie vite. Ward Cunningham, le créateur de Wiki, a choisi ce nom pour former un diminutif à partir de "WikiWikiWeb".

Le principe est simple : il s'agit d'un modèle coopératif de rédaction de documents. Concrètement, n'importe quel visiteur a le droit de modifier la page qu'il est en train de lire. Ainsi, un premier auteur va rédiger un article, un second va le compléter, puis un visiteur va corriger une erreur qu'il aura remarquée en navigant sur le site.

L'élève attentif aura tout de suite remarqué qu'un grave problème peut survenir ! Que se passetil si deux visiteurs veulent modifier ensemble une même page ? Il faut en protéger l'accès par un sémaphore. Quant aux processus et les threads, les utiliseton ici ? Non tout le travail multitâche sera effectué par le serveur web de l'école. Mais nous les retrouverons en troisième année.

Concevez un miniwiki proposant un document HTML que quiconque pourra modifier en cliquant sur un lien en bas de la page. Si un utilisateur est déjà entrain de modifier cette page, une autre page HTML lui signifiera. Pensez à mettre vos programmes CGI dans le répertoire ~/public_html/cgibin.

Inspirezvous de la page web suivante :http://www.ensicaen.ismra.fr/~lefebvre/cgi/cotravail.html

Remarques – Vous aurez besoin de passer des informations non modifiables par l'utilisateur à vos programmes CGI. Ceci se fait de cette manière : <input type="hidden" name="Fichier" value="velo.html"> Ici, le champs fichier reçoit la valeur « velo.html »

Ensi de Caen TP 2A instrumentation / microélectronique

Page 4 / 6 PhL  18/11/04  tp_se_2a.sxw

– Vous aurez aussi besoin de définir une zone de texte éditable. Par exemple pour une zone de 20 lignes et 70 colonnes : <TEXTAREA ROWS=20 COLS=70 NAME="docu"> – est modifiée, si l'utilisateur essaye de la voir de nouveau avec son navigateur, il ne verra pas lesLorsqu'une page modifications. En effet, pour accélérer l'accèsà internet les navigateurs gardent en mémoire (cache) les pages web, et c'est cette dernière qui est affichée. On peut préciser au navigateur de ne pas stocker en cache une page. Ceci se fait en modifiant l'entête HTTP. A la place d'écrire : "contenttype:text/html\n\n" on écrira "contenttype:text/html\n" "CacheControl: nostore, nocache, mustrevalidate\n\n" – La fonction perror renvoie des informations pertinentes sur les sémaphores en cas de problèmes sur leur création ou sur les opérations que l'on effectue. Mais perror envoie sont résultat sur la sortie standard et non pas sur le navigateur du client. Écrivez donc une fonction perreur qui permet d'envoyer le résultat de perror sur le navigateur.

– Lorsqu'un programme CGI reçoit une chaîne de caractère, celle ci a subit un traitement particulier. Les espaces on été transformés en '+' et les caractères accentués par "%XY" avec XY le code ascii du caractère. Écrivez une fonction qui retransforme cette chaîne en la chaîne d'origine.

Annexes :Extrait de la documentation Linux sur les threads :

AUTEUR  XavierLeroy <[e-mail]> This is release 0.7 (late beta) of LinuxThreads, a BiCapitalized implementation of the Posix 1003.1c "pthread" interface for Linux.

LinuxThreads provides kernellevel threads: each thread is a separate Unix process, sharing its address space with the other threads through the new system call clone(). Scheduling between threads is handled by the kernel scheduler, just like scheduling between Unix processes.

USING LINUX THREADS:

gcc D_REENTRANT ... lpthread

rem :  Threads share pretty much everything they should share according  to the standard: memory space, file descriptors, signal handlers,  current working directory, etc. One thing that they do not share  is their pid's and parent pid's. According to the standard, they  should have the same, but that's one thing we cannot achieve  in this implementation (until the CLONE_PID flag to clone() becomes  usable).

 The stacks for the threads are allocated high in the memory space,  below the stack of the initial process, and spaced 2M apart.  Stacks are allocated with the "grow on demand" flag, so they don't  use much virtual space initially (4k, currently), but can grow  up to 2M if needed.

 Reserving such a large address space for each thread means that,  on a 32bit architecture, no more than about 1000 threads can  coexist (assuming a 2Gb address space for user processes),  but this is reasonable, since each thread uses up one entry in the  kernel's process table, which is usually limited to 512 processes. ____________________________________ NOM pthread_create créé un nouveau thread

SYNOPSIS  #include<pthread.h>

 intpthread_create(pthread_t * thread,pthread_attr_t * attr, void *  (*start_routine)(void*), void * arg);

DESCRIPTION  pthread_createcréé un nouveau thread s'éxécutant concurremment avec le  threadappelant. Le nouveau thread exécute la fonction start_routine en  luipassant arg comme premier argument. Le nouveau thread s'achève soit  explicitementen appelant pthread_exit(3), ou implicitement lorsque la  fonctionstart_routine s'achève. Ce dernier cas est équivalent à  appelérpthread_exit(3) avec la valeur renvoyée par start_routine comme  codede sortie. _____________________________________ NOM pthread_join attend la mort d'un autre thread

SYNOPSIS  #include<pthread.h>

 intpthread_join(pthread_t th, void **thread_return);

DESCRIPTION  pthread_joinsuspend l'exécutiondu thread appelant jusqu'à ce que le  threadidentifié par th achève son exécution, soit en appelant  pthread_exit(3)soit après avoir été annullé.

 Sithread_return ne vaut pasNULL, la valeur renvoyée par th y sera  enregistrée.Cette valeur sera soit l'argumentpassé à  pthread_exit(3),soit PTHREAD_CANCELED si le thread th a été annullé.

Le thread joint th doit êtredans l'état joignable: il ne doit pas  avoirété détaché par pthread_detach(3) ou par l'attribut PTHREAD_CRE  ATE_DETACHEDlors de sa création par pthread_create(3).

 Quandl'exécution d'un thread joignable s'achève, ses ressources  mémoires(descripteur dethread et pile) ne sont pas désallouées  jusqu'àce qu'un autre thread lejoigne en utilisant pthread_join.  Aussi,pthread_join doit êtreappelée une fois pour chaque thread  joignablepour éviter des "fuites" de mémoire.

 Auplus un seul thread peut attendre la mort d'un thread donné. Appeler

Ensi de Caen TP 2A instrumentation / microélectronique

 pthread_joinsur un thread th dont un autre thread attend déjàla fin  renvoieune erreur. ________________________________________

NOM sched_setschedulerla politique, sched_getscheduler  Lire / fixer  d'ordonnancementet ses paramètres.

SYNOPSIS  #include<sched.h>

 intsched_setscheduler(pid_t pid, int policy, const structsched_param  *p);

 intsched_getscheduler(pid_t pid);

 structsched_param {  ...  intsched_priority;  ...  };

DESCRIPTION  sched_setschedulerfixe à la fois la politique d'ordonnancement et ses  paramètrespour le processus identifié par pid.Si pid vautzéro, la  politiquedu processus en cours sera fixée.L'interprétation du  paramètrep dépend de la politique employée. Actuellement il y atrois  politiquesproposées par Linux : SCHED_FIFO, SCHED_RR, et SCHED_OTHER.  Leurssémantiques respectives sont décrites cidessous.

 sched_getschedulerlit la politiqued'ordonnancement et ses paramètres  pourle processus identifié par pid.Si pid vaut zéro, la politique du  processusen cours sera récupérée.

 Politiquesd'ordonnancement  L'ordonnanceurest la partie du noyau qui décide quel processus prêt va  êtreexécuté ensuite. L'ordonnanceur de Linux propose trois politiques  différentes,une pour les processus classiques, et deux pour les appli  cationsà vocation tempsréel.

 Unevaleur de prioritéstatique sched_priority est assignée à chaque  processus,et ne peut être modifiée quepar l'intermédiaire d'appels  systèmes.Conceptuellement, l'ordonnanceur dispose d'une liste de tous  lesprocessus prêtspour chaque valeur possible de sched_priority  (sched_priorityest dans l'intervalle 0 à 99).

 Afinde déterminer quel processusdoit s'exécuter ensuite, l'ordon  nanceurde Linux recherche la liste nonvidede plus haute priorité  statiqueet prend leprocessus en tête de cette liste.La politique  d'ordonnancementdétermine pour chaque processusl'emplacement où il sera inséré dans la liste contenant les processus de même priorité sta  tique,et comment il se déplacera dans cette liste.

 SCHED_OTHERest l'ordonnancement universeltempspartagé par défaut,  utilisépar la plupart des processus. SCHED_FIFOet SCHED_RR sont  prévuspour des applications tempsréelqui nécessitent un contrôle  précisde la sélection des processus prêts.

 Lesprocessus ordonnancésavec SCHED_OTHER doivent avoir une priorité  statiquede 0, ceux ordonnancéspar SCHED_FIFO ou SCHED_RR peuvent  avoirune prioritéstatique dans l'intervalle 1 à 99.Seuls les pro  cessusdisposant de privilèges SuperUser peuvent obtenir unepriorité  statiquesupérieure a 0 afin d'être ordonnancé parSCHED_FIFO ou  SCHED_RR.

 Lesappels systèmessched_get_priority_min et sched_get_priority_max  permettentde déterminerl'intervalle de priorités valides de manière  portablesur les systèmes conformes à la norme POSIX.1b.

 Toutordonnancement est préemptif : Si un processus avecune priorité  statiqueplus élevée devient prêt, le processus en cours est interrompu  etretourne dans saliste d'attente. La politique d'ordonnancement  déterminesimplement l'ordre utilisé dans une liste de processus prêts  avecdes priorités statiques égales.

Page 5 / 6 PhL  18/11/04  tp_se_2a.sxw

 SCHED_FIFO:Ordonnancement FirstInFirst out (premier arrivé, premier  servi)  SCHED_FIFOne peut être utilisé qu'avec des priorités statiques  supérieuresà 0, ce qui signifie quedès qu'un processus SCHED_FIFO  devientprêt, un processus normal SCHED_OTHER en cours d'exécution sera  interrompu.SCHED_FIFO est un ordonnancement simple à base de tranches  detemps. Pour les processus ordonnancéspar SCHED_FIFO les règles  suivantessont appliquées :

 Unprocessus SCHED_FIFO qui a été préempté par unautre processus de  prioritésupérieure restera en tête de sa listeet reprendra son  exécutiondès que tous les processus de prioritéssupérieures sont à  nouveaubloqués.

 Quandun processusSCHED_FIFO devient prêt, il est inséré à la fin de  saliste.

 Unappel système sched_setscheduler ou sched_setparam placerale pro  cessusSCHED_FIFO identifié par pid à la fin de sa liste s'il est prêt.

 Unprocessus appelant sched_yield sera placé à la fin de sa liste.

 Aucunautre évènement ne modifiera l'ordre des listes de priorités sta tiques égales avec SCHED_FIFO.

 Unprocessus SCHED_FIFO s'exécute jusqu'à ce qu'il soit bloqué par une  opérationd'entrée/sortie, qu'il soit préempté par un processus de pri  oritésupérieure, ou qu'il appelle sched_yield.

 SCHED_RR:Ordonnancement Round Robin  SCHED_RRest une amélioration simple de la politique SCHED_FIFO. Tout  cequi est décrit pour SCHED_FIFO s'applique aussi à SCHED_RR, sauf que  chaqueprocessus nedispose que d'une tranche temporelle limitée pour  sonexécution. Siun processus sous politique SCHED_RRs'est exécuté  depuisune durée supérieure ou égaleà la tranche temporelle (time  quantum),il sera placé à la fin de la liste de sa priorité.

 Unprocessus sous SCHED_RR qui a été préempté par un processus de pri  oritésupérieure terminera sa tranche de temps lorsqu'il reprendra son  exécution.la longueur du time quantumpeut être lue avec  sched_rr_get_interval.

 SCHED_OTHER:Ordonnancement tempspartagé par défaut  Lapolitique SCHED_OTHER nepeut être utilisée qu'avec des priorités  statiquesà 0. C'est lapolitique standard de l'ordonnanceur temps  partagéde Linux, etest conçue pour tous les processus ne réclamant  pasde fonctionnalités tempsréel.

 Leprocessus à exécuter est choisi dans la liste des processus depri  oritésstatiques nulles, en utilisantune priorité dynamique qui ne  s'appliqueque dans cette liste.

 Lapriorité dynamique est basée sur la valeur de "gentillesse" dupro  cessus(fixée avec les appels systèmesnice ou setpriority) et est  incrémentéeà chaque time quantum où le processusest prêt mais non  sélectionnépar l'ordonnanceur.Ceci garantit une progression  équitablede tous les processus SCHED_OTHER.

 Tempsde réponse  Unprocessus de haute priorité bloqué en attente d'entrées/sortiesest  affectéd'un certaintemps de réponse avant d'être sélectionné à nou  veau.Le concepteur d'ungestionnaire de périphérique peut réduire  grandementce temps de réponse en utilisant un gestionnaire d'interrup  tionslentes comme décrit dans request_irq(9).

 Divers  Lesprocessus fils héritent de lapolitique d'ordonnancement et des  paramètresassociés lors d'un fork.

 Leverrouillage de pagesen mémoire est généralement nécessaire pour les processus temps réel afin d'éviter les délais depagination. Ceci

Ensi de Caen TP 2A instrumentation / microélectronique

 peutêtre effectué avec mlock(2) ou mlockall(2).

 Commeune boucle sansfin non bloquante dans un processus ordonnancé  sousune politique SCHED_FIFO ou SCHED_RRbloquera indéfiniment tous  lesprocessus avec une priorité plus faible, le développeur d'applica  tionstempsréel devrait toujours conserver sur uneconsole un shell  ordonnancéavec une priorité supérieure à celle del'application  testée.

 Cecipermettra un kill((1) d'urgence des applications testées qui ne se  bloquentpas ou qui ne se terminent pas comme prévu.Comme les proces  sussous SCHED_FIFO et SCHED_RR peuvent préempter les autres processus  normauxpour toujours, seuls les processusSuperUser ont le droit  d'activerces politiques sous Linux.

 Lessystèmes POSIX sur lesquels sched_setscheduleret sched_getsched  ulersont disponibles définissent _POSIX_PRIORITY_SCHEDULING dans  <unistd.h>.

VALEUR RENVOYÉE  sched_setschedulerrenvoie 0 s'il réussit sched_getscheduler renvoie la  politiquepour le processus s'il réussit.

 Encas d'échec, 1 est renvoyé et errno contient le code d'erreur.

ERREURS  ESRCHLe processus numéro pid n'existe pas.

 EPERMLe processusappelant n'a pas les privilèges nécessaires. Seul  lesprocessus SuperUser peuvent activerles politiques  SCHED_FIFOet SCHED_RR.Le processus appelant sched_setsched

Page 6 / 6 PhL  18/11/04  tp_se_2a.sxw

 ulerdoit avoir un UID effectif égal à celui du processuspid,  ouêtre SuperUser.

 EINVALLa valeur de politique d'ordonnancement policy n'existe pas, ou  leparamètre p n'a pas de signification pour la politiquepol  icy.

CONFORMITÉ  POSIX.1b(POSIX.4)

BOGUES  SousLinux 1.3.81,SCHED_RR n'a pas été testé totalement, et ne se com  portepeut être pas exactement comme décrit cidessus.

VOIR AUSSI  sched_setparam(2),sched_getparam(2), sched_yield(2), sched_get_prior ity_max(2), sched_get_priority_min(2), nice(2), setpriority(2), getpri  ority(2),mlockall(2), munlockall(2), mlock(2), munlock(2).

 Programmingfor the realworld  POSIX.4 by Bill O. Gallmeister,  O'Reilly& Associates, Inc., ISBN 1565920740  IEEEStd 1003.1b1993 (POSIX.1b standard)  ISO/IEC99451:1996 C'est une nouvelle révision 1996 de POSIX.1 qui  regroupeen un seul standard les normes POSIX.1(1990),POSIX.1b (1993),  POSIX.1c(1995),et POSIX.1i(1995).

TRADUCTION  ChristopheBlaess, 1997.