Parallélisme 1 - p
publicité
1 Contenu et objectifs
Licence
Parallélisme 1
3ème
année
—
P-F. Bonnefoi
Version du 31 décembre 2015
Table des matières
1
2
3
4
5
6
7
Contenu et objectifs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
Rappels d’architecture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
Qu’est-ce qu’un ordinateur ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
Architecture d’un ordinateur : plus de détails
Le processeur
Du problème à sa résolution
La segmentation : les différentes parties d’un processus . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
La pile : utilisation au travers d’appels de fonction
La pile : appel de fonction et passage de paramètres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
La multiprogrammation
Les interruptions
Horloge & interruption
Notion de programme et de processus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
Processus et démarrage système
Commutation de contexte
Présentation de la programmation «asynchrone» . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
La programmation asynchrone : le «producteur/consommateur»
Cours «Parallélisme I» – P-F. Bonnefoi – http://p-fb.net/
Volume horaire :
⋆ Cours : 9h, soient 6 séances ;
⋆ TD : 6h, soient 4 séances ;
⋆ TP : 15h, soient 10 séances.
Objectifs :
□ Rappels sur les processeurs/instructions/pile, tas & fonction ;
□ Parallélisme et multi programmation ;
□ Interruptions, Unix : mode noyau/utilisateur ;
□ Processus et commutation de contexte ;
□ Utilisation des IPC, « Inter-Process Communication » (Signaux, ou signals, Tubes, ou pipes ;
⋄ Mémoire partagée, ou Shared Memory.
□ Notion de Threads & programmation des Threads Posix ;
□ Parallélisme théorique :
⋄ notions de ressources et de blocage ;
⋄ Section critique/Exclusion mutuelle ;
⋄ Problème d’équité et de famine ;
⋄ Sémaphores
□ Programmation asynchrone : comparaison et utilisation avec Node.js.
Évaluation
▷ Examen écrit ;
▷ Réalisation d’un projet.
2 Rappels d’architecture
Plan
□ Architecture d’un processeur :
⋄ les différents composants ;
⋄ les multi-cores ;
⋄ l’hyperthreading ;
⋄ l’exécution d’un programme ;
□ Le processus
⋄ segmentation/exécution ;
⋄ Contexte ;
□ Le parallélisme
⋄ interruptions/horloge ;
⋄ Appel Systèmes et IPCs ;
—
31 décembre 2015 — 1
– les périphériques avec lesquels dialogue le processeur au travers des unités d’échange
(ou contrôleurs). On distingue en général :
– les périphériques d’entrée tels que le clavier ou la souris;
– les périphériques de sortie tels que les imprimantes et les écrans de visualisation;
– les périphériques d’entrée et de sortie tels que les disques magnétiques ou les
modems pour accéder aux réseaux de communication.
Réseau
d' échange
Mémoire
centrale
Unité d’échange
⋆ un processeur central ou CPU, «Central Processing Unit» qui réalise le traitement des informations logées en mémoire
Figure 1.1
Structure matérielle générale.
centrale :
Globalement le processeur permet l’exécution d’un programme. Chaque proces⋄ langage
le processeur
permet (les
l’exécution
programme
seur dispose d’un
de programmation
instructionsd’un
machine)
spécifique.;
Ainsi résoudre⋄un chaque
problèmeprocesseur
avec un processeur
consiste
exprimer de
ce problème
dispose
d’unàlangage
programmation composé d’instructions machine spécifiques ;
comme une suite de ses instructions machine. La solution à un problème est donc
⋄ résoudre un problème : exprimer ce problème en une suite d’instructions machines ;
spécifique de chaque processeur. Le programme machine et les données qui sont
solutionmachine
à ce problème
à chaque processeur ;
manipulées par⋄les la
instructions
sont placés est
dansspécifique
la mémoire centrale.
Examinons ⋄
à présent
plus en détail machine
la composition
et les
fonctionsmanipulées
de chacun despar ces instructions machine sont placés dans la mémoire centrale.
le programme
et les
données
⋆ des unités de contrôle de périphériques et des périphériques :
modules composant le processeur.
1.2.2 La mémoire
centrale
⋄ périphériques
d’entrée : clavier, souris, etc ;
La mémoire centrale
assure la fonction
stockage
de l’information
qui peut
⋄ périphériques
de de
sortie
: écran,
imprimante,
etc ;être
manipulée par⋄le microprocesseur
central),: disques
c’est-à-dire
le programme
périphérique (processeur
d’entrée/sortie
durs,
carte réseau, etc.
⋆ un bus de communication entre ces différents composants.
Computer Architecture Basics
is détails
a Computer anyway?
Architecture d’un ordinateurWhat
: plus de
∘
Unit» ;
I No separation of code and data in memory
⋄ d’une « unité
de contrôle » : contrôle du bus servant à échanger
données etIinstructions
;
Revolutionary
back in 1945
la mémoire n’est
pas d’accès uniforme, c-à-d que la vitesse d’accès
I A bit outdated by now
n’est pas toujours la même :
⋄ les registres : cases mémoires intégrées au processeur ;
Computer
Systems
⋄ le cacheModern
: zone mémoire
tampon entre
la mémoire centrale et le
processeurI: Control & Computation merged into CPU
⋆ permet d’éviter
l’accès
à la mémoire
centrale pour des données
(Central
Processing
Unit)
déjà accédées et mémorisées dans le cache ;
I Element communicate through a bus
⋆ évite d’utiliser le bus de données ;
Datadetransfer
⋄ le disque : permet
« simulerfacility
» de la mémoire.
I
Memory is not uniform
CPU
cache
CPU - Memory BUS
Bus
adapter
Cache
Network
Main
memory
North
Bridge
Screen
Disk
CPU
I/O BUS
1 • Structure générale
et fonctionnement d’un ordinateur
10
South
controllers Bridge
I/O Controllers
d’adresses a une largeur de m bits, le bus de données une largeur de p bits ce qui
Screen
Network
détermine la capacité de stockage en bits
de cetteDisk
mémoire,
soit 2m mots de p bits. Le
2 THE SYSTEM UNIT: PROCESSING AND MEMORY
bus de commandes permet de déterminerCHAPTER
le type
d’opération (lecture ou écriture) 73
que l’on souhaite réaliser.
CONTROL UNIT
Is in charge of the entire process, making sure
everything happens at the right time. It instructs
Bus d’adresses
the ALU, FPU, and registers what to do, based on
instructions from the decode unit.
m
Adresse
Martin Quinson
ARITHMETIC/LOGIC UNIT AND
FLOATING POINT UNIT
Performs the arithmetic
and
Lecture
logical operations, as directed
by the control unit.
Mémoire
ALU/FPU
2m mots de p bits
CONTROL
UNIT
Données
Figure 1.7
∘ «Prefetch Unit» : charger les données et instruc-
Mots
nombre à virgule flottante ;
(12/355)
tions en amont de leur traitement
pour accélerer
du processeur ;
«Decode Unit» : analyse les instructions pour le
processeur.
et données
le travail
Unités de stockage : Bit, Octet, Mot.
PREFETCH
UNIT
Adressage :
DECODE
UNIT
Mot
DECODE UNIT
Takes instructions from the
Temps
d’accès.
prefetch
unit and translates
them into a form that the
control unit can understand.
REGISTERS
HoldBus
the results
of
de commandes
processing.
BUS
INTERFACE
UNIT
∘
Technologies.
INTERNAL CACHE
MEMORY
Coûts.
p bits
INTERNAL CACHE MEMORY
Stores data and instructions
before and during
Bus de communication et mémoire
processing.centrale.
1.2.4
Le processeur
ou microprocesseur
Arithmetic/Logic
Unit (ALU)central
and Floating
Point Unit (FPU)
FIGURE 2-19
Inside a CPU core.
The arithmetic/logic unit (ALU) is the section of a CPU core that performs arithmetic (addiLe
(unité
centrale)
a integers
pour objet
d’exécuter
les instructions machines
tion,microprocesseur
subtraction, multiplication,
and division)
involving
and logical
operations (such
as comparing
pieces of data
to see if theyLa
are figure
equal or determining
if a specific
placées
entwomémoire
centrale.
1.8 présente
soncondition
architecture générale.
is true or false). Arithmetic requiring decimals is usually performed by the floating point unit
(FPU). Arithmetic operations are performed when mathematical calculations are requested
by the user, as well as when many other common computing tasks are performed. For examY1
ple, editing a digital photograph in an image editing program, running
the spell checker in a
Opération
word processing
and burning a musicZCD are all performed by the ALU, with help
Unitéprogram,
Arithmétique
from the FPU when needed,
using only arithmetic and logical operations.
Most CPUs today
Y2
et Logique
have multiple ALUs and FPUs that work together to perform the necessary operations.
Bus interne
Le processeur
Memory
Control
Unit
Arithmetic
Logic Unit
Accumulator
Input Output
Control Unit
The control unit coordinates and controls the operations and activities taking place within
a CPU core, such as retrieving
data and instructions and passing them on to the ALU or
Registres
FPU for execution. In other words, it directs the flow of electronic traffic within the core,
much like a traffic cop controls the flow of vehicles on a roadway. Essentially, the control
unit tells the ALU and FPU what to do and makes sure that everything happens at the right
time in order for the appropriate processing to take place.
Données
Commandes
Séquenceur
Unité de Commande
Prefetch Unit
Décodeur
RI
The prefetch unit orders data and instructions from cache or RAM
based on the curCO
rent task. The prefetch unit tries to predict what data and instructions will be needed and
RAD
retrieves them ahead of time, in order to help avoid delays in processing.
RDO
Registers
CPU
Cache
I
Disk
USB
Graphics
Controller Controller Adapter
Cache
Cache
Cache
Registers within CPU
Bus
Caches close to elements
Memory
(avoid bus’s cost if possible)
I Speed and capacities di↵er greatly
⋄ la vitesse entre ces différentes mémoires est très différentes :
MartinRegisters
Quinson
RSA (2008-2009)
Introduction
(8/355)
⋄ la tailleChap
de1:ces
memoires est très différente :
⋆ registres < 1𝑘𝑜
Cache
⋆ cache : qqs 𝑀𝑜 ;
Main Memory
⋆ mémoire centrale : qqs 𝐺𝑜 ;
⋆ le stockage sur disque : qqs 𝑇 𝑜 .
I
Electronic disk
Cache
Main Memory Disk storage
Cours few
«Parallélisme
I» – P-F. Bonnefoi – http://p-fb.net/
few Mb
Gb
100s of Gb
0.5 - 25
80 - 250
5,000,000
5k - 10k
1k - 5k
20 - 150
printer
scanner
keyboard
mouse
programme
Chap 1: Introduction
RSA (2008-2009)
REGISTERS
Écriture
Main
memory
∘ «FPU», «Floating Point Unit» : gère les calculs sur
PREFETCH UNIT
Requests instructions and data from cache or RAM and makes
sure they are in the proper order for processing; it attempts to
fetch instructions and data ahead of time so that the other
bits
components don’t have to wait.
Fonctions :
stockage
PSW
Von
∘ le processeur
est laNeumann
combinaison :Model
⋄ d’une « unité arithmétique et logique », «ALU», «Arithmetic Logic
Current design
“Archaic” design
BUS INTERFACE UNIT
de données
TheBus
place where
data
and instructions enter or
leave the core.
machine accompagné de ses données. En effet, le microprocesseur n’est capable
d’exécuter une instruction que si elle est placée dans la mémoire centrale.
memories
ntly
Bus
Mémoire
cache
archical
k)
Processeur
central
dans la même mémoire.
La lecture ou l’écriture dans la mémoire concerne une donnée
ou une instruction.
⋄ architecture «Harvard» : programme et données sont dans des
mémoires différentes ;
Il est possible de charger simultanément une instruction et une
donnée.
L’architecture d’un ordinateur est de type «von Neumann».
Des matériels embarqués, comme des modules Arduino ou des DSP,
«Digital Signal Processor», utilisent une architecture de type «Harvard».
Architecture de l’ordinateur : l’évolution
HW
Horloge
⋆ une mémoire centrale :
⋄ architecture «Von Neuman» : programme et données résident
<
3 Qu’est-ce qu’un ordinateur ?
Computer Architecture History
Lecture/Écriture
>Arithmetic/logic unit (ALU). The part of a CPU core that performs logical operations and integer Commandes
arithmetic. >Floating
point unit (FPU).
Bus
/ Mémoire
The
part Processeur
of a CPU core that
performs decimal arithmetic. >Control unit. The part of a CPU core thatAdresses
coordinates its operations. >Prefetch unit.
The part of a CPU core that attempts to retrieve data and instructions before they are needed for processing
in order to avoid delays.
Données
∘ les registres : zones de mémorisation in-
ternes au processeur :
⋄ nombre et taille varient suivant le type
du processeur ;
⋄ de type données : contient le contenu
d’un mot mémoire ;
⋄ de type adresse : contient l’adresse
d’un mot mémoire ;
⋄ spécifique : fonction précise (adresse
de la pile par exemple) ;
⋄ générique : sert à stocker des résultats
intermédiaires (calculs de l’UAL) ;
1.8 Le microprocesseur.
∘ l’Unité Arithmétique Figure
et logique
:
⋄ réalise tous les calculs possibles du processeur : addition , soustraction, multiplication, comparaison etc (pour les calculs
⋄ possède des registres d’entrées 𝐸1 et 𝐸2 et un registre de sortie 𝑆 ;
⋄ possède un registre d’état, le «PSW», «Program Status Word» : qui donne l’état du calcul réalisé : dépassement de
flottants on utilise une FPU) ;
C7114_ch02.indd 73
12/21/09 5:28:07 PM
∘ l’unité de commande : exécute les instructions machine à partir des registres et de l’UAL
⋄ possède des registres : CO, «Compteur ordinal», RI, «Registre d’instruction», RAD, «Registre d’ADresse», RDO, «Recapacité, valeur à zéro etc.
⋄ le CO est un registre d’adresse qui contient l’adresse de la prochaine instruction à exécuter et il avance à chaque
gistre de DOnnées» ;
⋄ le décodeur : sert à analyser l’instruction du RI et contôle le séquenceur qui manipule les 𝜇 instructions.
chargement d’instruction.
—
31 décembre 2015 — 2
MICROPROCESSEUR / MÉMOIRE CENTRALE
L’objet de cette partie est de présenter succinctement comment s’exécute un programme
machine sur le matériel que nous venons de définir. Pour être exécutable une instruction doit
présente en mémoire
centrale. La mémoire centrale
Le nécessairement
processeurêtre
: exécution
d’un programme
contient donc des instructions et des données. De plus toutes les informations en
mémoire
sur undoit
alphabet
binaire.
Les informations
sont
alors,
quelle que
∘ sont
un codées
instruction
être en
mémoire
centrale pour
être
exécutable
;
soit leur∘ nature,
des suites
de 0 et contient
de 1. Il faut
pouvoir
différencier instructions
la mémoire
centrale
desdonc
données
et instructions
:
et données ⋄
afinles
quedeux
le registre
instruction
RI contienne
instructions
et non
sont des
séquences
de bits à bien
«0» des
ou «1»
;
des données (et réciproquement). Dans le cas contraire le décodeur ne pourrait inter⋄ il du
fauttravail
faire àlafaire
différence,
ne charger
RI que des
(sinon bug !) ;
préter la nature
(RI ne pour
contenant
pas unedans
instruction
maisinstructions
une
Exécution
exécution
CO pointe sur 11, le RAD passe sur l’instruction
et la charge dans RI
Le registre R, contient la valeur de B (3), résultat
de l’instruction 10.
⋄ les données et les instructions sont situées à des emplacements mémoires différents.
Séquence de 𝜇 instructions :
Mémoire
Instructions
Données
1. le contenu de CO est placé dans RAD : sélection de l’instruction à exécuter ;
2. commande de lecture déclenchée et le bus de
données fournie la valeur dans RDO ;
3. copie de RDO dans RI via le bus de données
interne ;
4. le décodeur décode RI : il reconnait l’instruction et indique au séquenceur la nature de
l’instruction ;
5. le séquenceur déclenche, au rythme de l’horloge, la séquence de 𝜇 instructions rélisant
l’instruction.
L’opération de chargement d’instruction s’appelle le «fetch».
© Dunod – La photocopie non autorisée est un délit.
5
1.4 • Un exemple
1.4
15
3
Horloge
UN EXEMPLE4
1
Pour résumer ce que nous venons d’étudier, nous allons prendre un exemple de
problème à résoudre2avec un ordinateur. Nous définissons tout d’abord le problème
et l’ordinateur cible c’est-à-dire son langage de programmation (langage machine).
Puis nous construisons le programme machine exécutable par cet ordinateur. Enfin
nous plaçons ce programme
en1.9
mémoire
centrale.
Il peut
alors être exécuté par le
Figure
Exécution
d’une
instruction.
microprocesseur.
1.4.1 Le problème
Notre problème consiste à réaliser l’addition de X qui vaut 4 avec Y qui vaut 1 et à
placer le résultat dans Z. Nous souhaitons donc, à l’aide de notre ordinateur, réaliser
l’opération : Z = X + Y avec X = 4 et Y = 1.
1.4.2 L’ordinateur
Cet ordinateur a la structure générale définie dans la figure 1.11. Les mots de la
mémoire sont des octets (8 bits), tous les registres du microprocesseur ont une largeur
16
de 8 bits, les instructions et les données entières sont codées sur un mot mémoire.
Données : X est codé : 000001002 ; Y est codé : 000000012.
1 • Structure générale et fonctionnement d’un ordinateur
Le processeur : exécution d’un programme, exemple
Les instructions du langage sont définies dans la figure 1.10. La figure 1.11 résume
exécution
Le résultat du passage sur l’instruction 11 :
− positionner l’adresse de l’instruction sur le bus
d’adresse ;
− charger l’instruction «Add D,R,A» depuis le bus
de données dans RI ;
Exécution
phases
Problème : réaliser l’addition de X, valant 4 avec Y, valantles1,différentes
et placer
le amenant
résultatà l’exécution
dans Z. du programme machine solution de notre
1.4.3 Le langage machine
problème sur cette machine :
C-à-d Z = X + Y avec X=4 et Y=1.
– les données ont été chargées aux adresses 0100 (pour X), 0101 (pour Y), le résultat
Le code opération est codé sur 4 bits, le champ opérande sur 4 bits. Le champ opérande
⋆ les qu’une
mots sont
surAinsi
8 bits,
lesfaire
instructions
et deux
les données
sont
codées
sur
unZ);
mot mémoire ;
àtel
l’adresse
0110
(pour
ne référence
donnée.
pour
l’addition de
nombres un
– le programme machine est chargé à l’adresse 0111;
langage
que la première
est spécifiée dans l’instruction et la seconde
⋆ suppose
X : 00000100,
Ydonnée
: 00000001
– le compteur ordinal est chargé avec l’adresse 0111.
occupe une adresse implicite. Dans de nombreuses machines cette adresse implicite
⋆ le code opération est sur 4bits, le champs opérande sur 4 bits ;
est un registre appelé registre Accumulateur (noté A). L’addition porte alors surÀlatitre d’exercice vérifiez que l’exécution du programme machine résout bien notre
⋆ spécifiée
une adresse
impliciteet est
utilisée
une instruction
:le
registre
Accumulateur ou «A» :
donnée
dans l’instruction
le contenu
de dans
A, le résultat
étant placé dans
A.
problème.
l’addition porte sur la donnée spécifiée et le contenu de A, le résultat étant placé dans A.
© Dunod – La photocopie non autorisée est un délit.
Code opération
Faire l’addition
de X qui vaut 4
et de Y qui vaut 1,
placer le résultat
dans Z
Champ opérande
0001
0100
0001
0100
0010
0101
Additionner le contenu du registre A avec le contenu du mot
mémoire d’adresse 0101 et placer le résultat dans le registre A
0011
0110
Placer le contenu du registre A dans le mot mémoire d’adresse 0110
0000
0001 0100
0010 0101
0011 0110
0000
Traduction en langage machine
Z X Y
Programme
machine
Chargement
en mémoire
centrale
Charger le contenu du mot mémoire d’adresse 0100 dans le registre A
Mémoire
Instructions
Données
Adresses
Stopper le programme
A
Figure 1.10
exécution
CO est incrémenté sur 12.
La mémoire est accédée suivant le contenu du registre d’adresse (11).
Le langage de la machine.
Horloge
Exécution
RI
CO
RAD
RDO
0011
0100
0101
0110
0111
1000
1001
1010
11001001
00000100
00000001
00000000
00010100
00100101
00110110
0000
X 4
Y 1
Z X Y
Figure 1.11 Le programme solution.
⋆ X est stocké à l’adresse 0100 et Y à l’adresse 0101, le résultat Z à l’adresse
0110 ;
⋆ le programme machine est chargé à l’adresse 0111 ;
1.5 LES UNITÉS D’ÉCHANGES
⋆ le CO est chargé avec l’adresse 0111.
Les unités d’échanges permettent la communication entre les modules du processeur
et les périphériques. Cette fonction de communication est complexe et nous la
détaillons dans le chapitre 9.
Une unité d’échange a une double nature :
Cours «Parallélisme I» – P-F. Bonnefoi – http://p-fb.net/
– elle est en communication, via le bus interne du processeur, avec la mémoire
centrale et le microprocesseur. Des instructions machines spécifiques permettent
exécution
L’instruction est retournée sur le bus de données pour être chargée dans RI.
Le décodeur va commencer à interpréter
l’instruction 11 chargée dans le RI (tops
d’horloge).
—
31 décembre 2015 — 3
– un moyen de conserver des données : les périphériques de stockage tels que le
– à charge de l’être humain de trouver une ou plusieurs solutions au problème;
dur, la disquette, le CD-ROM.
– au moins une des solutions trouvées est ensuite exprimée sous formedisque
de règles
opératoires telles que des itérations, des conditionnelles, des tests booléens, des
opérations arithmétiques : c’est la construction de l’algorithme;
2.2 LES DIFFÉRENTS NIVEAUX DE LANGAGE
1.6 • Conclusion
17
Du problème
sa résolution
– l’algorithme
est codé sous à
forme
d’instructions dans un langage exécutable
et
DE L’ORDINATEUR
compréhensible par l’ordinateur : c’est l’activité de programmation qui construit
∘ le problème
est exprimé
langage
de «haut
niveau»,
tel
C, donc
Java,l’activité
Pythonqui
etc.consiste à traduire par un programme un
un programme.
Une instruction
équivautdans
à unun
ordre
qui entraîne
l’exécution
par que est
La programmation
∘ d’une
un compilateur
traduit le «source» du langage de haut
niveaudans
choisi,
en programme
en
l’ordinateur
tâche
élémentaire.
algorithme
und’échange.
langage
assimilable
par langage
l’ordinateur.
Cette instrucactivité;de programles
échanges
entre mémoire centrale
et unité
On
trouved’assemblage
des
Exécution
exécution
∘ ce langage d’assemblage est traduit en assembleur correspondant au programme exécutable par la machine.
L’instruction demande l’accès à la variable A :
− chargement dans le registe d’adresse de
14 ;
− échange sur le bus de données de la valeur
de A qui est 5 ;
− placement de la valeur 5 dans l’ALU.
Exécution
© Dunod – La photocopie non autorisée est un délit.
exécution
La valeur de R, 3, est placée dans l’ALU.
Le décodeur sélectionne l’opération «Add» de l’ALU.
Le résultat de l’addition, 8, est disponible.
tions d’écriture permettant au microprocesseur
de (a,placer
informations
dans
function perimetre
b : in integer)des
return integer
is
begin
l’unitéJ’ai d’échange
et
des
instructions
de
lecture
permettant
au
microprocesseur
perimetre : (2 * a) (2 * b);
un problème à résoudre :
Programme
langage
de haut niveau
end;
d’acquérir des
plus endes
d’outils
de
b informations à partir des unités d’échanges. De
instructions de haut niveau
synchronisation
permettant
d’harmoniser
les
activités
du
processeur
avec
celles
a périmètre ?
des périphériques qu’il pilote sont nécessaires : il ne faut, par exemple, envoyer
COMPILATEUR
des caractères vers une imprimante que si celle-ci
est prête à imprimer et attendre
dans le cas 2.contraire. Dans
nos
ordinateurs
les
unités
d’échanges ne communiperimetre
:
pop
Rg1
R1
J’écris une solution !
R2
ALGORITHME
quent pas directement avec
le bus interne pop
duRg1processeur
mais au travers de bus,
mul Im R1 2
a 2b
mul Im R2 2 variété
dits bus d’extension. Il Périmètre
existe 2une
assez grande
de
ces d’assemblage
bus d’extension
Programme
en langage
:
add Rg2 R1 R2
Instructions composées de Mmémoniques
push Rg1
R1
(ISA, USB, FireWire, Fiberchanel, PCI…) qui
satisfont
des fonctionnalités diverses
ret
et plus ou moins générales. Nous reviendrons plus en détail sur cette question
ASSEMBLEUR
dans le chapitre traitant des questions de communication;
3. En utilisant un langage de programmation, je code la solution
elle
est par
enl’ordinateur
communication avec les périphériquesMÉMOIRE
et à ce titre doit être capable de
pour–la faire
exécuter
01101110111110011
les
piloter.
Programme à exécuter :
01111010001011100
PROGRAMME constitué d’instructions
1.
CPU
function perimetre (a, b : in integer) return integer is
begin
perimetre : (2 * a) (2 * b);
end;
1.6
CONCLUSION
BUS
Résoudre un problème à l’aide de l’ordinateur.
Traduction
Figure 2.2
Les différents niveaux de programmation.
à la résolution d’un problème avec un ordinateur. La figure 1.12 résume ces différentes étapes.
Du problème à sa résolution
n)
© Dunod – La photocopie non autorisée est un délit.
Algorithme
io
tat
i
plo
e
tèm
Exécution
instructions machine et valeurs en binaire
ce chapitre
nous
avons mémorisables
fait le tour par
de un
toutes
lescorrespondant
étapes importantes
nécessaires
Les Dans
«mnémoniques»
sont des
appellations
humain,
aux instructions
machine.
Figure 2.1
Problème
Le décodage de l’instruction 11 est terminée : le décodeur est arrivé à la fin de son cycle.
Le registre d’état, PSW contient un état qui dépend du déroulement de l’instruction de l’ALU (en particulier,
s’il y a eu dépassement de capacité lors de l’addition, mais aussi de signe, de nullité).
Le nombre de tops d’horloge qui a été nécessaire est important et varie avec la nature de l’instruction : plus
important si on a besoin d’accéder à la mémoire centrale.
10111101110111111
00111011110111011
00111111000111101
s
Sy
n(
o
ati
pil
m
Co
programme
Langage de haut niveau
(exemple C)
x
d’e
(Système
d’exploitation)
(Processeur)
Programme
machine
(séquence
d’instructions
machine)
Programme assembleur/machine
Chargement (SE)
Programme machine en mémoire
• chargement Compteur Ordinal (CO)
(adresse de la première instruction)
exécution programme machine
• exécution séquentielle
du programme machine
exécution d’une instruction
• Chargement (fetch)
et modification du CO
• Décodage
• Exécution de la séquence
de micro-instructions
Figure
1.12d’Exploitation,
Principalesou
étapes
la résolution
avec l’ordinateur.
Un des rôles
du Système
«OS», de
«operating
system»d’un
est deproblème
chargé le programme
dans la machine.
Cours «Parallélisme I» – P-F. Bonnefoi – http://p-fb.net/
—
31 décembre 2015 — 4
Et les multi-cores ? Qu’est-ce qu’un «core» ?
Et les multi-cores ?
L’avenir ?
Non ! le multi-cores :
⟹
un seul cœur
Et les multi-cores ?
De plus près
Moins de 10%de la surface sert à l’exécution réelle
«OOO» : Out of Order
Cours «Parallélisme I» – P-F. Bonnefoi – http://p-fb.net/
—
31 décembre 2015 — 5
Et les multi-cores ?
Une «Hyperthread»
Processeur «multi-cores»
▷ On «grave» plusieurs processeurs sur le même support.
▷ Chaque cœur est vu par le système d’exploitation comme un processeur séparé.
Avantages
□ On augmente moins la cadence du processeur (échauffement, consommation, difficultés de
□ On va vers plus de parallélisme (bien !)
conception)
Et l’Hyperthreading ? Qu’est-ce que c’est ?
Hyperthreading : la notion de «processeur logique»
Un processeur logique
▷ un «architecture state», c-à-d un état matériel :
⋄ registres, RI, CO, PSW, Interruptions ;
⋄ son propre flot d’instruction ;
▷ peut être interrompu et stoppé indépendamment.
Un processeur composé de «processeurs logiques»
Tous les processeurs logiques partagent la partie «exécution» :
□ les caches mémoires ;
□ les bus mémoires ;
□ le CPU, ALU, FPU, etc.
D’après Intel
Each logical processor maintains a complete set of the architecture state. The architecture
state consists of registers including the general-purpose registers, the control registers, the advanced programmable interrupt controller (APIC) registers and some machine-state registers.
From a software perspective, once the architecture state is duplicated, the processor appears
to be two processors. The number of transistors to store the architecture state is an extremely
small fraction of the total. Logical processors share nearly all other resources on the physical
processor, such as caches, execution units, branch predictors, control logic and buses.
Cours «Parallélisme I» – P-F. Bonnefoi – http://p-fb.net/
—
31 décembre 2015 — 6
Programme vs Processus
La segmentation
Programme
entité purement statique associée à la suite des instructions qui la composent.
Processus
entité purement dynamique associée à la suite des actions réalisées par un
programme.
⋄ La notion de processus introduit implicitement le concept et le fonctionnement des systèmes multiprogrammé.
⋄ Un processus est une abstraction de données définies par 2 parties : un
état et un comportement.
À chaque étape d’exécution du programme :
▷ le contenu des registres du compteur ordinal évolue ;
▷ le contenu de la mémoire centrale peut être modifié : écriture ou lecture.
On appelle processus l’image de l’état du processeur et de la mémoire au cours de l’exécution d’un
programme.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#include
#include
#include
#include
24 int main()
25 {
our_prints();
26
return 0;
27
}
28
<stdio.h>
<stdlib.h>
<sys/types.h>
<unistd.h>
int our_init_data = 30;
int our_noinit_data;
xterm
void our_prints(void)
{
int our_local_data = 1;
char c;
int *our_dynamic_data = (int *)calloc(1,sizeof(int));
}
$ ./segments
Pid of the process is = 4697
Addresses which fall into:
printf("Pid of the process is = %d\n", getpid());
printf("Addresses which fall into:\n");
printf("1) Data segment = %p\n", &our_init_data);
printf("2) BSS
segment = %p\n", &our_noinit_data);
printf("3) Code segment = %p\n", &our_prints);
printf("4) Stack segment = %p\n", &our_local_data);
printf("5) Heap segment = %p\n", our_dynamic_data);
scanf("%c", &c);
xterm
$ nm -f sysv segments
Symbols from segments:
Name
Value
main
|08048558|
T
|
FUNC|00000012||.text
our_init_data
|0804a020|
Class
D
|
Type
OBJECT|00000004||.data
Size
Section
our_noinit_data
|0804a02c|
B
|
OBJECT|00000004||.bss
our_prints
|08048494|
T
|
1) Data
segment = 0x804a020
2) BSS
segment = 0x804a02c
3) Code
segment = 0x8048494
4) Stack segment = 0xbfe47454
5) Heap segment = 0x8d76008
xterm
$ more /proc/4697/maps
08048000-08049000 r-xp 00000000 08:01 424814
./segments
08049000-0804a000 r--p 00000000 08:01 424814
./segments
0804a000-0804b000 rw-p 00001000 08:01 424814
./segments
08d76000-08d97000 rw-p 00000000 00:00 0
[heap]
bfe28000-bfe49000 rw-p 00000000 00:00 0
[stack]
On remarque que sur la sortie du fichier «maps» :
⋆ le segment code possède les droits d’exécution ;
⋆ les segments bss, data possèdent les droits de lecture/écriture mais pas d’exécution.
FUNC|000000c4||.text
Le programme est statique et le processus représente la dynamique de son exécution.
4 La segmentation : les différentes parties d’un processus
Un programme sur un adressage sur 32 bits voit la mémoire de l’adresse 0 à 232 − 1, c-à-d 4𝐺𝑜 :
(4GB-1)
232-1
0
232-1
Stack
Shared Libs
Heap
Bss
0
Data
Text
Les segments :
⋆ chaque section possède des droits d’accès différents : read/write/execute
⋆ Text : les instructions du programme ;
⋆ Data : les variables globales initialisées ;
⋆ Bss : les variables globales non initialisées (elles seront initialisées à 0) ;
⋆ Heap : mémoire retournée lors d’allocation dynamique avec les fonctions
«malloc/calloc/new» : elle croît vers le haut ;
⋆ Stack : stocke les variables locales et les adresses de retour : elle croît vers le
bas.
Cours «Parallélisme I» – P-F. Bonnefoi – http://p-fb.net/
La pile : utilisation au travers d’appels de fonction
1 int main ()
2{
int a = 23;
3
int b = 14;
4
...
5
6
b = Watt(a);
/* main appelle
7
les deux */
b = Volt(a,b);
8
...
9
10 }
11
12 int Watt(int c);
13 {
int w = 5;
14
...
15
w = Volta(w,10);
/* Watt appelle
16
Volta */
...
17
return w;
18
19 }
20
21 int Volta(int q, int r)
22 {
int k = 3;
23
int m = 6;
24
...
25
return k+m;
26
27 }
c.
d.
e.
f.
a. l’état de la pile au démarrage du programme :
⋄ registre «R5», «frame pointer» : contient l’adresse
du début du contexte courant ;
⋄ registre «R6», «Top of Stack (TOS) pointer» :
contient l’adresse de la valeur de retour ;
b. appel de la fonction «Watt» ;
on remarque que le registre R5 bouge et pointe sur chaque «contexte» courant de fonction ;
le registre R6 désigne une case mémoire au sommet de la pile qui n’est valide qu’à la fin de l’exécution de la fonction ;
l’utilisation de la pile évolue : il y a réutilisation de la zone mémoire pour l’exécution d’une autre fonction ;
écrasement de l’utilisation de la pile par l’appel «Watt» par l’appel «Volta».
—
31 décembre 2015 — 7
La pile : analyse du contenu d’un contexte
5 La pile : appel de fonction et passage de paramètres
Le registre «R7» sert à mémoriser le contenu du «PC», «Program Counter» ou «compteur ordinal».
∘ soit l’état de la pile après l’appel de la fonction A :
R6
Function stacked stuff
⋄ la fonction A est associée à la «Frame A», ou le
……..
contexte de A :
Function B
Frame B
……..
⋆ les variables locales à la fonction ;
Local Variables
⋆ les arguments : «Function pass value 1 to n» ;
R5
-------⋆ la valeur de retour de la fonction A ;
Caller s Frame Pointer (R5)
⋆ les registres R5 et R6 contiennent des valeurs
Caller s R7 (contains caller s caller s PC)
relatives au contexte de A ;
Function Return Value
⋆ la valeur du «PC» ou «CO» de l’appelant de
Function Pass Value 1
Frame A
Function A
la fonction A, c-à-d la valeur du registre R7 ;
……..
Il est nécessaire de mémoriser l’ancienne vaFunction Pass Value n
leur du CO, puisqu’il sert maintenant à exécuter le code de la fonction A.
……..
Previous R5
Local Variables
∘ ensuite, la fonction A appelle la fonction B :
⋄ la fonction B est associée à la «Frame B», ou le contexte de B :
⋆ les éléments de la fonction, «Function stacked stuff» (arguments, valeur de retour etc.) ;
⋆ les registres R5 et R6 contiennent des valeurs relatives au contexte de B ;
∘ du point de vue de la fonction B, le registre R7 mémorisé dans la pile sous le nom de «Caller’s R7» correspond au
--------
∘ cela crée une «liste chaînée» des différents appels imbriqués : il est possible de remonter dans les contextes d’appels
«caller’s caller’s», c-à-d de «l’appelant de l’appelant» ;
lors du retour d’une fonction. Le mécanisme «d’exception» présent dans le langage C++, Java, Python etc. permet
en cas d’erreur de remonter de contexte de fonction en contexte de fonction appelante à la recherche d’une fonction
capable de traiter cette erreur.
La pile : analyse du contenu d’un contexte
Lors de l’appel de la fonction «Volta», par la fonction «Watt»,
la valeur contenue dans la variable locale «w» de «Watt» est transmise en tant que paramètre à la fonction «Volta».
Cet appel correspond à la ligne 16 du code source.
Dans le contexte de la fonction «Volta» :
∘ la variable locale «q» reçoit la valeur du paramètre transmis, c-à-d la valeur de «w» de la fonction «Watt» ;
∘ la variable locale «r» reçoit la valeur du paramètre transmis, c-à-d la valeur directe 10 ;
∘ pour son travail, elle utilise deux variables locales
«k» et «m» ;
∘ des sauvegardes des adresses concernant «Watt» :
⋄ de retour d’exécution ;
⋄ de restauration de contexte.
Volta s R5
(Watt s R5
!)
(Main s R5 !)
Cours «Parallélisme I» – P-F. Bonnefoi – http://p-fb.net/
Passage de paramètres par valeur
1
2
3
4
5
6
7
8
9
10
11
12
13
14
«Activation record» = «contexte»
#include <stdio.h>
void Swap(int firstVal, int second
Val);
int main()
{
int valueA = 3;
int valueB = 4;
}
Swap(valueA, valueB);
return valueA;
/* retourne 3 */
void Swap(int firstVal, int second
Val)
{
int tempVal; /* conserve firstVal
15 lors de l'échange */
16
tempVal = firstVal;
17
firstVal = secondVal;
18
secondVal = tempVal;
19
return;
20
21 }
22
Que fait le programme ?
L’état de la pile avant le retour de la fonction
La pile : appel de fonction et passage de paramètres
Passage de paramètres par référence
1
2
3
4
5
6
7
8
9
10
11
#include <stdio.h>
void NewSwap(int *firstVal, int *se
condVal);
int main()
{
int valueA = 3;
int valueB = 4;
NewSwap(&valueA, &valueB);
/* retourne 4
12 */return valueA;
13 }
14
15
NewSwap(int *firstVal, int *se
16 void
condVal)
17 {
int tempVal;/* conserve firstVal
18 lors de l'échange */
19
tempVal = *firstVal;
20
*firstVal = *secondVal;
21
*secondVal = tempVal;
22
return;
23
24 }
25
26
Que fait le programme ?
—
▷ «valueA» est à l’adresse 0xEFFA ;
▷ «valueB» est à l’adresse 0xEFF9 ;
▷ «firstVal» et «secondVal» sont des pointeurs :
⋄ «firstVal» contient l’adresse de «valueA», 0xEFFA ;
⋄ «secondVal» contient l’adresse de «valueB», 0xEFF9 ;
31 décembre 2015 — 8
Représentation fonctionnelle d’un ordinateur
Qu’est-ce que le parallélisme ?
L’image de la course de voiture
Plusieurs véhicules veulent aller d’un point A à un point B le plus vite possible, ils peuvent :
− faire la course sur la route et finir par :
⋄ soit se suivre les uns les autres ;
⋄ soit essayer de se voler mutuellement leurs positions respectives ;
⋄ soit avoir un accident !
− rouler sur différentes voies parallèles et arrivés ensemble sans entrer en collision ;
− emprunter des routes différentes pour aller de A à B.
On ajoute dans cette représentation fonctionnelle, une horloge et des contrôleurs de périphériques
Et le parallélisme ?
− Plusieurs tâches à réaliser : chaque voiture à acheminer ;
− Chacune de ses tâches peut s’exécuter
⋄ une à la fois sur un seul processeur : une seule route ;
⋄ en paralléle sur plusieurs processeurs : plusieurs voies sur la même route ;
⋄ de manière distribuées sur plusieurs processeurs : des routes séparées.
− Ces tâches nécessitent souvent d’être synchronisées pour éviter les collisions ou de s’arrêter à des feux de trafic ou bien
à des panneaux de signalisation (Stop).
On peut imaginer que :
− les voitures sont des processus ou threads ;
− les routes qu’elles veulent emprunter sont des applications ;
− la carte des routes correspond au matériel ;
le code de lapartie
route, aux
communications
et aux synchro6 − – etPremière
: Principes
de conception
des
nisations.
systèmes d’exploitation
Abstraction du déroulement
Conceptuellement, chaque processus a son propre processeur virtuel. Bien sûr, le vrai processeur commute entre plusieurs processus. Mais, pour bien comprendre le système, il est préférable
de penser à un ensemble de processus qui s’exécutent en (pseudo-) parallélisme plutôt
La
multiprogrammation
qu’à l’allocation du processeur entre différents processus. Cette commutation rapide est appeComment exécuter plusieurs programmes en «multi-tâche»
lée multi-programmation.
∘ charger différents programmes en mémoires :
La figure
1.1 la([TAN-87],
p.les
56)
montre
quatre processus
s’exécutant en même temps. La fi⋄ répartir
mémoire entre
différents
programmes
;
gure⋄(b)traduire
présente
une
abstraction
de
cette
situation.
Les
quatre
programmes deviennent quatre
les adresses etc.
processus indépendants disposant chacun de leur propre contrôle de flux (c’est-à-dire leur
∘ passer, «switcher», de l’exécution d’un programme à l’autre :
compteur ordinal). À la figure (c), on peut constater que, sur un intervalle de temps assez
⋄ associer un contexte du processeur à chaque programme ⟶ notion de processus ;
grand,
les processus ont progressé, mais qu’à un instant donné, il n’y a qu’un seul proces⋄ tous
passer d’un processus à un autre : sauvegarde un contexte et restaurer un autre contexte ;
sus actif.
⋄ passer d’un «CO» associé à un processus à un «CO» associé à un autre processus :
Représentation fonctionnelle d’un ordinateur
Les composants indispensables d’un système capable de supporter Unix :
□ La mémoire principale
□ La mémoire cache
□ Les contrôleurs de périphériques
□ Les bus de communication
□ Une horloge
Comment organiser la mémoire entre les différents processus ?
En utilisation le concept de «pagination».
Comment passer règulièrement et automatiquement d’un processus à l’autre ?
Figure 1.1 : Processus
En utilisant le concept «d’horloge» et d’«interruption».
Cours «Parallélisme I» – P-F. Bonnefoi – http://p-fb.net/
Variables d’environnement
Comme nous l’avons déjà dit, la donnée du programme est insuffisante pour la détermination
□ Un processeur permettant un mode noyau/utilisateur
□ Les interruptions
—
31 décembre 2015 — 9
cours d’exécution de se dérouter vers un programme du système d’exploitation
qui doit gérer une tâche particulière. Par exemple les instructions d’entréessorties, permettant les échanges d’informations entre le processeur et les périphériques, sont traitées de cette manière. Un ordre d’entrées-sorties est un appel au
système (une interruption logicielle) qui interrompt le programme en cours au
profit du programme spécifique (driver ou pilote) de gestion d’un périphérique;
– du processeur lui-même pour traiter des événements exceptionnels de type division par zéro, dépassement de capacité lors d’une opération arithmétique.
Les interruptions
∘ permet d’arrêter l’exécution du programme en cours afin d’exécuter une tâche jugée plus urgente :
Lorsque le périphérique signale une interruption il dépose sur le bus le numéro de
l’interruption, ce numéro identifie un point d’entrée dans le vecteur d’interruptions
donc l’adresse du programme de traitement.
La prise en compte d’une interruption se fait selon la séquence :
1. le programme utilisateur dispose du processeur. C’est lui qui est en cours d’exécu-
Il dispose des registres,
l’unité arithmétique et logique,
de l’unité de
Lestion.
interruptions
: ladecommutation
de contexte
7.4 • Les interruptions : modification du flux d’exécution d’un programme…
(5)
(3)
(3)
∘ il en existe trois sortes provenant
: de l’interruption. La figure 7.22 représente la prise en compte d’un événetement
ment externeexternes
provoquant
unepermettent
interruption. à un périphérique d’avertir le processeur ;
⋄ d’un périphérique : interruptions
qui
Adressage
signal indiquant qu’il veut alerter le processeur) et pour partie sur du logiciel de trai-
(4)
Processeur
(6)
(2)
Processeur
Programmes
d’interruption
(1)
programme de gestion
de l’interruption
Programme
en exécution
Programme
à la fin
machine
Interruption
INTA
Mémoire
INTR
© Dunod – La photocopie non autorisée est un délit.
Contrôleur de disque magnétique
⋄ d’un programme en cours d’exécution : interruptions logicielles internes nommées appels systèmes.
Figure 7.22
Prise en compte d’une interruption externe.
Chapitre 10. Mesure du temps sous Linux – 191
(exemple : les périphériques positionnent un signal qui est reçu par le processeur).
Principe
commutation de contexte provoquée par un signal géré par le matériel.
Ce signal est lui-même un événement qui peut être :
⋄ interne au processus et donc résultant de son exécution ;
⋄ extérieur indépendant de cette exécution.
Exemple
⋄ L’événement concerne 1 périphérique d’entrée / sortie.
⋄ L’événement concerne 1 utilisateur ou un opérateur.
Le signal :
▷ réalise un changement de contexte processeur lorsqu’il est matériel ;
▷ modifie un indicateur qui est consulté régulièrement par le système d’exploitation en vue de
déterminer la cause de l’interruption lorsqu’il est logiciel.
Cours «Parallélisme I» – P-F. Bonnefoi – http://p-fb.net/
Maintien de l’heure courante
Programme
machinecourante, certains
Pour mettre Logiciel
en œuvre une horloge qui
donne l’heure
systèmes
Instruction
en coursd’exploitad’exécution
tion, comme les premières versions de MS-DOS, demandaient la date et l’heure à l’utilisateur.
1 d’horloge écoulés2depuis, par exemple, le 1er janvier
Ils calculaient ensuite le nombre de tops
1970 à 12 h, comme le fait Unix, ou depuis toute autre date. L’heure courante est
ensuite mise
Programme
Interruption
3
à jour à chaque top d’horloge.
de gestion
évènement externe
de
l’interruption
Pour éviter de perdre l’heure(signal)
lorsque l’ordinateur est éteint, les machines la sauvegardent
de
nos jours dans des registres spéciaux alimentés par une pile.
Figure 7.24 Flux d’un programme avec prise en compte des interruptions.
Horloge
1.2 Le logiciel des horloges
Gestion logicielle de l’horloge
d’exécuter
une
instruction
(nouvelleàphase
de Fetch),
le Tout
processeur
Le circuit deAvant
l’horloge
ne fait que
générer
des interruptions
intervalles
réguliers.
le reste vérifie
présence
signal d’interruption.
signald’exploitation
d’interruption est
doit être la
pris
en chargeou
parl’absence
le logiciel,d’un
plus exactement
par la partie Si
du le
système
appelée pilote
l’horloge. de traitement de l’interruption est mis en œuvre sinon l’exécuposté, de
le mécanisme
L’horloge est géree par un «pilote d’horloge» pour fournir les services suivants :
tion du
utilisateur
continue
en séquence. Une instruction commencée se
du programme
pilote d’horloge
varie
d’un
∘ mettre à jour l’heure courante ;Le rôle exact
teur
; système d’exploitation à un autre, mais ce pitermine
toujours
même sides
unefonctions
interruption
est arrivée
son exécution.
lote assure,
en général,
la plupart
suivantes
: mettrependant
à jour l’heure
courante L’inter;
∘ empêcher les processus de dépasser
le
temps
qui
leur
est
∘
fournir
des
compteurs
garde
au système
;
empêcherruption
les processus
de dépasser
le temps
leurde
estl’instruction
alloué ;de
comptabiliser
l’allocation
sera prise
en compte
aprèsqui
la fin
et avant
le
début lui-même
de du
l’instrucprocesseur
; traiter
l’appel système∘ alarm()
processus
utilisateur ; fournir
des compteurs
alloué ;
fournirdesdiverses
informations
au système
(tracé d’exécution
suivante.
de garde au; système lui-même ; fournir
diverses
informations au système (tracé d’exécution,
∘ comptabiliser l’allocation du processeur
tion,
statistiques).
Ce mécanisme est fondamental,
nous n’avons fait que l’aborder superficiellement
statistiques).
∘ traiter l’appel système alarm() des car
processus
utilisail est d’une
grande complexité dès que l’on entre dans les détails de sa réalisation.
HorlogeIltemps
La première
fonction
pilote d’horloge,
à savoirpour
la gestion
d’une hor-efficace
est, enréel.
particulier,
utilisé
par ledusystème
d’exploitation
le traitement
Différentes horloges
logedes
temps
réel, est assez
simple
à réaliser. Elle
consiste
un compteur
à
entrées-sorties,
nous
y reviendrons
donc
dans àlaincrémenter
partie concernant
le traitement
chaque
top
d’horloge,
comme
nous
l’avons
déjà
précisé.
Le
seul
point
qui
mérite
uneleatmatériel
des«humaine».
entrées-sorties mais aussi dans les chapitres concernant
système
⋆ horloge «temps réel» : maintenir latention
date
etparticulière
l’heure
est le nombre de bits du compteur qui contient l’heure courante. Si la
d’exploitation.
▷ une date de référence : le 1er janvier
1970
fréquence
de; l’horloge est de 60 Hz, un compteur de 32 bits déborde au bout de 2 ans.
Le système
ne peut
donc
dans; un compteur de 32 bits l’heure courante
▷ un compteur exprimant le nombre
de «tops»
depuis
la pas
datemémoriser
de référence
exprimée en nombre de tops d’horloge depuis le premier janvier 1970.
▷ capacité du compteur : dépend du
nombre de bits du compteur et de la fréquence de l’horloge ;
Il existe trois solutions à ce problème, représentées sur la figure 10.2 ([TAN-87], p. 174) :
Exemple : un compteur sur 32bits, avec une horloge à 60𝐻𝑧 déborde en 2 ans…
Solutions :
© Dunod – La photocopie non autorisée est un délit.
Interruptions, Processeur & Système d’exploitation
de l’exécution du programme d’interruption;
6. le programme utilisateur reprend son exécution.
En résumé le mécanisme d’interruption modifie le flux standard d’exécution d’un
Figure 7.23 Prise en compte d’une interruption.
4. le compteur ordinal CO est chargé avecprogramme
l’adresse du
programme
de d’exécution,
traitement ettenant
celui-ci
s’exécute
;
machine.
Le flux
compte
de possibles
interruptions,
5. le contexte d’exécution du programmed’un
utilisateur
est rechargé
dansdans
le processeur
à la fin du programme d’interruption ;
programme
est résumé
la figure 7.24.
6. le programme utilisateur reprend son exécution.
En version simplifiée :
Matériel
Prise en compte par le processeur d’événements externes
Dans ce schéma
tous lesd’exécution
périphériques signalent
un événement
au processeur
par du système d’exploitation
Il s’agit de permettre à un programme
en cours
de se dérouter
vers un
programme
le biais d’une ligne d’interruption unique en positionnant le signal INTR. Le procesqui doit gérer une tâche particulière.
seur, par le signal INTA, indique au périphérique que l’événement a été reçu et qu’il
va être
pris en compte (il permettant
faut éviter queles
le échanges
périphériqued’informations
continue d’émettreentre
des le processeur et les périPar exemple les instructions
d’entrées/sorties,
En général:il n’existe qu’une seule ligne d’interruption et il faut donc déterphériques, sont traitées designaux).
cette manière
miner l’origine de l’interruption émise. Cela peut se faire par scrutation, en interroun ordre d’entrées/sortiesgeant
est un
au système
(une
logicielle)
interrompt le programme en cours
tousappel
les périphériques.
Une
autreinterruption
méthode consiste
à ce que lequi
périphérique,
au profit du programme spécifique (driver ou pilote) de gestion d’un périphérique.
⋄ du processeur : traiter des événements exceptionnels de type division par zéro, dépassement de capacité
157
1. le programme utilisateur dispose du processeur. C’est
lui qui est en cours d’exécution. Il dispose des registres,
commande. Le compteur ordinal
CO contient
l’adresse
de la prochaine
instruction
de l’unité
arithmétique
et logique,
de l’unité
de comà exécuter;
mande. Le compteur ordinal CO contient l’adresse de
2. une interruption est postéelapar
un périphérique;
prochaine
instruction à exécuter ;
3. il y a sauvegarde du contexte
d’exécution
du programme
et en
2. unematériel
interruption
est déclenchée
par un utilisateur
périphérique
;
particulier du compteur
ordinal
CO.
Ceci
nécessaire
pour la
reprise ultérieure
3. sauvegarde du est
contexte
matériel
d’exécution
du prode ce programme.
Le programme de reconnaissance s’exécute et lit le numéro de
Zone
gramme utilisateur et du compteur ordinal CO.
de sauvegarde
l’interruption.
Le numéro de l’interruption permet l’identification de l’adresse du
programme de traitement;Le programme de reconnaissance s’exécute et lit le numéro
de l’interruption.
4. le compteur ordinal CO est
chargé
avec l’adresse du programme de traitement et
Le numéro de l’interruption permet l’identification de
celui-ci s’exécute;
du programme
traitement
; le processeur
5. le contexte d’exécution dul’adresse
programme
utilisateur estderechargé
dans
Programme de reconnaissance de l’interruption
La prise en compte et le traitement d’une interruption s’appuient sur un méca-
«Un périphérique peut signaler
événement
important
(fin de ce
papier
dansnous
l’imprimante,
dépassement de température
nismeun
relativement
complexe.
Afin d’illustrer
mécanisme
prenons l’exemple
traitement
d’une interruption
externe,qui,
doncs’il
produite
par cette
un périphérique.
Pour exécute un programme de
signalée par une sonde placéedudans
un four...)
au processeur
accepte
interruption,
prendre en compte une interruption et la traiter il faut en déterminer son origine car
service (dit programme d’interruption)
traitant l’événement.
il y a plusieurs sources possibles d’interruptions, puis exécuter le programme adapté.
À la fin du programme d’interruption
le programme
reprend
exécution
normale.»
Ce mécanisme
s’appuie pour interrompu
partie sur le matériel
(unson
périphérique
positionne
un
Figure 10.2 : Maintien de l’heure courante
⋄ compteur sur 64bits : augmente la complexité du calcul
qui doit être réalisé de nombreuses fois par seconde ;
⋄ compteur sur 32 bits par seconde + compteur supplémentaire «tops → seconde»
d’incrémentation
du récupérée
compteur, qui
doit être effectuée
plusieurs
par seconde.
⋄ compteur de tops à partir de l’heure
du démarrage
automatique
(utilisateur
ou fois
réseau).
Solution retenue pour Unix : dépassement
de capacité
en de
2038
! Cette solution complique cependant l’opération
· On peut utiliser
un compteur
64 bits.
—
31 décembre 2015 — 10
Unix
Horloge
Autres services
⋆ Ordonnanceur : garantie qu’un processus ne s’exécute pas plus logntemps que son «quantum de temps» :
⋄ lorsqu’un processus démarre un compteur lui est associé avec un nombre de «tops» d’horloge ;
⋄ à chaque interruption de l’horloge ce compteur est décrémenté ;
⋄ lorsque le compteur est à zéro, l’ordonnanceur est rappelé et choisi un nouveau processus.
⋆ Temps d’allocation d’un processus : comptabiliser le temps alloué à chacun des processus :
⋄ on incrémente un compteur associé au processus à pef@darkstar:~$ time ls
chaque top d’horloge ;
Segments segments.c
⋄ on distingue le temps passé en mode noyau et en mode
real 0m0.010s
utilisateur au service de ce processus : on indique égaChapitre 10.
Mesure0m0.004s
du temps sous Linux – 193
user
lement le temps réel attendu par l’utilisateur devant son
sys 0m0.004s
Si le nombre des signaux à traiter est élevé, il est plus efficace de chaîner les requêtes en
écran.
attente en les triant par ordre décroissant sur le temps comme le montre la figure 10.3
([TAN-87],
176) : chaque
entréealerté
dans cette
liste un
chaînée
indique
le nombre
tops certaine heure.
⋆ Alarmes : chaque processus
peut p.demander
d’être
après
certain
temps
ou de
à une
Unix est un système supportant :
□ Plusieurs utilisateurs ;
□ Plusieurs programmes :
⋄ Partage du temps d’utilisation ;
⋄ Protection de la mémoire ;
⋄ Partage des ressources ;
⋄ Accès à distance.
□ Problèmes :
⋄ Équité ;
⋄ Gestion du matériel ;
⋄ Droits d’accès…
Type matériel
en route le moteur du lecteur de disquettes. De
Quels usages ?
Les ordinateurs utilisent l’un des deux types suivants d’horloges, qui diffèrent tous les deux
même, il est judicieux de n’arrêter le
moteur que si le lecteur reste inutilisé 3 secondes, par exemple, après le dernier accès, afin
des horloges et des montres dont nous nous servons
tous
les jours
: ms à chaque opération. D’autre part, le laisser en fonctionnement
d’éviter
le
délai
de
500
conserver la date et l’heure courante
: fournir
cette date àcertains
l’utilisateur,
estampiller les fichiers etc.
l’userait.
De lademême
terminaux à impression impriment à
· Les horloges les plus simples dépendent de permanent
l’alimentation
électrique
110 oumanière,
220 volts et
ladevitesse
200
caractères
seconde,
ne peuvent pas,
gérer
les alertes
: alertes
le de
noyau
ou
les par
programmes
; en 5 ms, replacer la tête
génèrent
une interruption
à chaque
périodepour
la tension
dont
la fréquence
est
de 50 mais
ou 60utilisateur
d’impression à la marge gauche. Le pilote du terminal doit donc attendre après chaque
Hertz.
générer les «tops d’horloges»
: nécessaire au fonctionnement du système d’exploitaiton.
retour chariot.
· Le deuxième type d’horloges, dites programmables, est constitué de trois composants : un
Le pilote
de l’horloge
pour
les([TAN-87],
compteurs de garde le même mécanisme que pour
oscillateur à quartz, un compteur et un registre,
comme
le montreutilise
la figure
10.1
les signaux
utilisateurs.
Lagénère
seule différence
Comment
ça marche
p. 173) : un cristal
de quartz ?placé aux bornes
d’unedes
source
de tension
un signal est que, à l’échéance d’un compteur, le
pilote appelle une procédure indiquée par l’appelant au lieu de générer un signal. Cette
procédure fait partie du code de l’appelant, mais
le pilote de l’horloge
peut quand
même
L’oscillateur
à quartz
permet
une meilleur qualité de
l’appeler puisque tous les pilotes sont dans le même espace d’adressage. Cette procédure
signal
périodique,
que Les
celui
de
ou
du coupeut effectuer n’importe quelle opération et même
générer
une interruption.
interruptions ne sont pas toujours commodes d’emploi dans le noyau et les signaux n’existent pas.
rant électrique : plus régulier, compris entre
et
C’est pourquoi on utilise des compteurs de garde.
∘
∘
∘
50𝐻𝑧
.
Tracé d’exécution. La dernière fonction est le tracé d’exécution.
Certains systèmes d’exploitation fournissent aux programmes des utilisateurs le tracé du compteur ordinal, pour
leur permettre de savoir où ils passent le plus de temps. Si cette facilité est implantée,
le pilote vérifie, à chaque top d’horloge, si l’on contrôle l’exécution d’un processus élu. Il
calcule, si le profil d’exécution est demandé, le nombre binaire qui correspond au compFigure 10.1
: Horloge
programmable
l’horloge
n’est
pas toujours
très bonne, et il vaut mieux synchroniser régulièrement
La qualité de
du système avec un serveur «NTP», «Network Time Protocol» afin d’éviter des écarts.
le processeur peut exécuter toutes les instructions disponibles du
système.
□ un mode utilisateur.
certaines instructions lui sont interdites, pour des raisons de sécurité du système.
Protection fondamentale
Les programmes sont exécutés en mode utilisateur :
⋄ obligation de faire appel au système d’exploitation pour
les opérations à risque qui nécessite de passer en mode
noyau.
On appelle ces opérations des appels système (exemple
: opérations de gestion de fichier pour modification des
données)
contrôlés par le système d’exploitation.
Modélisation de la machine physique
Compteur de garde. Le système doit parfois établir des compteurs de garde (en anglais
Horloge & interruption
watchdog timer). Par exemple, le pilote du disque doit attendre 500 ms après avoir mis
1.1 Le matériel de l’horloge
100𝑀𝐻𝑧
□ un mode noyau (ou système ou superviseur)
⋄ Tous les accès aux ressources et aux données sont
Figure 10.3 : Traitement des alarmes
Optimisation : une seule horloge + une liste
chaînée d’alarmes qui mémorise les délais entre chacune de ces
alarmes : sur la figure lesd’horloge
signaux
être
envoyés
pour 4203
, 4207
, 4213
, 4215
et 4216
quivont
séparent
ce signal
du précédent.
Dans cet
exemple,
les signaux
sont envoyés
aux instants 4203, 4207, 4213, 4215 et 4216. Sur cette figure, on voit que l’interruption
suivante se produira dans 3 tops. À chaque top, signal suivant est décrémenté. Quand
cette variable atteint la valeur 0, on envoie le signal de la première requête de la liste et
190 – Quatrième partie : Aspect dynamique sans
affichage
on retire
cette requête de la liste. Puis on affecte à signal suivant l’instant d’émission du
signal en tête de la liste, 4 dans cet exemple.
Unix est un système nécessitant un processeur récent disposant d’au
moins deux modes de fonctionnement pour lui permettre de contrôler les accès aux ressources de la machine :
Le système d’exploitation se présente comme une couche logicielle placée entre la machine matérielle et les applications.
60𝐻𝑧
5𝑀 ℎ𝑧
l’heure et la date
périodique très régulier dont la fréquence est comprise entre 5 et 100 MHz. Ce signal décrémente le compteur jusqu’à ce qu’il atteigne la valeur zéro, ce qui produit une interruption.
LaFonctionnement
suite dépend du système:d’exploitation.
∘
l’initialisation de l’horloge, une valeur est copiée dans le compteur ;
∘
le compteur ;
· Dans
mode nonle
répétitif
(en anglais
one-shot
mode),une
l’horloge
copie, au moment
son
∘ lelorsque
compteur
tombe
à zéro,
interruption
sedeproduit.
moment de
Horloges au
programmables
Il s’interface avec :
chaque
impulsion
crystal
décrèmente
Les horloges
programmables
ontdu
plusieurs
modes
d’opération :
initialisation, une valeur dans le compteur. Ce compteur est ensuite décrémenté à chaque
Deux
modes
de fonctionnement
impulsion
du cristal.
Lorsqu’il
atteint la valeur zéro,: l’horloge génère une interruption et
s’arrête jusqu’à ce qu’elle soit réinitialisée par le logiciel.
non répétitif : lorsque l’interruption se produit, l’horloge reste arrêtée.
· Dans le mode à répétition (en anglais square-wave mode), le registre de maintien est auà répétition
de chaque
interruption,
la valeur
du compteur est automatiquement
tomatiquement
rechargé dans :lelors
compteur
à chaque interruption.
Le processus
se reproduit
donc indéfiniment. Ces interruptions périodiques sont appelées des tops d’horloge.
se répète indéfiniment.
L’intérêt d’une horloge programmable est que la fréquence des interruptions peut être contrôCesSiinterruptions
périodiques
sont appelées
les «tops
d’horloge».
lée par le logiciel.
l’on utilise un cristal
à 1 MHz, le compteur
est décrémenté
toutes les
microsecondes. Avec des registres de 16 bits, la fréquence des interruptions peut varier de
1 microseconde à 65 535 ms. Une puce d’horloge contient en général deux ou trois horloges
programmables séparément et offre un grand nombre de possibilités (le compteur peut, par
exemple, être incrémenté, les interruptions inhibées, etc.).
Cours «Parallélisme I» – P-F. Bonnefoi – http://p-fb.net/
rechargé : le processus
□ la couche matérielle, notamment par le biais du mécanisme des interruptions.
□ les applications par le biais des primitives qu’il offre : appels système et commandes.
—
31 décembre 2015 — 11
Fonctions du système d’exploitation
□ Gestion du processeur : allouer le processeur aux différents programmes pouvant s’exécuter.
□ Gestion de la mémoire : allouer la mémoire centrale entre les différents programmes pouvant s’exécuter (pagiCette allocation se fait suivant un algorithme d’ordonnancement qui planifie de l’exécution des programmes.
□
□
□
□
□
□
nation/segmentation).
Mécanisme de mémoire virtuelle : traduction entre adresse logique et physique, chargement uniquement des
parties de code et de données utiles à l’exécution d’un programme.
Gestion des E/S :
⋄ accès aux périphériques,
⋄ faire la liaison entre appels de haut niveau des programmes (exemple : getchar()) et les opérations de bas
niveau du système d’exploitation responsable du périphérique (exemple : le clavier).
C’est le pilote d’E/S (driver) qui assure cette liaison.
Gestion de la concurrence : plusieurs programmes coexistent en mémoire centrale :
⋄ assurer les besoins de communication pour échanger des données ;
⋄ synchroniser l’accès aux données partagées afin de maintenir la cohérence de ces données.
Le système offre des outils de communication et de synchronisation entre les programmes.
Gestion du système de fichier : stockage des données sur mémoire de masse (disque dur, mémoire flash, SSD,
etc.)
Le système d’exploitation gère un format d’organisation (ext4 sous Linux), un système de protection (journalisation des modifications) et un format de fichier (inodes).
Gestion de la protection : mécanisme de garantie que les ressources (CPU, mémoire, fichiers) ne peuvent être
utilisées que par les programmes disposant des droits nécessaires.
Gestion des comptes et des droits ,
Protection du système d’exploitation : séparation du système d’exploitation en mode noyau et des programmes
en mode utilisateur.
6 Notion de programme et de processus
Un programme est une entité purement statique associée à la suite des instructions qui la composent
(le ou les fichiers stockés sur le disque dur).
Un processus est un programme en cours d’exécution auquel est associé :
□ un environnement processeur (CO, PSW, RSP, registres généraux) ;
□ un environnement mémoire appelés contexte du processus.
Un processus est :
− l’«instance dynamique» d’un programme ;
État d’un processus
État élu
Lors de son exécution, un processus est caractérisé par un état :
∘ lorsque le processus obtient le processeur et s’exécute, il est dans l’état élu.
∘ l’état élu est l’état d’exécution du processus.
État bloqué
Lors de cette exécution, le processus peut demander à accéder à une ressource (réalisation d’une
entrée/sortie, accès à une variable protégée) qui n’est pas immédiatement disponible :
∘ le processus ne peut pas poursuivre son exécution tant qu’il n’a pas obtenu la ressource (par
exemple, le processus doit attendre la fin de l’entrée-sortie qui lui délivre les données sur lesquelles il réalise les calculs suivants dans son code) ;
∘ le processus quitte alors le processeur et passe dans l’état bloqué : l’état bloqué est donc l’état
d’attente d’une ressource autre que le processeur.
État prêt
Lorsque le processus a enfin obtenu la ressource qu’il attendait, celui-ci peut potentiellement reprendre son exécution. Cependant, dans le cadre de systèmes multiprogrammés , il y a plusieurs
programmes en mémoire centrale, et donc plusieurs processus.
∘ lorsque le processus est passé dans l’état bloqué, le processeur a été alloué à un autre processus.
∘ le processeur n’est donc pas forcément libre : le processus passe alors dans l’état prêt .
L’état «Prêt» est l’état d’attente du processeur.
État d’un processus
Changement d’état
▷ Le passage de l’état prêt vers l’état élu constitue l’opération d’élection .
▷ Le passage de l’état élu vers l’état bloqué est l’opération de blocage .
▷ Le passage de l’état bloqué vers l’état prêt est l’opération de déblocage .
− le fil d ’exécution, thread, de celui-ci dans un espace d’adressage protégé (ensemble des instructions et des données accessibles en mémoire).
État d’un processus
C’est le système d’exploitation qui détermine et modifie l’état d’un processus sous
l’effet des événements.
Remarques
□ Un processus est toujours crée dans l’état prêt .
□ Un processus se termine toujours à partir de l’état élu (sauf anomalie).
Cours «Parallélisme I» – P-F. Bonnefoi – http://p-fb.net/
—
31 décembre 2015 — 12
Création de processus
Processus et cycle de vie
Un processus peut en créer un autre :
− le premier est appelé père
− le second fils.
− le fils peut à son tour créer d’autres processus : il devient le père de ses processus...
Construction d’une arborescence de processus ou la racine correspond au processus ancêtre.
PCB ou «Process Control Bloc»
Le système d’exploitation crée un PCB, une structure de description du processus associée au nouveau programme
exécutable qui contient les informations suivantes :
⋆ identificateur unique du processus (PID de type entier)
⋆ état courant du processus (élu, prêt, bloqué)
⋆ contexte processeur du processus : la valeur du CO, la valeur des
autres registres du processeur
⋆ contexte mémoire : ce sont des informations mémoire qui permettent de trouver le code et les données du processus en mémoire
centrale
⋆ informations diverses de comptabilisation pour les statistiques sur
les performances système
⋆ informations liées à l’ordonnancement du processus.
Le PCB permet la sauvegarde et la restauration du contexte mémoire
et du contexte processeur lors des opérations de commutations de
contexte (commutation d’un processus à un autre pour le processeur).
Processus Unix
Le bloc de contrôle du processus est divisé en deux parties, chaque processus dispose :
− d’une entrée dans une table générale du système, la table des processus.
cette entrée contient les informations sur le processus qui sont toujours utiles au système quel
que soit l’état du processus : l’identificateur du processus (pid), l’état du processus, les informations d’ordonnancement, les informations mémoire, c’est-à-dire l’adresse des régions mémoire
allouées au processus.
− d’une seconde structure : la Zone U. Cette Zone U contient d’autres informations concernant
le processus, mais ce sont des informations qui peuvent être temporairement «swappées» sur le
disque
Cours «Parallélisme I» – P-F. Bonnefoi – http://p-fb.net/
Cycle entre trois modes au cours de l’exécution d’un processus :
∘ le mode utilisateur qui est le mode normal d’exécution,
∘ le mode noyau en mémoire qui est le mode dans lequel se trouve un processus prêt ou bloqué (endormi)
∘ le mode swappé qui est le mode dans lequel se trouve un processus bloqué (endormi) déchargé de la mémoire
centrale dans la zone de swap sur le disque dur.
Le système Unix décharge de la mémoire centrale les processus endormis depuis trop longtemps (ils sont alors dans
l’état Endormi swappé).
Ces processus réintègrent la mémoire centrale lorsqu’ils redeviennent prêts (transition de l’état prêt swappé vers
l’état prêt).
Un processus qui se termine passe dans un état dit zombi. Il y reste tant que son PCB n’est pas entièrement détruit
par le système.
Processus et démarrage système
Le système Unix est entièrement construit à partir de la notion
de processus :
∘ au démarrage du système, un premier processus est crée :
le processus 0.
∘ le processus 0 crée à son tour un autre processus, le processus 1 ou init.
∘ le processus init lit le fichier /etc/inittab et crée chacun des
deux types de processus décrits dans ce fichier :
Les processus démons (dont le nom est suffixé par un "d")
qui sont des processus système responsables d’une fonction (inetd surveille le réseau, lpd gère les imprimantes,
crond gère un échéancier, etc.)
∘ les processus getty qui surveillent les terminaux
Attention : les dernières versions de Linux utilisent systemd.
Lorsqu’un utilisateur vient se loguer sur un terminal :
▷ un processus login est crée qui lit le nom de l’utilisateur et son mot de passe.
▷ Ce processus login vérifie la validité de ces informations en utilisant le fichier /etc/passwd décrivant les
comptes.
▷ Si les informations sont valides, le processus login crée un processus shell, c-à-d un interpréteur de commandes.
Cet interpréteur de commandes exécute alors les commandes et programmes de l’utilisateur en créant à chaque
fois un nouveau processus.
Les processus sont créés au travers d’appels sytème :
⋆ la primitive fork() crée un processus fils clone du processus père appelant.
⋆ la primitive exec() termine la création du processus en fournissant le code qui est propre à ce nouveau processus.
—
31 décembre 2015 — 13
Commutation de contexte
Commutation de contexte
Les appels systèmes constituent l’interface du système d’exploitation et sont les points d’entrées
permettant l’exécution d’une fonction du système :
□ les commandes permettent d’appeler les fonctions du système depuis le prompt de l’interpréteur
de commande (shell, invite du dos)
Déroulement d’un appel système
main()
{
int i,j,fd;
i = 3;
fd = open("mon_fichier", "r");
read(fd, j, 1);
j = j/i;
}
Mode noyau
Protection
Mode utilisateur
main()
{
int i,j,fd;
i = 3;
fd = open("mon_fichier", "r");
Exécution de read()
Exécution de open()
...
...
return
1 restitution du contexte utilisateur
2 chargement CO ⟵ CO sauvegardé
3 chargement PSW ⟵ PSW sauvegardé
...
...
return
Commutation de contexte
À la fin de l’appel système :
▷ passage du mode noyau au mode utilisateur ;
⟹ commutation de contexte : restitution du contexte utilisateur.
La commutation de contexte
Mode noyau
Protection
Mode utilisateur
Exécution de open()
...
...
1 sauvegarde CO, PSW utilisateur
2 chargement CO ⟵ adresse de la fonction open
3 chargement PSW ⟵ mode superviseur
Appel Système (ici open) :
− demande d’exécution d’une fonction du système d’exploitation ;
− passage du mode utilisateur au mode noyau :
⋄ déclenchement d’une interruption logicielle
que l’on peut vérifier dans le code assembleur
du programme ;
⋄ passage dans un mode d’exécution privilégié
qui est le mode d’exécution du système d’exploitation (mode noyau ou superviseur).
Accès à un plus grand nombre d’instructions machine que le mode utilisateur (permet l’exécution des instructions de masquage
et démasquage des interruptions interdites en
mode utilisateur).
⋄ sauvegarde du contexte utilisateur ;
⟹ commutation de contexte
Mode noyau
Exécution de open()
...
...
return
Lors de l’exécution d’un appel système, le programme utilisateur passe du mode d’exécution utilisateur au mode d’exécution superviseur ou privilégié.
main()
{
int i,j,fd;
i = 3;
fd = open("mon_fichier", "r");
Mode utilisateur
Protection
□ les appels système sont directement appelables depuis un programme.
Cours «Parallélisme I» – P-F. Bonnefoi – http://p-fb.net/
Trois causes de passage du mode utilisateur au mode noyau
□ appel d’une fonction du système :
demande explicite de passage en mode
noyau.
□ exécution d’une opération illicite
(division par 0, instruction machine interdite, violation mémoire…) : trappe.
L’exécution du programme utilisateur est
alors arrêtée.
□ interruption par le matériel et le système
d’exploitation :
le programme utilisateur est alors stoppé et
l’exécution de la routine d’interruption associée à l’interruption survenue est exécutée en mode superviseur.
□ interruption par l’horloge :
c’est une interruption matérielle qui permet au système d’exploitation de passer de
l’exécution d’un processus à un autre dans
le cadre de la «multiprogrammation».
Cette interruption ne peut être ignorée par
le processus.
On appelle ce mécanisme : la préemption.
—
31 décembre 2015 — 14
La figure 12.6 reprend le graphe d’états tel qu’il a été présenté sur la figure 12.1. Sur
cette figure, nous nous intéressons plus particulièrement aux transitions pouvant
exister entre l’état prêt (état d’attente du processeur) et l’état élu (état d’occupation
du processeur). Le passage de l’état prêt vers l’état élu constitue l’opération d’élection :
Préemption
c’est l’allocation
du processeur à un des processus prêts. Le passage de l’état élu
vers l’état prêt a été ajouté par rapport à la figure 12.1 : il correspond à une réquisi-
Les mécanismes
Préemption
Préemption
: commutation par l’horloge
98
Réveil
Élu
Élection
En exécution
Prêt
Parallélisme I — P-F. Bonnefoi
Parallélisme I — P-F. Bonnefoi
© Dunod – La photocopie non autorisée est un délit.
Fin
Préemption
En attente du processeur
Déblocage
Bloqué
Blocage
En attente de ressources
Figure 12.6
Opérations d’élection et de préemption.
100
Préemption
Préemption
Dans ce schéma, plusieurs processus sont présents en mémoire centrale.
Le graphe d'états montre les transitions pouvant exister entre l'état prêt (état d'attente
du processeur) et l'état élu (état d'occupation du processeur).
q P1 est élu et s'exécute sur le processeur.
q P3, P5 et P6 quant à eux sont dans l'état prêt : ils pourraient s'exécuter (ils ont à
leur disposition toutes les ressources nécessaires) mais ils ne le peuvent pas car le
processeur est occupé par P1.
Lorsque P1 quittera le processeur parce qu'il a terminé son exécution, les trois
processus P3, P5 et P6 auront tous les trois le droit d'obtenir le processeur.
Mais le processeur ne peut être alloué qu'à un seul processus à la fois : il faudra donc
choisir entre P3, P5 et P6.
C'est le rôle de l'ordonnancement qui élira un des trois processus.
99
Cours «Parallélisme I» – P-F. Bonnefoi – http://p-fb.net/
Le passage de l'état prêt vers l'état élu constitue l'opération d'élection : c'est
l'allocation du processeur à un des processus prêts.
Parallélisme I — P-F. Bonnefoi
Parallélisme I — P-F. Bonnefoi
q P2 et P4 sont dans l'état bloqué car ils attentent tous les deux une fin d'entréesortie avec le disque géréé par l’unité d’échange (UE).
Le passage de l'état élu vers l'état prêt a été ajouté ici : il correspond à une réquisition
du processeur , c'est-à-dire que le processeur est retiré au
processus élu alors que celui-ci dispose de toutes les ressources nécessaires à la
poursuite de son exécution.
Cette réquisition porte le nom de préemption.
101
—
31 décembre 2015 — 15
Préemption
Préemption
Ce schéma illustre le déroulement des opérations d'ordonnancement avec
deux processus P0 et P1.
Initialement le processus P0 est élu et s'exécute.
Le processus P1 est dans l'état prêt.
q si l'ordonnancement est non préemptif, la transition de l'état élu vers l'état prêt
296
12 • Gestion de l’exécution des programmes : le processus
est interdite : un processus
quitte le processeur s'il a terminé son exécution ou s'il
se bloque.
tion du processeur, c’est-à-dire que le processeur est retiré au processus élu alors que
celui-ci dispose de toutes les ressources nécessaires à la poursuite de son exécution.
q si l'ordonnancement est préemptif, la transition de l'état élu vers l'état prêt est
Cetteautorisée
réquisition
porte le nom de préemption.
: un processus quitte le processeur s'il a terminé son exécution , s'il se
Ainsi
selon
si
de réquisitionné.
réquisition est autorisée ou non, l’ordonnancement
bloque ou si lel’opération
processeur est
est qualifié d’ordonnancement préemptif ou non préemptif :
– si l’ordonnancement est non préemptif, la transition de l’état élu vers l’état prêt
102 est interdite : un processus quitte le processeur s’il a terminé son exécution ou s’il
se bloque;
– si l’ordonnancement est préemptif, la transition de l’état élu vers l’état prêt est
autorisée : un processus quitte le processeur s’il a terminé son exécution, s’il se
bloque ou si le processeur est réquisitionné.
Parallélisme I — P-F. Bonnefoi
Parallélisme I — P-F. Bonnefoi
Selon si l'opération de réquisition est autorisée ou non, l'ordonnancement sera
qualifié d'ordonnancement préemptif ou non préemptif :
ÉLU
Système d’exploitation
appels système :
read (données, disque)
Le processus P1 commence alors son exécution.
Préemption
Processus P1
Sauvegarde PCB 0
Il y a donc une opération d'élection et le processus P1 est élu : le contexte
processeur associé au processus P0 est sauvegardé dans le PCB du processus
P0 (PCB0) et le processeur est chargé avec le PCB du processus 1 (PCB1).
104
Préemption
Processus P0
Le processus P0 fait un appel système : il y a commutation de contexte avec
changement de protection pour aller exécuter le code de l'appel système
(passage en mode superviseur) au cours duquel le processus P0 se bloque.
Au cours de cette exécution, le processus P0 obtient la ressource
demandée au cours de son appel système et dont l'indisponibilité l'avait
bloqué, et donc repasse dans l'état prêt.
PRÊT
élection
103
BLOQUÉ
ÉLU
Interruption
PRÊT
Sauvegarde PCB 1
élection
it fin d’entrées-sorties
Recharge PCB 0
ÉLU
Figure 12.7
PRÊT
Déroulement des opérations d’ordonnancement.
La figure 12.7I»
schématise
le déroulement
des opérations d’ordonnancement préemptif
Cours «Parallélisme
– P-F. Bonnefoi
– http://p-fb.net/
avec deux processus P0 et P1. Initialement le processus P0 est élu et s’exécute. Le
processus P1 est dans l’état prêt. Le processus P0 fait un appel système, par exemple
read (données, disque) pour demander la lecture de données depuis un disque. Il y
Parallélisme I — P-F. Bonnefoi
Parallélisme I — P-F. Bonnefoi
Recharge PCB 1
Une interruption survient : il y a commutation de contexte avec
changement de protection pour aller exécuter le code de l'interruption
(passage en mode superviseur).
A la fin du traitement de l'interruption, une opération d'ordonnancement
est lancée : le processus P0 est de nouveau élu : le contexte processeur
associé au processus P1 est sauvegardé dans le PCB du processus P1
(PCB1) et le processeur est chargé avec le PCB du processus 0 (PCB0).
105
—
31 décembre 2015 — 16
297
Parallélisme I — P-F. Bonnefoi
Laopération
notion
de processus
fin de cette
d’entrées-sorties.
Le processus P1 est dérouté pour aller exécuter
o 1: d’interruption
le processuscorrespondant;
est sélectionné
le SE
le traitant
il ypar
a commutation
de contexte avec changele processus
a écoulé
quantumAu
decours
temps
mento 2:
de protection
(passage
en modeson
superviseur).
du traitant d’interruption,
le processus
bloqué
en attente
e/s une opération d’ordonl’étato 3:
du processus
P0 estest
modifié
et devient
égal àd'une
prêt, puis
o 4: leest
processus
reçu l'information
qu'il attendait
nancement
lancée : leaprocessus
P0 est de nouveau
élu. Le contexte processeur
associé au processus P1 est sauvegardé dans le PCB du processus P1 (PCB1) et le
processeur est chargé avec le PCB du processus 0 (PCB0).
Les opérations d’ordonnancement prennent place lors de tout changement d’états
des processus.
12.2.2 Entités systèmes responsable de l’ordonnancement
Les processus prêts et les processus bloqués sont gérés dans deux files d’attentes
distinctes qui chaînent leur PCB. Le module ordonnanceur (scheduler) trie la file des
processus prêts de telle sorte que le prochain processus à élire soit toujours en tête de
file. Le tri s’appuie sur un critère donné spécifié par la politique d’ordonnancement.
Dans un contexte multiprocesseur, le répartiteur (dispatcher) alloue un proces106 parmi les processeurs libres à la tête de file de la liste des processus prêts et
seur
réalise donc l’opération d’élection. Dans un contexte monoprocesseur le rôle du
répartiteur est très réduit puisqu’il n’a pas à choisir le processeur à allouer : il est
alors souvent intégré dans l’ordonnanceur. La figure 12.8 représente les modules
Préemption,
ordonnancement et répartition
évoqués
ici.
La structure d’un processus
Le processus dispose d'un espace d’adressage en mémoire pour
s'exécuter, et dans lequel il peut lire et écrire.
Cette zone mémoire est découpé en plusieurs partie:
o le code (le texte)
Parallélisme I — P-F. Bonnefoi
12.2 • Ordonnancement sur l’unité centrale
o Les données
o la pile qui permet de stocker l'état du processeur lors d'un appel
de fonction
o le tas qui permet de stocker les variables.
o les arguments passés en paramètre.
108
La structure d’un processus
Préemption
Adresse Haute = 0xFFFFFFFF
argc, argv, env…
Cpu
Tas
107
Élection
Blocage
Ordonnanceur
Classement
selon une politique
d’ordonnancement
Déblocage
Bloqués
Figure 12.8
Ordonnanceur et répartiteur.
12.2.3
PolitiquesI»d’ordonnancement
Cours
«Parallélisme
– P-F. Bonnefoi – http://p-fb.net/
La politique d’ordonnancement détermine quel sera le prochain processus élu. Selon
si la préemption est autorisée ou non, la politique d’ordonnancement sera de type
Parallélisme I — P-F. Bonnefoi
Cpu
Répartiteur
PCB
PCB
PCB
PCB
PCB
PCB
Parallélisme I — P-F. Bonnefoi
unod – La photocopie non autorisée est un délit.
Cpu
PCB
PCB
PCB
PCB
PCB
PCB
Prêts
Pile
Données non initialisées
Données initialisées
Texte
Initialisée à 0 par exec
Lu par exec
Adresse Basse = 0
109
—
31 décembre 2015 — 17
La structure d’un processus
La pagination
PAGINATION d’un segment
PAGINATION
d’un segment
• Les segments de l’espace d’adressage
sont eux-mêmes
paginés
une adresse
dans un segment
devient
une
paginée
••• L‘espace
L‘espace
d’adressage
linéaire
duadresse
segment
est
d’adressage
linéaire
du segment
est coupé
en: coupé
portions en
de portions de
(numéro
page,
déplacement
dans
la page)
taille
fixe
et et
égale
à l'unité
d'allocation
de la mémoire
: les
taille
fixede
égale
à l'unité
d'allocation
de la centrale
mémoire
centrale : les
pages.
adresse
au sein
segment
devient une
adresse
pages.Chaque
Chaque
adresse
au dusein
du segment
devient
une adresse
paginée
d’und’un
couple
(numéro
de page,de
déplacement
dans la
paginéeformée
formée
couple
(numéro
page, déplacement
dans la
page)
Les processus classiques (appelé aussi processus lourd) ont de
nombreux inconvénients:
page)
o Une perte de temps du fait de l’exécution séquentielle du code
110
Parallélisme I — P-F. Bonnefoi
Parallélisme I — P-F. Bonnefoi
o Un gaspillage de mémoire
384
Page 4
384
Espace d'adressage
du segment S2 (1024)
LINEAIRE
Espace
Adressed'adressage
linéaire
(déplacement
0)
du segment depuis
S2 (1024)
384 (Page 2, dep 128)
PAGINE 6
Adresse paginée (logique)
(n° de page, déplacement dans la page depuis 0)
LINEAIRE
Adresse linéaire
(déplacement depuis 0)
NSY103
Page 3
Espace d'adressage
du programme
Joëlle Delacroix
111
Joëlle Delacroix
Case 4
Case 3
Page 3
Case 5
Case 4
Page 2
Case 6
Case 5
Page
Case
Page
2 4 Case
6 7
Espace
d'adressage
Page
4
du programme
NSY103
#include <unistd.h>
pid_t getpid(void)
retourne le pid du processus appelant
Page 3
Case 3
Page 1
Case 2
Page 2
PagePage
4 2
• Primitive getpid, getppid
Page 4
pid_t getppid(void)
retourne le pid du père du processus
appelant
•
NSY103 2009-2010
J. Delacroix
Cours «Parallélisme I» – P-F. Bonnefoi – http://p-fb.net/
délivre la liste des processus avec leur caractéristiques (pid,
29
ppid, état, terminal,
durée d ’exécution, commande associée…)
% ps
PID TTY
20841 ttyq0 S
20844 ttyq0 R
5
Case 7
113
NSY103
Primitives et commandes générales
Commande ps
Parallélisme I — P-F. Bonnefoi
Parallélisme I — P-F. Bonnefoi
Page Page
3 1
6
Primitives et commandes générales
Mémoire
• L'espace d'adressage du programme est découpé en morceaux linéaires de même taille : la page.
L'espace d'adressage du programme est découpé en morceaux
• L'espace de la mémoire physique est lui-même découpé en morceaux linéaires de même taille : la
linéaires de même taille : la page.
Case 1
case ou cadre de pages
La pagination
L'espace de la mémoire physique est lui-même
découpé en morceaux
• La taillelinéaires
d'une case
est égale à la taille d'une page
Mémoire
de même taille : la case ou cadre de pages
• Les segments
ded'une
l’espace
d’adressage
sont
paginés
L'espace
d'adressage
duégale
programme
est eux-mêmes
découpé
en morceaux
La
taille
case est
à la taille
d'une page
Page 1
Case 2
linéaires de même taille : la page.
Case 1
Pagede1 l’espace d’adressage sont eux-mêmes paginés
Les segments
NSY103
Primitives et commandes de processus
La pagination
L'espace
de la mémoire
physique
est lui-même
en morceaux
Les segments
de l’espace
d’adressage
sont découpé
eux-mêmes
paginés
linéaires de même taille : la case ou cadre de pages
La taille d'une case est égale à la taille d'une page
384 (Page 2, dep 128)
Page 3
Joëlle Delacroix
La pagination
128)
Page 2
Page
4 d'adressage
Espace
du segment S2
PAGINE
Espace
d'adressage
Adresse paginée
(logique)
du segment
S2 0)
(n° de page, déplacement dans
la page depuis
Joëlle Delacroix
112
256 octets
128)
Page 2
Page 3
0
256 octets
Page 1
0
o Une gestion lourde par recopie pour créer de nouveau processus
0
Page 1
0
5
—
S
TIME
CMD
0:00.27 -csh (csh)
0:00.00 -ps (ps)
%ps ax
PID TTY
0 ??
S
R
TIME
CMD
14:30:59 [kernel idle]
1 ??
S
13:43.28 /sbin/init -a
683 ??
777 ??
S
S
0:00.49 telnetd
0:06.30 /usr/lbin/lpd
1177 ??
S
5:13.60 /usr/sbin/inetd
NSY103 2009-2010
J. Delacroix
31 décembre 2015 — 18
30
Primitives
et commandes
processus
Primitives
et commandesde
générales
Primitives et commandes de processus
• Création de processus : déroulement de l’appel système fork
Primitive de création de processus
• Commande kill
délivre un signal à un processus de numéro pid
MODE UTILISATEUR
S
TIME
CMD
0:00.27 -csh (csh)
0:00.45 essai
R
0:00.00 -ps (ps)
Parallélisme I — P-F. Bonnefoi
Parallélisme I — P-F. Bonnefoi
% ps
PID TTY
20841 ttyq0 S
20847 ttyq0 S
20844 ttyq0
%kill -9 20847 (signal n°9 (SIGKILL))
% ps
PID TTY
20841 ttyq0 S
20844 ttyq0
MODE SYSTEME
PROCESSUS PID 12222
S
TIME
CMD
0:00.27 -csh (csh)
R
0:00.00 -ps (ps)
Exécution de l ’appel système fork
Main ()
{
pid_t ret ;
int i, j;
Si les ressources noyau sont disponibles
- allouer une entrée de la table des processus
au nouveau processus
for(i=0; i<8; i++)
i = i + j;
- allouer un pid unique au nouveau processus
ret = fork();
- dupliquer le contexte du processus parent
(code, données, pile)
- retourner le pid du processus crée à son père
et 0 au processus fils
}
114NSY103 2009-2010
J. Delacroix
31
116
NSY103 2009-2010
Primitives
et commandes
de processus
Primitive
de création de processus
• Création de processus
: déroulement
de l’appel système
Primitive
de création
defork
processus
Primitive fork
MODE UTILISATEUR
PROCESSUS PID 12222
La primitive fork() permet la création dynamique d ’un nouveau
processus qui s ’exécute de manière concurrente avec le processus qui
l ’a créé.
Tout processus Unix/Linux hormis le processus 0 est crée à l ’aide de
cette primitive.
Le processus créateur (le père) par un appel à la primitive fork() crée un
processus fils qui est une copie exacte de lui-même (code et données)
Parallélisme I — P-F. Bonnefoi
Parallélisme I — P-F. Bonnefoi
#include <unistd.h>
pid_t fork(void)
J. Delacroix
33
PROCESSUS PID 12223
Exécution de l ’appel système fork
Main ()
{
pid_t ret ;
int i, j;
for(i=0; i<8; i++)
i = i + j;
for(i=0; i<8; i++)
i = i + j;
ret = fork();
ret = fork();
12223
Si les ressources noyau sont
disponibles
0
}
retourner
le pid du processus crée à son
père
et 0 au processus fils
117
NSY103 2009-2010
Cours «Parallélisme I» – P-F. Bonnefoi – http://p-fb.net/
MODE SYSTEME
Main ()
{
pid_t ret ;
int i, j;
}
115NSY103 2009-2010
34
Primitives et commandes de processus
• Création de processus
•
J. Delacroix
—
J. Delacroix
35
31 décembre 2015 — 19
Primitives
et commandes de processus
Primitive de création de processus
Primitives
et commandes de processus
Primitive de création de processus
Valeur de retour de l’appel système fork
PERE
signal_struct
Table des
Régions (mm_struct)
Données
files_struct
PROCESSUS
PID 12222
PROCESSUS
PID 12223
Main ()
{
pid_t ret ;
int i, j;
Main ()
{
pid_t ret ;
int i, j;
for(i=0; i<8; i++)
i = i + j;
for(i=0; i<8; i++)
i = i + j;
• Chaque processus père et fils reprend son
exécution après le fork()
Task_struct
Pile
User
118
Parallélisme I — P-F. Bonnefoi
Parallélisme I — P-F. Bonnefoi
Pile noyau
FILS
Code
partagé
Données
Table des
régions
Task_struct
Pile
User
Pile noyau
NSY103 2009-2010
J. Delacroix
36
120
Primitives
et commandes
processus
Primitive
de création dede
processus
Lors d'un accès en écriture par l'un des deux processus, le segment de
données ou la pile sont effectivement dupliqués.
Données
r
Père
NSY103 2009-2010
Table des
régions
Code
r
Pile
User
r
Fils
119
Données
Code
r
rw
Table des
régions
Père
Accès écriture
J. Delacroix
données
Pile
User
r
Parallélisme I — P-F. Bonnefoi
Parallélisme I — P-F. Bonnefoi
- le segment de code;
- le segment de données et la pile sont également partagés et
mis en accès lecture seule .
r
0
On utilise pour cela le code retour du fork()
qui est différent chez le fils (toujours 0)
et le père (pid du fils crée)
}
NSY103 2009-2010
J. Delacroix
PROCESSUS
PID 12222
Lors de sa création, le fils partage avec son père:
Table des
régions
}
ret = fork();
Main ()
{
pid_t ret ;
int i, j;
for(i=0; i<8; i++)
i = i + j;
for(i=0; i<8; i++)
i = i + j;
ret= fork();
ret= fork();
if (ret == 0)
printf(" je suis le fils ")
else
{
printf ("je suis le père");
printf ("pid de mon fils %d", ret)
}
}
if (ret == 0)
printf(" je suis le fils ")
else
{
printf ("je suis le père");
printf ("pid de mon fils, %d" , ret)
}
}
Pid du fils : 12223
getpid : 12222
getppid :shell
121
NSY103 2009-2010
Cours «Parallélisme I» – P-F. Bonnefoi – http://p-fb.net/
PROCESSUS
PID 12223
Main ()
{
pid_t ret ;
int i, j;
Fils
37
38
Valeur de retour
de l’appel de
système
fork de processus
Primitive
création
• Mécanisme du copy on write ( Copie sur écriture):
Données
12223
Primitives et commandes de processus
La table des régions ou des segments
Table des
régions
ret = fork();
• Le code et les données étant strictement
identiques, il est nécessaire de disposer d ’un
mécanisme pour différencier le comportement
des deux processus après le fork()
—
getpid : 12223
getppid :12222
J. Delacroix
39
31 décembre 2015 — 20
Synchronisation père / fils
Primitives et commandes de processus
Synchronisation père / fils
Primitives
et commandes de processus
Lorsqu'un processus se termine (exit), le système démantèle tout son
contexte, sauf l'entrée de la table des processus le concernant.
Actif Utilisateur
Synchronisa
Synchronisation père
/ fils
Synchronisation
père / fils
Mode Utilisateur
Nouveau
Prêt
Le processus père, par un wait(), "récupère" la mort de son fils, cumule
les statistiques
de celui-ci
avec
les siennes
et détruit
de
laLorsqu'un
table
son
processus
se termine
Lorsqu'un
processus
se termine
(exit),
le processus
système
démantèle
tout
Lorsqu'un
se l'entrée
termine
(exit),
le système
démantèle
tout son
des processus
concernant
son
fils
sauf
de la table
contexte,
sauf l'entrée
de la table
desdéfunt.
processus
le concernant.
contexte,
sauf l'entrée
de la table descontexte,
processus
le l'entrée
concernant.
Le processus fils disparaît complètement.
Le processus
père,
par fils,
un wait(),
Le processus père, par un wait(),
Le "récupère"
la mort
son
fils, "récupère"
cumule
processus père,
pardeun
wait(),
la mort
de son
cumu
les statistiques
celui-ci
l
les
Lastatistiques
communication
entre le
fils
zombie
et leetpère
s'effectue
par
lesiennes
biais
de celui-ci
avec
les
siennes
détruit
l'entrée
de
table
les
statistiques
de celui-ci
avec
lesla
et détruitde
l'entrée
deavec
la tab
des
processus concernant son fi
d'un
signal transmis
du fils
vers
père (signal
SIGCHLDson
ou fils
mort
du fils)
des
processus
concernant
son
filsle
défunt.
des
processus
concernant
défunt.
Le processus fils disparaît comp
Le processus fils disparaît complètement.
Le processus fils disparaît complètement.
Actif Noyau
Zombi
Endormi
122
Mode Noyau en mémoire
#include <stdlib.h>
void exit (int valeur);
pid_t wait (int *status);
Parallélisme I — P-F. Bonnefoi
Parallélisme I — P-F. Bonnefoi
• Primitive exit()
un appel à la primitive exit() provoque la terminaison du processus
effectuant l'appel avec un code retour valeur. (Par défaut, le
franchissement de la dernière } d'un programme C tient lieu d'exit)
un processus qui se termine passe dans l'état Zombie et reste dans cet
état tant que son père n'a pas pris en compte sa terminaison
Le processus père "récupère" la terminaison de ses fils par un appel
à la primitive wait ()
NSY103 2009-2010
J. Delacroix
ATTENTION : mauvaise synchronisation = saturation table des
Laetcommunication
entre
zo
= blocage
dulesystème
Laprocessus
La
communication
entre
fils
zombie
et le père s'effectue
parzombie
lebiais
communication
entre le fils
le père s'effectue
parlelefils
biais
d'un
signalSIGCHLD
transmis ou
du mort
fils vers
TASK
[0.. NR_TASKS]
d'un signal transmis du fils vers
le père
(signal
SIGCHLD
mort
du
fils)
d'un
signal
transmis
du filsou
vers
le père
(signal
du
Liste des PCB
: mauvaise
synchron
ATTENTION : mauvaise synchronisation
= saturation
des ATTENTION
ATTENTION
: mauvaisetable
synchronisation
= saturation
table des
processus = blocage du système
processus = blocage du système
processus = blocage du système
TASK [0.. NR_TASKS]
NSY103 2009-2010
}
Cours «Parallélisme I» – P-F. Bonnefoi – http://p-fb.net/
Delacroix
NSY103J.2009-2010
files_struct
mm_struct
signal_struct
• Decès et adoption
Main ()
{
Main ()
{ pid_t ret;
intret;
i, j;
pid_t
42
Un processus fils défunt reste zombie jusqu'à ce que son père
ait pris connaissance de sa mort
Parallélisme I — P-F. Bonnefoi
Parallélisme I — P-F. Bonnefoi
files_struct
mm_struct
signal_struct
NSY103 2009-2010
43
J. Delacroix
des processus
Unix
PrimitivesGénétique
et commandes
de processus
PROCESSUS
PID 12223
PROCESSUS
PID 12223
J. Delacroix
43
124
{
Main ()
pid_t ret ;
{
intret
i, j;;
pid_t
int i, j;
int i, j;
for(i=0; i<8; i++)
for(i=0; i<8; i++)
i + j;
i + j;
for(i=0; i<8;i =i++)
for(i=0; i<8;i =
i++)
ret=i fork();
ret=i =
fork();
= i + j;
i + j;
if
(ret
==
0)
ret= fork();
ret= fork();
{ == 0)
if (ret== 0)
if (ret
printf(" je suis le fils ");
{
{
if
(ret==
0)
exit(); }suis le fils ");
printf(" je
printf(" je suis le fils ");
{
else
exit(); }
exit; } suis le fils ");
printf(" je
else{
else
exit;
}
printf ("je suis le père");
{
else{
printf
("pid
de
mon
fils,
%d"
,
ret)
printf ("je suis le père");
printf ("je suis le père");
{
wait();
printf
("pid de mon fils, %d" , ret)
printf
depère");
mon fils, %d" ,ret);
printf
("je ("pid
suis le
}
wait();
wait();
printf
("pid de mon fils, %d" ,ret);
}
}
wait();
}
}
}
NSY103
2009-2010
J. Delacroix }
NSY103 2009-2010
J. Delacroix
41
Primitive de création de processus
Primitives
et commandes
deprocessus
processus
Primitive
de création de
123
Liste des PCB
mm_struct
signal_struct
NSY103 2009-2010
PROCESSUS
PID 12222
PROCESSUS
PID Main
12222()
TASK [0.. NR_TASKS]
Liste des PCB
files_struct
42
125
Un processus fils orphelin, suite au décès de son père (le
processus père s'est terminé avant son fils) est toujours adopté
par le processus 1 (init).
INIT
adoption
GRAND PERE
PERE
Hélas, je suis mort !!!
FILS
NSY103 2009-2010
—
J. Delacroix
44
31 décembre 2015 — 21
J. Delacro
Définition et contexte
Primitives
de recouvrement
(execl)
Primitives
et commandes
de processus
Primitives de recouvrement (execl)
Primitive
de recouvrement : remplacer le segment
de code
#include <sys/types.h>
PROCESSUS
int execl(const char *ref, const char *arg, …, NULL)
Chemin absolu du code exécutable
Chemin absolu du code exécutable
arguments
Parallélisme I — P-F. Bonnefoi
arguments
126
Création d'un processus fils
par duplication du code et données du père
Création d'un processus fils
par duplication du code et données du père
PROCESSUS
Main ()
{
Main ()
pid_t pid ;
{
int i, j;
pid_t pid ;
int i, j;
for(i=0; i<8; i++)
i = i + j;
for(i=0; i<8; i++)
= i + j;
pid=i fork();
pid=if fork();
(pid == 0)
{
if (pid == printf(" je
0)
suis le fils ");
{
Le processus fils recouvre le code et les données
execl("/home/calcul","calcul","3","4", NULL);
printf(" je
suis
le fils ");
hérités du père par ceux du programme calcul.
executable
paramètres
LeLe
processus
fils recouvre
le code de
et les
père transmet
des données
sondonnées
environnement
} execl("/home/calcul","calcul","3","4", NULL);
hérités
par les
ceux
du programme
calcul.
vers du
sonpère
fils par
paramètres
de l'exec
else
executable
paramètres
Le père transmet des données de son environnement
} {
vers son fils par les paramètres de l'exec
else printf ("je suis le père");
{
printf ("pid de mon fils, %d" , pid);
printf
("je suis le père");
wait();
Le père attend son fils
printf
("pid de mon fils, %d" , pid);
}
wait();
Le père attend son fils
} }
NSY103 2009-2010
J. Delacroix
47
NSY103 2009-2010
J. Delacroix
}
47
Parallélisme I — P-F. Bonnefoi
#include
<sys/wait.h>
#include
<sys/types.h>
int execl(const
char *ref, const char *arg, …, NULL)
#include
<sys/wait.h>
Signaux :
Un signal est une information atomique envoyée à un
processus ou à un groupe de processus par le système
d'exploitation ou par un autre processus.
Le signal constitue un système de communication
entre processus qui peut les amener à réagir en
conséquence.
128
Les IPCs, « Inter-Processes Communication »
Définition et contexte
• Signaux
• Tubes
• Mémoire partagée
127
Cours «Parallélisme I» – P-F. Bonnefoi – http://p-fb.net/
Parallélisme I — P-F. Bonnefoi
Parallélisme I — P-F. Bonnefoi
Lorsqu'il reçoit un signal, un processus peut réagir de
trois façons :
o Il est immédiatement dérouté vers une fonction
spécifique, qui réagit au signal
o Le signal est tout simplement ignoré.
o Le signal provoque l'arrêt du processus (avec ou
sans génération d'un fichier core).
129
—
31 décembre 2015 — 22
Signaux Classiques
Définition et contexte
o soit il ignore le signal ;
o soit il termine le processus (avec ou sans génération
d'un fichier core).
130
• signaux relatifs à la fin de processus :
– SIGCHLD (17) : mort
du fils
Méthodes de Programmation Système 2008/2009
J. Delacroix
– SIGKILL (9) : signal de terminaison
Parallélisme I — P-F. Bonnefoi
Parallélisme I — P-F. Bonnefoi
Par exemple, lorsqu'un processus reçoit un signal pour
lequel il n'a pas indiqué de fonction de traitement, le
système d'exploitation adopte une réaction par défaut
qui varie suivant les signaux :
Présentation des différents signaux POSIX
• L'événement associé à un signal
– extérieur au processus (frappe caractère, terminaison d'un
autre processus)
– intérieur
audes
processus
correspondant
à une erreur
(erreur
Liste
signaux
selon le standard
POSIX
arithmétique ou violation mémoire) : levée d'une trappe.
132
131
Cours «Parallélisme I» – P-F. Bonnefoi – http://p-fb.net/
J. Delacroix
4
J. Delacroix avec le terminal (extinction,
4
• signaux relatifs aux interactions
frappe touche DELETE et BREAK)
– SIGHUP, SIGINT (crtl C), SIGQUIT (crtl \)
Méthodes de Programmation Système 2008/2009
Parallélisme I — P-F. Bonnefoi
Parallélisme I — P-F. Bonnefoi
en employant la commande kill, ou en utilisant le gestionnaire de tâches
q Depuis un interpréteur de commandes
Depuis un programme en C
• signaux relatifs à des erreurs
• –signaux
relatifs
aux temporisations
SIGILL
(4) : instruction
illégale
SIGALRM
de temporisation (fonction alarm)
–– SIGFPE
(8) : (14):
erreurfin
arithmétique
• signauxListe
relatifs
temporisations
desaux
signaux
selon le standard POSIX
– SIGALRM (14): fin de temporisation (fonction alarm)
q consciemment, en tapant Control-C,
Envoi de signaux :
• signaux relatifs à des erreurs
– SIGILL
(4) à: instruction
illégale :
• signaux
relatifs
la fin de processus
SIGFPE (8)
: erreur
–– SIGCHLD
(17)
: mortarithmétique
du fils
–
SIGSEGV
(11)
:
violation
mémoire
– SIGKILL (9) : signal de terminaison
– SIGPIPE (13) : écriture dans un tube sans lecteur
Méthodes de Programmation Système 2008/2009
Vous avez certainement toutes et tous déjà utilisé des
signaux :
q ou inconsciemment, lorsqu'un de vos programme a affiché
segmentation fault (core dumped).
Liste des signaux selon le standard POSIX
– SIGSEGV (11) : violation mémoire
Présentation
des différents signaux
– SIGPIPE (13) : écriture dans un tube sans lecteur
Définition et contexte
3
• signaux relatifs à la mise au point de programmes
• Deux signaux disponibles pour les utilisateurs (SIGUSR1,
SIGUSR2)
133
—
Méthodes de Programmation Système 2008/2009
31 décembre 2015 — 23
J. Delacroix
5
Un exemple précis
Signaux : gestion par le noyau
1. Comment le noyau envoie-t-il un signal à un processus ?
void message1(int n) {
if (n == SIGQUIT) {
printf("SIGQUIT recu\n"); exit(1) ;
} else {
printf("SIGINT reçu\n"); exit(2) ;
}
}
void message2(int n) {
printf("Signal %d : recu\n", n);
}
int main(int argc, char **argv) {
int n;
signal(SIGINT, message1);
signal(SIGQUIT, message1);
signal(SIGUSR1, message2);
signal(SIGUSR2, message2);
for( ; ; );
}
• Positionnement d'un bit à 1 dans le champ signal de la table des
processus, correspondant au type de signal reçu.
– signal pendant (reçu)
fonction kill
Gestionnaire d'exception
– vecteur de bits : pas de mémorisation du nombre de signaux
d'un type reçu.
Parallélisme I — P-F. Bonnefoi
Parallélisme I — P-F. Bonnefoi
#include <signal.h>
134
31 30 29 28
Signal[0]
Entier de 32 bits
0
1
0
0
1
1
0
1
..........................
3
2
1
0
0
0
1
1
0
1
136
J. Delacroix traite-t-il un signal ? 8
2. Comment le noyau
Méthodes de Programmation Système 2008/2009
Signaux
: structures
dededonnées
duprocessus
processus
Signaux
: structures
données du
PCB
Typedef struct { unsigned long sig[2]; } sigset_t;
Signaux classiques 11100000001111111111111111111000
Signaux temps réel 01010011010010101001010101000101
files_struct
mm_struct
Struct signal_struct { ……
struct k_sigaction action [64];
…….}
signal_struct
135
Utilisateur
TASK_STRUCT
sigset_t signal; -- signaux reçus
sigset_t blocked; -- signaux bloqués (« masqués »)
struct task_struct *next_task, *prev_task; -- chainage PCB
struct task_struct *next_run, *prev_run; -- chainage PCB Prêt
int pid; -- pid du processus
struct task_struct *p_opptr, *p_pptr, *p_cptr,; -- pointeurs PCB père originel, père
actuel, fils
long need_resched; -- ordonnancement requis ou pas
long utime, stime, cutime, cstime;
-- temps en mode user, noyau, temps des fils en mode user, noyau
unsigned long policy; -- politique ordonnancement SCHED_RR, SCHED-FIFO,
SCHED_OTHER
struct thread_struct tss; -- valeurs des registres du processeur
struct mm_struct *mm; -- contexte mémoire
struct files_struct *files ; -- table fichiers ouverts
J. Delacroix
Cours «Parallélisme I» – P-F. Bonnefoi – http://p-fb.net/
Noyau
Un processus ne s'exécute jamais
en mode utilisateur avant de traiter
les signaux
137
struct signal_struct *sig ; -- table de gestion des signaux ; actions à réaliser
lors de la prise en compte des signaux par le processus
Méthodes de Programmation Système 2008/2009
• Le noyau traite la réception des signaux quand le processus
quitte le mode noyau pour retourner au mode utilisateur
– signal délivré
– le bit correspondant est remis à 0
Parallélisme I — P-F. Bonnefoi
Parallélisme I — P-F. Bonnefoi
volatile long state; - - état du processus
Signaux : gestion par le noyau
Méthodes de Programmation Système 2008/2009
7
—
J. Delacroix
Ordonnancement
Election
Examen des signaux reçus
par le processus élu
Traitement
(do_signal()) 9
31 décembre 2015 — 24
3. Comment un processus contrôle-t-il ses réactions
3. Exécution d’un handler de signal défini par
l’utilisateur
Exécution d’un handler de signal défini par l’utilisateur
vis-à-vis
des
signaux ?
Signaux : gestion
par le
processus
• Traitement des signaux
• Traitement des signaux
– A tout signal est associé un traitement par défaut
(ignorer, terminer le processus avec ou sans core,
stopper le processus);
– Tout processus peut installer pour chaque type de signal
(hormis SIGKILL), un nouveau handler
• handler SIG_IGN : pour ignorer le signal (sauf mort
du fils pour Linux)
• handler fonction utilisateur pour capter le signal
fonction signal et sigaction
138
1
4
}
fonction handler
{
sig_int
Co
}
2
@
@ handler
ha
nd
ler
3
140
Méthodes de Programmation Système 2008/2009
J. Delacroix
Méthodes de Programmation Système 2008/2009
10
3. Comment un processus contrôle-t-il ses réactions
signaux ?
Signaux : gestion vis-à-vis
par le des
processus
(fonction du noyau do_signal())
3
0
1
0
1
0
1
Indicateurs
de
Comportement
(sig)
0
1
..........................
0
0
1
0
0
1
mon_handler{
printf ("Signal
reçu \n"); }
1
..........................
139 Méthodes de Programmation Système 2008/2009
1
Gestionnaire d'interruption
Exécution de la routine
d'interruption horloge
CO
(y = y - 1)
2
IRQ horloge
1
SIG_IGN
rien
SIG_DFL
13
Mode noyau
Mode utilisateur
main()
{
int
x, y = 0;
signal (SIG_INT, mon_handler);
for (;;) {
x = x + 2;
y = y - 1;}
}
@handler
action définie par l’utilisateur
J. Delacroix
11
Parallélisme I — P-F. Bonnefoi
entier signal[0]
2
J. Delacroix
3. Exécution d’un handler de signal défini par l’utilisateur
Exécution d’un
handler de signal défini par l’utilisateur
• Traitement des signaux
Parallélisme I — P-F. Bonnefoi
Noyau
main()
{
Parallélisme I — P-F. Bonnefoi
Parallélisme I — P-F. Bonnefoi
Utilisateur
SIG_INT
5
Invoquer fonction
système
sig_return()
CO
(y = y - 1)
4 CO <-- @mon_handler
Exécution de
sig_return()
5
CO
(y = y - 1)
CO <-- CO ( y = y - 1)
Méthodes de Programmation Système 2008/2009
Cours «Parallélisme I» – P-F. Bonnefoi – http://p-fb.net/
3
@ mon_handler
6
141
ret_from_intr()
do_signal()
handle_signal()}
sig.sa_handler
—
5
6
J. Delacroix
14
31 décembre 2015 — 25
Les fonctions liées aux signaux
Signaux
synthèse
La synthèse du déroulement
de :la
gestion d’un signal
Les fonctions associées aux signaux
•
Envoyer un signal à un processus
– int kill (pid_t pid, int sig)
– kill -n°signal pid
Processus 1
•
kill (proc1, sig1)
Attendre un signal
– int pause();
142
{
signal(sig1, handler)
Armer une temporisation
– int alarm (int seconds)
alarm(10)
– au bout de seconds unités de temps, le signal SIGALRM est
envoyé au processus
•
Noyau
Processus 2
{
Associer un handler à un signal
– signal(int sig, fonction)
signal(SIGINT, p_hand)
– sigaction(int sig, struct sigaction action, NULL)
1
}
Signal pendant
handler()
{
}
handler
}
144
Méthodes de Programmation Système 2008/2009
Méthodes de Programmation Système 2008/2009
J. Delacroix
Utilisateur
Noyau
handler()
{
0
}
handler
{
145
J. Delacroix
Cours «Parallélisme I» – P-F. Bonnefoi – http://p-fb.net/
processus1
sig1
}
0
handler()
{
}
It horloge
Signal délivré
handler
ordonnancement
élection processus 1
examen, traitement signaux
}
}
Méthodes de Programmation Système 2008/2009
Processus 2
kill (proc1, sig1)
sig1
}
Noyau
signal(sig1, handler)
processus1
Parallélisme I — P-F. Bonnefoi
Parallélisme I — P-F. Bonnefoi
Processus 1
{
kill (proc1, sig1)
143
Utilisateur
Processus 2
signal(sig1, handler)
19
La synthèse du déroulement de la gestion d’un signal
Signaux : synthèse
{
{
J. Delacroix
16
Signauxde: synthèse
La synthèse du déroulement
la gestion d’un signal
Processus 1
processus1
sig1
Parallélisme I — P-F. Bonnefoi
Parallélisme I — P-F. Bonnefoi
•
Utilisateur
kill (12563, SIGKILL)
kill -9 12563
Méthodes de Programmation Système 2008/2009
J. Delacroix
20
18
—
31 décembre 2015 — 26
Signaux et interruptions
Définition et contexte
Comparaison signal/interruption
• Signaux
Le processus P2 envoie un
signal au processus P1 (signal
pendant chez P1)
Le dispositif matériel X envoie
une interruption lors de
l’exécution du processus P1.
Plus tard, le processus P1 est
élu. Il quitte le mode noyau. Il
exécute le handler du signal en
mode utilisateur (signal
délivré à P1).
Immédiatement, le processus
P1 est dérouté en mode noyau
pour exécuter le handler
« routine » de l’interruption.
146
Parallélisme I — P-F. Bonnefoi
Parallélisme I — P-F. Bonnefoi
Tuyaux :
• Interruptions
Chaque côté du tuyau est un descripteur de fichier
ouvert soit en lecture soit en écriture, ce qui permet de
s'en servir très facilement, au moyen des fonctions
d'entrée / sortie classiques.
148
Méthodes de Programmation Système 2008/2009
J. Delacroix
21
Définition et contexte
Tuyaux et synchronisation
Tuyaux :
Caractéristiques :
Les tuyaux permettent à un groupe de processus
d'envoyer des données à un autre groupe de
processus.
La lecture d'un tuyau est bloquante, c'est-à-dire que si
aucune donnée n'est disponible en lecture, le processus
essayant de lire le tuyau sera suspendu (il ne sera pas pris
en compte par l'Ordonnanceur et n'occupera donc pas
inutilement le processeur) jusqu'à ce que des données soient
disponibles.
Ces données sont envoyées directement en
mémoire sans être stockées temporairement sur
disque, ce qui est donc très rapide.
147
Cours «Parallélisme I» – P-F. Bonnefoi – http://p-fb.net/
Parallélisme I — P-F. Bonnefoi
Parallélisme I — P-F. Bonnefoi
Tout comme un tuyau de plomberie, un tuyau de
données a deux côtés :
q un côté permettant d'écrire des données
q un côté permettant de les lire.
L'utilisation de cette caractéristique comme effet de bord
peut servir à synchroniser des processus entre eux (les
processus lecteurs étant synchronisés sur les processeur
écrivains).
149
—
31 décembre 2015 — 27
Définition et contexte
Définition et contexte
Caractéristiques :
o Les tuyaux sont très utilisés sous UNIX pour faire
communiquer des processus entre eux. Ils ont cependant
deux contraintes :
Par exemple, si un processus écrit les deux caractères « ab » dans un tuyau
lu par les processus A et B et que A lit un caractère dans le tuyau, il lira le
caractère « a » qui disparaîtra immédiatement du tuyau sans que B puisse
le lire.
Si B lit alors un caractère dans le tuyau, il lira donc le caractère « b » que
A, à son tour, ne pourra plus y lire.
Si l'on veut donc envoyer des informations identiques à plusieurs
processus, il est nécessaire de créer un tuyau vers chacun d'eux.
150
Parallélisme I — P-F. Bonnefoi
Parallélisme I — P-F. Bonnefoi
La lecture d'un tuyau est destructrice, c'est-à-dire que si plusieurs
processus lisent le même tuyau, toute donnée lue par l'un disparaît pour
les autres.
o Les tuyaux ne permettent qu'une communication
unidirectionnelle
o Les processus pouvant communiquer au moyen d'un
tuyau doivent être issus d'un ancêtre commun.
152
Définition et contexte
L’appel système
Caractéristiques :
o Un tuyau se crée très simplement au moyen de l'appel système
pipe() :
o Vous avez sans doute déjà utilisé des tuyaux.
Par exemple, lorsque vous tapez ls | wc –l
o L'interprète de commandes relie la sortie standard de la commande
ls à l'entrée standard de la commande wc au moyen d'un tuyau.
151
Cours «Parallélisme I» – P-F. Bonnefoi – http://p-fb.net/
Parallélisme I — P-F. Bonnefoi
Parallélisme I — P-F. Bonnefoi
o De même qu'un tuyau en cuivre a une longueur finie, un tuyau de
données à une capacité finie. Un processus essayant d'écrire dans un
tuyau plein se verra suspendu en attendant qu'un espace suffisant se
libère.
o L'argument de pipe() est un tableau de deux descripteurs de
fichier (un descripteur de fichier est du type int en C) similaires à
ceux renvoyés par l'appel système open() et qui s'utilisent de la même
manière.
Lorsque le tuyau a été créé, le premier descripteur, tuyau[0],
représente le côté lecture du tuyau et le second, tuyau[1], représente
le côté écriture.
153
—
31 décembre 2015 — 28
o Un moyen mnémotechnique pour se rappeler quelle
valeur représente quel côté est de rapprocher ceci de
l'entrée et de la sortie standard.
o L'entrée standard, dont le numéro du descripteur de
fichier est toujours 0, est utilisée pour lire au clavier : 0
lecture.
o La sortie standard, dont le numéro du descripteur de
fichier est toujours 1, est utilisée pour écrire à l'écran : 1
écriture.
o Néanmoins, pour faciliter la lecture des programmes et
éviter des erreurs, il est préférable de définir deux
constantes dans les programmes qui utilisent les tuyaux.
154
L’implémentation d’un tuyau
Parallélisme I — P-F. Bonnefoi
Parallélisme I — P-F. Bonnefoi
L’appel système
156
L’implémentation d’un tuyau
L’implémentation d’un tuyau
La mise en place d'un tuyau permettant à deux processus de
communiquer est relativement simple.
Prenons l'exemple d'un processus qui crée un fils auquel il va envoyer des
données :
Un tuyau ayant plusieurs lecteurs peut poser des
problèmes, c'est pourquoi le processus père doit
fermer le côté lecture après l'appel à fork().
o Puis il crée un processus fils grâce à fork().
Les deux processus partagent donc le tuyau.
o Puisque le père va écrire dans le tuyau, il n'a pas besoin du côté
lecture, donc il le ferme.
o De même, le fils ferme le côté écriture.
o Le processus père peut dès lors envoyer des données au fils.
Cours «Parallélisme I» – P-F. Bonnefoi – http://p-fb.net/
Parallélisme I — P-F. Bonnefoi
Parallélisme I — P-F. Bonnefoi
o Le processus père crée le tuyau au moyen de pipe().
155
Le tuyau doit être créé avant l'appel à la
fonction fork() pour qu'il puisse être partagé
entre le processus père et le processus fils (les
descripteurs de fichiers ouverts dans le père
sont hérités par le fils après l'appel à fork()).
Il en va de même pour un tuyau ayant plusieurs
écrivains donc le processus fils doit aussi fermer le
côté écriture.
Omettre de fermer le côté inutile peut entraîner
l'attente infinie d'un des processus si l'autre se
termine.
157
—
31 décembre 2015 — 29
L’implémentation d’un tuyau
Tuyau et signal SIGPIPE
Imaginons que le processus fils n'ait pas fermé le côté
écriture du tuyau.
En revanche, s'il avait fermé le côté écriture, il aurait reçu un
code d'erreur en essayant de lire le tuyau, ce qui l'aurait
informé de la fin du processus père.
158
Parallélisme I — P-F. Bonnefoi
Parallélisme I — P-F. Bonnefoi
Si le processus père se termine, le fils va rester bloqué en
lecture du tuyau sans recevoir d'erreur puisque son
descripteur en écriture est toujours valide.
Comme le comportement par défaut de ce signal est
de terminer le processus, il peut être intéressant de
le gérer afin, par exemple, d'avertir l'utilisateur puis
de quitter proprement le programme.
160
L’implémentation d’un tuyau
Modèle Q/R
L - E
Synchronisation à l’aide des tuyaux
o Un effet de bord intéressant des tuyaux est la possibilité de
synchroniser deux processus.
o En effet, un processus tentant de lire un tuyau dans lequel
il n'y a rien est suspendu jusqu'à ce que des données soient
disponibles.
o Donc, il est possible de synchroniser le processus lecteur
sur le processus écrivain.
L - E
TUBE 1
Processus B
Processus A
Parallélisme I — P-F. Bonnefoi
Parallélisme I — P-F. Bonnefoi
Lorsqu'un processus écrit dans un tuyau qui n'a
plus de lecteurs (parce que les processus qui
lisaient le tuyau sont terminés ou ont fermé le côté
lecture du tuyau), ce processus reçoit le signal
SIGPIPE.
TUBE 2
L - E
L - E
Fermeture des descripteurs inutiles
159
Synchronisation
Ecriture E
Processus A
Lecture L
Ecriture E
Processus B
TUBE
Lecture L
163
– Soit: PA transmet à PB ou PB transmet à PA
C. Crochepeyre Cnam - Diapason
Unix: communications internes
Cours «Parallélisme I» – P-F. Bonnefoi – http://p-fb.net/
23
SI
—
31 décembre 2015 — 30
– PA dépose et PA lit => PB bloqué
– PA et PB déposent et PB lit => risque que PB lise sa propre
Synchronisation à l’aide des tuyaux
Les tuyaux nommés
Les tuyaux souffrent de deux limitations :
écriture
écriture
o ils ne permettent qu'une communication unidirectionnelle ;
Processus A
o les processus pouvant communiquer au moyen d'un tuyau doivent
être issus d'un ancêtre commun.
Processus B
o Les tuyaux nommés (développés dans le chapitre suivant)
o Les sockets réseaux qui permettent une communication
bidirectionnelle entre divers processus, fonctionnant sur la même
machine ou sur des machines reliées par un réseau.
164
Parallélisme I — P-F. Bonnefoi
Parallélisme I — P-F. Bonnefoi
open(“échange”)
Ainsi, d'autres moyens de communication entre processus ont été
développés pour pallier ces inconvénients :
“echange”
lecture
lecture
168
C. Crochepeyre Cnam - Diapason
Les tuyaux nommés
menthe22> echo coucou > fifo &
[1] 25312
menthe22> cat fifo
[1] + done
echo coucou > fifo
Coucou
166
Cours «Parallélisme I» – P-F. Bonnefoi – http://p-fb.net/
Parallélisme I — P-F. Bonnefoi
o Une fois créé, un tuyau nommé s'utilise très facilement :
31
Un processus tentant d'écrire dans un tuyau nommé
ne possédant pas de lecteurs sera suspendu jusqu'à
ce qu'un processus ouvre le tuyau nommé en
lecture.
o Un tuyau nommé est donc un fichier :
menthe22> mkfifo fifo
menthe22> ls -l fifo
prw-r--r-- 1 in201
in201
0 Jan 10 17:22 fifo
o Il s'agit cependant d'un fichier d'un type particulier, comme le montre le
p dans l'affichage de ls.
Unix: communications internes
Les tuyaux nommés
o Les processus désirant communiquer désignent le tuyau qu'ils
souhaitent utiliser.
Ceci se fait grâce au système de fichiers.
Parallélisme I — P-F. Bonnefoi
open(“échange”)
TUBE
C'est pourquoi, dans l'exemple, echo a été lancé en
tâche de fond, afin de pouvoir récupérer la main
dans le shell et d'utiliser cat.
On peut étudier ce comportement en travaillant dans
deux fenêtres différentes.
169
—
31 décembre 2015 — 31
Les tuyaux nommés
Les tuyaux nommés
En C, un tuyau nommé se crée au moyen de la
fonction mkfifo() :
On peut étudier ce comportement en reprenant
l'exemple mais en lançant d'abord cat puis echo.
170
Il doit ensuite être ouvert (grâce à open() ou à
fopen()) et s'utilise au moyen des fonctions
d'entrées / sorties classiques.
Parallélisme I — P-F. Bonnefoi
Parallélisme I — P-F. Bonnefoi
De même, un processus tentant de lire dans un
tuyau nommé ne possédant pas d'écrivains se verra
suspendu jusqu'à ce qu'un processus ouvre le tuyau
nommé en écriture.
172
Les tuyaux nommés
Les tuyaux
• EXEMPLE
TUBEnommés
NOMMÉ
o En particulier, ceci signifie qu'un processus
ne peut pas utiliser un tuyau nommé pour
stocker des données afin de les mettre à la
disposition d'un autre processus une fois le
premier processus terminé.
o On retrouve le même phénomène de
synchronisation qu'avec les tuyaux
classiques.
171
Cours «Parallélisme I» – P-F. Bonnefoi – http://p-fb.net/
Parallélisme I — P-F. Bonnefoi
Parallélisme I — P-F. Bonnefoi
/* Processus ecrivain */
173
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
main()
{mode_t mode;
int tub;
mode = S_IRUST | S_IWUSR;
mkfifo (“fictub”,mode)
tub = open(“fictub”,O_WRONLY)
write (tub,”0123456789”,10);
close (tub);
exit(0);}
C. Crochepeyre Cnam - Diapason
—
/* création fichier FIFO */
/* ouverture fichier */
/* écriture dans fichier */
Unix: communications internes
37
31 décembre 2015 — 32
La mémoire partagée, « shared memory »
Shared memory
Les tuyaux nommés
• Création ou accès à une région de mémoire partagée
int shmget (key_t cle, int taille, int option)
/* Processus lecteur */
Identification
Interne de la région Identification Taille de la région
externe de la région
en octet
tub = open(“fictub”,O_RDONLY)
read (tub,buf,10);
buf[11]=0;
printf(“J’ai lu %s\n, buf);
close (tub);
exit(0); }
Parallélisme I — P-F. Bonnefoi
Parallélisme I — P-F. Bonnefoi
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
main()
{int tub;
char buf[11];
/* ouverture fichier */
/* lecture du fichier */
174
176
C. Crochepeyre Cnam - Diapason
Unix: communications internes
Identification
Interne de la région
Adresse de
la région
(0 ou valeur)
• Détachement d'une région de mémoire partagée
void *shmdt (void *shmadd)
Joëlle Delacroix
NSY103
/******************************************************************/
/*
processus créateur du segment et écrivain
/******************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
privé
privé
Processus B
41
Région
mémoire,pouvant
ou segment,
être partagée
entre plusieurs
processus
• Région
de de
mémoire
êtrepouvant
partagée
entre plusieurs
processus
• un processus doit attacher le région à son espace d'adressage avant de pouvoir
l'utiliser doit attacher le région à son espace d'adressage avant
• Un processus
• Outil IPC repéré par une clé unique
de pouvoir
l'utiliser
• L'accès
aux données présentes dans la région peut requérir une synchronisation (outil
sémaphore)
• Outil• IPC
repéré
une correspond
clé uniqueà des pages de mémoire.
la région
ou par
segment
• 175L'accès aux données présentes dans la région peut requérir une
synchronisation (outil sémaphore)
40
*/
#define CLE 256
Parallélisme I — P-F. Bonnefoi
Processus A
Parallélisme I — P-F. Bonnefoi
Adresse effective
de la région
La mémoire partagée, « shared memory »
Régions en MC
Cours
«Parallélisme I» – P-F. Bonnefoi
– http://p-fb.net/
Joëlle Delacroix
NSY103
• Attachement d'une région de mémoire partagée
void *shmat (int shmid, const void *shmadd, int option)
38
La mémoire partagée, « shared memory »
Shared memory
Constantes IPC_CREAT,
IPC_EXCL
et droits d'accès
177
main()
{
int shmid;
char *mem ;
/* création du segment de mémoire partagée avec la clé CLE */
shmid=shmget((key_t)CLE,1000,0750 |IPC_CREAT | IPC_EXCL);
/* attachement */
if((mem=shmat(shmid,NULL,0))==(char *)-1) {
perror("shmat");
exit(2);
}
/* écriture dans le segment */
strcpy(mem,"voici une écriture dans le segment");
exit(0);
}
—
31 décembre 2015 — 33
La mémoire partagée, « shared memory »
Le concept de thread
178
int main()
{
char *mem;
int shmid;
/* récupération du segment de mémoire */
shmid=shmget((key_t)CLE,0,0);
/* attachement */
mem=shmat(shmid,NULL,0);
/* lecture dans le segment */
printf("lu: %s\n",mem);
/* détachement du processus */
shmdt(mem);
/* destruction du segment */
shmctl(shmid,IPC_RMID,NULL);
exit(0);
}
Du point de vue de l'utilisateur, ces exécutions semblent se
dérouler en parallèle.
Parallélisme I — P-F. Bonnefoi
Parallélisme I — P-F. Bonnefoi
/******************************************************************/
/* processus destructeur du segment et lecteur */
/******************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#define CLE 256
Le concept de thread
Threads et espace d’adressage mémoire
L’idée
donc
de dissocier
plusieurs
chemins
ou fils d’exécution
L’idée
est est
donc
de dissocier
plusieurs
chemins
ou fils d’exécution
parallèle
dans
un
même
processus
lourd.
parallèle dans un même processus lourd.
Mémoire locale
(une pile par thread)
Parallélisme I — P-F. Bonnefoi
Parallélisme I — P-F. Bonnefoi
Parallélisme I — P-F. Bonnefoi
OnOn
distingue
ainsiainsi
des processus
légerslégers
au seinau
dusein
même
(ou
distingue
des processus
duprocessus
même processus
(ou
thread
traduit
par
fil
d’exécution,
unité
de
traitement,
unité
thread traduit par fil d’exécution, unité de traitement, unité
d'exécution,
fil d'instruction
,ou processus
allégé )allégé
.
d'exécution,
fil d'instruction
,ou processus
).
dans un processus lourd.
Par contre, tous les processus légers possèdent leur propre pile
système.
180
Leconcept
concept
thread
Le
de de
thread
Il y a au moins un processus léger
Il y a au moins un processus léger
dans un processus lourd.
Toutefois, là où chaque processus lourd possède son propre espace
d’adressage, les processus légers appartenant au même processus
se partagent son espace d’adressage en mémoire.
Thread A
Thread B
Pile
Pile
…
Code thread B
Mémoire partagée
(mémoire du
processus lourd)
Code
Code thread A
…
Code commun
Données
globales
123
179
Cours «Parallélisme I» – P-F. Bonnefoi – http://p-fb.net/
181
—
31 décembre 2015 — 34
Le concept de thread
Comparaison processus-thread
Processus lourd UNIX
Un thread est plus léger à gérer et sa gestion peut être
personnalisée.
Création par recopie intégrale du processus
(1,5 ms)
La commutation de contexte est plus simple entre threads.
Des contextes d’exécution différents
impliquent des communications par le
noyau : plus lent et nécessite une
programmation spécifique
Parallélisme I — P-F. Bonnefoi
Parallélisme I — P-F. Bonnefoi
États uniques pour chaque thread:
o identificateur de thread ;
o état des registres ;
o pile ;
o masques de signaux (décrivent à quels signaux le thread
répond) ;
o priorité ;
o données privées au thread.
182
Tas
Pile
I/O
Compteur
Code
Tas
Pile
I/O
Compteur
Pile
Code
Tas
I/O
Noyau du système
d’exploitation
184
Le concept deNotion
thread
de processus léger
Code
Compteur
Comparaison processus-thread
Processus léger POSIX
Fil d ’exécution Ressources
183
Fil d ’exécution
Fil d ’exécution
Fil d ’exécution
Création par recopie de certains éléments
(0,05 ms)
Processus classique
Un même contexte d’exécution entraîne des
communications par la mémoire commune :
plus rapide et un effort de programmation
moins important
Contexte mémoire
Ressources
Espace d ’adressage
Parallélisme I — P-F. Bonnefoi
Parallélisme I — P-F. Bonnefoi
Contexte processeur
CO, Pile
Espace d ’adressage
Processus à threads
Contexte mémoire
Contexte processeur
CO, Pile
Contexte processeur
CO, Pile
Contexte processeur
CO, Pile
NSY103 2009-2010
J. Delacroix
Cours «Parallélisme I» – P-F. Bonnefoi – http://p-fb.net/
52
Compteur
Code
Tas
Pile
I/O
Compteur
Pile
Compteur
Code
Tas
I/O
Pile
Noyau du système
d’exploitation
185
—
31 décembre 2015 — 35
Processus vs thread
Dérivée de la notion de processus
— unité d'exécution concurrente dans un même programme applicatif ("Light-weight process")
— introduit notion de programme dit "multi-threads"
• les threads partagent le même espace d'adressage, la mémoire du processus "englobant" : Code,
données globales, tas
• elles exécutent même code ou des fonctions dédiées ;
• elles partagent tout ou partie ressources OS (E/S par exemple)
• elles peuvent disposer d'un contexte de travail privé alloué par application
— bibliothèques standardisées Posix : pthreads.
186
Les processus séparent complétement
le pointeur d'instruction (IP) ;
la pile (stack) ;
— le tas ;
— les variables ;
— l'allocation mémoire
—
—
Parallélisme I — P-F. Bonnefoi
Parallélisme I — P-F. Bonnefoi
Différences
Un processus ne convient pas toujours :
— contexte lourd, coûteux à créer et à détruire ;
— pas efficace (changement de contexte lent)
Contexte mémoire important
— partage de données "pas naturel" : il faut utiliser des IPC (Inter Process Communication) pour passer
par l'OS ;
— pas intégré dans les langages de programmation (à part le fork)
— fournis par des services OS complexes, pas souples du point de vue de l'utilisateur
— programmation difficile, non contrôlable par l'utilisateur.
Fonctionnement
— le temps processeur est partagé entre les différents processus ;
— le processeur passe d'un processus à l'autre suivant un intervalle régulier ou lorsque un processus
actif est retardé ;
— permet de dé-programmer (deschedule) les processus bloqués en attente de fin d'E/S par exemple.
Processus vs threads
Les threads partagent
le même espace mémoire ;
— les variables.
—
188
Organisation d'un multi-programme
Mise en œuvre des threads
Notion de processus léger
Chaque thread est une unité d'exécution indépendante, et possède :
une pile(s) d'exécution(s)
— un contexte CPU (registres)
— un état courant et attributs d'ordonnancement
— identificateur.
—
espace d ’adressage protégé à n fils
d ’exécution (n ≥ 1)
Parallélisme I — P-F. Bonnefoi
Parallélisme I — P-F. Bonnefoi
espace d ’adressage protégé à un fil
d ’exécution
187
189
Commutation de contexte
toujours changement d ’espace
d ’adressage
Communication
outils entre espace d ’adressage
(tubes, messages queues)
Pas de parallélisme dans un espace
d ’adressage
Commutation de contexte : allégée
pas de changement d ’espace
d ’adressage entre fils d ’un
même processus
Communication : allégée
les fils d ’exécution d ’un même
processus partagent les données, mais
attention à la synchronisation
Parallélisme dans un espace d ’adressage
NSY103 2009-2010
Cours «Parallélisme I» – P-F. Bonnefoi – http://p-fb.net/
Processus à threads (léger)
Processus classique (lourd)
—
J. Delacroix
56
31 décembre 2015 — 36
Notion de processus léger
Mise en œuvre des threads
• Les threads sont implémentés au niveau noyau; le noyau
Les threads sont implémentées au niveau noyau;
connait l’existence éventuelle de plusieurs threads dans un
Le noyau connait l’existence éventuelle de plusieurs threads dans un processus
processus
C
NOYAU
Parallélisme I — P-F. Bonnefoi
Notion de processus léger
• Primitives
do_fork(CLONE_VM,
CLONE_FS,
CLONE_FILES,
CLONE_SIGHAND)
Pthread_create
Création
fork
Threads
Ordonnanceur noyau thread
NSY103 2009-2010
int pthread_create (pthread_t *thread, const pthread_attr_t *attr, void *
(*start_routine)(void *), void *arg);
do_fork(NULL)
C
D
IEEE Portable Operating System Interface, POSIX, 1003.1 standard
Parallélisme I — P-F. Bonnefoi
USER
Posix threads
J. Delacroix
57
Un processus permet de partager des ressources entre différentes threads (une ou plusieurs).
Une thread représente un fil d’exécution (on parle de tâche ou task).
190 L’ordonnanceur, scheduler, répartit le temps d’exécution entre tâches.
synchronisation entre threads
int pthread_join ( pthread_t
terminaison de threads
int pthread_exit (void **value_ptr);
192
NSY103 2009-2010
Linux : les threads noyau
Linux : les threads noyau
J. Delacroix
Posix threads
Le noyau Linux comporte un ensemble de 5 threads noyau qui s'exécutent
Le noyau Linux comporte un ensemble de 5 threads noyau qui s'exécutent en mode superviseur et
en mode
superviseur
et remplisse des tâches spécifiques:
remplisse
des tâches
spécifiques:
• thread 0 : s'exécute lorsque le CPU est idle;
• kupdate, -bdflush
du cachelorsque
disque; le CPU est idle;
thread: gestion
0 : s'exécute
• kswapd, kpiod
: gestion
de la mémoire
centrale.
- kupdate,
bdflush
: gestion
du cache disque;
thread, void **value_ptr);
SEC. 2.2
53
THREADS
IEEE Portable Operating System Interface, POSIX, 1003.1 standard
107
a few of the major ones to give an idea of how it works. The calls we will describe
below are listed in Fig. 2-14.
- kswapd, kpiod : gestion de la mémoire centrale.
Thread noyau 0
kupdate
bdflush
création
Thread noyau 1
création
transformation
Processus 1 : init
création
Processus daemon
NSY103 2009-2010
création
Processus getty
kswapd
création
kpiod
Fichier /etc/inittab
Création (fork, exec)
Processus getty
J. Delacroix
191
Cours «Parallélisme I» – P-F. Bonnefoi – http://p-fb.net/
58
Parallélisme I — P-F. Bonnefoi
Parallélisme I — P-F. Bonnefoi
Création (kernel_thread)
création
Thread call
Description
Pthread create
Create a new thread
Pthread exit
Terminate the calling thread
Pthread join
Wait for a specific thread to exit
Pthread yield
Release the CPU to let another thread run
Pthread attr init
Create and initialize a thread’s attribute structure
Pthread attr destroy
Remove a thread’s attribute structure
Figure 2-14. Some of the Pthreads function calls.
All Pthreads threads have certain properties. Each one has an identifier, a set of
registers (including the program counter), and a set of attributes, which are stored
in193a structure. The attributes include the stack size, scheduling parameters, and
other items needed to use the thread.
identifier
of 37
A new thread
is created using the pthread create call. The31thread
—
décembre
2015 —
the newly created thread is returned as the function value. This call is intentionally
very much like the fork system call (except with parameters), with the thread iden-
Posix threads
Posix threads
IEEE Portable Operating System Interface, POSIX, 1003.1 standard
— depuis le programme principal (qui devient la thread principale) : exécution de la thread1
— puis attente de la terminaison (synchronisation) avec le join.
Création d’une thread : comparaison avec la création d’un processus
Notion de processus léger
Main()
Main()
suite
pthread_create (addition)
Parallélisme I — P-F. Bonnefoi
Parallélisme I — P-F. Bonnefoi
2 fils d’exécutions dans un même
espace d’adressage qui exécutent un code
différent
194
196
Posix threads
Main()
fork
Main()
suite
Main()
suite
2 fils d’exécutions dans deux espaces
d’adressages qui reprennent le même code,
au même point
NSY103 2009-2010
J. Delacroix
55
La thread
Il est possible de lancer des threads sans s'occuper de leur terminaison :
— en les détachant detached thread
— lorsque ces threads terminent elles sont détruites tout simplement, et leur espace mémoire est
récupéré.
La thread évolue suivant différents états
la préemption correspond à une suspension venant de l'extérieur ;
la notion de courante correspond à la threads qui s'exécute.
—
Parallélisme I — P-F. Bonnefoi
Parallélisme I — P-F. Bonnefoi
—
195
197
Cours «Parallélisme I» – P-F. Bonnefoi – http://p-fb.net/
addition
—
31 décembre 2015 — 38
Courante -> bloquée (mise en attente)
La thread doit arrêter son exécution pour attendre l'arrivée d'un événement (fin d'E/S)
— elle libère volontairement la ressource CPU
— l'OS alloue le CPU à la thread prête la plus prioritaire (le scheduler ?)
Bloquée -> prête (réveil)
La thread est réveillée par
— un événement ou par une fonction d'interruption (fin d'E/S)
— la thread courante (le scheduler ?)
Elle rejoint le groupe des demandeurs de ressource CPU.
Communication
Il existe deux mécanismes principaux pour faire communiquer deux processus :
— la communication via la mémoire
— la communication par échange de messages
Principales caractéristiques :
— synchrone ↔ asynchrone
— directe ↔ indirecte
— de type un-vers-un : le tube…
— de type un-vers-plusieurs : plusieurs tubes…
Prête -> élue (élection)
Le CPU est attribué à la thread prête la plus prioritaire
— pour donner le CPU à la thread la plus prioritaire
=> thread préemptée par OS
Au niveau d'une thread
Les threads qui ont besoin d’échanger des données le font via la mémoire en partageant une partie de
la mémoire, partie qui est attachée à leur espace d’adressage commun.
On appelle segment de mémoire partagé cette mémoire commune.
Élue -> prête (préemption)
— le CPU est retiré à la thread courante pour être attribué à la thread la plus prioritaire
Point(s) de préemption d'un OS
— après le réveil de la thread la plus prioritaire elle devient la thread courante
Quand/où l'OS préempte la thread courante
— Coarse-Grain system :
• pas de préemption dans le noyau
• préemption au retour d'un appel système (dépend de la durée exécution de l'appel système)
— Fine-Grain system
• Préemption dans le noyau immédiate
198
• ordonnancement choisi par l'utilisateur
Posix threads
Exemple de programme
Parallélisme I — P-F. Bonnefoi
Parallélisme I — P-F. Bonnefoi
Interactions
Problèmes
Que se passe-t-il si deux threads lisent en même temps ?
...rien de particulier.
Que se passe-t-il si une thread lit pendant qu’une autre écrit ?
...un gros problème, la donnée risque de ne pas être dans un état cohérent et peut ne correspondre
ni à la la donnée avant l’écriture, ni à la donnée après l’écriture.
Que se passe-t-il si deux threads écrivent simultanément ?
...de gros problèmes en perspective.
Problèmes de synchronisation des processus et de protection des accès.
200
Exemple
Notion de processus léger
Guichet bancaire
— dépôt de s euros au guichet ;
— retrait par carte de s euros.
#include <stdio.h>
#include <pthread.h>
(1)
(2)
(3)
pthread_t pthread_id[3];
199
main()
{
int i;
for (i=0; i<3; i++)
if (pthread_create(pthread_id + i, pthread_attr_default, f_thread,
i) == -1)
fprintf(stderr, "erreur de creation pthread numero %d\n", i);
printf ("je suis la thread initiale %d.%d\n", getpid(),
pthread_self());
pthread_join();
}
NSY103 2009-2010
J. Delacroix
Cours «Parallélisme I» – P-F. Bonnefoi – http://p-fb.net/
||
||
||
(4)
(5)
(6)
x' : = moi.solde
x' : = x' – s
moi.solde : = x'
Entrelacement des instructions :
main
Parallélisme I — P-F. Bonnefoi
Parallélisme I — P-F. Bonnefoi
void f_thread(int i) {
printf ("je suis la %d-eme pthread d'identite %d.%d\n", i, getpid(),
pthread_self());
}
x : = moi.solde
x:=x+s
moi.solde : = x
f_thread
54
—
(1) (2) (4) (5) (3) (6)
x = solde; x = solde + s;
x' = solde ; x' = x' – s ; solde = x ; solde = x’
Soit une perte d'argent !
(1) (2) (4) (5) (6) (3)
x = solde; x = solde + s;
—
x' = solde ; x' = x' – s ; solde = x' ; solde = x
Soit un gain d'argent !
201
—
31 décembre 2015 — 39
Notion de ressources
Interactions
Problème
Les opérations de lecture/écriture en mémoire ne sont pas atomiques.
⇒ une lecture comme une écriture peut être interrompue au cours de son action.
Utilisation d'une ressource par un processus de poids léger, appelé
aussi thread
La solution
Les sémaphore d’exclusion mutuelle (mutex) :
— elles rendent les opérations de lecture/écriture atomiques en restreignant l’accès à un segment de
mémoire partagé à une seule thread à la fois ;
—
t1 pour libérer s1 a besoin d’accéder à s2 ;
—
Mais t2 pour libérer s2, a besoin de lire s3.
—
—
Si t3 n’a pas besoin de quoi que ce soit d’autre, il fait ce qu’il a à faire, puis libère s3 , ce qui libère s2
et par la suite s1 ... ouf ! !
par contre, si t3 a besoin de lire s1 pour libérer s3 ...
→ situation d’interblocage.
202
Parallélisme I — P-F. Bonnefoi
Parallélisme I — P-F. Bonnefoi
Risques ?
Il existe plusieurs segments de mémoire partagée s1, s2 et s3, plusieurs threads t1, t2 et t3.
— t1 bloque l’accès à s1 , t2 bloque l’accès à s2 et t3 bloque l’accès à s3 ;
q Les phases d'allocation et de restitution doivent
assurer que le ressource est utilisée conformément à son nombre de
points d'accès
q Une ressource critique à un seul point d'accès
204
Notion de ressources
Interblocage,Interblocage,
Famine, Coalition
Famine et Coalition
• Interblocage
Définitions
Interblocage
q Une ressource désigne toute entité dont a besoin
un processus pour s'exécuter.
Ensemble
de n processus
une de
ressource
déjà
possédée
que parattendant
un autre chacun
processus
l'ensemble
possédée que par un autre processus de l'ensemble.
Ensemble de n processus attendant chacun une ressource déjà
q Une ressource est caractérisé
• par un état : libre /occupée
• par son nombre de points d'accès (nombre de processus pouvant
l'utiliser en même temps)
Parallélisme I — P-F. Bonnefoi
• Ressource matérielle (processeur, périphérique)
• Ressource logicielle (variable)
Parallélisme I — P-F. Bonnefoi
q Trois étapes :
• Allocation
• Utilisation
• Restitution
R1 et R2 à
un seul point
R1 et R2
à
un seul d'accès
point
R1
Prendre R1
Prendre R2
Traitement
d'accès
Prendre R2
Prendre R1
Traitement
R2
Cours «Parallélisme I» – P-F. Bonnefoi – http://p-fb.net/
P2
Aucun processus ne
peut poursuivre
exécution
Aucun
processus son
ne peut
poursuivre son exécution
à Attente Infinie Attente Infinie
J. Delacroix, Méthodes de Programmation système 2008 - 2009
203
P1
205
—
24
31 décembre 2015 — 40
Interblocage,
Famine,
Coalition
Interblocage,
Famine
et Coalition
Interblocage, Famine, Coalition
Coalition
• Coalition
Conditions nécessaires à l'obtention d'un interblocage
Ensemble de n processus monopolisant les ressources au détriment
de n processus monopolisant les ressources au
deEnsemble
p autres processus
• Ressource critique : Une ressource au moins doit se trouver dans un
mode non partageable
détriment de p autres processus
P1
Parallélisme I — P-F. Bonnefoi
Parallélisme I — P-F. Bonnefoi
R1
Prendre R1
Prendre R2
Traitement
Prendre R1
Prendre R2
Traitement
R2
P2
à Famine
Famine
à Attente finie
mais indéfinie
• Occupation et attente : Un processus au moins occupant une
ressource attend d'acquérir des ressources supplémentaires détenues
par d'autres processus
• Pas de réquisition : Les ressources sont libérées sur seule volonté
des processus les détenant
• Attente circulaire : au moins un processus P1 attend une ressource
détenue par un autre processus P2, P2 attend lui-même une ressource
détenue par P1
Attente finie mais indéfinie
25
208
Interblocage, Famine, Coalition
Interblocage
Attente Circulaire… la détection est possible mais complexe à
réaliser…et que faire ensuite ?
Parallélisme I — P-F. Bonnefoi
Interblocage, Famine, Coalition
Parallélisme I — P-F. Bonnefoi
206
J. Delacroix, Méthodes de Programmation système 2008 - 2009
207
209
Cours «Parallélisme I» – P-F. Bonnefoi – http://p-fb.net/
—
31 décembre 2015 — 41
l'exclusion mutuelle entre processus
l'exclusion mutuelle entre processus
Un premier problème de synchronisation est celui de l'accès par un
ensemble de processus à une ressource critique, c'est-à-dire une
ressource à un seul point d'accès donc utilisable par un seul processus à
la fois.
Parallélisme I — P-F. Bonnefoi
Parallélisme I — P-F. Bonnefoi
Client 1
Demande Réservation
Nb_Place > 0 = 1
210
212
l'exclusion mutuelle entre processus
Cours «Parallélisme I» – P-F. Bonnefoi – http://p-fb.net/
Nb_Place = Nb_Place - 1
Nb_Place = -1 !!!
Processus
Début
• Ressource critique : utilisable par
un seul processus à la fois
Entrée Section Critique
Parallélisme I — P-F. Bonnefoi
Parallélisme I — P-F. Bonnefoi
211
Demande Réservation
Nb_Place > 0 = 1
Nb_Place = Nb_Place - 1
Nb_Place = 0
Définitions de la section critique
Nous allons mettre en lumière le problème qui peut se poser sur un exemple
simple :
Réservation :
Si nb_place > 0
alors
Réserver une place
nb_place = nb_place - 1
fsi
Client 2
213
Ressource Critique
Nb_Place
SECTION CRITIQUE
(code d'utilisation
de la ressource critique)
Sortie Section Critique
Fin
L'entrée et la sortie de la Section Critique (SC) doivent assurer qu'à tout
moment, un seul processus s'exécute en SC
à exclusion mutuelle
—
31 décembre 2015 — 42
Définitions de la section critique
Généralisation du problème
On retrouve cette problématique dans:
o
o
o
o
o
o
Partie d’un programme dont l’exécution de doit pas
s’entrelacer avec d’autres programmes.
Une fois qu’une tâche y entre, il faut lui permettre
de terminer cette section sans permettre à d’autres
tâches de travailler sur les mêmes données.
Écriture algorithmique :
Parallélisme I — P-F. Bonnefoi
Parallélisme I — P-F. Bonnefoi
Section critique :
Les bases de données
Le partage des ressources (fichiers, connections, réseaux, …)
Les automates (exemple du DAB)
Le Hardware (Disque dur, …)
Le développement (MMORPG, clients/serveur, …)
Etc…
Repeat
Section d’entrée
Section critique, SC
Section de sortie
Section restante, SR
Forever
Plusieur types de solutions
o Solutions matériel
o Solutions algorithmique
214
216 o Solutions fournies pas le Système
Définitions de la section critique
Client 1
Demande Réservation
Protection de Nb_Place
Nb_Place > 0 = 1
Solution matériel
Client 2
Masquage de l’interruption d’horloge
Nb_Place = Nb_Place - 1
Fin protection de Nb_Place
Protection de Nb_Place
Nb_Place = 0
215
Cours «Parallélisme I» – P-F. Bonnefoi – http://p-fb.net/
Processus 1
Parallélisme I — P-F. Bonnefoi
Parallélisme I — P-F. Bonnefoi
Demande Réservation
Nb_Place non accessible
Masquer IT
Si nb_place > 0
alors
Réserver une place
nb_place = nb_place - 1
fsi
Démasquer IT
Non prise en compte
Processus 2
En Attente
217
—
31 décembre 2015 — 43
Solution matériel
Solution algorithmique
Masquage des interruptions
Algorithme 1 :Threads se donnant mutuellement le tour
o La variable partagée turn est initialisée à 0 ou 1
o La SC de Ti est exécutée ssi turn = i
o Ti est occupé à attendre si Tj est dans SC.
q Une solution pour réaliser une section critique est donc d'interdire la prise
en compte des interruptions durant l'utilisation de la ressource critique.
Thread Ti:
repeat
while(turn!=i){};
SC
turn = j;
SR
forever
Elle provoque l’attente de tous les processus car le processeur est
monopolisé
Elle ne peut s’effectuer qu’en mode superviseur
Il faut trouver une solution bloquant seulement les processus concernés :
solution algorithmique ou solution par le système d’exploitation.
218
Parallélisme I — P-F. Bonnefoi
Parallélisme I — P-F. Bonnefoi
q Mais cette solution présente des inconvénients majeurs :
220
Solution algorithmique
Première solution algorithmique
Initialisation de Turn à 0 ou 1
Solution par logiciel
Nous considérons d’abord 2 threads
Parallélisme I — P-F. Bonnefoi
Parallélisme I — P-F. Bonnefoi
Notation
Débutons avec 2 threads: T0 et T1
Lorsque nous discutons de la tâche Ti, Tj dénotera toujours l’autre tâche (i != j)
219
221
Cours «Parallélisme I» – P-F. Bonnefoi – http://p-fb.net/
Thread T0:
repeat
while(turn!=0){};
SC
turn = 1;
SR
forever
—
Thread T1:
repeat
while(turn!=1){};
SC
turn = 0;
SR
forever
31 décembre 2015 — 44
Première solution algorithmique
L’excès de courtoisie
Thread T0:
repeat
while(turn!=0){};
SC
turn = 1;
SR
forever
Thread T1:
repeat
while(turn!=1){};
SC
turn = 0;
SR
forever
222
o Une variable Booléenne par Thread:
flag[0] et flag[1]
o Ti signale qu’il désire exécuter sa SC par:
flag[i] =vrai
Parallélisme I — P-F. Bonnefoi
Parallélisme I — P-F. Bonnefoi
Initialisation de Turn à 0 ou 1
224
Première solution algorithmique
L’excès de courtoisie
Initialisation de Turn à 0 ou 1
Thread T0:
repeat
while(turn!=0){};
SC
turn = 1;
SR
forever
Thread T1:
repeat
while(turn!=1){};
SC
turn = 0;
SR
forever
Algorithme 1 vue globale
Généralisation à n threads: chaque fois, avant qu’un thread puisse rentrer dans
sa section critique, il lui faut attendre que tous les autres aient eu cette chance!
223
Cours «Parallélisme I» – P-F. Bonnefoi – http://p-fb.net/
Thread T0:
repeat
flag[0] = vrai;
while(flag[1]==vrai){};
SC
flag[0] = faux;
SR
forever
Parallélisme I — P-F. Bonnefoi
Parallélisme I — P-F. Bonnefoi
Thread Ti:
repeat
flag[i] = vrai;
while(flag[j]==vrai){};
SC
flag[i] = faux;
SR
forever
Après vous,
monsieur
Thread T1:
repeat
flag[1] = vrai;
while(flag[0]==vrai){};
SC
flag[1] = faux;
SR
forever
Après vous,
monsieur
225
—
31 décembre 2015 — 45
L’excès de courtoisie
Thread T0:
Thread T1:
repeat
repeat
while(flag[1]==vrai)
{};
SC
flag[0] = faux;
SR
forever
flag[1] = vrai;
while(flag[0]==vrai){};
SC
flag[1] = faux;
SR
forever
226
Parallélisme I — P-F. Bonnefoi
flag[0] = vrai;
Parallélisme I — P-F. Bonnefoi
L’algorithme de Dekker
228
L’excès de courtoisie
L’algorithme de Dekker
L’équité
Thread T0:
Thread T1:
repeat
repeat
Parallélisme I — P-F. Bonnefoi
while(flag[1]==vrai){};
SC
flag[0] = faux;
Une hypothèse d’équité simple, suffisante pour raisonner au sujet de l'algorithme de Dekker,
est la suivante.
flag[1] = vrai;
while(flag[0]==vrai){};
SC
flag[1] = faux;
SR
SR
forever
forever
227
Cours «Parallélisme I» – P-F. Bonnefoi – http://p-fb.net/
à Tout processus qui a la possibilité d'exécuter une instruction finira toujours par le faire.
Parallélisme I — P-F. Bonnefoi
flag[0] = vrai;
Le fonctionnement correct de l'algorithme de Dekker dépend du fait que chaque processus
finit toujours par progresser.
229
—
31 décembre 2015 — 46
L’algorithme de Dekker
L’instruction Test and Set
Une version C++ de test-and-set:
Les propriétés de sûreté :
Ce sont les propriétés qui expriment que certains états indésirables
ne sont jamais atteints. Elles ne dépendent pas de l'utilisation d'une
hypothèse d‘équité.
Les propriétés de vivacité :
Celles-ci expriment que des états désirables seront
immanquablement atteints. Habituellement, ces propriétés ne sont
vraies qu'en présence d'une hypothèse d‘équité.
230
Parallélisme I — P-F. Bonnefoi
Parallélisme I — P-F. Bonnefoi
Parmi les propriétés que l'on spécifie pour un programme parallèle, on
distingue les deux catégories suivantes :
flag[0] = flag[1] =
faux
turn = i ou j
Désire d’exécuter SC
est indiqué par
flag[i] = vrai
flag[i] = faux à la
section de sortie
Variable partagée b est initialisée à
0
C’est le 1er Pi qui met b à 1 qui entre
dans SC
Tâche Pi:
while
testset(b)==false{};
SC //entre quand vrai
b=0;
SR
L'inconvénient majeur de ces solutions logicielles
est l'attente active.
Thread Ti:
repeat
flag[i] = vrai;
// je veux entrer
turn = j;
// je donne une
chance à l’autre
do while
(flag[j]==vrai &&
turn==j){};
SC
flag[i] = faux;
SR
forever
Cours «Parallélisme I» – P-F. Bonnefoi – http://p-fb.net/
Parallélisme I — P-F. Bonnefoi
Initialisation:
Un algorithme utilisant testset pour
Exclusion Mutuelle:
Nécessité d’utiliser d’autres méthodes
Combine les deux idées :
flag[i]=intention d’entrer; turn=à qui le tour
Parallélisme I — P-F. Bonnefoi
Instruction atomique
232
L’algorithme de Peterson
231
bool testset(int& i)
{
if (i==0) {
i=1;
return true;
} else {
return false;
}
}
Une autre solution est d'utiliser un outil de
synchronisation offert par le système :
à les sémaphores.
233
—
31 décembre 2015 — 47
Définition d’un sémaphore
Définition d’un sémaphore
Structure
Parallélisme I — P-F. Bonnefoi
Parallélisme I — P-F. Bonnefoi
Opération Init (Val, Sem)
234
236
Définition d’un sémaphore
Opération P (Sem)
235
Cours «Parallélisme I» – P-F. Bonnefoi – http://p-fb.net/
Parallélisme I — P-F. Bonnefoi
Parallélisme I — P-F. Bonnefoi
q l'opération INIT (S, Val) fixe le nombre de jetons Initial
q l'opération V(S) restitue un jeton et débloque un processus de S.L
si il en existe un.
« masquer_it » et « demasquer_it » servent à
empêcher l’interruption de l’opération par
une interruption (rendre atomique Init).
Définition d’un sémaphore
Un sémaphore S peut être vu comme un distributeur de
Jetons
q l'opération P(S) attribue un jeton au processus appelant si il en
reste sinon bloque le processus dans S.L
Init (Val, Sem)
début
masquer_it
Sem. K := Val jetons;
Sem. L := vide
demasquer_it
fin
P (Sem)
début
masquer_it
Si il reste un jeton
alors
le donner à ce processus
sinon
ajouter ce processus à Sem.L
bloquer ce processus
fsi
demasquer_it
fin
237
—
31 décembre 2015 — 48
Opération P (Sem) : 1er cas (non bloquant)
Opération V (Sem)
Parallélisme I — P-F. Bonnefoi
Définition d’un sémaphore
Parallélisme I — P-F. Bonnefoi
Définition d’un sémaphore
238
240
Définition d’un sémaphore
Définition d’un sémaphore
Opération V (Sem) : 1er cas (sans réveil)
Parallélisme I — P-F. Bonnefoi
Parallélisme I — P-F. Bonnefoi
Opération P (Sem) : 2 ème cas (bloquant)
239
241
Cours «Parallélisme I» – P-F. Bonnefoi – http://p-fb.net/
V (Sem)
début
masquer_it
Ajouter un jeton à S.K
Si il y a un processus en attente
de jeton dans S.L
alors
sortir un processus de Sem.L
lui donner un jeton
réveiller ce processus
fsi
demasquer_it
fin
—
31 décembre 2015 — 49
Définition d’un sémaphore
Section critique avec sémaphore
Sur l’exemple de la réservation :
Opération V (Sem) : 2ème cas (avec réveil)
Parallélisme I — P-F. Bonnefoi
Parallélisme I — P-F. Bonnefoi
Réveil
242
244
Section critique avec sémaphore
Section critique avec sémaphore
Client 1
Demande Réservation
P(Mutex)
Nb_Place > 0 = 1
1 seul processus en section critique : 1 seul jeton
Entrée section_critique
Section Critique
V (Mutex)
Sortie section_critique
243
Cours «Parallélisme I» – P-F. Bonnefoi – http://p-fb.net/
Parallélisme I — P-F. Bonnefoi
Parallélisme I — P-F. Bonnefoi
Sémaphore Mutex initialisé à 1
P (Mutex)
Réservation :
P(Mutex)
Si nb_place > 0
alors
Réserver une place
nb_place = nb_place - 1
fsi
V(Mutex)
Client 2
Demande Réservation
P(Mutex)
Nb_Place non accessible
Nb_Place = Nb_Place - 1
V(Mutex)
Nb_Place = 0
245
—
31 décembre 2015 — 50
L’allocation de ressources
L’allocation de ressources
Un deuxième problème de synchronisation est celui de l'accès par un
ensemble de processus à un ensemble de n ressources critiques :
à c'est une généralisation du cas précédent.
246
Init (Res, 3)
Parallélisme I — P-F. Bonnefoi
Parallélisme I — P-F. Bonnefoi
Accès à un ensemble de n ressources critiques
248
L’allocation de ressources
L’allocation de ressources
Sémaphore Res initialisé à N
(1 jeton par ressource)
Allocation : P(Res)
Utilisation Ressource
Restitution V(Res)
247
Cours «Parallélisme I» – P-F. Bonnefoi – http://p-fb.net/
Init (Res, 3)
Parallélisme I — P-F. Bonnefoi
Parallélisme I — P-F. Bonnefoi
N ressources exclusives de même type
Allouer une ressource = prendre un jeton Res
Rendre une ressource = rendre un jeton Res
249
—
31 décembre 2015 — 51
Les Lecteurs/Rédacteurs
Les Lecteurs/Rédacteurs
Le contenu du fichier doit rester cohérent :
à pas d'écritures simultanées
Ecriture seule - Lectures simultanées
Un écrivain exclut
à les écrivains
à les lecteurs
Parallélisme I — P-F. Bonnefoi
Parallélisme I — P-F. Bonnefoi
Les lectures doivent être cohérentes :
à pas de lectures en même temps que les écritures
250
252
251
Consulter_Fichier_annonce
debut
ouvrir(fichier_annonce, lecture);
pour chaque annonce du fichier
lire(annonce)
fin pour
fermer(fichier_annonce)
Fin
Modifier_Fichier_annonce (in annonce, operation)
avec operation = ajouter, modifier ou effacer
debut
ouvrir(fichier_annonce, ecriture);
operation(annonce)
fermer(fichier_annonce)
fin
Cours «Parallélisme I» – P-F. Bonnefoi – http://p-fb.net/
Les Lecteurs/Rédacteurs
Un écrivain exclut les écrivains et les lecteurs
à Un écrivain accède toujours seul
à Un écrivain effectue des accès en exclusion mutuelle des autres
écrivains et des lecteurs
Parallélisme I — P-F. Bonnefoi
Parallélisme I — P-F. Bonnefoi
Les Lecteurs/Rédacteurs
Un lecteur exclut
à les écrivains
Sémaphore d'exclusion mutuelle Accès initialisé à 1
253
—
31 décembre 2015 — 52
Les Lecteurs/Rédacteurs
Les Lecteurs/Rédacteurs
Un lecteur exclut les écrivains
Ecrivain
à Un premier lecteur doit s'assurer qu'il n'y a pas d'accès en
écriture en cours
à Le dernier lecteur doit réveiller un éventuel
Écrivain
M'assurer que l'accès au fichier est libre
entrer en écriture
Libérer l'accès au fichier
V(Accès)
254
Parallélisme I — P-F. Bonnefoi
Parallélisme I — P-F. Bonnefoi
P(Accès)
256
Les Lecteurs/Rédacteurs
Consulter_Fichier_annonce
debut
ouvrir(fichier_annonce, lecture);
pour chaque annonce du fichier
lire(annonce)
fin pour
fermer(fichier_annonce)
Fin
Modifier_Fichier_annonce (in annonce, operation)
avec operation = ajouter, modifier ou effacer
debut
P(ACCES)
ouvrir(fichier_annonce, ecriture);
operation(annonce)
fermer(fichier_annonce)
fin
V(ACCES)
255
Cours «Parallélisme I» – P-F. Bonnefoi – http://p-fb.net/
Les Lecteurs/Rédacteurs
Lecteur
Parallélisme I — P-F. Bonnefoi
Parallélisme I — P-F. Bonnefoi
NL, nombre de lecteurs courants, initialisé à 0
Compter un lecteur de plus
Si je suis le premier lecteur
alors
Y-a-t-il un écrivain ?
si oui, attendre
Fsi
P(Mutex)
NL : = NL + 1
Si (NL = 1)
alors
P(ACCES)
fsi
V(Mutex)
entrer en lecture
Accès lecture
Compter un lecteur de moins
Si je suis le dernier, réveiller
un écrivain
P(Mutex)
NL := NL - 1;
Si (NL = 0)
alors
V(ACCES)
fsi
V(Mutex)
257
—
31 décembre 2015 — 53
le producteur/consommateur
258
Consulter_Fichier_annonce
debut
ouvrir(fichier_annonce, lecture);
pour chaque annonce du fichier
lire(annonce)
fin pour
fermer(fichier_annonce)
fin
P(Mutex)
NL : = NL + 1
Si (NL = 1)
alors
P(ACCES)
fsi
V(Mutex)
Modifier_Fichier_annonce (in annonce, operation)
avec operation = ajouter, modifier ou
effacer
P(ACCESS)
debut
ouvrir(fichier_annonce, ecriture);
operation(annonce)
fermer(fichier_annonce)
V(ACCESS)
fin
P(Mutex)
NL := NL - 1;
Si (NL = 0)
alors
V(ACCES)
fsi
V(Mutex)
Parallélisme I — P-F. Bonnefoi
Parallélisme I — P-F. Bonnefoi
Les Lecteurs/Rédacteurs
• Un producteur ne doit pas produire si le tampon est plein
• Un consommateur ne doit pas faire de retrait si le tampon est vide
• Producteur et consommateur ne doivent jamais travailler
dans une même case
260
le producteur/consommateur
Parallélisme I — P-F. Bonnefoi
Parallélisme I — P-F. Bonnefoi
Les Lecteurs/Rédacteurs
259
261
Cours «Parallélisme I» – P-F. Bonnefoi – http://p-fb.net/
Gestion en FIFO
• Producteur
Si il n'y a pas de case libre
alors
attendre
sinon
déposer le message
fsi
• Consommateur
Si il y a pas de case pleine
alors
attendre
sinon
prendre le message
fsi
On associe un ensemble de jetons aux cases vides : N jetons VIDE
deposer le message = prendre un jeton VIDE
On associe un ensemble de jetons aux cases pleines : 0 jetons PLEIN
prendre le message = prendre un jeton PLEIN
—
31 décembre 2015 — 54
Supprimer l’attente active
262
• Producteur
Si il n'y a pas de case libre
alors
attendre
sinon
déposer le message
Nouvelle case pleine
fsi
• Consommateur
Si il y a pas de case pleine
alors
attendre
sinon
prendre le message
nouvelle case vide
fsi
On associe un ensemble de jetons aux cases vides : N jetons VIDE
deposer le message = prendre un jeton VIDE et génerer un jeton PLEIN
On associe un ensemble de jetons aux cases pleines : 0 jetons PLEIN
prendre le message = prendre un jeton PLEIN et générer un jeton VIDE
le producteur/consommateur
allocation de ressources
cases pleines
P (Sémaphore Plein)
Parallélisme I — P-F. Bonnefoi
Parallélisme I — P-F. Bonnefoi
le producteur/consommateur
264
le producteur/consommateur
allocation de ressources cases vides
P (Sémaphore Vide)
une ressource case pleine disponible
V (Sémaphore Plein)
263
Cours «Parallélisme I» – P-F. Bonnefoi – http://p-fb.net/
Parallélisme I — P-F. Bonnefoi
Parallélisme I — P-F. Bonnefoi
le producteur/consommateur
Producteur
Si il n'y a pas de case libre
alors
attendre
sinon
déposer le message
nouvelle case pleine
fsi
une ressource
case vide disponible
V (SémaphoreVide)
Consommateur
Si il y a pas de case pleine
alors
attendre
sinon
prendre le message
nouvelle case vide
fsi
• Producteur
• Consommateur
P(Vide)
déposer le message
V(Plein)
P(Plein)
retirer le message
V(Vide)
Sémaphore Vide initialisé à N : Init (Vide, N)
Sémaphore Plein initialisé à 0 : Init (Plein, 0)
265
—
31 décembre 2015 — 55
le producteur/consommateur
Programmation des Sémaphores en C sous GNU/Linux
Pour utiliser les sémaphores
Il faut
• inclure semaphore.h
• relier avec la bibliothèque pthread
Pour créer la sémaphore
Parallélisme I — P-F. Bonnefoi
Parallélisme I — P-F. Bonnefoi
sem_t semaphore;
266
268
sem_init( & semaphore, partagée, nombre);
où partagée indique si la sémaphore doit être partagée entre différents processus.
On mettra la valeur 0 pour indiquer qu’elle n’est pas partagée entre processus mais entre threads.
où nombre indique la valeur initiale de la sémaphore.
Prendre et libérer la sémaphore
sem_wait(&semaphore);
sem_post(&semaphore);
Pour détruire la sémaphore
sem_destroy(&semaphore);
En résumé
q Le sémaphore S est un outil système de synchronisation assimilable à
un distributeur de jeton et manipulable par seulement trois opérations
atomiques : P(S), V(S) et Init(S)
q Il existe plusieurs schémas typiques de synchronisation à partir
desquels sont élaborés des outils de communication entre processus :
– l'exclusion mutuelle
– les lecteurs/rédacteurs
– les producteur/consommateur
267
Cours «Parallélisme I» – P-F. Bonnefoi – http://p-fb.net/
Parallélisme I — P-F. Bonnefoi
Parallélisme I — P-F. Bonnefoi
q Les exécutions de processus ne sont pas indépendantes : les processus
peuvent vouloir communiquer et accéder de manière concurrente à des
ressources
269
—
31 décembre 2015 — 56
cations, an asynchronous model may yield performance benefits over traditional multithreading. Much of
the material presented in this document is taken from Dave Peticola’s excellent introduction to Twisted1 , a
Python framework for asynchronous programming.
1
The Models
7 Présentation de la programmation «asynchrone»
We will start by reviewing two (hopefully)Qu’est-ce
familiar modelsque
in order
contrast them with the asynchronous
la toprogrammation
asynchrone ?
model. By way of illustration we will imagine a program that consists of three
distinct
tasks
Leconceptually
contraire
de la
programmation
which must be performed to complete the program. Note I am using task in the non-technical sense of
something that needs to be done.
The first model we will look at is the single-threaded synchronous model, in Figure 1 below:
synchrone !
Imaginons que nous voulions exéctuer un programme décomposable en 3
tâches «Task{1,2,3}» :
∘ la version «single threaded» indiquée à gauche est la version la plus
Parallélisme I — P-F. Bonnefoi
simple : chaque tâche est exécutée une à la fois, l’une s’achevant complètement avant que l’autre ne commence :
⋄ les tâches s’exécutent dans un ordre prédéfini ;
⋄ la dernière tâche peut ainsi être sûre que :
⋆ les tâches précédentes se sont exécutées sans erreur ;
⋆ que tous les résultats de ces tâches précédentes sont disponibles ;
Figure 1: The single-threaded synchronous model
270
This is the simplest style of programming. Each task is performed one at a time, with one finishing
completely before another is started. And if the tasks are always performed in a definite order, the impleCS168
mentation of a later task can assume thatLa
all earlier
tasks have finishedasynchrone
without
errors, with
all their output
programmation
vs programmation
«multi-thread»
available for use — a definite simplification in logic.
We can contrast the single-threaded synchronous
model
with the multi-threaded
∘ la version
«multi-threaded»
permet à synchronous
chaque tâchemodel
illustrated in Figure 2.
de s’exécuter dans une thread de contrôle différente :
In this model, each task is performed in a separate thread of control. The threads are managed by the
operating system and may, on a system with multiple processors or multiple cores, run truly concurrently,
1
http://krondo.com/?page_id=1327
⋄ les threads sont ordonnancées par le système
d’exploitation ;
⋄ les threads peuvent s’exécuter de manière concur1
Parallélisme I — P-F. Bonnefoi
Async Prog
Figure 2: The threaded model
rente :
or may dispose
be interleaved
togetherprocesseurs
on a single processor.
⋆ réellement si l’ordinateur
de différents
ou cœurs ;The point is, in the threaded model the
⋆ de manière entrelacée
si l’ordinateur
ne dispose
que d’un
processeur
;
streams
which may run
simultaneously.
Although
the diagram
is simple, in practice threaded prog
execution are handled by the OS and the programmer simply thinks in terms of independent in
⋄ le programmeur pense en
de flotsisd’instructions
s’exécutant
simultanément
;
andterme
coordination
an advanced programming
topic
and can be difficult
to get right.
be quite complex because of the need for threads to coordinate with one another. Thread comm
⋄ la coordination et la communication
entre
ces are
différentes
est complexe
et difficile.
the programming
details
different, threads
conceptually
it is the same
model as in Figure 2.
Some programs implement parallelism using multiple processes instead of multiple threads.
Now we can introduce the asynchronous model2 , depicted in Figure 3:
271
Cours «Parallélisme I» – P-F. Bonnefoi – http://p-fb.net/
—
31 décembre 2015 — 57
he need for threads to coordinate with one another. Thread communication
ed programming topic and can be difficult to get right.
t parallelism using multiple processes instead of multiple threads. Although
fferent, conceptually it is the same model as in Figure 2.
La programmation asynchrone : la gestion direct de l’entrelacement
∘ la version «asynchrone» :
⋄ les tâches s’exécutent de manière entrelacées au sein de la même «thread»
asynchronous model2 , depicted in Figure 3:
de contrôle ;
⋄ le modèle de programmation est plus simple que celui «multi-threaded»
car le programmeur sait «qu’une seule tâche s’exécute à la fois» :
lorsqu’une
tâche
est exécutée, aucune autre ne s’exécute
Async
Programming
⋄ bien que dans un environnement avec un seul processeur, la version «multithread» s’exécute aussi de manière entrelacée, le programmeur doit tou-
rence between the asynchronous and threaded models. In a threaded system the
jours penser en terme de threads pouvant s’exécuter simultanément ;
hread and execute another is largely outside of the programmer’s control. Rather,
the operating
system,
and the programmer must assume that a thread may be
Figure 3: The
⋄asynchronous
la versionmodel
«aynchrone» s’exécute toujours de manière entrelacée même dans un environnewith another at almost any time. In contrast, under the asynchronous model a task
one another,
but
into
a single
ment
multi-processeurs
itinterleaved
explicitlywith
relinquishes
control
other thread
tasks. of;control. This is simpler
se the programmer always knows that when one task is executing, another
⋄ a dans
la version
«multi-thread»,
le système d’exploitation qui décide de l’ordonnancegle-processor system
threaded
program will
also execute in c’est
an interleaved
in terms
Figure 2, notthreads
Figure 3,
the program
nhreads should still thinkment
desofdifférentes
etlest
le programmeur
doit en tenir compte : chaque thread peut être
to a multi-processor system. But a single-threaded asynchronous system will
suspendue
à
n’importe
quel
moment
pour
laisser
la place
à l’exécution d’une autre thread.
ng, even onmodel
a multi-processor
chronous
is in somesystem.
ways simpler than the threaded one because there
is
m and tasks explicitly
relinquish
control
instead of being
arbitrarily.
⋄ dans
le modèle
«asynchrone»,
unesuspended
tâche s’exécute
jusqu’à ce qu’elle décide de libèrer le
model
is also introduces
referred to as “preemptive
multitasking,” with
the programmer
asynchronous model
called
del
clearly
its own complexities.
The
must
organize each
contrôle
à
une
autre
tâche.
aller steps that execute intermittently. If one task uses the output of another, the
ritten to accept its input as a series of bits and pieces instead of all together.
2
ual parallelism, it appears
from our diagrams that an asynchronous program will
te as a synchronous one. But there is a condition under which an asynchronous
synchronous one, sometimes dramatically so. This condition holds when tasks are
s illustrated in
Figure
Quel
est4:l’intérêt de la programmation «asynchrone» ? les performances !
La programmation asynchrone : mieux utiliser le processeur
∘ le modèle «asynchrone» est plus simple que le modèle «multi-
La programmation asynchrone : les avantages
∘ lorsqu’une tâche est bloquée dans le modèle synchrone, il est possible d’exécuter une tâche
qui est capable de progresser :
⋄ le passage d’une tâche à une autre correspond :
⋆ soit à la terminaison de la tâche courante,
⋆ soit à l’arrivée à un point où la tâche va se bloquer ;
⋄ avec un nombre important de tâches pouvant potentiellement se bloquer, le modèle «asynchrone» peut obtenir de bien meilleures performances que le modèle «synchrone».
Le modèle «asynchrone» est meilleur dans le cas où :
▷ il y a de nombreuses tâches à réaliser, de telle manière à ce qu’il y est toujours une tâche capable
de progresser dans son exécution ;
▷ les tâches réalisent beaucoup d’entrées/sorties, qui méneraient un programme synchrone à
gaspiller beaucoup de temps bloqué alors qu’une tâche serait capable de s’exécuter ;
▷ les tâches sont indépendantes les unes des autres, ce qui fait qu’il y a peu de communication
nécessaire entre elles.
La programmation asynchrone : les avantages
Dans le cas de nombreuses entrées/sorties
Les performances sont très différentes en fonction des périphériques :
thread» : un seul fil de contrôle et le passage du contrôle d’une tâche
device
à une autre est explicite ;
∘ le modèle «asynchrone» impose au programmeur de «penser»
L1-cache
L2-cache
tant de manière intermittente :
⋄ si une tâche utilise la sortie d’une autre tâche, la tâche dépendant
par morceaux au lieu d’une réception en totalité ;
chrone…
sections represent periods of time when a particular
task is waiting (blocking) and
∘
Mais
lorsqu’une
tâche
est
forcée
d’attendre
bloquée
ogress. Why would a task be blocked? A frequent reason
is that itouis est
waiting
to en attente d’une ressource externe
ata to or from an external
device. Aaccès
typical
CPU can
handle
transfer rates
(accès réseau,
disque,
etc),
c’estdata
l’ensemble
dethat
l’application qui est retardé : le temps
aster than a disk or a network link is capable of sustaining. Thus, a synchronous
d’exécution du modèle «asynchrone» peut être très nettement inférieur à celui synchrone (voir
s of I/O will spend much of its time blocked while a disk or network catches up.
duprogram
modèlefor
asynchrone)
ram is also called schéma
a blocking
that reason.!
a blocking program, looks a bit like Figure 3, an asynchronous program. This is
ndamental idea behind the asynchronous model is that an asynchronous program,
Cours «Parallélisme I» – P-F. Bonnefoi – http://p-fb.net/
hat would normally block in a synchronous program, will instead execute some
3
cache de niveau 1
3 cycles
cache de niveau 2
14 cycles
sur le processeur
de cette sortie doit être écrite de manière à obtenir ses entrées
∘ le modèle «asynchrone» n’exploite pas de parallélisme : le temps
cycles d'horloge
sur le processeur
chaque tâche comme une succession d’étapes plus petites s’exécu-
Figure 4: Blocking in a synchronous program
d’exécution de l’application est le même que dans le modèle syn-
périphérique
RAM
mémoire vive
Disk
disque dur
41 000 000 cycles
réseau
240 000 000 cycles
Network
250 cycles
L’utilisation d’une seule thread permet de travailler en gaspillant le moins possible de cycles d’horloge : moins de défaut de cache, pas de changement de contexte.
Les entrées/sorties mémoire, disque et réseau étant très lentes, on peut effectuer beaucoup de travail
pendant qu’elles se déroulent, ce qui justifie l’utilisation d’E/S asynchrones.
—
31 décembre 2015 — 58
La programmation asynchrone : intérêt ?
Dans quel domaine d’application le modèle asynchrone peut-il s’appliquer ? le réseau !
Une application serveur (comme un serveur Web) peut tirer parti de ce modèle :
∘ les bibliothèques «Twisted» et «Tornado» pour Python ;
∘ le serveur applicatif basé sur Javascript «Node.js».
Pourquoi le modèle «multi-threaded» n’est-il pas une bonne réponse ?
∘ lorsqu’une thread se bloque sur une entrée/sortie, une autre thread peut s’exécuter : pareil que
dans le modèle asynchrone ;
∘ mais avec chaque thread, il y a un surcoût :
⋄ de mémoire : une pile d’exécution associée à chaque thread plus les structures diverses de
gestion et de protection des threads ;
⋄ de temps : pour passer d’une thread à une autre : changement de contexte (sauvegarde de
registres, manipulation mémoires etc.) et restauration du contexte de la nouvelle thread.
Ce surcoût peut alourdir considérablement le travail de gestion d’un serveur.
Programmation asynchrone : le diner des philosophes
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
for(i=0; i<5; i++)
liste_philosophes.push(philosophe(i));
liste_philosophes_a_traiter = liste_philosophes.slice(0);
function scheduler()
{
var numero_philosophe = Math.floor(Math.random() * liste_philosophes_a_traiter.length);
philosophe_a_reveiller = liste_philosophes_a_traiter[numero_philosophe];
liste_philosophes_a_traiter.splice(numero_philosophe, 1);
if (liste_philosophes_a_traiter.length == 0)
{
liste_philosophes_a_traiter = liste_philosophes.slice(0);
}
setTimeout(reveil_philosophe,0);
setTimeout(scheduler,0);
}
− ligne 33 :
⋄ on lance 5 fonctions philosophes en état suspendu (utilisation de la déclaration «function*») ;
⋄ on ajoute chacune de ces fonctions suspendues dans une liste ;
− ligne 36 : on duplique la liste des philosophes ;
− ligne 38 : la fonction «scheduler» permet de :
⋄ ligne 40 : de choisir un philosphe de manière aléatoire dans la liste des philosophes à traiter ;
⋄ ligne 41 : on positionne le philosophe à réveiller sur celui que l’on vient de sélectionner ⟹ un événement le
scheduler();
⋄ ligne 42 : on enlève le philosophe choisi de la liste qui sera réinitialisée en ligne 43-46 quand elle est vide ;
réveillera dans la fonction «reveil_philosophe» ;
− lignes 47-48 : l’ordonnancement : ré-activation du philosophe et rappel de l’ordonnanceur.
La programmation asynchrone : le «producteur/consommateur»
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
var produit = 0;
function appel_producteur() {
producteur.next();
}
function* p() {
var compteur = 0;
while(true)
{
compteur++;
produit = compteur;
console.log("Production " + produit);
setTimeout(appel_consommateur,0);
yield null;
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
function appel_consommateur() {
consommateur.next();
}
function* c() {
while(true)
{
console.log("Consommation "+pro
duit); setTimeout(appel_producteur, 0);
yield null;
}
}
var producteur = p();
var consommateur = c();
▷ l’instruction «yield» permet de retourner une valeur et de conserver l’état de la fonction.
producteur.next();
L’appel à la méthode «next()» permet de retourner à l’instruction suivant le «yield».
▷ l’instruction «setTimeout(function,0)» permet d’ajouter une fonction à exécuter dans
la boucle d’événement de NodeJs.
Cet événement ne sera déclenché que lors de la terminaison de la fonction courante : on prépare
l’avenir de l’application.
Cours «Parallélisme I» – P-F. Bonnefoi – http://p-fb.net/
—
31 décembre 2015 — 59
