2 ProcessusETD

2.
Mcanismes dexcution
F. Boyer, Laboratoire Lig
Fabienne.Boyer@imag.fr!
Cycle de vie dun programme !

Notion de processus!
Modle dexcution dun processus!
Ordonnancement des processus!
Notion de thread!
F. Boyer, UJF!
Cours de Systmes dExploitation RICM4!
1!
Ce cours a t conu partir de!
Cours de E. Berthelot!
http://www.iie.cnam.fr/EBerthelot/!
Cours de A. Sylberschatz!
www.sciences.univ-nantes.fr/info/perso/permanents/attiogbe/SYSTEME/
CoursSysteme.html!
Cours de A. Griffaut!
http://dept-info.labri.fr/~griffault/Enseignement/SE/Cours!
Cours de H. Bouzourfi, D. Donsez!

http://www-adele.imag.fr/~donsez/cours/#se!
!
!
!
F. Boyer, UJF!
2!
Notion de processus!
Programme en cours dexcution!

Lanc la demande du systme ou dune application!
Cr par un processus pre!
Identifi de manire unique (pid)!
!
Regroupe deux units !

Unit d'excution!
Flt de contrle logique squentiel (excute une suite d'instruction)!
Unit d'adressage!
Espace d'adressage (mmoire manipulable par les instructions
excutes), propre au processus!
!
Espace isol!
Isolation des fautes!
Isolation mmoire!
F. Boyer, UJF!
3!
Contexte dexcution!
Etat courant du processus!

Etat de lespace dadressage!
Code du programme excut!
Etat des donnes !
Etat des autres ressources utilises par le processus!
Registres (PC, SP, etc.,)!

Liste des fichiers ouverts!
Variables denvironnement!
!
sauvegarder lorsque le processus est commut!

restaurer lorsque le processus reprend la main!
F. Boyer, UJF!
4!
Modes dexcution!
Mode utilisateur!
Accs rduit lespace dadressage propre au processus !
Instructions limites!
Mode superviseur!
Toutes les instructions autorises et toute la mmoire accessible !
Superviseur # SuperUser (shell)!
Passage du mode utilisateur au mode superviseur!

Interruptions, !
Droutements!
Appels au superviseur!
!
F. Boyer, UJF!
5!
Cycle de vie!
inexistant
termin
cration
lu
prt
prempt
fin attente
bloqu
actif
fin exc.
appel syst. bloquant

(E/S, ..)
Remarque : certains SE dfinissent des tats supplmentaires (suspendu, )"

F. Boyer, UJF!
6!
Oprations de base sur les

processus!
!
Cration / destruction!
Activation / suspension!
Suspension momentane!
Attente de la terminaison dun fils!
Commutation (opration de bas niveau)!
F. Boyer, UJF!
7!
Gestion des processus par le SE!
!
Files de processus !
File des prts (Ready queue)!
File des bloqus sur E/S (Device queues) !
File des bloqus sur conditions de synchronisation (Blocked
queue)!
...!
Un processus actif!
Le SE fait migrer les processus entre les files!
F. Boyer, UJF!
8!
Contrle des processus!
Etat processus,
priorit,.. "
Identifications "
PCB (Process Control Block):!
informations requises pour
permettre au SE de grer un
processus!
!
Table des Processus:!
PCB [ MAX-PROCESSUS ]!
!
!
PC, SP, mep "

Autres registres "
Limites mmoire "
Liste fichiers"
Image mmoire"
"
F. Boyer, UJF!
9!
Usage des processus : exemple du Shell!
Un processus qui cre dautres processus pour excuter des commandes (sauf
pour les commandes built-in)!
Les variables denvironnement du shell sont initialises via des fichiers de

configuration!
Fichiers typiques : .login, .logout, .cshrc ou .bashrc, ..!
Variables typiques : HOME, PATH, TERM, CURRENT-DIR!
!
Dautres variables peuvent tre cres ou celles existantes modifies pour le

