Introduction aux Systèmes et aux Réseaux

Introduction aux Systèmes et aux RéseauxCours 5 Processus

D’après un cours de Julien Forget (univ Lille1)

Laure Gonnordhttp://laure.gonnord.org/pro/teaching/

[email protected]

Master CCI - Université Lyon 1 - FST

http://laure.gonnord.org/pro/teaching/

[email protected]

Plan

1 Notions de base

2 Gestion Système des processusOrdonnancementCommunication et synchronisation inter-processusLes interruptions

3 Processus, programmation CUtilitaires de gestion de processusCréation d’un nouveau processus : ForkRecouvrement d’un processus : ExecCommunication par tuyau : Pipe

Laure Gonnord (CCI/Univ Lyon1) SystCCI Cours 5 : Processus 2014 � 2 / 70 �

Plan

Les processus

Objectif :Connaître les caractéristiques système d’un processus.Programmation C de processus.


Notions de base

1 Notions de base

2 Gestion Système des processus

3 Processus, programmation C


Notions de base

Programme et processusDéfinitionUn processus est un programme en cours d’exécution.

Chaque exécution d’un programme (éventuellementplusieurs fois le même) donne lieu à un processusdifférent ;A tout instant, un processeur exécute au plus unprocessus ;Dans un OS multi-tâches, le système alterne entrel’exécution de plusieurs processus ;Seuls les systèmes multi-cœur ou multi-processeurexécutent réellement plusieurs processus en même temps(un par cœur/processeur) ;Plus généralement, les processus partagent l’accès àdifférentes ressources : processeur mais aussi mémoire etpériphériques.


Notions de base

Propriétés d’un processus

A un instant donné, un processus est caractérisé par denombreuses informations, dont :

Son état : exécution, suspendu, etc. ;Son identificateur ;Son compteur ordinal : indique la prochaine instruction àexécuter ;Sa pile d’exécution : mémorise l’empilement des appels defonction ;Ses données en mémoire ;Toutes autres informations utiles à son exécution (E/S,fichiers ouverts, . . . )


Notions de base

Création de processus

En Unix :Au lancement du système, un unique processus ;L’appel système fork crée un nouveau processus ;Le processus père et le processus fils s’exécutent enparallèle ;Le père et le fils peuvent à nouveau effectuer un fork ;

⇒ Hiérarchie arborescente de processus.


Notions de base

Commande pstree

Visualiser l’arborescence des processus : pstree

init ---NetworkManager ---2*[ dhclient]

| | -3*[{ NetworkManager }]

...

|-gnome -terminal ---bash ---emacs

|-more

|-pstree


Notions de base

Mode d’exécution

Deux modes d’exécution d’un processus :Mode noyau : accès sans restriction (manipulation de lamémoire, dialogue avec les contrôleurs de périphériques,. . . )Mode utilisateur : accès restreint, certaines instructionssont interdites (pas d’accès direct aux périphériques). Ilpeut être interrompu par d’autres processus.

⇒ Les appels systèmes permettent à un processus en modeutilisateur d’accéder (temporairement) à des fonctionsnécessitant le mode noyau.


Notions de base

Identificateurs d’un processus

Plusieurs identificateurs sont associés à un processus (UNIX) :Numéro de processus (pid) ;Numéro du processus père (ppid) ;Identificateurs d’utilisateur, et de groupe, . . .

Possibilité de connaître ces informations dynamiquement viades appels systèmes.


Notions de base

Evolution de l’état au cours de l’exécution


Notions de base

Etat d’un processus

non créé : le code n’est pas en mémoire ;créé : le code est en mémoire, en attente d’activation ;éligible : l’activation a été demandée. En attente de l’accèsau processeur ;élu : le processus s’exécute ;suspendu : une ressource est indisponible (allouée à unautre processus).


Notions de base

Préemption

