CHAPITRE III : GESTION DES ENTRÉE/SORTIE

BELGUERCHE & ZEBBANE 1

PROGRAMME
 Chapitre III : GESTION DES ENTRÉE / SORTIE
 Introduction
 Présentation du matériel
 Périphériques / Contrôleurs
 Projection des E/S
 Modes de pilotage d’une E/S
 Direct : Synchrone et Asynchrone
 Indirect : Accès Direct à la Mémoire (DMA)
 Traitement d’E/S simultanées
 E/S Tamponnées
 Couches Logicielles d’E/S 2

BELGUERCHE & ZEBBANE

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.

BELGUERCHE & ZEBBANE 3

INTRODUCTION

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

BELGUERCHE & ZEBBANE 4

PRÉSENTATION DU MATÉRIEL
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,..)
BELGUERCHE & ZEBBANE 5
PRÉSENTATION DU MATÉRIEL

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
BELGUERCHE & ZEBBANE Accès Aléatoire 6
PRÉSENTATION DU MATÉRIEL

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.
 Mettre certaines données du périphérique ou de l’UC en mémoire tampon afin d’ajuster
BELGUERCHE & ZEBBANE 7

les vitesses de communication.

PRÉSENTATION DU MATÉRIEL

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,...). 8
BELGUERCHE & ZEBBANE
PRÉSENTATION DU MATÉRIEL

Les Contrôleurs

BELGUERCHE & ZEBBANE 9

PRÉSENTATION DU MATÉRIEL

Les Contrôleurs
Périphérique 1
Contrôleur i
R
PC RC 0

RE 1 Périphérique i

RD

M Adr
Périphérique n
C
BELGUERCHE & ZEBBANE 10
PRÉSENTATION DU MATÉRIEL

Les Contrôleurs
Périphérique 1
Contrôleur i
R XX
PC X RC 1

RE 01 Périphérique i

RD XX
X

M Adr XX
X Périphérique n
C
BELGUERCHE & ZEBBANE 11
PROJECTION DES E/S

 La communication entre le processeur et le coupleur se fait par l’intermédiaire des

registres du coupleur.
 La désignation (L’adressage) de ces registres fait appel à l’une des deux techniques
suivantes :
 Mappage sur les ports (Port-Mapped I/O, PMIO) :
 Les périphériques et la mémoire centrale ont chacun leur propre espace d’adressage.
 L'accès au contrôleur se fait via des instructions spécialisées (IN et OUT ).

 Mappage en mémoire (Memory-Mapped I/O, MMIO) :

 Les périphériques et la mémoire centrale partagent le même espace d’adressage.
12

 Les registres peuvent être lus ou modifiés par des instructions ordinaires (MOV).
BELGUERCHE & ZEBBANE
MODES DE PILOTAGE DES E/S

Modes de pilotage

Direct Indirect

Synchrone Asynchrone
DMA: Direct
Memory Access
Le PC est impliqué Le PC est impliqué
complètement dans le Partiellement dans le Le PC est déchargé
control et le suivi de l’E/S control et le suivi de l’E/S complètement du control et du
suivi de l’E/S

Mode Mode Multiprogrammé & Temps partagé 13

BELGUERCHE & ZEBBANE
Monoprogrammé
MODES DE PILOTAGE DES E/S : MODE SYNCHRONE

Pgme A SVC(Cause = Dem E/S,….) A A A B B B B

Début

E/S
C.P.Cxt
<S.G.Cxt> I T A A T A A A T T B T T
Dem E/S C D F C D F
A E A B E B

CPU
/ /
Traitement de la Dem d’E/S S S
A B

R.P.Cxt 0 1 2 3 4 5 6 7 8 9 1 1 1 1 1 1 1 1 1 1

T(ut)
0 1 2 3 4 5 6 7 8 9
<R.G.Cxt>
Fin.

Quel est le programme système qui se Comment une Dem d’E/S est
charge du traitement d’une Dem d’E/S? traitée?

BELGUERCHE & ZEBBANE

Pilote Selon le mode de 14

pilotage
MODES DE PILOTAGE DES E/S : MODE SYNCHRONE

Pgme A SVC(Cause = Dem E/S,….) A A A

Début

E/S
C.P.Cxt
<S.G.Cxt> I TC A A S P A A A T F
Dem E/S A A
V
i
Appel au Pilote_Synchrone C
l

