Les systèmes d’exploitation

Samar TAWBI
samartawbi@yahoo.com
1
Chapitre 1.
Le système d’exploitation :Notions

2
Système d’exploitation (SE)
Définition

« Ensemble de tous les programmes permettant à l’utilisateur du

système informatique d’exploiter au mieux les ressources de la
machines de façon cohérente et coordonnée dans des conditions
raisonnables de confort »

Interface entre les utilisateurs du Système Informatique et la

machine physique

applications
APPLICATIONS (jeux, outils bureautiques, …)

SYSTEME Interpréteur de commandes, compilateur,

D’EXPLOITATION noyau
Langage machine
MATERIEL
Dispositifs physiques
3
Système d’exploitation

Fournit l’interface utilisateurs/machine:

Masque les détails du matériel aux applications
Le SE doit donc traiter ces détails

Contrôle l’exécution des applications

En reprenant périodiquement le contrôle de l’UC
Informe l’UC quand exécuter tel programme

Il doit optimiser l’utilisation des ressources pour maximiser

la performance du système

4
Vue abstraite des composants d’un SI

Kernel (noyau)

5
Le noyau
Différents types de services assurés

gestion du(des) processeur(s)

chargement et lancement des programmes

gestion de la mémoire (primaire et secondaire)

gestion des entrées/sorties (périphériques)

6
Les principaux SE (1/2)
Solaris/Linux
Bâtis sur le noyau Unix
le meilleur compromis : fiable, efficace, souple, portable, évolutif
reste (très) difficile d'accès pour un novice, voire pour un informaticien
Distributions de Linux
Red Hat
Fedora
S.u.S.e

MacOS
désormais peu répandu car submergé par Windows
ergonomie géniale, fiable, stable
a développé ses propres standards (y compris pour le hardware)…et a
perdu la concurrence contre Windows (il lui reste quelques niches, telles
que la photo numérique)

7
Les principaux SE (2/2)
Windows
le plus diffusé, très orienté utilisateur (configuration
automatique toujours disponible), large gamme d’utilitaires
(certains étant désormais des standards), prise en main très
simple
peu fiable même si des progrès depuis Win2000/XP, sécurité
inexistante (virus, intrusions très fréquentes)
peu ouvert, impose la plupart des choix technologiques et
"enferme" les utilisateurs dans ces choix
stratégie industrielle douteuse sur le plan de l'éthique

D'autres systèmes réservés aux gros serveurs

VMS, GCOS, MVS et AS400 …

8
Historique des SE

9
1ère génération
Mode d'exploitation
l'utilisateur écrit un programme en langage machine
il réserve la machine pour une durée déterminée
il rentre son programme en mémoire "à la main"
il l'exécute
si exécution non conforme à ses attentes alors
exécution pas à pas et modification éventuelle
nouvel essai jusqu'à satisfaction ou temps de réservation
atteint

Mode d'exploitation totalement inefficace

10
2ème génération : Traitement par lots
Amélioration du matériel

transistors et circuits imprimés

apparition et diversification des périphériques

lecteurs de cartes perforées
imprimantes
supports magnétiques (bandes, cartes, …)

11
Comment ça fonctionne?
les premiers SE (mi-50)
L’usager soumet une tâche (job) à un opérateur
Programme suivi par données

L’opérateur place un lot de plusieurs jobs sur le dispositif de

lecture
Un programme, le moniteur (SE), gère l'exécution de chaque
programme du lot
Le moniteur est toujours en mémoire et prêt à être exécuté
Les utilitaires (compilateur) du moniteur sont chargés au besoin
Un seul programme à la fois en mémoire, programmes sont
exécutés en séquence
La sortie est normalement sur un fichier, imprimante, ruban magnétique…

12
Cartes perforées

Une ligne de données ou de programme était codée

dans des trous qui pouvaient être lus par la machine
13
Opérateur lisant un paquet de cartes
perforées

14
3ème génération : Multiprogrammation
Les opérations E/S sont extrêmement lentes (comparées
aux autres instructions)
ex. une boucle de programme pourrait durer 10 microsecondes,
une opération disque 10 millisecondes
C’est la différence entre 1 heure et un mois et demi!
Même avec peu d’E/S, un programme passe la majorité de son
temps à attendre

Donc: pauvre utilisation de l’UC lorsqu’un seul programme

se trouve en mémoire

15
Comment ça fonctionne?
Multiprogrammation
plusieurs activités progressent en parallèle
– une activité garde le CPU jusqu'à la prochaine
demande d'E/S
– traitement des fins d'E/S du processeur grâce aux
interruptions

16
Exigences pour multiprogrammation
Interruptions
afin de pouvoir exécuter d’autres jobs lorsqu’un job
attend après E/S
Protection de la mémoire: isole les jobs
Gestion du matériel
plusieurs jobs prêts à être exécutées demandent des
ressources:
UC, mémoire, unités E/S
Langage pour gérer l’exécution des travaux: interface
entre usager et OS
jadis JCL (Job Control Language), maintenant shell,
command prompt ou semblables

17
Plusieurs programmes en mémoire
pour la multiprogrammation

18
Avantages et Inconvénients
Avantages
bonne gestion des ressources (CPU, mémoire, périphériques)
temps de réponse correct pour les travaux courts

Inconvénients
complexité du matériel et du système d'exploitation
partage et protection des ressources

19
4ème génération: Temps partagé
Temps partagé
Le traitement par lots multiprogrammé ne supporte pas l’interaction
avec les usagers
excellente utilisation des ressources
mode d'exploitation
travail à partir d'un terminal interactif
solution
allocation du processeur aux usagers à tour de rôle et pour un
"quantum" de temps limité
la fin du quantum est signalée par une interruption d'horloge

20
Clients / Serveur

Terminaux
‘stupides’

Ordinateur principal
(mainframe)
21
Chaque terminal a sa propre partition de mémoire

22
Temps partagé

23
Aujourd’hui

Terminaux
‘intelligents’ (PC)

Ordinateur principal
(mainframe)
24
Retour aux concepts de Temps partagé
Plusieurs PC (clients) peuvent être desservis par un
ordinateur plus puissant (serveur)
pour des services qui sont trop complexes pour eux
(clients/serveurs, bases de données, telecom)

Les grands serveurs utilisent beaucoup des concepts

développés pour les systèmes Temps partagé

25
Les systèmes Linux …

Conçus par des programmeurs pour des programmeurs

26
LINUX : le logiciel libre
L’idée d’un SE libre est née en 1984 (Free Software
Fondation)

Idée originale par un étudiant finlandais (Linus Torvalds)

Code sous licence GPL (General Public Licence)

Noyau Unix totalement libre

Evolution basée sur les « bonnes volontés »

27
Philosophie des systèmes Linux
Système multi-utilisateur
Plusieurs utilisateurs simultanément
Chaque utilisateur à sa disposition l’ensemble des ressources du
système
Mécanisme d’identification

Utilise un système de gestion de fichier hiérarchisé

arborescent
Les entrées-sorties sont généralisées
Les périphériques sont considérés comme des fichiers
Indépendance du système par rapport au matériel

Système portable
Écrit en langage C (99%)

28
Ouverture/Fermeture d’une session
Travailler sous Linux implique une connexion au système

Login:
Identification de l’utilisateur: login + mot-de-passe
droits accordés par le super-utilisateur (root (administrateur))

Logout:
NE PAS ETEINDRE une machine “sauvagement”
commande “logout” dans la console

MAINTENANT INTERFACE GRAPHIQUE

29
Initiation au shell
Une fois connecté, le système nous connaît, ouvre une
session à notre nom et nous positionne dans le répertoire
d’accueil

Le système attend nos instructions via un programme

spécial : le Shell

Le Shell = interpréteur de commandes

interface utilisateur “de base”
interprétation ligne à ligne
plusieurs shells: sh, csh, tcsh, bash, ksh, zsh, ...
langage de programmation

Shell par défaut : bash