Le système interrompt l’exécution d’un processus pour enexécuter un autre (ressource indisponible, processusprioritaire, etc.) ;Il sauve le contexte du processus et le remplace par celuid’un autre ;Il rétablira plus tard le contexte du processus préempté.

Contexte d’un processus : valeur des registres, des variables,où on en est dans son exécution . . .I Une préemption prend du temps : le temps de commutation


Notions de base

Classification des systèmes

Gestion des processusmono-tâche : CPU dédié à un processus ;multi-tâche : CPU partagé entre les processus ;multi-tâche préemptif : possibilité de suspendre puis rétablirun processus en cours d’exécution.

Gestion des utilisateursmono-utilisateur : pas de cohabitation entre utilisateurs ;multi-utilisateur : cohabitation possible.


Notions de base

Exemples de système d’exploitation

MS-DOS : mono-utilisateur, mono-tâche ;Windows : mono-utilisateur, multi-tâche ;WinNT : mono-utilisateur, multi-tâche préemptif ;UNIX : multi-utilisateur, multi-tâche préemptif.


Notions de base

Visualisation (statique) des processus 1/2

Sous UNIX :l’information sur les processus en cours peut être obtenuepar :

ps [options]

Attention les options sont de deux types (bsd/gnu).Quelques exemples :

ps -ef : every,full.ps -eo pid,ppid,tt,user,fname | grep laure


Notions de base

Visualisation (statique) des processus 2/2

laure@sorlin :~$ psPID TTY TIME CMD

18220 pts /13 00:00:00 bash18270 pts /13 00:00:00 pslaure@sorlin : ~ : ps −efUID PID PPID C STIME TTY TIME CMDroo t 1 0 0 07:59 ? 00:00:00 / sb in / i n i tr oo t 2 0 0 07:59 ? 00:00:00 [ kthreadd ]roo t 3 2 0 07:59 ? 00:00:00 [ k s o f t i r q d / 0 ]. . .l au re 19717 1909 0 10:34 ? 00:00:00 evince . . .l au re 19856 3014 0 10:34 pts /14 00:00:00 bashlau re 20093 5867 3 10:35 ? 00:00:01 / usr / l i b /

chromium−browser / chrolau re 20238 19856 0 10:36 pts /14 00:00:00 ps −ef


Notions de base

Visualisation des processus

Sous UNIX :visualisation dynamique des processus :

top [options]


Notions de base

Interruption des processus

Sous UNIX :

kill [numéro_de_signal] numéro_de_processus

kill -l donne l’ensemble des signaux disponiblesexemple de signaux :

SIGHUP (1) : émis à tous les processus associés à unterminal lorsque celui-ci se déconnecteSIGINT (2) : émis à tous les processus associés à unterminal lorsque <ctrl + C > est tapéSIGKILL (9) : tue un processus quel que soit son état. C’estl’arme absolue.SIGTERM (15) : signal de terminaison normale d’unprocessus


Notions de base

Lancement en arrière plan

Il est possible de lancer une commande sans que le shellcourant en attende la terminaison :

commande &

Elle ne peut plus lire au clavier ;Les sorties standards sont toujours associées, par défaut,au terminal ;Elles ne sont plus interruptibles à partir du clavier (ctrl-cpar exemple).

Connaître les processus lancés en arrière plan (pour unshell donné) :

jobs


Notions de base

Changement d’état d’un processusSous UNIX (%n est le numéro obtenu par jobs)


Notions de base

Démo

Les PID seront récupérés avec la commande ps -ef lancéedans un autre terminal.