CPU
R.P.Cxt o
<R.G.Cxt>
t
Fin.
e

0 1 2 3 4 5 6 7 8 9 10 11

T(ut)
Tc Dem d’E/S
15
BELGUERCHE & ZEBBANE
MODES DE PILOTAGE DES E/S : MODE SYNCHRONE

Pilote_Synchrone(….) A A A
Début

E/S
Répéter I TC A A S P P P P A A A T F
A A
V
 Lancer le transfert d’un i i i i
C
caractère ou d’un bloc en l l l l
initialisant les registres RC et

CPU
RE. o o o o
 Attendre la fin du Transfert t t t t
d’un caractère ou d’un bloc en
vérifiant le registre RE e e e e

Jusqu’à le transfert de tous 0 1 2 3 4 5 6 7 8 9 10 11

T(ut)

des caractères ou blocs

Fin.
16
BELGUERCHE & ZEBBANE
MODES DE PILOTAGE DES E/S : MODE SYNCHRONE

Exemple: Entrée Synchrone

Périphérique 1
Contrôleur i
R X
PC Ci 01

Fi 10 Périphérique i

BUF X X
i Y
Adr
M X Périphérique n
C
BELGUERCHE & ZEBBANE 17
MODES DE PILOTAGE DES E/S : MODE SYNCHRONE

Exemple: Entrée Synchrone

Périphérique 1
Contrôleur i
R Y
PC RC 1

RE 10 Périphérique i

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

S
/
I TC A A S P P P P A A A T F
A A
V i i i i

l l l l
C
(1) Lancer le transfert

CPU
o o o o
(2) Attendre la fin de transfert
(3) Placer le car en mémoire t t T t
(4) Vérifier si il existe d’autre
car à transférer
T 0 1 2 3 4 5 6 7 8 9 10 11
u
(

t
)
2eme 3eme Neme
1er
E/S

Car Car Car Car

I TC A A S (1) (2) (3) (4) (1) (2) (3) (4) (1) (2) (3) (4) (1) .... .... (1) (2) (3) (4) A A A TFA
A
V
CPU

C P I T E
L O
0 1 2 3 4 7 8 9 10 11 20
T(ut)

BELGUERCHE & ZEBBANE

MODES DE PILOTAGE DES E/S : MODE ASYNCHRONE
Idée : Eviter l’attente active A A A

E/S
Comment I TC A A T B B B T B …
? A
D F
…

CPU
E/S E/S

Au lieu que le PC attend la fin 0 1 2 3 5 6 7 8 9 10

du transfert, il exécute un