30
Initiation au shell
- commandes -
Format des commandes:

cde [-option(s)] [argument(s)]

Respecter la casse
et les espaces!!

31
Initiation au shell
Exemples:
date
whoami
affiche le nom de l’utilisateur connecté
echo
affiche un message (echo "bonjour !")
ls
liste le contenu
d’un répertoire
man <cde>
manuel en ligne

32
Les fichiers
« structure » contenant des informations ou bien un
programme

Un répertoire est un fichier particulier

Contient des noms de fichiers

Noms de fichier
Un nom de fichier est unique dans un répertoire donné
Il est possible d’avoir des noms de fichiers identiques dans des
répertoires différents
Jusqu’à 256 caractères
Eviter les caractères : - * ? < > ! / \ <espace>
Différences entre minuscules et majuscules (Toto != tOTo)
33
Droits d’accès des fichiers (1)
Chaque fichier est caractérisé par des droits d’accès

Trois catégories d’utilisateurs de fichiers

L’utilisateur (user) : propriétaire du fichier
Les groupes (group) : définis par l’administrateur
Les autres (others)

Les droits d’accès sont de 4 types

Lecture (r) : affichage du fichier
Écriture (w) : modification et copie d’un fichier
Exécution (x) : exécution d’un fichier
Aucun (-) : Protection totale

34
Droits d’accès des fichiers (2)
Les droits d’accès sont de 4 types
Lecture (r) : affichage du fichier
Écriture (w) : modification et copie d’un fichier
Exécution (x) : exécution d’un fichier
Aucun (-) : Protection totale

Combinaison des droits (r,w,x) pour les classes (u,g,o)

obtenir les droits d’un fichier ou d’un répertoire.
Affichable grâce à ls –l

-rw-r--r-- 1 belloir 184025 ali 15 16:23 cours.txt

-rw-r--r-- 1 belloir 4024 ali 15 12:23 td1.txt

Lecture pour tout le monde et écriture pour utilisateur

35
Droits d’accès des fichiers (3)
Exemple de type de fichier : d rwxr-xr-x

La 1ère lettre détermine le type de fichier (7 types)

- fichier ordinaire
d répertoire (directory)
l lien sur un fichier ou un répertoire

Les droits d’accès sont modifiables par le propriétaire du fichier

chmod utilisateur opération permission nomfic

36
Droits d’accès : modifiables par le propriétaire du
fichier

chmod permission nomfic

Droits binaire octal
--- 000 0
--x 001 1
-w- 010 2
-wx 011 3
r-- 100 4
r-x 101 5
rw- 110 6
rwx 111 7

-rwxr-x--x chmod 777 titi.c -rwxrwxrwx

37
Arborescence
Organisation hiérarchique des fichiers
Imbrication de répertoires
Organisation standardisée partielle (sic)
/ : racine
/bin : binaires et programmes exécutables
/dev : fichiers spéciaux relatifs aux périphériques
/etc : fichiers de configuration et d’administration
/lib : bibliothèques des langages de programmation
/lost+found : fichiers perdus sur erreur système
/mnt : réservé au montage temporaire des disques
/usr : sous-préfectoraux pour le spool, courrier, programmes locaux,
exécutables des commandes utilisateurs,…
/tmp : répertoire de travail temporaire
/home : sous répertoires des utilisateurs
/var fichiers et répertoires exploités par l’administrateur
38
Arborescence
/

/dev /etc /bin /home /tmp /usr /var

39
Arborescence
Référence absolue ou relative à un fichier
Absolue : chemin exact depuis la racine (toujours le même)
/home/info/belloir/ise/sujettd1.txt
Relative : chemin depuis le répertoire courant (variable)
(depuis belloir) ise/sujettd1.txt ou ~/ise/sujettd1.txt

Se déplacer dans l’arborescence

Commande cd nomrep (Change Directory)
Chaque répertoire possède 2 fichiers particuliers
. Est un lien sur le répertoire courant. Sert à forcer le système à
considérer le répertoire courant comme point de départ
.. Est un lien vers le répertoire supérieur dans la hiérarchie

40
Arborescence
/

cd /home

home

belloir lacayr gouard

cd ..

ise se

cd ..
cours td
cd .

41
Commandes relatives aux fichiers
Donne le répertoire courant : pwd

Liste le contenu du répertoire : ls

Option Signification
-a affiche tous les fichiers (même cachés)
-l format long avec les permissions, prop, taille, date…
-R liste des sous-répertoires
-s taille des fichiers en blocs
-t affichage en fonction de la date de dernière modif
…

42
Commandes relatives aux fichiers
Création d’un fichier
Avec un éditeur de texte
Redirection de sortie avec >

Copie d’un fichier

cp nomsource nomdest
-r copie de répertoire

Renommer ou déplacer un fichier

mv nom_source nom_dest

43
Commandes relatives aux fichiers
Destruction d’un fichier
rm nomfic
Attention aux caractères de substitution !!! (*)
-i demande confirmation
-r détruit un répertoire

Création et destruction d’un répertoire

mkdir nomrep
-p création d’une arborescence complète
mkdir –p /ise/cours/tmp

rmdir nomrep efface un répertoire s’il est vide

rm -r nomrep efface un répertoire non vide
(récursivement) DANGER !!!

44
Commandes relatives aux fichiers
Affichage du contenu d’un fichier

cat nomfic
Intégralement affiché à l’écran

more nomfic
Affichage page par page (avancement par <esp> ou
<enter>)

file nomfic
S’assure qu’un fichier est lisible

45
Les processus
Processus = objet dynamique
qui représente un programme en cours d’exécution et son
contexte

Pour voir les processus en cours: ps

temps CPU utilisé

[lewandow:~] ps
PID TT STAT TIME COMMAND
3899 p1 S 0:00.08 -zsh
numéro de 4743 p1 S+ 0:00.14 emacs
processus 4180 std S 0:00.04 -zsh commande
exécutée

état du
terminal processus: R actif
T bloqué
associé S endormi
Z tué 46
Les processus
Options de ps:
-a liste tous les processus actifs
-u format d’affichage long
-x inclut les processus sans terminal

Tuer un processus:
kill -9 <PID>

Processus en arrière-plan: &

(le terminal n’est pas bloqué)
exemple: emacs monfichier.c &

47
Chapitre 2.
Gestion de la mémoire centrale

48
Gestion de mémoire: objectifs
Optimisation de l ’utilisation de la mémoire
principale = RAM

Le plus grand nombre possible de processus actifs

doit y être gardé, de façon à optimiser le
fonctionnement du système en
multiprogrammation
garder le système le plus occupé possible, surtout l’UC
s’adapter aux besoins de mémoire de l ’usager
allocation dynamique au besoin

49
Mémoire/Adresses physiques et logiques
Mémoire physique:
la mémoire principale RAM de la machine

Adresses physiques: les adresses de cette mémoire

Mémoire logique: l’espace d’adressage d’un programme

Adresses logiques: les adresses dans cet espace

Il faut séparer ces concepts car normalement, les

programmes sont chargés de fois en fois dans positions
différentes de mémoire
Donc adresse physique ≠ adresse logique

50
Traduction
adresses logiques adr.physiques
Dans les premiers systèmes, un programme était toujours chargé dans
la même zone de mémoire

La multiprogrammation et l’allocation dynamique ont engendré le

besoin de charger un programme dans positions différentes

Aujourd’hui, ceci est fait par le MMU au fur et à mesure que le progr.
est exécuté

Ceci ne cause pas d’hausse de temps d ’exécution, car le MMU agit en

parallèle avec autres fonctions d ’UCT
P.ex. l ’MMU peut préparer l ’adresse d ’une instruction en même temps
que l ’UCT exécute l ’instruction précédente

51
Traduction
adresses logiques adr.physiques
Un mécanisme de translation d’adresse est alors nécessaire
Transformer les adresses symboliques en adresses réelles

Registre de base (b): plus basse adresse mémoire utilisée par un

processus
Longueur (l): la longueur de l’espace physique allouée