shell courant!
setenv VAR value (ou VAR=value en bash)!
Ou bien modifier le fichier de configuration et le resourcer (e.g., source .cshrc)!
!
Les variables sont hrites par un shell fils pourquoi?!

Mais elles sont crases par la relecture des fichiers de configuration!
Sauf pour les variables exportes (visibles par les shells secondaires)!
Ex dans bash : export VAR!
!
F. Boyer, UJF!
10!
Exemple du shell!
xterm 1!
[initialisation des variables denvt partir du fichier .bashrc]!
env!
USERNAME=fabienne"
PATH=.:/usr/local/bin:/usr/bin:/sbin:/bin"
PWD=/home/fabienne"
PATH=$PATH:/usr/lib/jvm/java-6-sun/bin!
CLASSPATH=.!
env!
USERNAME=fabienne"
PATH=.:/usr/local/bin:/usr/bin:/sbin:/bin:/usr/lib/jvm/java-6-sun/bin"
PWD=/home/fabienne"
CLASSPATH=."
>xterm &!
!
.bashrc!
USERNAME=fabienne!
PATH=.:/usr/local/bin:.!
PWD=/home/fabienne!
..!
xterm 2!
[initialisation des variables denvt partir du fichier .bashrc]!
env!
USERNAME=fabienne"
PATH=.:/usr/local/bin:/usr/bin:/sbin:/bin"
CLASSPATH et PATH ne sont pas hrits dans le shell fils!
PWD=/home/fabienne"
Il aurait fallu les exporter dans le pre pour ce faire!
!
!
!
F. Boyer,
UJF!
11!
Allocation du processeur au
processus!
Ordonnanceur (scheduler) est la partie du
SE qui gre l'allocation du processeur!

!
Critres!
quitable !
Efficace !
Minimisant les temps d'attente / de rponse des
processus!
Maximisant le rendement (nombre de travaux par unit
de temps)!
!
F. Boyer, UJF!
12!
Stratgies!
Algorithme avec / sans premption!

Transition interrompu du cycle de vie autorise si premption
(temps partag) et interdite sinon (multiprogrammation seule)!
Choix du quantum!
Petit ou grand!
Gestion de priorits!
Processus systmes!
Processus utilisateurs interactifs!
Processus utilisateurs peu interactifs!
F. Boyer, UJF!
13!
Algorithmes dordonnancement!
Multiprogrammation!
!
FIFO / FCFS !
Efficace (utilisation maximale de lUC) et quitable!
!
Multiprogrammation + temps partag!

PCTE / SJF (Plus Court Temps Excution)!
!
Tourniquet / Round Robin
!!
!
!
F. Boyer, UJF!
14!
Shortest-Job-First (SJF)!
Associe chaque processus la dure de son
excution!
Excute en priorit le processus dont la dure est la
plus courte!
Deux possibilits !
Non premptif !
Premptif (algorithme Shortest-Remaining-Time-First (SRTF))!
Evaluation!
SJF est optimal par rapport au temps de rponse moyen!
Impose de connatre le temps dexcution!
Non quitable!
!
F. Boyer, UJF!
15!
Round Robin!
Principes!
Les processus prts sont dans une file de type FIFO!
Lors dune commutation, le processus le suivant dans la file est lu
(getFirst())!
Le processus prempt sinsre en fin de file (putLast())!
Evaluation!
Efficace (sauf si quantum trop petit)!
Equitable et bon / temps de rponse et rendement (sauf si
quantum trop grand)!
!
F. Boyer, UJF!
16!
Round Robin avec priorits

statiques!
Principes!
Les processus ont des priorits!
Une priorit est associe un nombre de quantum (1, 2, 4, ..)!
Plus la priorit est forte, plus le quantum est petit!
Le processus le plus prioritaire est lu!
Evaluation!
Bon compromis efficacit / rendement!
Temps de rponse bons (travaux interactifs prioritaires)!
Non quitable!
Famine possible !
Les processus de faible priorit peuvent ne jamais s'excuter!
Aging Solution augmenter la priorit d'un processus avec
son ge!
priorits dynamiques!
!
!
F. Boyer, UJF!
17!
Round Robin avec priorits

