cours 1 du module systeme d'exploitation L3 INFORMATIQUE

1. CHAPITRE I : GESTION DES ENTRÉE/SORTIE
ZEBBANE 86
DR BAHIA ZEBBANE
ZEBBANE@GMAIL.COM

2. ◾ Chapitre IV : GESTION DES ENTRÉE / SORTIE
◾ Introduction
◾ Présentation du matériel
◾ Périphériques / Contrôleurs
◾
◾ Modes de pilotage d’une E/S
◾ Direct : Synchrone et Asynchrone
◾ Indirect : Accès Direct à la Mémoire (DMA)
◾
◾
◾
PROGRAMME
87
ZEBBANE

3. INTRODUCTION
◾ Un programme en exécution interagit avec l’environnement pour:
◾ Alimenter le programme avec les données à traiter et
◾ Récupérer le résultat du traitement.
◾ Comment?
En utilisant des organes d’entrées/sorties (périphériques)
comme interface entre l’utilisateur et le système.
ZEBBANE 88

4. INTRODUCTION
ZEBBANE 89
Définition
◾ On appelle Entrée/Sortie (Input/Output) toute opération de transfert
d’informations
(processeur et
(données et programmes) entre l’ordinateur
mémoire centrale) et les organes externes
(périphériques de stockage et de communication).

5. PRÉSENTATION DU MATÉRIEL
90
Les périphériques
◾ Un périphérique (Device) est un appareil qui interagit avec l’UC et
la mémoire.
◾ Classification
◾ Selon leurs branchements :
◾ Périphériques externes (Ecrans, claviers, souris, imprimantes …)
◾ Périphériques internes (Disques durs…)
◾ Selon le sens du transfert d’informations :
◾ Périphériques d’Entrées (claviers, souris,…)
◾ Périphériques de Sortie (Ecrans, imprimantes …)
◾ Périphériques d’Entrée/Sortie (Disques durs,..)
ZEBBANE

6. PRÉSENTATION DU MATÉRIEL
91
Les périphériques
◾ Classification (suite)
◾ Selon le mode du transfert d’informations :
◾ Périphériques de type caractères (claviers, souris, Ecrans, imprimantes …)
◾ Les données sont envoyées ou reçues octets par octets
Accès Séquentiel
◾ Périphériques de type Blocs (Disques durs,..)
◾ Les données sont envoyées ou reçues Blocs par Blocs
Accès Aléatoire
ZEBBANE

7. PRÉSENTATION DU MATÉRIEL
92
Les Contrôleurs
◾ Un contrôleur (Controller) est une unité spéciale, appelée aussi module
d’E/S (I/O module) ou coupleur, qui sert d’interface entre le périphérique
et l’UC.
◾ Fonctions d’un contrôleur d’E/S :
◾ Lire ou écrire des données du périphérique.
◾ Lire ou écrire des données de l’UC/Mémoire.
◾ Contrôler le périphérique et lui faire exécuter des séquences de tâches.
◾ Tester le périphérique et détecter des erreurs.
Z
E
B
B
A
N
◾E
Mettre certaines données du périphérique ou de l’UC en mémoire tampon afin
d’ajuster les vitesses de communication.

8. PRÉSENTATION DU MATÉRIEL
93
Les Contrôleurs
◾ Un contrôleur dispose, pour chaque périphérique qu’il gère, de trois
(03) types de registres :
◾ Registres de données (RD): destinés à contenir les informations
échangées avec le périphérique. Ils peuvent être lus (entrée) ou écrits
(sortie).
◾ Registre d’état (RE) : qui permet de décrire l’état courant du coupleur
(libre, en cours de transfert, erreur détectée,...).
◾ Registre de contrôle (RC) : qui sert à préciser au coupleur ce qu’il
doit faire, et dans quelles conditions (vitesse, format des
échanges,...).
ZEBBANE

9. PRÉSENTATION DU MATÉRIEL
Les Contrôleurs
ZEBBANE 94

10. PRÉSENTATION DU MATÉRIEL
Les Contrôleurs
Périphérique 1
Périphérique i
Périphérique n
RC 0
RE 1
RD
MC
R
PC
Adr
Contrôleur i
ZEBBANE 95