Peut être formulée sous la forme F:S R

a b+a
1) Si a<0 alors violation de mémoire
2) Sinon Si a > l alors violation de la mémoire
3) Sinon f(a) = a’ = b+a
4) a’ est une adresse valable

52
Traduction
adresses logiques adr.physiques
Registre de base =
la plus basse adresse mémoire utilisée

Registre
de base

MMU: unité de gestion de mémoire

unité de traduction adresses
(memory management unit)
53
Permutation de programmes (swapping)
Un programme, ou une partie de programme,
peut être temporairement enlevé de mémoire
pour permettre l’exécution d’autres programmes

il est mis dans mémoire secondaire, normal. disque

54
Affectation contiguë de mémoire

Nous avons plusieurs programmes à exécuter

Nous pouvons les charger en mémoire les uns

après les autres
Le programme en entier est chargé
le lieu où un programme est lu n’est connu qu’au
moment du chargement

55
Affectation contiguë de mémoire

SE

progr. 1

progr. 2

disponible

progr. 3

Nous avons ici 4 partitions pour des programmes -

chacun est chargé dans une seule zone de mémoire
56
Fragmentation: mémoire non utilisée

Un problème majeur dans l’affectation contiguë:

Il y a assez d ’espace pour exécuter un programme,

mais il est fragmenté de façon non contiguë

externe: l’espace inutilisé est entre partitions

interne: l’espace inutilisé est dans les partitions

57
 Partitions fixes

Mémoire principale
subdivisée en régions
distinctes: partitions

Les partitions sont soit de

même taille ou de tailles
inégales

N’importe quel progr. peut

être affecté à une partition
qui soit suffisamment
grande

58
Algorithme de placement pour
partitions fixes
Partitions de tailles
inégales: utilisation de
plusieurs files
assigner chaque processus à
la partition de la plus petite
taille pouvant le contenir
1 file par taille de partition
tente de minimiser la
fragmentation interne
Problème: certaines files
seront vides s’il n’y a pas de
processus de cette taille
(fr. externe)

59
Algorithme de placement pour
partitions fixes
Partitions de tailles
inégales: utilisation d’une
seule file

On choisit la plus petite

partition libre pouvant
contenir le prochain
processus

le niveau de
multiprogrammation
augmente au profit de la
fragmentation interne

60
Partitions fixes
Simple, mais...

Inefficacité de l’utilisation de la mémoire: tout

programme, si petit soit-il, doit occuper une partition
entière. Il y a fragmentation interne.

Les partitions à tailles inégales diminuent ces

problèmes mais ils y demeurent...

61
Partitions dynamiques

Partitions en nombre et tailles variables

Chaque processus est alloué exactement la taille de

mémoire requise

Probablement des trous inutilisables se formeront dans

la mémoire: c’est la fragmentation externe

62
 Partitions dynamiques: exemple

(d) Il y a un trou de 64K après avoir chargé 3 processus: pas assez

d’espace pour autre processus
Si P2 se bloquent (p.ex. attente d’un événement), il peut être permuté et
P4=128K peut être chargé.

63
 Partitions dynamiques: exemple

(e-f) P2 est suspendu, P4 est chargé. Un trou de 224-128=96K est créé

(fragmentation externe)
(g-h) P1 se termine, P2 est repris : produisant un autre trou de 320-
224=96K...
Nous avons 3 petits trous et probablement inutiles. 96+96+64=256K de
fragmentation externe
COMPRESSION pour en faire un seul trou de 256K 64
Compression (compaction)
Une solution pour la fragmentation externe

Les programmes sont déplacés en mémoire de façon à

réduire à 1 seul grand trou plusieurs petits trous disponibles

Effectuée quand un programme qui demande d’être exécuté

ne trouve pas une partition assez grande, mais sa taille est
plus petite que la fragmentation externe existante

Inconvenients:
temps de transfert programmes
besoin de rétablir tous les liens entre adresses de différents
programmes

65
 Algorithmes de Placement

pour décider de l’emplacement

du prochain processus
But: réduire le besoin de la
compression (qui prend du
temps...)
Choix possibles:
Best fit: choisir le plus petit trou
(meilleur accès)
First-fit: choisir 1er trou à partir
du début (premier accès)
Next-fit: choisir 1er trou à partir
du dernier placement (prochain
accès)
Worst fit: le plus grand (pire
accès)

66
Allocation non contiguë
Afin de réduire la fragmentation
diviser un programme en morceaux et permettre l`allocation
séparée de chaque morceau
les morceaux sont beaucoup plus petits que le programme
entier et donc permettent une utilisation plus efficace de la
mémoire
les petits trous peuvent être utilisés plus facilement

Deux techniques: la pagination et la segmentation

la segmentation utilise des parties de programme qui ont une
valeur logique (des modules)
la pagination utilise des parties de programme arbitraires
(morcellement du programmes en pages de longueur fixe).
elles peuvent être combinées

67
Les segments sont des parties logiques du
programme

A
JUMP(D, 100) B
Progr.
Princ. LOAD(C,250) Données

C
D
Données Sous- LOAD(B,50)
progr.

4 segments: A, B, C, D
68
Les segments comme unités d’alloc mémoire

0 3

2
3 1

espace usager mémoire physique

Étant donné que les segments sont plus petits que les programmes entiers, cette
technique implique moins de fragmentation (qui est externe dans ce cas)
69
 Mécanisme pour la segmentation
Un tableau contient l’adresse de début de
tous les segments dans un processus

Chaque adresse dans un segment

est ajoutée à l ’adresse de début
du segment par la MMU

1
Adr de 3
segment courant Adr de 2
Adr de 1 2
Adr de 0

Tableau de descripteurs
de segments mémoire physique
70
Détails
L’adresse logique consiste d ’une paire:
 <No de segm, décalage>
 où décalage est l ’adresse dans le segment

Le tableau des segments contient: descripteurs de segments

Adresse (registre) de base
longueur du segment
Infos de protection, …

Dans le PCB (Process Control Block) du processus il y aura un pointeur

à l ’adresse en mémoire du tableau des segments

Il y aura aussi là dedans le nombre de segments dans le processus

Au moment de la commutation de contexte, ces infos seront chargées

dans les registres appropriés d’UC

71
Traduction d`adresses dans la segmentation

erreur!
Aussi, si d > longueur: 72
Le mécanisme en détail (implanté dans le
matériel)

Dans le programme

Adresse finale
73
Partage de segments:
le segment 0 est partagé
P.ex: Programme Word utilisé pour éditer
différents documents

74
Segmentation et protection
Chaque descripteur de segment peut contenir des infos de
protection:
longueur du segment
privilèges de l’usager sur le segment: lecture, écriture, exécution
Si au moment du calcul de l’adresse on trouve que l’usager n’a
pas droit d’accèsinterruption
ces infos peuvent donc varier d ’usager à usager, par rapport au
même segment!

limite base read, write, execute?

Tableau de descripteurs
de segments
75
Évaluation de la segmentation simple
Avantages: l’unité d’allocation de mémoire est
plus petite que le programme entier
une entité logique connue par le programmeur
les segments peuvent changer de place en mémoire
la protection et le partage de segments sont aisés (en principe)

Inconvévients: le problème des partitions dynamiques:

La fragmentation externe n’est pas éliminée:
trous en mémoire, compression?

Une autre solution est d’essayer à simplifier le mécanisme en utilisant

des unités d`allocation mémoire de tailles égales

PAGINATION

76
Segmentation contre pagination

Le pb avec la segmentation est que l’unité d’allocation de

mémoire (le segment) est de longueur variable

La pagination utilise des unités d’allocation de mémoire

fixe, éliminant donc ce problème

77
 Pagination simple
La mémoire est partitionnée en petits morceaux de même
taille: les pages physiques ou ‘cadres’ ou ‘frames’

Chaque processus est aussi partitionné en petits morceaux

de même taille appelés pages (logiques)

Les pages logiques d’un processus peuvent donc être

assignés aux cadres disponibles n’importe où en mémoire
principale

Conséquences:
un processus peut être éparpillé n’importe où dans la mémoire
physique.
la fragmentation externe est éliminée
78
Exemple de chargement de processus

Supposons que le processus B se termine ou est suspendu

79
 Exemple de chargement de processus
Nous pouvons maintenant
transférer en mémoire un progr.
D, qui demande 5 cadres
bien qu`il n’y ait pas 5 cadres
contigus disponibles