Lancement du logiciel eog et terminaison avec CTRL-c oukill -SIGINT.Lancement du logiciel eog en arrière plan. CTRL-c nepermet pas de terminer. kill -SIGINT le peut (ou kill

sans option (SIGTERM).Lancement du logiciel eog puis suspendu (CTRL-z) puis enarrière plan (bg), puis suspendu avec kill -SIGSTOP, puisfg.


Gestion Système des processus

1 Notions de base


3 Processus, programmation C


Gestion Système des processus

Problématiques de la gestion de processus

Difficulté principale : gestion de l’accès concurrent à diversesressources :

Accès au processeur : ordonnancement ;Lecture/écriture de données :

Assurer la cohérence des données ;Gérer les synchronisations lecteur/écrivain ;Eviter les blocages.


Gestion Système des processus Ordonnancement

1 Notions de base





Définition

L’ordonnancement (scheduling) est une fonctionfondamentale d’un système d’exploitation ;A la base de la programmation multi-tâche :

Plusieurs processus en mémoire en même temps ;Assignation du processeur à un processus en fonction decertains critères ;

Objectif = optimiser l’utilisation concurrente du processeur.



Ordonnanceur vs dispatcher

L’ordonnanceur est responsable de l’organisation des filed’attente des tâches éligibles ;Le dispatcher réalise l’élection d’un processus et lechangement de contexte associé.



Décisions de l’ordonnanceur

Les décisions de l’ordonnanceur peuvent avoir lieu dans lescirconstances suivantes :

Quand un processus passe de l’état "élu" à "suspendu"(attente de disponibilité d’une ressource) ;Quand un processus passe de l’état "élu" à l’état "éligible"(à cause d’une interruption) ;Quand un processus passe de l’état "suspendu" à l’état"éligible" (libération d’une ressource) ;Quand un processus se termine.



Pour aller plus loin

Différents algorithmes (FIFS, tourniquet), . . . . (voir lalittérature).

http://fr.wikipedia.org/wiki/Ordonnancement_dans_les_

syst%C3%A8mes_d'exploitation


http://fr.wikipedia.org/wiki/Ordonnancement_dans_les_syst%C3%A8mes_d'exploitation

http://fr.wikipedia.org/wiki/Ordonnancement_dans_les_syst%C3%A8mes_d'exploitation

Gestion Système des processus Communication et synchronisation

1 Notions de base





Processus communicantsLes processus concurrents d’un système d’exploitationpeuvent être :

Indépendants : les traitements qu’ils effectuent ne sont pasliés ;Communicants : les processus ont besoin d’échanger desdonnées.

Plusieurs raisons pour la communication :Le partage d’information ;L’accélération du calcul ;La modularité (séparation d’un programme complexe enplusieurs processus).

La communication peut se faire :Via une zone mémoire commune ;Par échange de messages ;Par fichiers.

Nécessite de synchroniser les processus communicants.



Le problème des accès concurrents

Les processus communicants partagent des données ⇒assurer la cohérence des données.

Exemple :out indique le fichier à imprimer ;in indique où mettre en attente un fichier à imprimer ;Problème : si B interrompt A juste quand il lit la valeur dein.



Exclusion mutuelle

Il faut interdire l’accès simultané à une ressourcepartagée ;On parle d’exclusion mutuelle entre processusconcurrents ;L’exclusion mutuelle ne concerne qu’une portion del’exécution des processus : les sections critiques ;Il faut assurer que :

On n’a jamais deux processus simultanément en sectioncritique ;La solution ne dépend pas de la vitesse relative desprocessus ;Un processus suspendu hors section critique ne bloquepas les autres ;Tout processus finit par rentrer en section critique.



Plusieurs solutions à ce problème

Exclusion par verrouExclusion par alternance.Sémaphores



Exclusion par sémaphoreExemple : 3 tâches qui désirent utiliser une ressourcecommune (une imprimante) ;Les processus à synchroniser partagent un sémaphore ;Sémaphore binaire : le compteur vaut 0 ou 1 ⇒ ressourceunique, pas d’accès simultané.



Communication par messages

Dans le cas de systèmes distribués (mémoires distinctes) :On doit synchroniser des processus distants les uns desautres ;On utilise un système d’échange de message :

Envoi du message : sendMsg(destinataire, message) ;Réception du message : rcvMsg(expéditeur, message).

Principaux modes d’échange de messages possibles :Boîte aux lettres ;Rendez-vous.



Echange de messages : problèmes classiques

Réseau imparfait ⇒ possibilité de perte de message ;Côté producteur : s’assurer que le message est bien arrivé(acquittement) ;Côté consommateur, si aucune donnée n’arrive :

Continuer avec une donnée ancienne ?Attendre l’arrivée d’une nouvelle donnée ?


Gestion Système des processus Les interruptions

1 Notions de base





Interruption

Cas particulier de “communication” :Une interruption est un signal provenant de l’extérieur duprocessus-programme (émis par l’OS) et non synchroniséavec le processus en cours ;Le processus en cours d’exécution est suspendu dans sonactivité ;On exécute un programme prédéfini associé au traitementde cette interruption ;Les causes d’interruptions sont multiples (cf http://en.wikipedia.org/wiki/Interrupt_descriptor_table

(exemple, div by 0) et il faut prévoir leur traitement.I Un exemple en TP.


http://en.wikipedia.org/wiki/Interrupt_descriptor_table

http://en.wikipedia.org/wiki/Interrupt_descriptor_table


À retenir de cette partie

Qu’est-ce qu’un ordonnanceur ? (partie de l’OS)Quels sont les problèmes qui se posent lorsque deuxprocessus communiquent (programmation système) ?Qu’est-ce qu’une interruption ?


Processus, programmation C

1 Notions de base

2 Gestion Système des processus



Processus, programmation C

Arborescence de processus / Rappel

Au lancement du système, un unique processus ;Création d’un nouveau processus :

Duplication = création d’un fils identique au père (fork) ;Le fils a les mêmes propriétés que le père (code, données,pile, droits, ...)Recouvrement du code du fils par le programme voulu(exec) ;Eventuellement, communication entre père et fils (pipe).


Processus, programmation C Utilitaires

1 Notions de base





Accès aux propriétés du processus

#include <sys/types.h>

#include <unistd.h>

pid_t getpid(void) : l’identifiant du processus ;pid_t getppid(void) : l’identifiant du père du processus ;char *getcwd(char *buf, size_t size) : le répertoirede travail ;int chdir(const char *path) : changer le répertoire detravail ;. . .



Divers

unsigned int sleep(unsigned int seconds) : endormirle processus pour quelques secondes ;void exit(int status) : termine le processus + renvoieun code de retour.


Processus, programmation C Fork

1 Notions de base





Primitive

#include <unistd.h>

pid_t fork(void);

Crée dynamiquement un processus ;Processus qui exécute le fork = père du processus créé(fils) ;Fils = copie exacte du père ;Exécution concurrente du père et du fils (entrelacementpossible des instructions).



Schéma d’exécution (1)

pere

fils

fork()



Propriétés du fils

Le fils hérite de son père :le même code ;une copie des données (variables et valeurs) ;le même environnement (e.g. répertoire de travail) ;la même priorité ;les mêmes droits ;les descripteurs de fichiers ;la gestion des signaux.



Exemple (création)

# inc lude < s t d i o . h># inc lude <un is td . h>i n t main ( ) {

p r i n t f ( " 1 − proc %d , pere %d \ n " , ge tp id ( ) , getpp id ( ) ) ;f o r k ( ) ; /∗ 2 processus ∗ /p r i n t f ( " 2 − proc %d , pere %d \ n " , ge tp id ( ) , getpp id ( ) ) ;f o r k ( ) ; /∗ 4 processus ! ∗ /p r i n t f ( " 3 − proc %d , pere %d \ n " , ge tp id ( ) , getpp id ( ) ) ;

}



Schéma d’exécution de l’exemple

l au re@sor l in : ~ / . . . / Cours / $ . /f o rk1

1 − proc 990 , pere 115392 − proc 990 , pere 115393 − proc 990 , pere 115392 − proc 991 , pere 9903 − proc 992 , pere 9903 − proc 991 , pere 19093 − proc 993 , pere 991

laure@sor l in : ~ / . . . / Cours / $

fin

990

991

fork()

fin

fork()

992

fin

fork()

993

fin



Exemple fork1- 3/3

Sur l’exemple précédent, bien observer les dates d’impression.D’autres exécutions sont possibles, lesquelles ?



Terminaison d’un processus

Les processus terminent lorsqu’ils arrivent à la fin de leur code.Dans l’exemple précédent, le processus de pid 990 termineavant que le processus 991 n’exécute son printf(3...), lepère de 991 est alors le processus init (ou init-user).



Distinguer père et fils

Grâce à la valeur de retour du fork :Le PID du fils est retourné au père ;0 est retourné au fils ;-1 est retourné au père si erreur.



Exemple (distinction père/fils)#include <sys / types . h> /∗programme creerproc ∗ /. . .i n t main ( ){

p i d_ t n ;n= f o r k ( ) ;i f ( n == −1){ pe r ro r ( " c rea t i on de processus " ) ;

e x i t ( 1 ) ; }i f ( n == 0){ /∗ seul l e processus f i l s execute cec i ∗ /

p r i n t f ( " dans f i l s n = %d \ n " , n ) ;p r i n t f ( " PID f i l s %d \ n " , ge tp id ( ) ) ;

} else{ seu l l e processus pere execute cec i ∗ /

p r i n t f ( " dans pere n = %d \ n " , n ) ;p r i n t f ( " PID pere %d \ n " , ge tp id ( ) ) ;p r i n t f ( " f i n proc pere \ n " ) ;

}e x i t ( 0 ) ;

}