11. MODES DE PILOTAGE DES E/S
98
ZEBBANE
impliqué
dans le
suivi de
Le PC est
complètement
control et le
l’E/S
Modes de
pilotage
Direct Indirect
Le PC est
complètement du
déchargé
control
et du suivi de l’E/S
Synchrone Asynchrone
Le PC est impliqué
Partiellement dans le
suivi de
control et le
l’E/S
DMA: Direct
Memory Access
Mode Monoprogrammé Mode Multiprogrammé & Temps partagé

12. MODES DE PILOTAGE DES E/S : MODE SYNCHRONE
99
ZEBBANE
A A A B B B B
I T
C
A
A A T
D
E
/
S
A
A A A T
F
A
T
C
B
B T
D
E
/
S
B
T
F
B
0 1 2 3 4 5 6 7 8 9 1
0
1
1
1
2
1
3
1
4
1
5
1
6
1
7
1
8
1
9
E/S
CPU
T(ut)
SVC(Cause = Dem E/S,….)
Début
<S.G.Cxt>
C.P.Cxt
Pgme A
Dem E/S
Traitement de la Dem d’E/S
R.P.Cxt
<R.G.Cxt>
Fin.
Quel est le programme système qui
se charge du traitement d’une Dem
d’E/S?
Comment une Dem d’E/S est
traitée?
Pilote Selon le mode de
pilotage

13. MODES DE PILOTAGE DES E/S : MODE SYNCHRONE
100
A A A
I TC
A
A A S
V
C
P
i
l
o
t
e
A A A T F
A
0 1 2 3 4 5 6 7 8 9 10 11
E/S
CPU
T(ut)
SVC(Cause = Dem E/S,….)
Début
<S.G.Cxt>
C.P.Cxt
Pgme A
Dem E/S
R.P.Cxt
<R.G.Cxt>
Fin.
Appel au Pilote_Synchrone
Tc Dem d’E/S
ZEBBANE

14. MODES DE PILOTAGE DES E/S : MODE SYNCHRONE
101
A A A
I TC
A
A A S
V
C
P
i
l
o
t
e
P
i
l
o
t
e
P
i
l
o
t
e
P
i
l
o
t
e
A A A T F
A
0 1 2 3 4 5 6 7 8 9 10 11
E/S
CPU
T(ut)
Pilote_Synchrone(….)
Début
Répéter
 Lancer le transfert d’un
caractère ou d’un bloc en
les registres
initialisant
RC et RE.
 Attendre la fin
Transfert d’un caractère
du
ou
d’un bloc en vérifiant le
registre RE
Jusqu’à le transfert de tous
des caractères ou blocs
Fin.
ZEBBANE

15. MODES DE PILOTAGE DES E/S : MODE SYNCHRONE
Exemple: Entrée Synchrone
Périphérique 1
Périphérique i
Périphérique n
Ci 0
Fi 1
BUFi
MC
R
PC
Adr
Contrôleur i
X
X
X
1
0
1
XY
ZEBBANE 102

16. MODES DE PILOTAGE DES E/S : MODE SYNCHRONE
Exemple: Entrée Synchrone
Périphérique 1
Périphérique i
Périphérique n
RC 1
RE 1
RD
MC
R
PC
Adr
Contrôleur i
Y
Y
X
0
1
Y
ZEBBANE 103
XY

17. MODES DE PILOTAGE DES E/S : MODE SYNCHRONE
104
ZEBBANE
SVC(Cause = E,Id_Périph, N=Taille(x),
Adr = Adr(x))
Début
<S.G.Cxt>
Cas cause vaut
Entée:
//Appel au Pilote
Entrée_Synchrone (N, Adr);
Fcas;
<R.G.Cxt>
Fin.
C.P.Cxt
Pgme A
Lire(x);
R.P.Cxt
Entrée_Synchrone(N, Adr)
Début
// (1)Lancer le transfert d’1 car
RC := 1;
Et1: RE := 0;
// (2)Attendre la fin du transfert
Et2:Si RE = 0 Alors goto Et2; Fsi;
// (3) Placer le car en MC
R := RD; Mov Adr, R;
// (4) Vérifier si  un autre car à
transférer
N--;
Si N ≠ 0 Alors Adr ++;
goto Et1;
Sinon RC := 0;
Fsi;
Fin.
Exemple: Entrée Synchrone