ut)
T(
autre pgme
2eme 3eme Neme
1er
E/S

Car Car Car Car

I TC A A S (1) (2) (3) (4) (1) (2) (3) (4) (1) (2) (3) (4) (1) .... .... (1) (2) (3) (4) B … ….
A
V
B B B B
CPU

Init Rit Rit Rit Rit 21

BELGUERCHE & ZEBBANE
0 1 2 3 4 7 8 9 10 11
T(ut)
MODES DE PILOTAGE DES E/S : MODE ASYNCHRONE

Pilote Asynchrone

Init Rit
Elle s’exécute une seule fois
Elle s’exécute N fois et permet
et permet de lancer le
de lancer le transfert des
transfert du premier car ou
autres car ou bloc
bloc

22
BELGUERCHE &
ZEBBANE
 MODES DE PILOTAGE DES E/S : MODE ASYNCHRONE
Exemple:
2eme
1er 3eme Neme

E/S
Car Car
Car Car
A A A
E/S

I TC A A S Init B Rit B Rit B Rit .... .... B Rit B ...

I TC A A T B B B T B …… A
V

CPU
A
D F
CPU

C
E/S E/
S 7 8 9
0 1 2 3 4

T(ut)
0 1 2 3 4 5 6 7 8 9
ut)
T(

Tc
Dem
d’E/S

Tc Fin
d’E/S

23
BELGUERCHE &
ZEBBANE
MODES DE PILOTAGE DES E/S : MODE ASYNCHRONE

Exemple: Entrée Asynchrone

Périphérique 1
It Fin
Contrôleur i
d’E/S
R X
PC RC 01
RE 10 Périphérique i

RD X X
Y
Adr
M X Périphérique n
C
BELGUERCHE & ZEBBANE 24
MODES DE PILOTAGE DES E/S : MODE ASYNCHRONE

Exemple: Entrée Asynchrone

Périphérique 1
It Fin
Contrôleur i
d’E/S
R Y
PC RC 1

RE 10 Périphérique i

RD Y X
Y
Adr
M X Y Périphérique n
C
BELGUERCHE & ZEBBANE 25
 MODES DE PILOTAGE DES E/S : MODE ASYNCHRONE
P-Actif Exemple: Entrée Asynchrone
Pgme A SVC(Cause,Id_Périph, N, Adr) Entrée_Asynchrone.Init(N, Adr)
Début Début
<S.G.Cxt> //Vérifier la disponibilité du périphérique
C.P.Cxt Cas cause vaut Si RE = 1 Alors //Lancer le transfert d’1 car
Lire(x); Entée: RC := 1;
Vérifier les droits d’accès RE := 0;
P-Actif.etat := ”Bloqué
P-Actif.etat ”; ”;
:= ”Bloqué
Enfiler
Enfiler (F pb, P-Actif);
(Fpb, P-Actif);
P-Actif Sinon //Mettre en attente la dem
//Appel au Pilote
d’E/S
Pgme B Entrée_ASynchrone.Init (N, Adr);
Enfiler (FE/S, Dem);
LPSW(Scheduler);
LPSW(Scheduler)
Fcas; ; Fsi;
Fin. Fin.

Scheduler()
…..
BELGUERCHE
//Choisir une autre pgme user 26
& ZEBBANE LPSW(B);
 MODES DE PILOTAGE DES E/S : MODE ASYNCHRONE
Exemple: Entrée Asynchrone (Suite)
Entrée_Asynchrone.Rit(N, Adr)
P-Actif Début
Pgme B <S.G.Cxt>
//Placer le car en MC
C.P.Cxt R := RD; Mov Adr, R;
// Vérifier si  un autre car à transférer
N--;
It-Fin d’E/S Si N ≠ 0 Alors Adr ++;
RE := 0;
Sinon //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;
27
BELGUERCHE R.P.Cxt Fsi;
& ZEBBANE
<R.G.Cxt>
Fin.
MODES DE PILOTAGE DES E/S : MODE D’ACCÈS DIRECT À LA
MÉMOIRE (MODE DMA)
Idée : Eliminer l’envoi des interruptions au
PC à chaque fin de transfert d’un car ou
bloc
Comment
? 1er
2eme 3eme Neme

E/S
Car Car
Car Car
I TC A A S Init B Rit B Rit B Rit .... .... B Rit B ...
A
En déchargeant le PC de la tache de V
transférer la données vers ou de la

CPU
MC C Tc Fin
d’E/S
Tc
Dem
0 1 2 3 d’E/S 4 7 8 9
T(ut)

Avoir un composant matériel capable

d’accéder à la MC pour transférer
des car/bloc vers ou de la MC
28
BELGUERCHE &
ZEBBANE
MODES DE PILOTAGE DES E/S : MODE ASYNCHRONE DMA

Architecture
Périphérique 1
Contrôleur DMA Contrôleur i

PC RC 0
Accès
verrouillé
RCpt
RE 1 Périphérique i
RAdr
RD

M Périphérique n
C
BELGUERCHE & ZEBBANE 29
Gestionnaire de
conflits
MODES DE PILOTAGE DES E/S : MODE ASYNCHRONE DMA

Pilote Asynchrone
DMA

Init Rit

Elle s’exécute 1 seule fois

Elle s’exécute 1 seule fois à la
et permet d’initialiser le
fin du transfert de tous les
contrôleur DMA et le
car/bloc et permet de lancer
contrôleur du
d’autres demandes d’E/S
périphérique

30
BELGUERCHE &
ZEBBANE
MODES DE PILOTAGE DES E/S : MODE D’ACCÈS DIRECT À LA
MÉMOIRE (MODE DMA)

2eme 3eme Neme

1er
E/S

Car Car
Car Car
I TC A A S Init B B B B B B .... .... .... B Rit B ...
A
V
CPU

0 1 2 3 4
T(ut)

31
BELGUERCHE &
ZEBBANE
MODES DE PILOTAGE DES E/S : MODE ASYNCHRONE DMA

Exemple: Traitement d’une dem d’E/S en mode DMA

Périphérique 1
Contrôleur DMA It
Contrôleur i
Fin
Accès
d’E/
verrouillé
PC S
RC 10
Accès
verrouillé
RCpt N--
N Signal
RE 01 Périphérique i
RAdr Adr
Adr++ ACK
RD X

Adr X
M Demand
e d’accès Périphérique n
C
BELGUERC
à la MC

HE & 32
ZEBBANE Gestionnaire de
conflits
 MODES DE PILOTAGE DES E/S : MODE ASYNCHRONE DMA
P-Actif Exemple: Entrée Asynchrone DMA
Pgme A SVC(Cause,Id_Périph, N, Adr) Entrée_Asynchrone_DMA.Init(N, Adr)
Début Début
<S.G.Cxt> //Vérifier la disponibilité du DMA
Cas cause vaut Si DMA libre
Lire(x); Entée: Alors //Initialiser le DMA
C.P.Cxt Vérifier les droits d’accès Rcpt := N;
P-Actif.etat := ”Bloqué ”;
Radr := Adr;
Enfiler (Fpb, P-Actif);
P-Actif //Initialiser le controleur
//Appel au Pilote
Entrée_Asynchrone_DMA.Init (N,Adr); RC := 1;
Pgme B RE := 0;
LPSW(Scheduler);
LPSW(Scheduler)
Fcas; ; Sinon //Mettre en attente la dem d’E/S
Fin. Enfiler (FE/SDMA, Dem);
Fsi;
Scheduler() Fin.
…..
BELGUERCHE
//Choisir une autre pgme user 33
& ZEBBANE LPSW(B);
 MODES DE PILOTAGE DES E/S : MODE ASYNCHRONE DMA
Exemple: Entrée Asynchrone DMA (Suite)
P-Actif Entrée_Asynchrone_DMA.Rit(N, Adr); //Elle est lancée à la fin du transfert de tous les car
Pgme B Début
<S.G.Cxt>
C.P.Cxt Défiler (Fpb, P);
P.état := Prêt ;
Enfiler(Fp, P);
It-Fin d’E/S Si  vide (FE/SDMA)
Alors Défiler (FE/SDMA,Dem) ;
Entrée_Asynchrone_DMA.Init(Dem.N, Dem.Adr);
Sinon RC := 0;

R.P.Cxt Fsi;
<R.G.Cxt>
Fin.

34
BELGUERCHE
& ZEBBANE
 MODES DE PILOTAGE DES E/S : MODE ASYNCHRONE DMA
P-Actif Exemple: Pilote Asynchrone DMA
Pgme A SVC(Cause,Id_Périph, N, Adr) Pilote_Asynchrone_DMA.Init(N, Adr)
Début Début
<S.G.Cxt> //Vérifier la disponibilité du DMA
Cas cause vaut Si DMA libre
Ecrire(x); Entrée/Sortie: Alors //Initialiser le DMA
C.P.Cxt Vérifier les droits d’accès Rcpt := N;
P-Actif.etat := ”Bloqué ”;
Radr := Adr;
Enfiler (FpbDMA, P-Actif);
P-Actif //Initialiser le controleur
//Appel au Pilote
Pilote_Asynchrone_DMA.Init (N,Adr); RC := 1;
Pgme B RE := 0;
LPSW(Scheduler);
LPSW(Scheduler)
Fcas; ; Sinon //Mettre en attente la dem d’E/S
Fin. Enfiler (FE/SDMA, Dem);
Fsi;
Scheduler() Fin.
…..
BELGUERCHE
//Choisir une autre pgme user 35
& ZEBBANE LPSW(B);
 MODES DE PILOTAGE DES E/S : MODE ASYNCHRONE DMA
Exemple: Pilote Asynchrone DMA (Suite)
P-Actif Pilote_Asynchrone_DMA.Rit(N, Adr); //Elle est lancée à la fin du transfert de tous les car
Pgme B Début
<S.G.Cxt>
C.P.Cxt Défiler (FpbDMA, P);
P.état := Prêt ;
Enfiler(Fp, P);
It-Fin d’E/S Si  vide (FE/SDMA)
Alors Défiler (FE/SDMA,Dem) ;
Pilote_Asynchrone_DMA.Init(Dem.N, Dem.Adr);
Sinon RC := 0;

R.P.Cxt Fsi;
<R.G.Cxt>
Fin.

36
BELGUERCHE
& ZEBBANE