Exemple (distinction père/fils) (2)

l au re@sor l in : ~ / . . / Cours$ . / creeprocdans pere n = 2577PID pere 2576f i n proc peredans f i l s n = 0PID f i l s 2577laure@sor l in : ~ / . . / Cours$

Ici (dans cette exécution) le père se termine avant le fils ;Le fils est alors “adopté” par le processus init (PID 1) ouinit-user.



Synchronisation

#include <sys/types.h>

#include <sys/wait.h>

pid_t wait (int *status)

Suspend le processus jusqu’à ce qu’un de ses fils termine ;Valeur de retour :

-1 si pas de fils ;Le PID du fils terminé sinon.

pid_t waitpid(pid_t pid, int *status, int opts)

Attend le fils de PID pid.

status “décrit” l’état de terminaison du fils.



Exemple (synchronisation)

void main ( ) /∗ sync1 . c ∗ /{

i f ( f o r k ( ) == 0){

p r i n t f ( " f i l s − PID = %d \ n " , ge tp id ( ) ) ;e x i t ( 3 ) ;

} else {p i d_ t m; i n t n ;m = wa i t (&n ) ;p r i n t f ( " f i n proc %d avec code %d \ n " , m, n ) ;

}}

laure@sor l in : ~ / . . / Cours / $ . / sync1f i l s − PID = 2689f i n proc 2689 avec code 768laure@sor l in : ~ / . . / Cours / $