18. MODES DE PILOTAGE DES E/S : MODE SYNCHRONE
105
ZEBBANE
T
(
u
1er
Car
2eme
Car
3eme
Car
Neme
Car
I TC
A
A A S
V
C
(1) (2) (3)
P
(4)
I
(1)
L
(2)
O
(3)
T
(4)
E
(1) (2) (3) (4) (1) .... .... (1) (2) (3) (4) A A A T F A
0 1 2 3 4 7 8 9 10 11
E/S
CPU
T(ut)
A A A
I TC
A
A A S
V
C
P
i
l
o
t
P
i
l
o
t
P
i
l
o
T
P
i
l
o
t
A A A T F
A
0 1 2 3 4 5 6 7 8 9 10 11
E
/
S
CPU
(1)Lancer le transfert
(2)Attendre la fin de
transfert
(3)Placer le car en mémoire
(4) Vérifier si il existe
d’autre car à transférer
Exemple: Entrée Synchrone

19. MODES DE PILOTAGE DES E/S : MODE SYNCHRONE
106
ZEBBANE
SVC(Cause = S,Id_Périph, N=Taille(x),
Adr = Adr(x))
Début
<S.G.Cxt>
Cas cause vaut
Sortie:
//Appel au Pilote
Sortie_Synchrone (N, Adr);
Fcas;
<R.G.Cxt>
Fin.
C.P.Cxt
Pgme A
Ecrire(x);
R.P.Cxt
Sortie_Synchrone(N, Adr)
Début
// (1) Récupérer le car de la MC et le
placer dans le RD
Et1 : Mov R, Adr; RD := R;
// (2)Lancer le transfert du car placé
dans RD
RC := 1; RE := 0;
// (3)Attendre la fin du transfert
Et2:Si RE = 0 Alors goto Et2; Fsi;
// (4) Vérifier si  un autre car à
transférer
N--;
Si N ≠ 0 Alors Adr ++;
goto Et1;
Sinon RC := 0;
Fsi;
Fin.
Exemple: Sortie Synchrone

20. MODES DE PILOTAGE DES E/S : MODE SYNCHRONE
107
ZEBBANE
T
(
u
1er
Car
2em
e
Car
3eme
Car
Neme
Car
I TC
A
A A S
V
C
(1) (2) (3)
P
(4)
I
(1)
L
(2)
O
(3)
T
(4)
E
(1) (2) (3) (4) (1) .... .... (1) (2) (3) (4) A A A TFA
0 1 2 3 4 7 8 9 10 11
E/S
CPU
T(ut)
A A A
I TC
A
A A S
V
C
P
i
l
o
t
P
i
l
o
t
P
i
l
o
T
P
i
l
o
t
A A A T F
A
0 1 2 3 4 5 6 7 8 9 10 11
E
/
S
CPU
(1)Ramener le car de la mémoire
(2)Lancer le transfert
(3)Attendre la fin de transfert
(4)Vérifier si il existe d’autre
car à transférer
Exemple: Sortie Synchrone

21. MODES DE PILOTAGE DES E/S
108
ZEBBANE
impliqué
dans le
suivi de
Le PC est
complètement
control et le
l’E/S
Modes de
pilotage
Direct Indirect
Le PC est
complètement du
déchargé
control
et du suivi de l’E/S
Synchrone Asynchrone
impliqué
dans le
suivi de
Le PC est
Partiellement
control et le
l’E/S
DMA: Direct
Memory Access
Mode Monoprogrammé Mode Multiprogrammé & Temps partagé
Inconvénient :
Attente Active

22. MODES DE PILOTAGE DES E/S : MODE ASYNCHRONE
109
ZEBBANE
E/S
1er
Car
2eme
Car
3eme
Car
Neme
Car
CPU
I TC
A
A A S
V
C
(1) (2)
B
(3) (4) (1) (2)
B
(3) (4) (1) (2)
B
(3) (4) (1) .... .... (1) (2)
B
(3) (4) B … ….
T(ut)
0 1 2 3 4 7 8 9 10 11
A A A
I TC
A
A A T
D
E/S
B B B T
F
E/S
B …
…
0 1 2 3 5 6 7 8 9 10
E/S
CPU
T(
ut)
Idée : Eviter l’attente
active
Comment?
Au lieu que le PC attend
la fin du transfert, il
exécute un autre pgme
Init Rit Rit Rit Rit

23. MODES DE PILOTAGE DES E/S : MODE ASYNCHRONE
Pilote
Asynchrone
Init
Elle s’exécute une
seule fois et permet
de lancer le transfert
du premier car ou bloc
Rit
Elle s’exécute N fois et
permet de lancer le
transfert des autres car
ou bloc
110
ZEBBANE

24. MODES DE PILOTAGE DES E/S : MODE ASYNCHRONE
E/S
1er
Car
2eme
Car
3eme
Car
Neme
Car
CPU
I TC
A
A A S
V
C
Init B Rit B Rit B Rit .... .... B Rit B ...
T(ut)
0 1 2 3 4 7 8 9
A A A
I TC
A
A A T
D
E/S
B B B T
F
E/
S
B ……
0 1 2 3 4 5 6 7 8 9
E/S
CPU
T(
ut)
Exemple:
Tc Dem
d’E/S
Tc Fin
d’E/S
111
ZEBBANE

25. MODES DE PILOTAGE DES E/S : MODE ASYNCHRONE
Exemple: Entrée Asynchrone
Périphérique 1
Périphérique i
Périphérique n
RC 0
RE 1
RD
MC
R
PC
Adr
Contrôleur i
X
ZEBBANE 112
X
X
1
0
1
XY
It Fin
d’E/S

26. MODES DE PILOTAGE DES E/S : MODE ASYNCHRONE
Exemple: Entrée Asynchrone
Périphérique 1
Périphérique i
Périphérique n
RC 1
RE 1
RD
MC
R
PC
Adr
Contrôleur i
Y
Y
X
0
1
Y
XY
It Fin
ZEBBANE 113
d’E/S

27. MODES DE PILOTAGE DES E/S : MODE ASYNCHRONE
114
ZEBBANE
Pgme B
Scheduler()
…..
//Choisir une autre pgme
user
LPSW(B);
C.P.Cxt
Pgme A
Lire(x);
Entrée_Asynchrone.Init(N, Adr)
Début
//Vérifier la disponibilité du périphérique
Si RE = 1 Alors //Lancer le transfert d’1 car
RC := 1;
RE := 0;
Sinon //Mettre en attente la dem
d’E/S
Enfiler (FE/S, Dem);
Fsi;
Fin.
SVC(Cause,Id_Périph, N, Adr)
Début
<S.G.Cxt>
Cas cause vaut
Entée:
Vérifier les droits d’accès
P-Actif.etat := ”Bloqué ”;
Enfiler (Fpb, P-Actif);
//Appel au Pilote
Entrée_ASynchrone.Init (NB,Adr);
LPSW(Scheduler);
Fcas;
Fin.
P-Actif Exemple: Entrée Asynchrone(Périphérique de type caractère: sens unique)
P-Actif

28. MODES DE PILOTAGE DES E/S : MODE ASYNCHRONE
115
ZEBBANE
Exemple: Entrée Asynchrone (Suite)
Pgme B
It-Fin d’E/S
Entrée_Asynchrone.Rit(N, Adr)
Début
<S.G.Cxt>
//Placer le car en MC
R := RD; Mov Adr, R;
// Vérifier si  un autre car à transférer
NB--;
Si N ≠ 0 Alors
Sinon
Adr ++;
RE := 0;
//Fin de transfert de tous les car
Défiler (Fpb, P);
P.état := Prêt ;
Enfiler(Fp, P);
Si  vide (FE/S)
Alors Défiler (FE/S,Dem) ;
Entrée_Asynchrone.Init(Dem.N, Dem.Adr);
Sinon RC := 0;
Fsi;
Fsi;
<R.G.Cxt>
Fin.
C.P.Cxt
R.P.Cxt
P-Actif

29. MODES DE PILOTAGE DES E/S : MODE ASYNCHRONE
Exemple: Sortie Asynchrone
Périphérique 1
Périphérique i
Périphérique n
RC 0
RE 1
RD
MC
R
PC
Adr
Contrôleur i
X
X
1
0
1
It Fin
d’E/S
X
X Y
ZEBBANE 116

30. MODES DE PILOTAGE DES E/S : MODE ASYNCHRONE
Exemple: Sortie Asynchrone
Périphérique 1
Périphérique i
Périphérique n
RC 1
RE 1
RD
MC
R
PC
Adr
Contrôleur i
Y
Y
0
It Fin
d’E/S
X Y
1
ZEBBANE 117
X Y

31. MODES DE PILOTAGE DES E/S : MODE ASYNCHRONE
118
ZEBBANE
Pgme B
Scheduler()
…..
//Choisir une autre pgme
user
LPSW(B);
C.P.Cxt
Pgme A
Ecrire(x);
Sortie_Asynchrone.Init(N, Adr)
Début
//Vérifier la disponibilité du périphérique
Si RE = 1 Alors //Ramener le car de la mémoire
Mov R, Adr;
RD := R;
//Lancer le transfert d’1 car
RC := 1;
RE := 0;
Sinon //Mettre en attente la dem
d’E/S
Enfiler (FE/S, Dem);
Fsi;
Fin.
SVC(Cause,Id_Périph, N, Adr)
Début
<S.G.Cxt>
Cas cause vaut
Sortie:
Vérifier les droits d’accès
P-Actif.etat := ”Bloqué ”;
Enfiler (Fpb, P-Actif);
//Appel au Pilote
Sortie_ASynchrone.Init (N, Adr);
LPSW(Scheduler);
Fcas;
Fin.
P-Actif Exemple: Sortie Asynchrone (Périphérique de type caractère: sens unique)
P-Actif

32. MODES DE PILOTAGE DES E/S : MODE ASYNCHRONE
119
ZEBBANE
Exemple: Sortie Asynchrone (Suite)
Pgme B
It-Fin d’E/S
Sortie_Asynchrone.Rit(N, Adr)
Début
<S.G.Cxt>
// Vérifier si  un autre car à transférer
N--;
Si N ≠ 0 Alors
Sinon
//Ramener un autre car de la MC et lancer son transfert
Adr ++;
Mov R,Adr; RD:=R;
RE := 0;
//Fin de transfert de tous les car
Défiler (Fpb, P);
P.état := Prêt ;
Enfiler(Fp, P);
Si  vide (FE/S)
Alors Défiler (FE/S,Dem) ;
Sortie_Asynchrone.Init(Dem.N, Dem.Adr);
Sinon RC := 0;
Fsi;
Fsi;
<R.G.Cxt>
Fin.
C.P.Cxt
R.P.Cxt
P-Actif

33. MODES DE PILOTAGE DES E/S
120
ZEBBANE
impliqué
dans le
suivi de
Le PC est
complètement
control et le
l’E/S
Modes de
pilotage
Direct Indirect
Le PC est
complètement du
déchargé
control
et du suivi de l’E/S
Synchrone Asynchrone
impliqué
dans le
suivi de
DMA: Direct
Memory Access
Mode Monoprogrammé
Inconvénient :
Attente Active
Le PC est
Partiellement
control et le
l’E/S
Inconvénient : Le nombre
important des Interruptions
reçues
transfert d’un car ou bloc
à chaque fin de
ce
qui augmente le Temps de
réponse des pgmes
Mode Multiprogrammé & Temps partagé

34. MODES DE PILOTAGE DES E/S : MODE D’ACCÈS DIRECT À LA MÉMOIRE
(MODE DMA)
121
ZEBBANE
E/S
1er
Car
2eme
Car
3eme
Car
Neme
Car
CPU
I TC A
A
A Init B Rit B Rit B Rit .... .... B Rit B ...
T(ut)
0 1 2 3 4 7 8 9
S
V
C
Tc
d’
Dem
E/S
Tc Fin
d’E/S
Idée : Eliminer l’envoi des
interruptions au PC à chaque fin
de transfert d’un car ou bloc
Comment?
En déchargeant le PC de la tache
de transférer la données vers
ou de la MC
Avoir un composant matériel
capable d’accéder à la MC
pour transférer des car/bloc
vers ou de la MC

35. MODES DE PILOTAGE DES E/S : MODE ASYNCHRONE DMA
122
Architecture
ZEBBANE
Périphérique 1
Périphérique i
Périphérique n
RC 0
RE 1
RD
MC
PC
Contrôleur i
Contrôleur DMA
RCpt
RAdr
Gestionnaire
de conflits
Accès
verrouillé

36. MODES DE PILOTAGE DES E/S : MODE ASYNCHRONE DMA
Elle s’exécute 1
seule fois et permet
le
d’initialiser
contrôleur DMA et le
contrôleur du
périphérique
Pilote
Asynchrone
DMA
Init Rit
Elle
fois
transfert de tous
s’exécute 1 seule
à la fin du
les
car/bloc et permet de
lancer d’autres demandes
d’E/S
123
ZEBBANE

37. MODES DE PILOTAGE DES E/S : MODE D’ACCÈS DIRECT À LA MÉMOIRE
(MODE DMA)
124
ZEBBANE
1er
Car
2eme
Car
3eme
Car
Neme
Car
I TC
A
A A S
V
C
Init B B B B B B .... .... .... B Rit B ...
0 1 2 3 4
E/S
CPU
T(ut)

38. MODES DE PILOTAGE DES E/S : MODE ASYNCHRONE DMA
125
Exemple: Traitement d’une dem d’E/S en mode DMA
ZEBBANE
Périphérique 1
Périphérique i
Périphérique n
RC 0
RE 1
RD
MC
PC
Contrôleur i
It
Fin
d’E
/S
Contrôleur DMA
RCpt
RAdr
N
1
Adr
X
Signal
ACK
Gestionnaire
de conflits
Accès
verrouillé
Accès
verrouillé
Demande
d’accès
à la MC
Adr X
N--
Adr++
0
1

39. MODES DE PILOTAGE DES E/S : MODE ASYNCHRONE DMA
126
ZEBBANE
Pgme B
Scheduler()
…..
//Choisir une autre pgme
user
LPSW(B);
C.P.Cxt
Pgme A
Lire(x);
Entrée_Asynchrone_DMA.Init(N, Adr)
Début
//Vérifier la disponibilité du DMA
Si DMA libre
Alors //Initialiser le DMA
Rcpt := N;
Radr := Adr;
//Initialiser le controleur
RC := 1;
RE := 0;
Sinon //Mettre en attente la dem d’E/S
Enfiler (FE/SDMA, Dem);
Fsi;
Fin.
SVC(Cause,Id_Périph, N, Adr)
Début
<S.G.Cxt>
Cas cause vaut
Entée:
Vérifier les droits d’accès
P-Actif.etat := ”Bloqué ”;
Enfiler (Fpb, P-Actif);
//Appel au Pilote
Entrée_Asynchrone_DMA.Init (N,Adr);
LPSW(Scheduler);
Fcas;
Fin.
P-Actif Exemple: Entrée Asynchrone DMA
P-Actif

40. MODES DE PILOTAGE DES E/S : MODE ASYNCHRONE DMA
127
ZEBBANE
Exemple: Entrée Asynchrone DMA (Suite)
Pgme B
It-Fin d’E/S
Entrée_Asynchrone_DMA.Rit(N, Adr); //Elle est lancée à la fin du transfert de tous les car
Début
<S.G.Cxt>
Défiler (Fpb, P);
P.état := Prêt ;
Enfiler(Fp, P);
Si  vide (FE/SDMA)
Alors Défiler (FE/SDMA,Dem) ;
Entrée_Asynchrone_DMA.Init(Dem.N, Dem.Adr);
Sinon RC := 0;
Fsi;
<R.G.Cxt>
Fin.
C.P.Cxt
R.P.Cxt
P-Actif

41. MODES DE PILOTAGE DES E/S : MODE ASYNCHRONE DMA
128
ZEBBANE
Pgme B
Scheduler()
…..
//Choisir une autre pgme
user
LPSW(B);
C.P.Cxt
Pgme A
Ecrire(x);
Sortie_Asynchrone_DMA.Init(N, Adr)
Début
//Vérifier la disponibilité du DMA
Si DMA libre
Alors //Initialiser le DMA
Rcpt := N;
Radr := Adr;
//Initialiser le controleur
RC := 1;
RE := 0;
Sinon //Mettre en attente la dem d’E/S
Enfiler (FE/SDMA, Dem);
Fsi;
Fin.
SVC(Cause,Id_Périph, N, Adr)
Début
<S.G.Cxt>
Cas cause vaut
Sortie:
Vérifier les droits d’accès
P-Actif.etat := ”Bloqué ”;
Enfiler (Fpb, P-Actif);
//Appel au Pilote
Sortie_Asynchrone_DMA.Init (N,Adr);
LPSW(Scheduler);
Fcas;
Fin.
P-Actif Exemple: Sortie Asynchrone DMA
P-Actif

42. MODES DE PILOTAGE DES E/S : MODE ASYNCHRONE DMA
129
ZEBBANE
Exemple: Sortie Asynchrone DMA (Suite)
Pgme B
It-Fin d’E/S
Sortie_Asynchrone_DMA.Rit(N, Adr); //Elle est lancée à la fin du transfert de tous les car
Début
<S.G.Cxt>
Défiler (Fpb, P);
P.état := Prêt ;
Enfiler(Fp, P);
Si  vide (FE/SDMA)
Alors Défiler (FE/SDMA,Dem) ;
Sortie_Asynchrone_DMA.Init(Dem.N, Dem.Adr);
Sinon RC := 0;
Fsi;
<R.G.Cxt>
Fin.
C.P.Cxt
R.P.Cxt
P-Actif

43. MODES DE PILOTAGE DES E/S : MODE ASYNCHRONE DMA
130
ZEBBANE
Exemple: Pilote Asynchrone DMA(Périphérique de type caractère: sens unique)
Pgme B
Scheduler()
…..
//Choisir une autre pgme
user
LPSW(B);
C.P.Cxt
Pgme A
Ecrire(x);
Pilote_Asynchrone_DMA.Init(N, Adr)
Début
//Vérifier la disponibilité du DMA
Si DMA libre
Alors //Initialiser le DMA
Rcpt := N;
Radr := Adr;
//Initialiser le controleur
RC := 1;
RE := 0;
Sinon //Mettre en attente la dem d’E/S
Enfiler (FE/SDMA, Dem);
Fsi;
Fin.
SVC(Cause,Id_Périph, N, Adr)
Début
<S.G.Cxt>
Cas cause vaut
Entrée/Sortie:
Vérifier les droits d’accès
P-Actif.etat := ”Bloqué ”;
Enfiler (FpbDMA, P-Actif);
//Appel au Pilote
Pilote_Asynchrone_DMA.Init (N,Adr);
LPSW(Scheduler);
Fcas;
Fin.
P-Actif
P-Actif

44. MODES DE PILOTAGE DES E/S : MODE ASYNCHRONE DMA
131
ZEBBANE
Exemple: Pilote Asynchrone DMA (Suite)
Pgme B
It-Fin d’E/S
Pilote_Asynchrone_DMA.Rit(N, Adr); //Elle est lancée à la fin du transfert de tous les car
Début
<S.G.Cxt>
Défiler (FpbDMA, P);
P.état := Prêt ;
Enfiler(Fp, P);
Si  vide (FE/SDMA)
Alors Défiler (FE/SDMA,Dem) ;
Pilote_Asynchrone_DMA.Init(Dem.N, Dem.Adr);
Sinon RC := 0;
Fsi;
<R.G.Cxt>
Fin.
C.P.Cxt
R.P.Cxt
P-Actif

45. MODES DE PILOTAGE DES E/S : MODE ASYNCHRONE DMA
132
ZEBBANE
Exemple: Pilote Asynchrone DMA(Périphérique à double sens)
Pgme B
LPSW(B);
C.P.Cxt
Pgme A
Ecrire(x);
Pilote_Asynchrone_DMA.Init(N, Adr,sens)
Début
//Vérifier la disponibilité du DMA
Si DMA libre
Alors //Initialiser le DMA
Rcpt := N;
Radr := Adr;
//Initialiser le controleur
RC[1] := 1; RC[2]:=sens
RE := 0;
Sinon //Mettre en attente la dem d’E/S
Enfiler (FE/SDMA, Dem);
Fsi;
Fin.
SVC(Cause,Id_Périph, N, Adr)
Début
<S.G.Cxt>
Cas cause vaut
Entrée/Sortie:
Vérifier les droits d’accès
P-Actif.etat := ”Bloqué ”;
Enfiler (FpbDMA, P-Actif);
//Appel au Pilote
sens:= 0 ou 1
Pilote_Asynchrone_DMA.Init (N,Adr,sens)
LPSW(Scheduler);
Fcas;
Fin.
Scheduler()
…..
//Choisir une autre pgme
user
P-Actif
P-Actif

46. MODES DE PILOTAGE DES E/S : MODE ASYNCHRONE DMA
133
ZEBBANE
Exemple: Pilote Asynchrone DMA (Suite)
Pgme B
It-Fin d’E/S
Pilote_Asynchrone_DMA.Rit(N, Adr); //Elle est lancée à la fin du transfert de tous les car
Début
<S.G.Cxt>
Défiler (FpbDMA, P);
P.état := Prêt ;
Enfiler(Fp, P);
Si  vide (FE/SDMA)
Alors Défiler (FE/SDMA,Dem) ;
Pilote_Asynchrone_DMA.Init(Dem.N, Dem.Adr, Dem.sens);
Sinon RC := 0;
Fsi;
<R.G.Cxt>
Fin.
C.P.Cxt
R.P.Cxt
P-Actif