La fragmentation externe est

limitée au cas que le nombre de
pages disponibles n’est pas
suffisant pour exécuter un
programme en attente

Seule la dernière page d’un

progr peut souffrir de
fragmentation interne (moy. 1/2
cadre par proc)

80
Tableaux de pages

Les entrées dans le tableau de

pages sont aussi appelées
descripteurs de pages

81
Tableaux de pages

Le SE doit maintenir une table de pages pour chaque processus

Chaque descripteur de pages contient le numéro de cadre où la page

correspondante est physiquement localisée

Une table de pages est indexée par le numéro de la page (logique) afin
d’obtenir le numéro du cadre

Une liste de cadres disponibles est également maintenue

(free frame list)
82
Traduction d’adresses

L’adresse logique est facilement traduite en adresse

physique
car la taille des pages est une puissance de 2
les pages débutent toujours à des adresses qui
sont puissances de 2
qui ont autant de 0s à droite que la longueur de
l’offset
donc ces 0s sont remplacés par l’offset

Ex: si 16 bits sont utilisés pour les adresses et que la

taille d’une page = 1K: on a besoin de 10 bits pour le
décalage, laissant ainsi 6 bits pour le numéro de page

L’adresse logique (n,m) est traduite à l ’adresse physique

(k,m) en utilisant n comme index sur la table des pages
et en le remplaçant par l ’adresse k trouvée
m ne change pas
83
Mécanisme: matériel

84
Traduction d’adresse (logique-
physique) pour la pagination

85
 Trad. d’adresses: segmentation et pagination
Tant dans le cas de la segmentation, que dans le cas
de la pagination, nous ajoutons le décalage à
l’adresse du segment ou page.

Cependant, dans la pagination, l’addition peut être

faite par simple concaténation:

11010000+1010
=
1101 1010

86
 Segmentation simple vs Pagination