Exemple : synchronisation (2)

main ( ) /∗ sync2 . c ∗ /{

i f ( f o r k ( ) == 0){

p r i n t f ( " PID f i l s = %d \ n " , ge tp id ( ) ) ;for ( ; ; ) ; /∗ on va te rminer ce proc par un k i l l ∗ /}else{

i n t n ; p i d_ t m ;m = wai t (&n ) ;p r i n t f ( " f i n proc %d avec code %d \ n " , m, n ) ;

}}


Processus, programmation C Exec

1 Notions de base





Primitives

# inc lude <un is td . h>

i n t execl ( const char ∗path , const char ∗arg , . . . ) ;i n t execlp ( const char ∗ f i l e , const char ∗arg , . . . ) ;. . .

Exécute un nouveau programme ;Ce programme recouvre l’ancien (pas de processus créé) ;Conservation des propriétés système :

PID, PPID, priorité ;descripteurs de fichiers ;. . .



Un exemple simple

i n t main ( ) /∗ my_ls . c ∗ /{

i f ( execlp ( " l s " , " l s " , "− l " , NULL) ==−1){

pe r ro r ( " echec execlp \ n " ) ;e x i t ( 1 ) ;

}p r i n t f ( " ce t t e l i g n e ne sera jamais a f f i c h e e \ n " ) ;e x i t ( 0 ) ;

}