dynamiques!
Principes!
Dterminer la nature dun processus (interactif, calcul)!

Monter la priorit dun processus sil est interactif ou g!
Mise en oeuvre!
Un paramtre (une dure et un nombre dinterruptions, ou l'ge)
permet daugmenter ou diminuer la priorit des processus!
Ou bien la priorit p est fonction de la fraction de quantum (f)
utilise (p = 1/f)!
Evaluation!
Equitable!
Bon rendement!
Temps moyen de rponse bons!
!
!
F. Boyer, UJF!
18!
Algorithmes dordonnancement
plusieurs niveaux!
Ensemble des processus prts trop important pour tenir en
mmoire centrale!
!
Certains sont dchargs sur disque, ce qui rend leur activation
plus longue!
!
Le processus lu est toujours pris parmi ceux chargs en
mmoire centrale!
!
En parallle, on utilise un deuxime algorithme
dordonnancement pour grer les dplacement des processus

prts entre le disque et la mmoire centrale!
!
F. Boyer, UJF!
19!
Cycle de vie avec deux niveaux

dordonnancement!
cration
inexistant
prt disque
fin E/S
bloqu
dcharg
lu
prt RAM
charg
appel bloquant (E/S, ..)

actif
interrompu
fin exc.
termin
RAM = Random Access Memory"

F. Boyer, UJF!
20!
Echange de donnes entre

processus!
Au moment de la cration!
Hritage de ltat du pre!
Via des segments de mmoire partage!

Portion partage de lespace dadressage!
Via des messages!

Pipes, tubes, etc.!
!
!
F. Boyer, UJF!
21!
Notion de thread!
Flot dexcution lger!

Contexte allg!
Une partie partage : mmoire adressable, fichiers ouverts, !
Une partie propre : pile, registres, ...!
Commutations rapides!
Partage de donnes!
Facilit et efficacit dcriture des applications concurrentes!
!!
F. Boyer, UJF!
22!
Processus single-threaded et multithreaded!
A.Sylberschatz!
F. Boyer, UJF!
23!
Exemple threads C!
#define _REENTRANT
#include <stdio.h>
#include <thread.h>
/* create the threads */

for (i=0; i<5; i++)
thr_create(NULL, 0, Add_to_Value,
(void*)(2*i), 0, NULL);
/* sample array data structure */

struct {
mutex_t data_lock[5];
int int_val[5];
float float_val[5]; } Data;
/* wait till all threads have finished */

for (i=0; i<5; i++)
thr_join(0,0,0);
/* thread function */
void * Add_to_Value();
main() {
int i; /* initialize the mutexes and data */
for (i=0; i<5; i++) {
mutex_init(&Data.data_lock[i], USYNC_THREAD, 0);
Data.int_val[i] = 0;
Data.float_val[i] = 0;
}
F. Boyer, UJF!
/* print the results */

printf("Final Values.....\n");
for (i=0; i<5; i++) {
printf("integer value[%d] =\t%d\n",
i, Data.int_val[i]);
printf("float value[%d] =\t%.0f\n\n",
i, Data.float_val[i]); } return(0); }
24!
Exemple threads C!
/* Threaded routine */
void *Add_to_Value(void *arg) {
int inval = (int) arg;
int i;
for (i=0;i<10000;i++){
mutex_lock(&Data.data_lock[i%5]);
Data.int_val[i%5] += inval;
Data.float_val[i%5] += (float) 1.5 * inval;
mutex_unlock(&Data.data_lock[i%5]);
}
return((void *)0);
}
F. Boyer, UJF!
25!
Exemple pthreads!
#include <stdio.h>
#include <pthread.h>
int main (void) {

pthread_t ta;
pthread_t tb;
static void *task_a (void *p_data) {

puts ("Hello world A");
return NULL;
}
puts ("main init");

pthread_create (&ta, NULL, task_a, NULL);
pthread_create (&tb, NULL, task_b, NULL);
static void *task_b (void *p_data) {

puts ("Hello world B");
return NULL;
}
pthread_join (ta, NULL);

pthread_join (tb, NULL);
puts ("main end");
return NULL;
}
F. Boyer, UJF!
26!
Historique des threads!
Unit dadressage!
Unit dexcution!
2 notions historiquement couples avec les
!
processus, dissocies avec les threads!

!
!
UA
UE!
UA
UE!
Remarque : un processus est galement associ une unit de protection !
F. Boyer, UJF!
27!
Types de threads!
!
Threads User-level !
Threads Kernel-supported!
Solutions mixtes!
F. Boyer, UJF!
28!
Threads user-level!
Code de gestion des threads dans une librairie !

Pas de modification du noyau !
Le gestionnaire de threads ainsi que les threads sexcutent au
sein dun processusutilisateur!

Ex: POSIX Pthreads, Mach C-threads, Solaris threads, Threads Java (initialement) !
th1!
th2!
th1!
Gestionnaire de threads!
Processus A!
th2!
th1!
Processus B!
Noyau!
F. Boyer, UJF!
29!
Avantages et inconvnients des

threads User-level!
Efficacit (+)!
La commutation de contexte est rapide!
Paralllisme (-)!
Pas de paralllisme rel entre les threads dun EV!
!
Appels systmes bloquants (-)!

Le processus est bloqu au niveau du noyau!
Tous les threads sont bloqus tant que lappel systme (ex: I/O)
nest pas termin!
Il ny a donc pas de multiprogrammation dans un espace virtuel!
!
!
F. Boyer, UJF!
30!
Threads kernel-level!
Notion de thread gre par le noyau!
Lorsquun thread se bloque, le noyau alloue le processeur un
autre thread!
Examples: Windows 95/98/NT/2000, Solaris, Tru64 UNIX, Linux, Threads Java (HotSpot)!
!
th1!
th2!
th1!
th1!
th2!
Processus B!
Processus A!
F. Boyer, UJF!
Noyau!
31!
Avantages et inconvnients des

threads Kernel-supported!
Appels systmes bloquants (+)!

Pas de blocage des threads dun EV lors dun appel systme!
!
Paralllisme rel (+)!

N threads dun EV peuvent sexcuter sur K processeurs!
Efficacit (-)!
Commutation plus chre que pour les threads User-level, car
demande un passage en mode noyau.!
F. Boyer, UJF!
32!
Solutions hybrides permettant une

commutation lgre!
Principes des threads User-level (commutations
gres au niveau utilisateur)!

!
Modification du noyau pour grer les appels
systmes de manire ne pas bloquer les threads!

Lorsquun thread fait un appel systme bloquant, le noyau ne
prempte pas le processeur!
Un mcanisme de signaux permet de grer la fin de lappel
bloquant!
Lordonnanceur est dpartag entre lespace systme et lespace
utilisateur (ordonnanceurs cooprants)!
F. Boyer, UJF!
33!
Solutions hybrides permettant une

commutation lgre (2)!
User-level threads!
Appel
bloquant!
ordonnanceur!
ordonnanceur! User space!
B"
A"
ordonnanceur!
F. Boyer, UJF!
Processus!
Kernel space !
34!
Autres solutions hybrides permettant

un paralllisme rel!
On utilise les deux types de threads !

Les threads Kernel-level fournissent la capacit de
paralllisme !
Les threads User-level fournissent la capacit davoir
des commutations lgres!

On peut associer plusieurs threads User-level un thread kernelsupported!
Appels systmes bloquants grs ou non par le systme!
!
F. Boyer, UJF!
35!
Autres solutions hybrides permettant

un paralllisme rel!
User-level threads!
ordonnanceur!
ordonnanceur!
User space!
Kernel space !
B"
A1" A2"
Kernel-level threads!
ordonnanceur!
F. Boyer, UJF!
36!
Modles de Threads!
Many-to-One
Un thread noyau plusieurs threads utilisateurs!
One-to-One
Un thread noyau un thread utilisateur!
Many-to-Many!
Pool de threads noyau Pool de threads

utilisateurs!
!
F. Boyer, UJF!
37!
Modle de threads Many-to-Many!
A. Sylberschatz!
F. Boyer, UJF!
38!
Principales familles de threads!
POSIX threads API (systmes Unix, threads noyaux)!

POSIX Threads (IEEE POSIX 1003.1c-1995 standart) (appels
Pthreads)!
DCE Threads!
Solaris Threads!
Microsoft-style threads (PCs)!

Win32 (Microsoft Windows95 and WindowsNT)!
OS/2 threads (IBM)!
F. Boyer, UJF!
39!
Threads Java!
User-level / Kernel-level, selon limplmentation de la
JVM (gnralement kernel-level)!

Cration!
Extension de la classe Thread!
Implmentation de linterface Runnable
!
F. Boyer, UJF!
40!
Exemple / threads!
...!
new Thread(new Runnable() {!
public void run() {!
........!
........!
}!
}).start()!
...!
F. Boyer, UJF!
41!

2 ProcessusETD

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

2 ProcessusETD

Transféré par

Droits d'auteur :

Formats disponibles

2.

Cycle de vie dun programme !

Cours de Systmes dExploitation RICM4!

Ce cours a t conu partir de!

Cours de H. Bouzourfi, D. Donsez!

Cours de Systmes dExploitation RICM4!

Programme en cours dexcution!

Regroupe deux units !

Cours de Systmes dExploitation RICM4!

Etat courant du processus!

Registres (PC, SP, etc.,)!

sauvegarder lorsque le processus est commut!

Cours de Systmes dExploitation RICM4!

Passage du mode utilisateur au mode superviseur!

Cours de Systmes dExploitation RICM4!

appel syst. bloquant

Remarque : certains SE dfinissent des tats supplmentaires (suspendu, )"

Cours de Systmes dExploitation RICM4!

Oprations de base sur les

Cours de Systmes dExploitation RICM4!

Gestion des processus par le SE!

Le SE fait migrer les processus entre les files!

Cours de Systmes dExploitation RICM4!

Contrle des processus!

PC, SP, mep "

Cours de Systmes dExploitation RICM4!

Usage des processus : exemple du Shell!

Les variables denvironnement du shell sont initialises via des fichiers de

Dautres variables peuvent tre cres ou celles existantes modifies pour le

Les variables sont hrites par un shell fils pourquoi?!

Cours de Systmes dExploitation RICM4!

SE qui gre l'allocation du processeur!

Cours de Systmes dExploitation RICM4!

Algorithme avec / sans premption!

Cours de Systmes dExploitation RICM4!

Multiprogrammation + temps partag!

Cours de Systmes dExploitation RICM4!

Associe chaque processus la dure de son

Cours de Systmes dExploitation RICM4!

Cours de Systmes dExploitation RICM4!

Round Robin avec priorits

Cours de Systmes dExploitation RICM4!

Round Robin avec priorits

Dterminer la nature dun processus (interactif, calcul)!

Cours de Systmes dExploitation RICM4!

Ensemble des processus prts trop important pour tenir en

dordonnancement pour grer les dplacement des processus

Cours de Systmes dExploitation RICM4!

Cycle de vie avec deux niveaux

appel bloquant (E/S, ..)

RAM = Random Access Memory"

Cours de Systmes dExploitation RICM4!

Echange de donnes entre

Via des segments de mmoire partage!

Via des messages!

Cours de Systmes dExploitation RICM4!

Flot dexcution lger!

Cours de Systmes dExploitation RICM4!

Processus single-threaded et multithreaded!

Cours de Systmes dExploitation RICM4!

/* create the threads */

/* sample array data structure */

/* wait till all threads have finished */

static void task_a (void p_data) {

static void task_b (void p_data) {