simple
La pagination se préoccupe seulement du problème du chargement, tandis
que
La segmentation vise aussi le problème de la liaison
La segmentation est visible au programmeur mais la pagination ne l’est
pas
Le segment est une unité logique de protection et partage, tandis que la
page ne l’est pas
Donc la protection et le partage sont plus aisés dans la segmentation
La segmentation requiert un matériel plus complexe pour la traduction
d’adresses (addition au lieu d`enchaînement)
La segmentation souffre de fragmentation externe (partitions dynamiques)
La pagination produit de fragmentation interne, mais pas beaucoup (1/2
cadre par programme)
Heureusement, la segmentation et la pagination peuvent être combinées

87
Pagination et segmentation combinées
Les programmes sont divisés en segments et les segments
sont paginés

Donc chaque adresse de segment n`est pas une adresse

de mémoire, mais une adresse au tableau de pages du
segment

Les tableaux de segments et de pages peuvent être eux-

mêmes paginés
Méthode inventée pour le système Multics de l’MIT, approx. 1965.

88
 Adressage (sans considérer la pagination des
tableaux de pages et de segments)
s p d’

segment table base register: un

registre de l`UCT

89
Exercice 2-1
(Allocation Contiguë, Partition Dynamique)

On considère la suite de demandes d’allocation (+) et de libération

(-) suivantes dans un espace mémoire de 1000 blocs, en utilisant
l’allocation contiguë avec des partitions dynamiques:

+300, +200, +260, -200, +100, -300, +250, +400, -260, +150,
+120, -100, -120, +200, -150, -250, +100, -400, +600, -100, -200,
-600

Indiquer comment, à partir d’une mémoire libre, l’OS réalise

l’allocation avec les stratégies Best Fit, First Fit.

90
Exercice 2-2
Segmentation

On considère la table des segments suivante:

Segment Base Longueur

0 540 234
1 1234 128
2 54 328
3 2048 1024
4 976 200
Calculer les adresses réelles correspondant aux adresses virtuelles
suivantes:
(0, 128), (1, 99), (1, 100), (2, 465), (3, 888), (4, 100), (4, 344)

91
Exercice 2-3
Pagination
Dans un système paginé, les pages font 256 mots chacune et la
mémoire centrale comprend 4 cadres. On considère la table des pages
suivantes

0 3
Calculer la taille de la mémoire physique
1 0
Donnez le nombre de bits nécessaires pour
2 i
l’adresse du programme (logique)
Calculer les adresses réelles correspondant 3 i
aux adresses virtuelles: 4 2
(0,240), (2,34), (2,35), (6,42), (7,230)
5 i
Trouver l’adresse réelle correspondant à
l’adresse virtuelle 456 6 i
7 1

92
De la pagination et segmentation à la
mémoire virtuelle
Un processus est constitué de morceaux (pages ou segments) ne nécessitant pas
d’occuper une région contiguë de la mémoire principale
Références à la mémoire sont traduites en adresses physiques au moment
d’exécution
Un processus peut être déplacé à différentes régions de la mémoire, aussi
mémoire secondaire!
Donc: tous les morceaux d’un processus ne nécessitent pas d’être en mémoire
principale durant l’exécution
L’exécution peut continuer à condition que la prochaine instruction (ou donnée)
est dans un morceau se trouvant en mémoire principale
La somme des mémoires logiques des procs en exécution peut donc
excéder la mémoire physique disponible
Le concept de base de la mémoire virtuelle
Une image de tout l’espace d’adressage du processus est gardée en mémoire
secondaire (normal. disque) d’où les pages manquantes pourront être prises au
besoin
Mécanisme de va-et-vien ou swapping

93
Mémoire virtuelle:
résultat d’un mécanisme qui combine
la mémoire principale et les mémoires secondaires

94
Nouveau format du tableau des pages
(la même idée pour les tableaux de segments)

bit présent
Adresse de la Bit 1 si en mém. princ.,
page présent 0 si en mém second.

Au début, bit présent = 0 pour toutes les pages

95
Pages en RAM ou sur disque

Page A en RAM et sur

disque

Page E seulement sur

disque

96
Avantages du chargement partiel
Plus de processus peuvent être maintenus en exécution en
mémoire
Car seules quelques pièces sont chargées pour chaque
processus

Plusieurs pages ou segments rarement utilisés n’auront peut être

pas besoin d`être chargés du tout

Il est maintenant possible d’exécuter un ensemble de processus

lorsque leur taille excède celle de la mémoire principale
Il est possible d’utiliser plus de bits pour l’adresse logique que le
nombre de bits requis pour adresser la mémoire principale

97
Mémoire Virtuelle: Pourrait Être Énorme!
Ex: 16 bits sont nécessaires pour adresser une mémoire
centrale de 64KB
En utilisant des pages de 1KB, 10 bits sont requis pour le
décalage
Pour le numéro de page de l’adresse logique nous pouvons
utiliser un nombre de bits qui excède 6 (plus que 2 6 cases
dans la table des pages), car toutes les pages ne doivent pas
obligatoirement être en mémoire simultanément
Donc la limite de la mémoire virtuelle est le nombre de bits
qui peuvent être réservés pour l ’adresse
La mémoire logique est donc appelée mémoire virtuelle
Est maintenue en mémoire secondaire
Les pièces sont amenées en mémoire principale seulement quand
nécessaire, sur demande

98
Exécution d’un Processus
Le SE charge la mémoire principale de quelques pièces
(seulement) du programme (incluant le point de départ)

Chaque entrée de la table de pages (ou segments) possède un

bit présent qui indique si la page ou segment se trouve en
mémoire principale

L’ensemble résident (résident set) est la portion du processus

se trouvant en mémoire principale

Une interruption est générée lorsque l’adresse logique réfère à

une pièce qui n’est pas dans l’ensemble résident
défaut de pagination, page fault

99
Exécution d’une défaut de page: va-et-vient
plus en détail

Mémoire
virtuelle

100
Quand la RAM est pleine mais nous
avons besoin d’une page pas en RAM

101
Remplacement de pages
Quoi faire si un processus demande une nouvelle page et il
n’y a pas de cadres libres en RAM?
choisir une page déjà en mémoire principal,
appartenant au même ou à un autre processus,
qu’il est possible d ’enlever de la mémoire principale
C’est la victime!

102
La page victime...

103
Algorithmes pour la politique de
remplacement
L’algorithme optimal (OPT) choisit pour page à
remplacer celle qui sera référencée le plus
tardivement
produit le + petit nombre de défauts de page
impossible à réaliser (car il faut connaître le futur)

104
Algorithmes pour la politique de
remplacement
Ordre chronologique d’utilisation (LRU)
Least Recently Used
Remplace la page dont la dernière référence remonte au
temps le plus lointain (le passé utilisé pour prédire le futur)

105
Comparaison OPT-LRU
Exemple: Un processus de 5 pages s’il n’y a que 3 pages
physiques disponibles.
Dans cet exemple, OPT occasionne 3+3 défauts, LRU 3+4.

106
Premier arrivé, premier sorti (FIFO)
Logique: une page qui a été longtemps en mémoire a eu sa chance
d ’exécuter

Lorsque la mémoire est pleine, la plus vieille page est remplacée.

Donc: “first-in, first-out”

Simple à mettre en application

Mais: Une page fréquemment utilisée est souvent la plus vielle, elle
sera remplacée par FIFO!

107
Comparaison de FIFO avec LRU

Contrairement à FIFO, LRU reconnaît que les pages 2 and 5 sont utilisées
fréquemment
Dans ce cas, la performance de FIFO est moins bonne:
LRU = 3+4, FIFO = 3+6

108
Implantation de FIFO
Facilement implantable en utilisant une queue de cadres de
mémoire
Qui ne doit être mis à jour que à chaque défaut de page
Exercice: concevoir l’implantation de ce tampon (v. exemple précédent)

2 3 1 5 2 4 3 5 2
2 3 1 5 2 4 3 5
2 3 1 5 2 4 3

109
L’algorithme de l’horloge (deuxième
chance)

Semblable à FIFO, mais il tient compte de l’utilisation récente de

pages
Structure à liste circulaire
Les cadres qui viennent d’être utilisés (bit=1) ne sont pas remplacées
(deuxième chance)
Les cadres forment conceptuellement un tampon circulaire
Lorsqu’une page est chargée dans un cadre, un pointeur pointe sur le
prochain cadre du tampon
Pour chaque cadre du tampon, un bit “utilisé” est mis à 1 (par le
matériel) lorsque:
une page est nouvellement chargée dans ce cadre
sa page (celle de ce cadre) est utilisée
Le prochain cadre du tampon à être remplacé sera le premier
rencontré qui aura son bit “utilisé” = 0.
Durant cette recherche, tout bit “utilisé” = 1 rencontré sera mis à 0

110
Algorithme de l’horloge: un exemple

La page 727 est chargée dans le cadre 4.

La proch. victime est 5, puis 8. 111
Comparaison: Horloge, FIFO et LRU

Astérisque indique que le bit utilisé est 1

L’horloge protège du remplacement les pages fréquemment
utilisées en mettant à 1 le bit “utilisé” à chaque référence
LRU = 3+4, FIFO = 3+6, Horloge = 3+5

112
Détail sur le fonctionnement de l’horloge

Tous les bits étaient à 1. Nous avons fait tout

le tour et donc nous avons changé le bit de
toutes les pages à 0. Donc la 1ère page est
réutilisée
113
Systeme de gestion des fichiers

114
Chapitre 4.
Gestion de Processus

115
Processus et terminologie
Programme
Description des actions à entreprendre pour aboutir au résultat recherché

Processeur
Entité matérielle capable d’exécuter des instructions

Processus
un programme en exécution (entité dynamique correspondant à l’exécution
des instructions)
Possède des ressources de mémoire, périphériques, etc

Possède ses propres données

Exemple de tanenbaum
Préparation gâteaux, piqûre d’abeille, des invités (un nouveau gâteau)
116
Processeur Virtuel
Plusieurs processus peuvent exécuter le même programme
Chacun possède ses propres variables

L’indépendance entre les processus introduit la notion du

processeur virtuel

Chaque processus possède son propre processeur virtuel qui exécute

les instructions du programme uniquement pour son compte

En réalité, le système attribue alternativement le processeur réel

entre les différents processus

Chaque processus avance au rythme du processeur virtuel

Temps virtuel: le temps d’utilisation du processeur virtuel
Correspond à la fraction du temps réel pendant laquelle le
processeur réel est attribué au processus
117
Création de processus
Création statique
Certains systèmes créent, à l’initialisation, un nombre fixe de processus
banalisés qui seront utilisés selon la demande
Inconvénient: occupation de la place en mémoire lorsqu’ils ne sont pas
utilisés

Création dynamique
Création dynamique et destruction des processus
L’opération de création doit permettre d’initialiser l’état du nouveau
processus
Définir le programme (la suite d’instructions)
L’état initial de son contexte (variables, données, registres mémoire …)

Id = créer_processus(programme, contexte)
Où id est l’identificateur du nouveau processus

118
Arbre de processus en UNIX
Le système Unix structure les processus en arbre

119
Exemple de Unix
Dans le système Unix, la création dynamique est simple
Créer un processus qui est une exacte copie de celui qui demande
la création
Aucun paramètre n’est donc nécessaire
id est l’identificateur du
id = fork(); nouveau processus

La seule distinction entre le processus créateur (père) et le

processus créé (fils) réside dans la valeur retournée
Id == -1 : création échouée
Id == 0 : le processus fils
Id != 0 : l’identité du processus fils

Après l’appel de la fonction fork(), les deux processus

repartent avec le même programme
120
Exemple de Unix
Si le processus père se termine avant le processus fils, le
fils est rattaché au processus racine

Le processus père peut attendre la terminaison d’un de ses

fils par la fonction du langage c:

id_fils = wait(&status);

id_fils : identificateur du fils terminé

La fonction wait met dans status la façon dont ce processus
s’est terminée
S’il y a encore de fils actifs, le processus père se met en attente
s’il y en a plus, la fonction retourne -1

121
Exemple de création de processus
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
#include <stdio.h>

int main(void)
{
pid_t pid = fork();
int raison;

switch (pid) {

case -1 : printf("Erreur de création du processus"); exit(1);

case 0 : /* on est chez le fils */

printf("Pid du fils = %d\n", getpid());
sleep(20); //attente de 20 secondes
break;

default : /* on est chez le père */

printf("Pid du père = %d\n", getpid());
printf("Attente de la terminaison du fils...\n");
pid = wait(&raison);

} /* switch */
return (0);} 122
Notion de ressources
On appelle ressource toute entité dont a besoin un
processus pour s’exécuter (CPU, mémoire, périphériques…)

Une ressource peut être caractérisée par le nombre de

processus qui peuvent l’utiliser au même moment

Un nombre quelconque de processus. Il n’y a pas de contrôle à

mettre en œuvre. Exemple: l’horloge

Plusieurs processus, mais en nombre limité.

Un seul processus peut l’utiliser à un moment donné

Ressource critique (comme le CPU)

123
État de processus
Au fur et à mesure qu’un processus exécute, il change d’état
Nouveau:
le processus vient d ’être créé

Exécutant - running:
le processus est en train d ’être exécuté par le processeur

Attente - waiting:
le processus est en train d ’attendre un événement (p.ex. la fin
d ’une opération d ’E/S)

Prêt - ready:
le processus est en attente d’être exécuté par l ’UC

Terminé :
fin d ’exécution
124
Diagramme de transition d’états d’un
processus

Ordonnanceur = scheduler en anglais 125

États Nouveau, Terminé:
Nouveau
Le SE a créé le processus
a construit un identificateur pour le processus
a construit les tableaux pour gérer le processus
mais ne s’est pas encore engagé à exécuter le processus (pas encore
admis)
pas encore alloué des ressources
La file des nouveaux travaux est souvent appelée spoule travaux
(job spooler)

Terminé:
Le processus n ’est plus exécutable, mais ses données sont encore
requises par le SE (comptabilité, etc.)

126
Transitions entre processus
Prêt  Exécution
Lorsque l ’ordonnanceur UC choisit un processus pour
exécution

Exécution  Prêt
Résultat d’une interruption causée par un événement
indépendant du processus
Il faut traiter cette interruption, donc le processus courant
perd l’UC
Cas important: le processus a épuisé son intervalle de
temps (minuterie)

127
Transitions entre processus
Exécution  Attente
Lorsqu’un processus fait un appel de système (interruption
causée par le processus lui-même)
initie une E/S: doit attendre le résultat
a besoin de la réponse d’un autre processus

Attente  Prêt
lorsque l'événement attendu se produit

128
Sauvegarde d’informations processus
En multiprogrammation, un processus exécute sur l ’UC de façon
irrégulière

Chaque fois qu’un processus reprend l ’UC (transition prêt  exécution)

il doit la reprendre dans la même situation où il l’a laissée (même
contenu de registres UC, etc.)

Donc au moment où un processus sort de l’état exécution il est

nécessaire de sauvegarder ses informations essentielles, qu’il faudra
récupérer quand il retourne à cet état

Process Control Block

129
PCB = Process Control Block:

Représente la situation actuelle d ’un

processus, pour le reprendre plus tard

Registres du CPU

130
Process Control Block (PCB)
pointeur: les PCBs sont rangés dans des listes enchaînées

état de processus: ready, running, waiting…

numéro de processus: son identificateur

compteur programme: le processus doit reprendre à l ’instruction suivante

autres registres UC

bornes de mémoire

fichiers qu’il a ouvert

Etc.

131
Commutation de processeur

Aussi appelé commutation de contexte ou context

switching

Quand le processeur passe de l’exécution d ’un processus 0

à l ’exécution d`un proc 1, il faut

mettre à jour et sauvegarder le PCB de 0

reprendre le PCB de 1, qui avait été sauvegardé avant
remettre les registres du processeur tels que le compteur
d ’instructions etc. dans la même situation qui est décrite
dans le PCB de 1

132
Commutation de processeur (context
switching)

Il se peut que beaucoup de temps passe avant le retour au

processus 0, et que beaucoup d’autres proc soient exécutés
entre temps 133
Rôle du matériel et du logiciel dans le
traitement d’interruptions
MATÉRIEL LOGICIEL
Infos mises à jour et
sauvegardées dans PCB
Signal d’interruption généré

Le code de traitement de
processeur termine l’instruction l’interruption est exécuté
courante et détecte interruption

L’ordonnanceur choisit un
Registres du CPU sont processus dans la file prêt
sauvegardés dans une pile

Les infos relatives à ce processus

sont rétablies à partir de son PCB

Les registres du CPU sont rechargés dispatcher

avec ce qu’on avait sauvegardé
dans PCB pour ce processus,
qui reprend l’exécution
134
Concepts de base
La multiprogrammation vise à obtenir une
utilisation optimale des ressources, surtout le CPU
et aussi à un bon temps de réponse pour l’usager

L’ordonnanceur du processeur est la partie du SE qui

décide quel processus dans la file ready/prêt obtient le CPU
quand elle devient libre

Le processeur est la ressource la plus précieuse dans un

ordinateur, donc nous parlons d’elle
Cependant, les principes que nous verrons s ’appliquent aussi à
l ’ordonnancement des autres ressources (unités E/S, etc).

135
Les cycles d’un processus

Cycles (bursts) de CPU et E/S: l’exécution d’un processus consiste de

séquences d’exécution sur le processeur et d’attentes E/S
136
Histogramme de durée des cycles CPU

Observation expérimentale:
dans un système typique, nous observerons un grand nombre de
court cycles, et un petit nombre de long cycles
137
Ordonnanceur CPU
Choisit parmi les processus prêts en mémoire,
et alloue la CPU à l’un d’eux

Les décisions d’ordonnancement de la CPU sont pris lors:

1. Du changement d’état “exécution” à “en attente”
2. Du changement d’état de “exécution” à “prêt”
3. Du changement d’état de “en attente” à “prêt”
4. De la terminaison d’un processus
• en conclusion, tout événement dans un système cause une
interruption du processeur et l’intervention de l’ordonnanceur, qui
devra prendre une décision concernant quel proc aura le processeur
après

Préemption: on a préemption si on enlève le processeur à un processus

qui l’avait et ne l’a pas laissée de propre initiative
L’ordonnancement dans les cas 1 et 4 est non préemptif
Pour les autres cas, c’est préemptif

138
Dispatcheur
Le dispatcheur donne le contrôle de la CPU au processus
choisi par l’ordonnanceur à court terme; ceci comprend:
Commutation de contexte
Passer en mode utilisateur
Sauter au bon endroit dans le programme pour le relancer

Latence de dispatcheur (dispatcher latency)

temps pris par le dispatcheur pour stopper un processus et
(re)lancer un autre
il est souvent négligé, il faut supposer qu’il soit petit par rapport à
la longueur d’un cycle

139
Critères d’ordonnancement
Il y aura normalement plusieurs processus dans la file prêt

Quand le processeur devient disponible, lequel choisir?

Critères généraux:
Bonne utilisation du CPU
Réponse rapide à l’usager

Mais ces critères peuvent être jugés différemment...

140
Critères d’Ordonnancement

Utilisation de la CPU
utiliser la CPU le maximum possible

Débit (Throughput)
nombre de processus qui terminent leur exécution par unité de temps

Temps de rotation (Turnaround time)

le temps depuis l’arrivée du processus jusqu’à sa terminaison (les
attentes incluses)

Temps d’attente
temps d’un processus dans la file d’attente des processus prêts

Temps de réponse
temps mis entre une requête émise et la première réponse, pas la sortie
(pour les environnements à temps partagé)

141
Critères d’ordonnancement:
maximiser/minimiser
Utilisation de la CPU: pourcentage d’utilisation
ceci est à maximiser

Débit = Throughput: nombre de processus qui complètent dans l ’unité de

temps
ceci est à maximiser

Temps de rotation (turnaround): temps terminaison moins temps arrivée

à minimiser

Temps d’attente: attente dans la file prêt

à minimiser

Temps de réponse (pour les systèmes interactifs): le temps entre une

demande et la réponse
à minimiser

142
Ordonnancement First-Come, First-Served (FCFS)

Processus Tps CPU

P1 24
P2 3
P3 3
Supposons que les processus arrivent dans l’ordre suivant: P1 , P2 ,
P3 Le diagramme de Gantt correspondant est:

P1 P2 P3
Temps d‘attente de P1 = 0; P2 = 24; P3 = 27
Temps d’attente moyen: (0 + 24 + 27)/3 = 17
0 24 27 30

143
Premier arrivé, premier servi
Utilisation UCT = 100%

Débit = 3/30 = 0,1

3 processus complétés en 30 unités de temps

Temps de rotation moyen: (24+27+30)/3 = 27

P1 P2 P3

0 24 27 30

144
Tenir compte du temps d’arrivée!
Dans le cas où les processus arrivent à moment différents, il faut
soustraire les temps d’arrivée
Exercice: répéter les calculs si:
P1 arrive à temps 0 et dure 24
P2 arrive à temps 2 et dure 3
P3 arrive à temps 5 et dure 3

Donc P1 attend 0 comme avant

Mais P2 attend 24-2, etc.

P1 P2 P3

0 24 27 30
arrivée P2
145
Premier arrivé, premier servi
Si les mêmes processus arrivent à 0 mais dans l’ordre
P2 , P3 , P1 .
Le diagramme de Gantt est:

P2 P3 P1

0 3 6 30

Temps d’attente pour P1 = 6 P2 = 0 P3 = 3

Temps moyen d’attente: (6 + 0 + 3)/3 = 3
Temps de rotation moyen: (3+6+30)/3 = 13
Beaucoup mieux!
Donc pour cette technique, les temps peuvent varier grandement par
rapport à l’ordre d’arrivée de différent processus
Exercice: calculer aussi le débit, etc.

146
Ordonnancement Shortest-Job-First (SJF)
Plus court d’abord

Associer à chaque processus son prochain temps d’utilisation du CPU.

Utiliser ces temps pour associer le CPU au processus avec le temps le plus
petit

Deux schémas:
Non préemptif – dès que le CPU est donné à un processus, ce dernier ne
peut être interrompu avant la fin de son temps CPU

préemptif – si un nouveau processus débarque avec un temps CPU plus

petit que le reste du temps CPU du processus courant, on commute vers le
nouveau processus.
Ce schéma est connu sous le nom de Shortest-Remaining-Time-First
(SRTF)

SJF est optimal – donne un temps moyen minimal pour un ensemble

de processus donnés
147
Exemple de SJF Non-Préemptif
Processus Tps d’Arrivée Tps CPU
P1 0.0 7
P2 2.0 4
P3 4.0 1
P4 5.0 4
SJF (non préemptif)

P1 P3 P2 P4

0 3 7 8 12 16

Temps moyen d’attente = (0 + 6 + 3 + 7)/4 - 4

148
Exemple de SJF Préemptif
Processus Tps d’Arrivée Tps CPU
P1 0.0 7
P2 2.0 4
P3 4.0 1
P4 5.0 4
SJF (préemptif)

P1 P2 P3 P2 P4 P1

0 2 4 5 7 11 16

Temps d’Attente Moyen = (9 + 1 + 0 +2)/4 - 3

149
Ordonnancement avec Priorité
Une priorité (nombre entier) est associée à chaque processus

Le CPU est alloué au processus à la priorité la plus grande (le plus petit
entier  la plus grande priorité)
avec ou sans préemption
il y a une file prêt pour chaque priorité

SJF est un ordonnancement à priorité où la priorité correspond au

temps CPU suivant

Problème  Famine – processus à faible priorité peuvent ne jamais

s’exécuter
Solution  Vieillissement – avec le temps, incrémenter la priorité des
processus en attente

150
Tourniquet/Round Robin (RR)
Chaque processus se voit alloué le CPU pour un temps limité
(quantum), en général 10-100 milliseconds.

A la fin de ce temps, le processus est arrêté et ajouté à la fin de la file

d’attente des processus prêts.
Méthode préemptive

Si n processus sont dans la file d’attente des processus prêts et le

quantum est q, alors chaque processus reçoit 1/n du temps CPU en
parties de q unités.
Aucun processus attend plus de (n-1)q.

Performance
q large  FIFO
q petit  q doit être large comparé au temps de commutation de tâche,
sinon l’overhead est trop grand
151
 Exemple de RR avec Q = 20

Processus Temps CPU

P1 53
P2 17
P3 68
P4 24
Le diagramme de Gantt est:

P1 P2 P3 P4 P1 P3 P4 P1 P3 P3

0 20 37 57 77 97 117 121 134 154 162

temps de rotation et temps d’attente moyens beaucoup plus élevés que

SJF
mais aucun processus n’est favorisé
152
Une petite tranche augmente les
commutations de contexte (temps de SE)

153
Temps de Rotation Varie avec le Quantum

Exemple qui montre que le temps de rotation moyen ne s’améliore

pas nécessairement en augmentant la tranche (sans considérer les temps de
commutation contexte)
154
File Multiniveaux
La file d’attente est partagée en files séparées:
premier plan/foreground (interactif)
arrière plan/background (batch)

Chaque file a sa propre politique d’ordonnancement

foreground – RR
background – FCFS

Un ordonnancement inter-files doit exister

Ordonnancement à priorité fixe; (i.e., servir tous les processus de la file
foreground puis ceux de la file background).
Possibilité de famine.
Time slice – chaque file obtient une partie du temps CPU qu’elle utilise
pour ordonnancer ces processus en attente; i.e., 80% pour la file
foreground en RR et 20% pour la file background en FCFS

155
Ordonnancement à Files Multiniveaux

156
Ordonnancement avec Files Multiniveaux à
Retour
Un processus peut passer d ’une file à l ’autre, p.ex. quand
il a passé trop de temps dans une file

Un Ordonnanceur de files multiniveaux à retour est défini

suivant les paramètres suivants:
Nombre de files
Politique d’ordonnancement pour chaque file
Méthode déterminant la promotion d’un processus vers une file
d’attente plus prioritaire
Méthode déterminant le passage d’un processus dans une file
moins prioritaire
Méthode déterminant dans quelle file placer un nouveau service

157
Exemple de File Multiniveaux à Retour
Trois files:
Q0 – quantum de 8 millisecondes
Q1 – quantum de 16 millisecondes
Q2 – FCFS

Ordonnancement
Un nouveau processus est placé dans Q0 au début; à sa première
exécution, il reçoit 8 millisecondes. S’il ne termine pas son
exécution, il est replacé dans Q1.
Si un processus de la file Q1 est servi (16 msec) et ne se termine
pas, il est replacé dans Q2.

158
Files avec Multiniveaux à Retour

PRIO = 0
la + élevée

PRIO = 1

PRIO = 2

159
Synchronisation de Processus

160
Problèmes avec concurrence =
parallélisme
Les processus concurrents doivent parfois partager
données (fichiers ou mémoire commune) et ressources
On parle donc de tâches coopératives

Si l’accès n’est pas contrôlé, le résultat de l’exécution du

programme pourra dépendre de l’ordre d’entrelacement de
l’exécution des instructions (non-déterminisme).

Un programme pourra donner des résultats différents et

parfois indésirables de fois en fois

161
Un exemple

Deux processus exécutent M. X demande une

cette même procédure et réservation
partagent la même base de d’avion
données
Base de données
Ils peuvent être interrompus dit que fauteuil
n’importe où A est disponible

Fauteuil A est
Le résultat de l ’exécution
assigné à X et
concurrente de P1 et P2
marqué occupé
dépend de l`ordre de leur
entrelacement

162
Vue globale d’une exécution possible
P1 P2
Interruption
M. Leblanc demande une ou retard
réservation d’avion
M. Guy demande une
réservation d’avion

Base de données dit

que fauteuil 30A est
disponible Base de données dit
que fauteuil 30A est
disponible

Fauteuil 30A est Fauteuil 30A est

assigné à Leblanc et assigné à Guy et
marqué occupé marqué occupé

163
2ème exemple
processus P1 processus P2

static char a; static char a;

void echo() void echo()

{ {
cin >> a;
cin >> a;
cout << a;
}
cout << a;
}

 Si la var a est partagée, le premier a est effacé 164

Section Critique

Partie d’un programme dont l’exécution de doit pas

entrelacer avec autres programmes

Une fois qu’un tâche y entre, il faut lui permettre de terminer cette
section sans permettre à autres tâches de jouer sur les mêmes
données

La section critique doit être verrouillée

165
Le problème de la section critique
Lorsqu’un processus manipule une donnée (ou ressource)
partagée, nous disons qu’il se trouve dans une section critique
(SC) (associée à cette donnée)

Le problème de la section critique est de trouver un algorithme

d`exclusion mutuelle de processus dans l`exécution de leur SCs
afin que le résultat de leurs actions ne dépendent pas de l’ordre
d’entrelacement de leur exécution (avec un ou plusieurs
processeurs)

L’exécution des sections critiques doit être mutuellement

exclusive: à tout instant, un seul processus peut exécuter une
SC pour une var donnée (même lorsqu’il y a plusieurs
processeurs)

Ceci peut être obtenu en plaçant des instructions spéciales dans

les sections d`entrée et sortie
166
Structure du programme
Chaque processus doit donc demander une
permission avant d’entrer dans une section critique
(SC)

La section de code qui effectue cette requête est la section

d’entrée
La section critique est normalement suivie d’une section de
sortie
Le code qui reste est la section restante (SR): non-critique
repeat
section d’entrée
section critique
section de sortie
section restante
forever 167
Application

M. X demande une
réservation d’avion

Section d’entrée

Base de données dit que

fauteuil A est disponible
Section
critique
Fauteuil A est assigné à X et
marqué occupé

Section de sortie

168
Critères nécessaires pour solutions valides
Exclusion Mutuelle
À tout instant, au plus un processus peut être dans une section
critique (SC) pour une variable donnée

Non interférence:
Si un processus s’arrête dans sa section restante, ceci ne devrait
pas affecter les autres processus

Mais on fait l ’hypothèse qu’un processus qui entre dans une

section critique, en sortira.
Absence d’interblocage

Les méthodes que nous verrons utilisent des instructions

implantées par des appels au SE (system calls)

169
Sémaphores

Un sémaphore S est un entier qui, sauf pour l'Initialisation,

est accessible seulement par ces 2 opérations atomiques et
mutuellement exclusives:
wait(S)
signal(S)

Il est partagé entre tous les processus qui

s’intéressent à la même section critique

170
Sémaphores occupés à attendre (busy
waiting)
S est un entier initialisé à une wait(S):
valeur positive, de façon que while S==0 ;
un premier processus puisse S--;
entrer dans la SC
Attend si nombre de processus
Quand S>0, jusqu’à n qui peuvent entrer = 0
processus peuvent entrer

S ne peut pas être négatif signal(S):

S++;

Augmente de 1 le no des processus

qui peuvent entrer
171
Initialisation d’un sémaphore S à >=1

processus T1: processus T2:

repeat repeat
wait(S); wait(S);
SC SC
signal(S); signal(S);
SR SR
forever forever

Semaphores: vue globale

Peut être facilement généralisé à plus. processus

172
Utilisation des sémaphores pour sections
critiques

Pour n processus
processus Ti:
Initialiser S à 1 repeat
Alors 1 seul processus peut wait(S);
être dans sa SC SC
signal(S);
Pour permettre à k SR
processus d’exécuter SC, forever
initialiser S à k

173
Utilisation des sémaphores pour
synchronisation de processus
On a 2 processus : T1 et T2
Énoncé S1 dans T1 doit être
exécuté avant énoncé S2 dans T2
Définissons un sémaphore S
Initialiser S à 0
Synchronisation correcte
lorsque T1 contient:
 S1;
 signal(S);

et que T2 contient:
 wait(S);
 S2;

174
Interblocage et famine avec les
sémaphores
Famine: un processus peut n’arriver jamais à
exécuter car il ne teste jamais le sémaphore au bon
moment
Interblocage: Supposons S et Q initialisés à 1

T0 T1
wait(S)
wait(Q)

wait(Q) wait(S)
175
Le problème des philosophes mangeant
5 philosophes qui mangent
et pensent
Pour manger il faut 2
fourchettes, droite et
gauche
On en a seulement 5!
Un problème classique de
synchronisation

176
Le problème des philosophes mangeant
Un processus par philosophe
Un sémaphore par int sem[5]={1,1,1,1,1}
fourchette:
sem: tableau de 5 Philosophe(int i){
semaphores
while(true){
Initialisation: sem[i] =1 for
i:=0..4 penser();
wait(sem[i]);
Première tentative:
wait(sem[i+1 mod 5]);
interblocage si chacun
débute en prenant sa manger;
fourchette gauche! signal(sem[i+1 mod 5]);
wait(sem[i]) signal(sem[i]);
}
}

177
Le problème des philosophes mangeant
Une solution: admettre
seulement 4 philosophes à la int sem[5]={1,1,1,1,1}
fois qui peuvent tenter de int T =4;
manger
Il y aura touj. au moins 1 philosophe(int i){
philosophe qui pourra while(true){
manger penser();
même si tous prennent 1
fourchette
wait(T);
wait(sem[i]);
Ajout d’un sémaphore T qui
limite à 4 le nombre de
wait(sem[i+1 mod 5]);
philosophes “assis à la table” manger;
initial. de T à 4 signal(sem[i+1 mod 5]);
N’empêche pas famine!
signal(sem[i]);
signal(T);
}
} 178
Le problème des lecteurs et rédacteurs
Plusieurs processus qui essaient d’écrire et lire à/sur une
base de données

On peut avoir autant de processus que l’on veut qui lisent

de la base de données simultanément

Seulement un seul processus peut accéder la base de

données si il écrit

179
Le problème des lecteurs et rédacteurs
Difficultés:
Une exclusion mutuelle simple ne marche pas parce que
nous voulons plusieurs lecteurs dans la base de données
en même temps.
On ne peut pas utiliser un sémaphore binaire sur la
base de données
Un sémaphore qui compte simplement nous rend la
tâche difficile pour empêcher un rédacteur d’entrer
pendant les lectures

180
Une solution
Variable rc: nombre de threads lisant la base de données

Sémaphore mutex: protège la SC où rc est mis à jour

Sémaphore db: exclusion mutuelle entre rédacteurs et lecteurs

Les rédacteurs doivent attendre sur db

les uns pour les autres
et aussi la fin de toutes les lectures

Les lecteurs doivent

attendre sur db quand il y a des rédacteurs qui écrivent
bloquer les rédacteurs sur db quand il y a des lecteurs qui lisent
redémarrer les rédacteurs quand personne ne lit

181
Le problème des lecteurs et rédacteurs
Solution:

wait

wait
signal

wait

wait signal
signal
signal

182
Le problème des lecteurs et rédacteurs
Deux choses sont intéressantes avec cette solution:

Le lecteur fait wait() seulement une fois sur le sémaphore

binaire,
Le premier lecteur le fait
Ceci permet au lecteurs multiples d’entrer dans la base de
données simultanément

Parce que signal() sur le sémaphore db est protégé en dedans

du mutex, les lecteurs qui essaient d’entrer dans la base de
données après le premier vont être bloqués sur le mutex, pas sur
le db

183
Exercice 1
Soit 5 processus P1, P2, P3, P4 et P5 dont la durée respective est de
10, 6, 2, 4 et 8 secondes.
1/ Si elles arrivent en même temps, et que Les priorités sont de 3, 5,
2, 1 et 4 pour P1, P2, P3, P4 et P5 respectivement. Si on applique les
séparément les algorithmes FIFO, SJF (préemptif et non préemptif), et
Round Robin avec un quantum de 4 secondes, déterminer :
l’ordre d’exécution des processus
Le temps moyen de rotation
le temps moyen d’attente.
2/ si les processus n’arrivent pas en même temps. Les dates d’arrivée
sont 0, 2, 3, 5, 5.001 pour P1, P2 , P3, P4 et P5 respectivement. En
utilisant l’algorithme du tourniquet, tracer le schéma d’exécution des
processus en déterminant le temps d’attente de chacun des processus
ainsi que le temps de réponse moyen. Les priorités sont de 3, 5, 2, 1
et 4 pour P1, P2, P3, P4 et P5 respectivement. Le quantum étant de 2
secondes.
184
Exercice 2
Qu’affiche le programme suivant?
int main(void)
{
int raison;
pid_t pid;
printf(“\n A“);
pid = fork();

switch (pid) {

case -1 : printf("Erreur de création du processus"); exit(1);

case 0 : /* on est chez le fils */

printf(“B“);
switch (fork()){
case 0: printf(“C“); break;
default: wait (&raison); printf(“D“);
}
break;
default : /* on est chez le père */
pid = wait(&raison);
printf(“\n E");
} /* switch */
fork(); printf("byebye");} 185