I Liste des arguments, comme argc/argv.



Shell simple

Schéma simplifié d’un Shell :

tant que vrai faire

lire(commande)

Si (fork()==0)

exec(commande)

Sinon

wait(-1)

fin_tq



Conclusion

Le langage C fournit des primitives pour :Créer, inspecter des processusExécuter des commandes système.

Ce que l’on n’a pas vu :Comment faire les pipe (tubes, tuyaux) en C (dup,pipe)La notion de processus léger (thread) : partage d’unemême zone de “mémoire virtuelle”, et son utilisation en C.


Processus, programmation C Pipe

1 Notions de base





Duplication de descripteur

#include <unistd.h>

int dup(int oldfd);

int dup2(int oldfd , int newfd);

Duplique oldfd ;dup retourne la plus petite valeur possible ;dup2 :

ferme newfd ;copie oldfd vers newfd ;

Retourne -1 si échec ;Utilisation : redirection d’E/S standard.



Exemple

main ( ) {i n t desc ;i f ( ( desc = c rea t ( " e r reu r . t x t " , 0666) ) == −1) {

pe r ro r ( " c rea t i on f i c h i e r e r reu r imposs ib le " ) ;e x i t ( 1 ) ;

}/∗ r e d i r e c t i o n de l a s o r t i e e r reu r standard ∗ /c lose ( 2 ) ;dup ( desc ) ;f p r i n t f ( s tde r r , " message d ’ e r reu r r e d i r i g e dans e r reu r . t x t \ n " )

;}



Communication par FIFO (file/tube/pipe)

Communication typique 1 producteur → 1 consommateur ;Taille limitée ;On écrit d’un côté......et on lit de l’autre (dans le même ordre que l’écriture) ;Le système bloque :

La lecture si tube vide ;L’écriture si tube plein.



Tubes en POSIX#include <unistd.h>

int pipe(int pipefd [2]);

Tube = 1 fichier, mais pas de référence dans le système ;On lit/écrit avec les primitives classiques sur les fichiers ;Tube = 2 descripteurs (sur le même fichier) :

fd[0] pour l’écriture ;fd[1] pour la lecture.

Retourne 0 si ok, -1 si erreur (ex : trop de descripteursouverts) ;S’utilise typiquement avec fork (communicationpère↔fils) ;Il faut systématiquement fermer les descripteurs de tubesnon utilisés



Exemplemain ( ) {

i n t tube [ 2 ] ;i n t i , p id , r e t ;i f ( p ipe ( tube ) <0) {

pe r ro r ( " e r reu r ouver ture pipe " ) ; e x i t ( 1 ) ;}i f ( ( p id= f o r k ( ) ) <0) {

pe r ro r ( " e r reu r f o r k " ) ; e x i t ( 1 ) ;}i f ( p id !=0 ) {

c lose ( tube [ 0 ] ) ; /∗ pere ne l i t pas ds l e tube ∗ /for ( i =1; i <=1000 ; i ++)

w r i t e ( tube [ 1 ] , &i , sizeof ( i n t ) ) ;c lose ( tube [ 1 ] ) ;wa i t (& r e t ) ;

} else {c lose ( tube [ 1 ] ) ; /∗ f i l s n ’ e c r i t pas ds tube ∗ /while ( read ( tube [0 ] ,& i , sizeof ( i n t ) ) ==sizeof ( i n t ) )

p r i n t f ( "%d " , i ) ;p r i n t f ( " \ n " ) ;c lose ( tube [ 0 ] ) ;

} }


Documents

Introduction aux Systèmes et aux Réseaux