Docstoc

Processes and Threads

Document Sample
Processes and Threads Powered By Docstoc
					        Chapitre 1

Concepts de base des O.S.
   1.1. Qu'est-ce un O.S. ?
   1.2. Histoire des O.S.
   1.3. La jungle des O.S.
   1.4. Composantes des O.S.
   1.5. Les appels-systèmes




                               1
     1.1. Qu'est-ce qu'un O.S. ?
• C'est la couche logicielle indispensable entre le
  hardware et les programmes applicatifs

• C'est une machine étendue
   – Présentation à l'utilisateur d'une machine virtuelle
   – Masquage de la complexité technique

• C'est un gestionnaire de ressources
   – Allocation équitable du temps (CPU) et de l'espace
     (mémoire) entre les différents processus
   – Allocation équitable des autres ressources périphériques

                                                                2
  L’O.S. est plus qu’une interface

• Beaucoup                         Hardware
  d’utilisateurs ne voient
  que l’interface (shell)      Operating System
• Intégration de plus en     Libraries   Utilities
  plus forte actuellement
  entre les services (cfr          Interface
  Windows/Internet)



                                                     3
                 Objectifs de l’O.S.
• Utilisation efficace des ressources
   – Eviter les bouchons (bottlenecks) et les temps d’attente
   – Partage “optimal” du CPU, mémoire, I/O
• Facilité d’utilisation
   – Le client est roi
• Disponibilité, fiabilité, sécurité
   – les systèmes informatiques sont le cerveau de nombreuses
     entreprises
   A failed system can mean a failed company...


                                                                4
Vue abstraite d'un système informatique




Un système informatique est composé de:
   – hardware
   – programmes systèmes
   – programmes d'applications

                                          5
1.2. Historique des OS




                         6
Première génération OS 1945 - 1955

• Systèmes batch (par lots) simples
• Mono-tâche et séquentiel (héritier: DOS)
  Read   Compute   Print
                           Read   Compute   Print




         Gaspillage d ’utilisation CPU !

                                                    7
 Seconde génération OS 1955 - 1965
• Systèmes batch avec spooling
  (Simultaneous Peripheral Operations On-
  Line) lecture et écriture

  Read   Compute   Print
          Read      Compute       Print
                           Read   Compute   Print

• Mieux, mais problème des longs jobs


                                                    8
Troisième génération OS 1965–1980

• Introduction des concepts de temps partagé et
  d’interactivité avec les utilisateurs (premiers
  terminaux texte tty)
     systèmes multi-tâches, multi-utilisateurs
• Nécessité d’un ordonnanceur et de gestion de
  processus (priorités, tranches de temps)
• Les premiers O.S. modernes, propriétaires (IBM,
  Dec,…) ou de domaine public (Unix)
• Vers une gestion moins gaspilleuse des ressources

                                                      9
Base de la multiprogrammation
Plusieurs jobs sont résidents en mémoire. Nécessité
d’un ordonnanceur pour sélectionner le job suivant
devant s’exécuter




                                                      10
  Quatrième génération 1980 – ...

• Les premiers PCs: retour en arrière au
   niveau des O.S. (mono-tâche, mono-user)!
• Les premiers réseaux: intégration des
   protocoles de communication dans les O.S.
• L’avènement réel de l’informatique
   moderne
 Internet a 30 ans! Unix aussi! C également!

                                               11
  Quatrième génération 1980 – ...
• “The system is the network.” (Sun
  Microsystems)




• Multi-utilisateurs, Multi-tâches, Multi-
  processeurs, Multi-ordinateurs (systèmes
  distribués)
                                             12
Résumé de l’histoire de l’informatique




                                         13
            1.3. La jungle des O.S.

•   Mainframe operating systems
•   Server operating systems
•   Multiprocessor operating systems
•   Personal computer operating systems
•   Real-time operating systems (O.S. temps-réel)
•   Embedded operating systems (O.S. embarqués)
•   Smart card operating systems (O.S. pour cartes à puces)




                                                              14
              Systèmes parallèles

• Plusieurs CPU coopérant en topologie rapprochée (cartes
  multiprocesseurs, clusters)
• À mémoire partagée, distribuée, ou distribuée et
  virtuellement partagée.
• Pourquoi ?
   – Coût/Performance
   – Fiabilité/Tolérance aux pannes/Qualité de Service
   – Sécurité



                                                            15
               Systèmes distribués

• L’application est répartie sur plusieurs ordinateurs (loosely
  coupled).

• Avantages
   – Partage de ressources
   – Adaptation application/architecture
• Nouveau concept : Cluster & Grid computing (voir
  http://www.top500.org)



                                                                  16
                 Systèmes temps-réel

• Contraintes de temps strictes
• Souvent utilisés pour des applications dédicacées de contrôle
  (industrie, domaine médical, scientifique,…)
• Hard real-time system
  Nécessite un O.S. + hardware adapté
• Soft real-time system
  Nécessite un paramètrage de l’O.S. (ordonnanceur spécialisé)




                                                                  17
      Systèmes mobiles (embarqués ou
               spécialisés)
• de l'informatique dans toutes les machines: cartes à puce,
  machines à laver, notebook, agenda électroniques, GSM,...
• nécessité d'un O.S. standard, miniature et adapté pour les
  programmer : Windows CE, adaptation de Linux,
  PalmOS,...




                                                               18
               1.4. Composantes des O.S.

•   Gestion des processus
•   Gestion de la mémoire
•   Gestion des fichiers
•   Gestion des I/O et périphériques
•   Administration et sécurité
•   Réseau
• Services utilisateurs (interface, audit, monitoring…)




                                                          19
            Gestion des processus
• Un processus est un programme en cours d’exécution
   – Il occupe des ressources (mémoire, fichiers ouverts,
     CPU,..)
   – Il a un contexte d’exécution (état)
• Les fonctions indispensables sont:
   – Création et terminaison
   – Allocation des ressources
   – Synchronisation et communication
   – Administration



                                                            20
             Gestion de la mémoire

•   Partage équitable de la mémoire entre processus
•   Gestion d’une mémoire virtuelle (swap)
•   Protection des accès
•   Récupération des blocs devenus libres (garbage collection)




                                                                 21
  Gestion de la mémoire secondaire

L'O.S. doit gérer efficacement:

   – L'allocation/désallocation de l'espace disque
   – Les accès (lents) aux disques
   – Les transferts mémoire-vive/mémoire secondaire




                                                      22
               Gestion des fichiers

• Administration des fichiers
   – Création/effacement/copiage fichiers/répertoires
   – Modification des propriétés d’un fichier
   – Correspondance fichier/stockage physique
   – Backup et archivage

            create, delete, open, close
                 read, write, seek
               get or set attributes

                                                        23
L'arbre des fichiers




         .




                       24
                   L'arbre des fichiers




• Before mounting,
   – Les fichiers sur "Floppy" sont inacessibles
• After mounting floppy on b,
   – Les fichiers sur "floppy" font partie de l'arbre des
     fichiers
                                                            25
                  Gestion des I/O

• Assurer un niveau d’abstraction: cacher les particularités
  des systèmes
• Composantes principales
   – Gestion de buffering, caching et spooling
   – Drivers




                                                               26
       Administration et sécurité
• Gestion des comptes utilisateurs
   – quotas, compatibilité, droits d’accès
• Audit du système
• Démarrage (boot) et redémarrage en cas de panne
• Lutte contre le piratage
  Les fonctions réseaux jouent un rôle majeur aujourd’hui
  (accès distants au CPU et aux périphériques)




                                                            27
Administration réseau
• Lié de plus en plus à l’O.S.
• 4 types de systèmes
   – Stand alone (en voie d'extinction)
   – Multiprocesseurs
   – Clusters (LAN)
   – Distribué (WAN)
• 2 modèles de communication
   – Par passage de message
   – Mémoire (virtuellement) partagée

                                          28
             Services utilisateurs
• Interface (conviviale)
   – Shell
   – GUI (Graphic User Interface)
   – Scripting (langages de commande)
• Comptabilité, administration
• Sécurité, Audit

     L’utilisateur veut un O.S. simple d'emploi, efficace,
     fiable (cfr évolution de l’automobile)


                                                             29
          Structure d’O.S. type - UNIX
                          USERS
                        shells and commands
                      compilers and interpreters
                           system libraries
                    system call interface to kernel
        signals                file system            CPU scheduling
   terminal handling            swapping              page replacement
  character I/O system      block I/O system           demand paging     N
    terminal drivers      disk and tape drivers        virtual memory    O
                                                                         Y
                     kernel interface to the hardware interface          A
                                                                         U
terminal controllers       device controllers       memory controllers
     terminals               disks and tapes          physical memory

                             HARDWARE

                                                                             30
              1.5. Les appels-systèmes
• Les appels-systèmes permettent aux applications d'utiliser les
  ressources systèmes (gestion des processus, fichiers, mémoire
  I/O).

• Ils font basculer l'application de l'exécution en mode utilisateur
  à l'exécution en mode "kernel" (noyau)

• Ils déclenchent pour cela une interruption du cours normal de
  l'exécution vers un traitement (handler) en mode noyau.




                                                                       31
                  Chapitre 2

            Gestion des Processus

2.1. Les processus
2.2. L'ordonnancement des processus




                                      32
                2.1. Les processus


• Un processus est un programme en exécution

• Un processus est caractérisé par un contexte d ’exécution

   – segments de texte, données et pile
   – compteur spécifiant l’instruction suivante à exécuter
   – registres




                                                              33
    Les segments d'un processus: le texte, les
               données, la pile




.




                                                 34
    Etats d'un processus

       ordonnanceur




.




                           35
      L'importance de l'ordonnanceur




• Une des bases d'un OS multiprogrammé est
   – le traitement des interruptions
   – l'ordonnancement


                                             36
         Opérations sur les processus

• Création de nouveaux                      P1
  processus
• Terminaison de processus            P2          P4
• Suspension                     P3        P5          P7
   – Interne (wait)
                                                 P6
   – Externe (attente d’une
     ressource)
                              Arbre de processus



                                                            37
                Création de processus
• Un processus (père) peut créer des processus fils
   – stockage en une structure d'arbre de processus,
   – chaque processus connaît son père
• Partage de ressources (mémoire, fichiers) entre père et fils
   – total ou partiel
• Exécution
   – soit concurrente
   – soit le père attend la terminaison du fils




                                                                 38
         La terminaison de processus

• Exécution de la dernière instruction ou appel système
  exit() .
   – L'O.S. libère les ressources employées
   – Le père en attente peut se réactiver
• Un parent peut arrêter son exécution (abort()) ou un
  processus peut "tuer" un autre s'il en a le droit (kill())
• Les processus orphelins (père mort) sont généralement
  associés au processus racine.




                                                               39
        La terminaison de processus

4 possibilités:
1. Sortie normale (appel exit() ou fin de code)
2. Sortie en cas d'erreur (volontaire, appel abort())
3. Erreur fatale (involontaire, kill() par l'O.S.)
4. Processus tué par un autre (involontaire, appel- système
     kill())




                                                              40
        Implémentation des processus

PCB = Process Control Block
Bloc d'informations caractérisant complètement un processus
   – état
   – compteur d'instruction
   – état des registres
   – paramètres de priorité et d'ordonnancement
   – paramètres de gestion de la mémoire
   – informations comptables
   – informations I/O (fichiers ouverts…)



                                                              41
Process Control Block (PCB)




                              42
Les PCB permettent d'interrompre et de
       relancer des processus




                                         43
      2.2. L'ordonnancement des processus




• Bursts of CPU usage alternate with periods of I/O wait
   – (a) a CPU-bound process
   – (b) an I/O-bound process
                                                           44
        Objectifs de l’ordonnancement
• Beau problème multicritère!
• Il n ’y a pas qu’une politique d’ordonnancement mais des
  politiques paramétrées
• Souvent, on choisit une politique, que l’on adapte (tuning)
  à la situation concrète
    nombre et type de processus, priorités, contraintes,...




                                                                45
        Algorithmes d'ordonnancement

•   Premier arrivé, premier servi (FCFS)
•   Plus court d'abord (SJF)
•   Avec priorité
•   Carrousel (Round Robin)
•   Avec files multiples




                                           46
  L’ordonnancement le plus simple First
           Come First Served
• Simple
• Souvent frustrant (attente
   pour les jobs courts)
                         t=0       24     30
     Job CPU use
                               1        2 3
       1     24
       2      3
       3      3
temps d'attente moyen =17




                                               47
               Ordonnancement
            Shortest-Job-First (SJF)
• Associe à chaque processus une estimation n+1 de la durée
  de la prochaine utilisation CPU (CPU burst).
• Choisit le processus avec le plus petit n+1
• Difficulté: l'estimation n+1
• SJF est optimal : il donne le temps moyen d'attente
  minimal pour un ensemble de processus donnés (où l'on
  connaît les temps successifs d'exécution!)




                                                               48
       SJF non préemptif ou préemptif
• 2 schémas possibles
   – nonpréemptif
   – préemptif: réquisitionner le CPU si un processus
     nouveau a une estimation n+1 plus petite que le temps
     estimé restant du processus en cours. Ce schéma est
     connu sous le nom de
     Shortest-Remaining-Time-First (SRTF).




                                                              49
         Ordonnancement par priorité

• Une priorité (nombre entier positif) est associée à chaque
  processus
• Le CPU est alloué au processus prêt avec la plus haute
  priorité (FIFO par priorité) (plus petit entier = plus haute
  priorité), de manière préemptive ou non.
• SJF est en fait un ordonnancement par priorité où la
  priorité est l'estimation du temps CPU du prochain cycle
• Problème  Famine: un processus avec faible priorité peut
  attendre très longtemps
• Solution  Priorité dynamique en fonction du temps
  d'attente. Au plus on attend, au plus la priorité augmente

                                                                 50
        Ordonnancement "Carrousel"
            Round Robin (RR)
• Définition d'une durée maximale d'utilisation continue du
  CPU par processus (quantum), par ex. 10-100
  millisecondes. Quand un processus en exécution atteint
  son quantum, il est interrompu.Choix FIFO des processus
  prêts (Carrousel)
• Si n processus prêts avec un quantum q, chaque processus
  utilisera 1/n du CPU au plus un temps q. Aucun processus
  n'attend donc plus de (n-1)q unités de temps
• si q grand => FIFO
• si q petit, beaucoup de pertes

                                                              51
   Ordonnancement avec files multiples

• Le pool des processus prêts est partitionné en différentes
  files suivant le type de processus ou ses priorités
• Chaque file peut avoir son propre algorithme
  d'ordonnancement
   – file de processus utilisateurs interactifs – RR
   – file de processus système – FCFS
   – file de processus batch - Par priorité

• Un ordonnancement doit être effectué entre les files.


                                                               52
 Ordonnancement avec files multiples (2)

• Priorités de files: d'abord les processus systèmes, ensuite
  les processus interactifs, enfin les batchs. Si priorité fixe,
  danger de famine.

• Réserver des quotas d'utilisation CPU par files: maximum
  20% pour la file système, 50% pour l'interactive, 30% pour
  la batch (éventuellement quota dynamique suivant le
  moment de la journée).




                                                                   53
Ordonnancement avec files multiples (3)




                                          54
 Ordonnancement avec files multiples et
             feedback
• Possibilité de transition d'un processus d'une file à une
  autre en fonction de son temps d'attente
• De nombreux paramètres sont à considérer:
   – nombre de files
   – ordonnanceur pour chaque file
   – algorithme de rehaussement de priorité
   – algorithme d'abaissement de priorité
   – algorithme de choix de file de départ



                                                              55
         Ordonnancement temps-réel

  Garantie d'exécution de certains processus en des
  temps déterminés. Cela nécessite de
  l'ordonnanceur:

• la préemption possible (réquisition du CPU)
• la gestion des priorités




                                                      56
                        2.3. Threads
Dans la plupart des systèmes d’exploitation, chaque processus a
un espace d’adresse et un seul chemin d’exécution. Cependant,
on trouve des situations dans lesquelles il est souvent souhaitable
d’avoir plusieurs chemins d’exécution partageant le même espace
d’adressage et fonctionnant en quasi-parallèle comme si c’étaient
des processus distincts.
Plusieurs systèmes d’exploitation nouveaux proposent un tel
mécanisme à travers des threads. Un thread est une unité de base
d’utilisation de l’UC. Chaque thread s’exécute séquentiellement,
possède son propre compteur d’instructions, ses registres et sa
propre pile. Les threads partagent l’UC de la même façon que les
processus: l’un d’entre eux est exécuté, puis c’est le tour d’un
autre.

                                                                      57
                       Chapitre 3
    Communication entre processus

3.1. Mécanismes
3.2. Synchronisation
3.3. Problèmes classiques




                                    58
                   3.1. Mécanismes

                            Signaux
Un signal est la notification à un processus de l'occurrence d'un
événement. Il existe différents signaux, chacun destiné à un
type d'événement particulier. Les signaux peuvent être vus
comme des interruptions logicielles effectuées sur les
processus.
Les signaux sont asynchrones, c’est-à-dire que le processus
auquel un signal est délivré ne peut pas déterminer à l'avance le
moment où il recevra le signal.
Les processus ne peuvent pas échanger des données par ce
mécanisme.
                                                                    59
                               Tubes
Un tube est un canal de communication directe entre 2 processus.
Il transporte un flot d'octet. L'ordre des caractères en entrée est
conservé en sortie (premier entré, premier sorti). Un tube est de
taille limitée (souvent 4096 caractères). Pour lire et écrire dans un
tube, le système d’exploitation fournit des appels système read,
write aux processus. Le système assure donc la synchronisation
de l'ensemble dans le sens où:
- il bloque le processus lecteur du tube lorsque le tube est vide en
attendant qu'il se remplisse;
- il bloque (éventuellement) le processus écrivain lorsque le tube
est plein (si le lecteur est plus lent que l'écrivain et que le volume
des résultats écrits est important).

                                                                         60
                       Mémoire partagée


Le concept de mémoire partagée permet à plusieurs processus
d'accéder à un même segment de mémoire. Aucun transfert entre
processus n'est nécessaire, les données sont simplement placées à
un endroit accessible par les différents processus.
C'est le moyen le plus rapide pour échanger des données entre
processus mais cette façon de communiquer pose certains
problèmes de cohérence d’informations et de coordination.




                                                                    61
                      Files de messages
Une file de messages est un mécanisme de communication
s’apparentant au concept de boîte aux lettres qui permet la
communication indirecte entre différents processus. Avec ce
mécanisme, les messages sont envoyés et reçus à la file de
messages comme dans une boîte aux lettres. Un processus peut
communiquer avec d’autres à travers plusieurs files de messages
différents. Deux processus ne peuvent communiquer que s’ils
partagent une file de messages. Chaque file de message a une
identification unique et les primitives send et receive.
Avec la file de messages, les processus peuvent échanger des
données structurées.



                                                                  62
                           Les sockets
Les sockets sont des points de connexion pour une
communication. Une socket en utilisation possède généralement
une adresse associée par laquelle un processus pourra émettre ou
recevoir de l’information. En première approximation, les
modèles de communication qui sont accessibles à travers les
sockets sont tout à fait analogues à deux outils de la vie
courante: le courrier et le téléphone.
Le mécanisme de socket peut être utilisé par des processus qui
ne sont pas en relation. De plus, il fournit une interface générale
pour les fonctions de gestion de réseaux.




                                                                      63
   3.2. La synchronisation entre processus

L’exclusion mutuelle de ressources non partageables
La synchronisation car la vitesse relative de deux processus est
imprévisible puisqu'elle dépend de la fréquence des interruptions
de chaque processus, ainsi que de la durée de travail et de la
fréquence d’attribution des processeurs aux processus. On peut
dire que les processus se déroulent de manière asynchrone les uns
par rapport aux autres. Toutefois, pour assurer une certaine
coopération, les processus doivent synchroniser leurs activités à
certains moments du traitement lorsqu’un processus ne peut pas
poursuivre avant qu’un autre processus n’ait achevé son
traitement. Le système d’exploitation doit donc fournir un
mécanisme de synchronisation.
                                                                    64
Section critique

Problème d'accès concurrents (race condition)

Soient deux processus comptables P1 et P2 qui partagent une
même zone mémoire. Chaque processus veut retirer un montant
d’un compte:

if (balance - retrait >=0)
        balance := balance - retrait;
        else
                 error( "on ne peut plus retirer !" );

Supposez que la balance soit égale à 800, le processus P1 veut
retirer 500 et le processus P2 400.

                                                                 65
Un bon moyen d’éviter le conflit d'accès doit satisfaire les
quatre conditions suivantes:
-Deux processus ne peuvent être en même temps en section
critique.
-Aucune hypothèse ne doit être faire sur les vitesses relatives
des processus et sur le nombre de processus.
-Aucun processus suspendu en dehors d’une section critique ne
doit bloquer les autres processus.
-Aucun processus ne doit attendre trop longtemps avant d’entrer
en section critique.



                                                                  66
Solution " busy waiting"
Solutions logicielles
Les variables de verrouillage
Les processus partagent une variable (verrou), unique, qui a
initialement la valeur 0. Un processus doit tester ce verrou avant
d’entrer en section critique. Si le verrou vaut 0, le processus le
met à 1 et entre dans sa section critique. Si le verrou est déjà à 1,
le processus attend qu’il repasse à 0.
L’alternance
C’est une approche applicable à seulement deux processus à la
fois. On laisse aux processus partager une variable partagée,
tour. Ne fonctionne que si l'alternance est parfaite.

                                                                        67
Solutions matérielles
Le masquage des interruptions
Laisser aux processus masquer les interruptions avant
d’entrer dans la section critique et les restaurer à la fin de la
section. (L’interruption horloge ne peut pas avoir lieu lorsque
les interruptions sont masquées). Le processeur ne pourra
donc plus être alloué à un autre processus.




                                                                    68
L’instruction TSL
Solution qui requiert un peu d’aide de la part du matériel.
Plusieurs ordinateurs fournissent une instruction spéciale qui
permet de tester et de modifier le contenu d’un mot d’une
manière atomique.


while (TRUE) {
       while (Test-and-Setlock(lock));
              section-critique();
              lock := FALSE;
              section-noncritique();
       }



                                                                 69
Solutions « SLEEP and WAKEUP »


Pour éviter l’inconvénient du busy waiting, on peut utiliser
quelques primitives de communication interprocessus qui se
bloquent au lieu de prendre du temps processeur lorsqu’elles
ne sont pas autorisées à entrer en section critique.
SLEEP est un appel système qui suspend l’appelant en
attendant qu’un autre processus le réveille. L’appel WAKEUP
a un seul paramètre: le processus à réveiller.




                                                               70
Sémaphores
Introduit par E. J. Dijkstra en 1965, un sémaphore s est une
variable qui a les propriétés suivantes:
-Une valeur e(s) qui est un entier positif.
-Une file d'attente f(s) qui contient des processus bloqués sur le
sémaphore s
Sur un sémaphore, seules deux opérations sont autorisées:
-Down (s): décrémente la valeur du sémaphore. Si la valeur du
sémaphore s est >= à 0, le processus poursuit son exécution
normalement, sinon, le processus est mis en attente.
-Up (s): incrémente la valeur du sémaphore s. Si un ou
plusieurs processus étaient en attente sur le sémaphore s,
bloqués par une opération Down, l’un d’entre eux sera choisi
par le système pour terminer son Down.                               71
Down (s):
        e(s) := e(s) - 1;
        if e(s) < 0 {
                 état (P):= bloqué;
                 entrer (P, f(s));
                 }
Up (s):
        e(s) := e(s) + 1;
        if e(s)  0 {
                 sortir (Q, f(s)); // Q est un processus bloqué sur s;
                 état(Q) := prêt;
                 entrer(Q, file d’attente de processus prêts);
                 }



                                                                         72
Sémaphores d'Exclusion Mutuelle
Le concept de sémaphore permet de résoudre le problème de la
section critique pour n processus. Les n processus partagent un
sémaphore s, e(s) est initialisé à 1. Tous les processus doivent
suivre la même règle suivante:


while (TRUE) {
       Down (s)
       section-critique();
       Up (s)
       section-noncritique();
       }



                                                                   73
Sémaphores de Synchronisation
Dans une situation où un processus doit en attendre un autre pour
continuer (ou commencer) son exécution. Les deux processus
partagent un sémaphore s, e(s) est initialisée à 0. Tous les deux
doivent suivre la règle suivante:
 Processus 1
while (TRUE) {
       travail1 ();
       Up (s);                 // réveille processus 2
       }
 Processus 2
while (TRUE) {
       Down (s);               // attente processus 1
       travail2 ();
       }
                                                                    74
Moniteurs
C’est au compilateur de réaliser l’exclusion mutuelle au
niveau des entrées dans le moniteur.


Echange de messages
Un processus contrôle la ressource et octroie la ressource en
fonction des messages reçus.




                                                                75
3.3 Problèmes classiques de synchronisation
Problème du producteur – consommateur


BufferSize := 3;      // nbre d’emplacements dans le buffer
Semaphore mutex := 1;         //Contrôle accès section critique
Semaphore vide := BufferSize; // nbre d’emplacements libres
Semaphore plein := 0;         // nbre d’emplacements occupés




                                                                  76
Producer()
  {
  int objet;
  while (TRUE) {
         produire_objet (&objet);      // produire l’objet suivant
         down (&vide); // décrémente nbre d’emplacements libres
         down (&mutex);                // entrer en section critique
         mettre_objet (objet); // mettre l'objet dans le buffer
         up (&mutex);                  // sortir de la section critique
         up (&plein); // incrémente nbre d’emplacements occupés
}
}


                                                                          77
Consumer()
 {
 int objet;
 while (TRUE) {
        down (&plein); // décrémente nbre d’emplacements occupés
        down (&mutex);                   // entrer en section critique
        retirer_objet (&objet);          // retirer l’objet du buffer
        up (&mutex);            // sortir de la section critique
        up (&vide); // incrémente nbre d’emplacements libres
        utiliser_objet (objet);          // utiliser l’objet
        }
        }


                                                                     78
           Gestion des processus:
            gare aux deadlocks!




(a) Un deadlock potentiel   (b) Un deadlock réel

                                                   79
Consumer()
 {
 int objet;
 while (TRUE) {
        down (&mutex);                   // entrer en section critique
        down (&plein); // décrémente nbre d’emplacements occupés
        retirer_objet (&objet);          // retirer l’objet du buffer
        up (&mutex);            // sortir de la section critique
        up (&vide); // incrémente nbre d’emplacements libres
        utiliser_objet (objet);          // utiliser l’objet
        }
        }


                                                                     80
Le modèle des lecteurs et des rédacteurs
semaphore mutex := 1;       // contrôler accès à rc
semaphore bd := 1;          // contrôler accès à base de données
int rc;                     // nombre de processus lecteurs

Rédacteur()
 {
  while (TRUE) {
       creer_donnees ();            // section non critique
       down (&bd);                  // obtenir l’accès exclusif à bd
       ecrire_donnees ();           // mettre à jour les données
       up (&bd);                    // libérer l’accès à rc
  }

                                                                       81
Lecteur ()
 {
  while (TRUE) {
        down (&mutex);                  // obtenir l’accès exclusif à rc
        rc := rc + 1;                   // un lecteur de plus
        if (rc = 1)                     // si c’est le premier lecteur
           down (&bd); // empêcher un rédacteur d’accéder à bd
        up (&mutex);           // libérer l’accès à rc
        lire_base_de_donnees ();        // lire les données
        down (&mutex);                  // obtenir l’accès exclusif à rc
        rc := rc - 1;                   // un lecteur de moins
        if (rc = 0)                     // si c’est le dernier lecteur
             up (&bd);    // permettre au rédacteur d’accéder à bd
        up (&mutex);           // libérer l’accès à rc
        utiliser_donnees_lues ();       // section non critique
} }
                                                                           82
3.4 Interblocage (deadlock)
Un ensemble de processus est en interblocage si chaque
processus attend un événement que seul un processus de
l’ensemble peut engendrer. Exemple: problème du dîner des
philosophes

                          P1




                P5                   P2




                                P3
                     P4




                                                            83
Il faut réunir quatre conditions pour provoquer un interblocage:
 L’exclusion mutuelle: chaque ressource est, soit attribuée à un
seul processus, soit disponible.
 La détention et l’attente: les processus qui détiennent des
ressources précédemment obtenues peuvent en demander de
nouvelles.
 Pas de réquisition: les ressources obtenues par un processus ne
peuvent lui être retirées contre son gré. Elles doivent être
explicitement libérées par le processus qui les détient.
 L’attente circulaire: il doit y avoir un cycle d’au moins deux
processus, chacun attendant une ressource détenue par un autre
processus du cycle.


                                                                    84
Traitement des interblocages


 Prévenir
 Eviter
 Détecter
 Corriger




                               85
                        Chapitre 4
               Gestion de la mémoire

La mémoire est un tableau à une dimension de mots machines
(ou d’octets) chacun ayant une adresse propre. Les échanges
avec l’extérieur se font en général par des lectures ou des
écritures à des adresses spécifiques. La mémoire est le point
central dans un système d’exploitation; c’est à travers elle que
l’UC communique avec l’extérieur.




                                                                   86
 correspondance entre adresses logiques et adresses
physiques: comment convertir les adresses symboliques dans un
programme en adresses réelles dans la mémoire principale?
 gestion de la mémoire physique: comment étendre la
mémoire disponible pour pouvoir maintenir plusieurs
processus?
 partage de l’information: comment permettre aux différents
processus de partager des informations en mémoire?
 protection: comment éviter au processus de porter atteinte
aux zones de mémoire allouées aux autres processus?



                                                                87
Espace adresse logique versus espace adresse physique


Adresse logique - produite par l’unité centrale de traitement;
également désignée sous le nom d'adresse virtuelle.
Adresse physique - adresse vue par l’unité de mémoire.


- La conversion au moment de l’exécution des adresses logiques
en adresses physiques est effectuée par la memory-management
unit (MMU) qui est un dispositif matériel. Les adresses logiques
et physiques sont les mêmes dans le schéma de liaison d’adresses
au moment de la compilation et du chargement; les adresses
logiques et physiques diffèrent dans le schéma de liaison
d’adresses au moment de l’exécution.
                                                                   88
Allocation contigüe
Systèmes monoprogrammés: La mémoire est partagée entre le
système d’exploitation et un processus unique. A un instant
donné, une portion de la mémoire contient le système
d’exploitation, le reste contient un seul processus. Ce processus
peut parfois utiliser toute la mémoire disponible.
Systèmes multiprogrammés avec des partitions fixes: La
mémoire est divisée en n partitions ayant une taille fixe (des
partitions différentes peuvent avoir des tailles égales ou
inégales). Utilisation des registres de base et limite.
Systèmes multiprogrammés avec partitions variables: On alloue
des partitions variables aux processus et on choisit
l'emplacement dynamiquement lors de l’entrée en mémoire du
processus.
                                                                    89
Systèmes multiprogrammés avec "swapping": Un processus qui
est en attente durant une période relativement longue sera
transféré en mémoire auxiliaire (swap out) pour libérer la
mémoire principale pour d'autres processus. Quand son attente
est terminée, il peut être ramené en mémoire principale (swap in)
pour continuer son exécution.




                                                                    90
Allocation non contigüe
Pagination: La mémoire physique est découpée en blocs de taille
fixe appelés cadres de pages. La mémoire logique est également
subdivisée en blocs de la même taille appelés pages. Quand on
doit exécuter un processus, on charge ses pages dans les cadres
de pages de mémoire disponibles. Un processus de taille N
pages requiert N cadres de pages libres.


Memory Management Unit pour la pagination: Pour définir la
conversion d’adresse, le support matériel pour la pagination est
une table de pages. La table de pages contient l’adresse de base
de chaque page dans la mémoire physique.



                                                                   91
Mémoire virtuelle


La mémoire virtuelle est une technique autorisant l'exécution
de processus pouvant ne pas être complètement en mémoire. La
mémoire virtuelle schématise la mémoire comme un tableau de
stockage uniforme extrêmement grand, séparant la mémoire
logique telle que la voit l’utilisateur de la mémoire physique.


La mémoire virtuelle est communément implémentée avec la
pagination à la demande équivalente à la pagination avec
swapping.



                                                                  92
                   3      la page est dans la mémoire auxiliaire
          OS
                                         déroutement
                   M                         2
                                  Mémoire virtuelle             3’
                    é
                référence
                                                     page out
                   m                      Mémoire victime
                     1                              la
                   oi
                                           virtuelle
                                            M
                   re              i                            M
charge M           vi
                Mémoire                      é
                 6                                              é
                    rt
                virtuelle                   m
                    M     table de pages oi         Mémoirem
            redémarre
                   ue                                           oi
                     é
            instruction
                   lle                      re cadrevirtuelle
                                                      libre /victime
                     m                                          re        ramène en
                                    5       vi                       4
Mémoire         M oi                                            vi        mémoire la
                            restaure la tablert
 logique         é re        Mémoire ue                         rt       page absente
                                de pages                       ue
                 m vi
            Mémoire          virtuelle      lle Mémoire physique
                 oi rt                                         lle
             virtuelle             M                                 M
                 re Les
       Figure 4.5 ue étapes pour manipuler un défaut de page
                                    é                                é
                 vi lle                                                   Mémoire
                                                                                    93
                         Chapitre 5
                 Protection et sécurité

5.1 Objectifs de la protection
5.2 Domaines de protection
5.3 Matrice d'accès
5.4 Implémentation de la matrice de droits
5.5 Sécurité



                                             94
          5.1 Objectifs de la protection

 éviter la violation pernicieuse intentionnelle d’une
restriction d’accès par un utilisateur,
 assurer que chaque composante d’un système emploie les
ressources du système seulement dans une forme cohérente
avec les politiques instaurées pour l’utilisation de ces
ressources,
 améliorer la fiabilité d’un système en détectant des erreurs
latentes dans les interfaces entre les sous-systèmes
composants.



                                                                 95
           5.2 Domaines de protection
Tous les processus fonctionnent dans un certain domaine de
protection. Le domaine de protection indique à quelles
ressources le processus peut accéder et quelles exécutions
particulières le processus peut exécuter.
La capacité d'exécuter une certaine exécution sur une certaine
ressource s'appelle un droit d'accès. Un domaine est une
collection de droits d'accès. On définit un domaine par une paire
ordonnée <objet, ensemble de droit d'accès>.
Les domaines peuvent partager les droits d’accès. L’association
entre un processus et un domaine peut être statique ou
dynamique. Le processus peut devoir changer dynamiquement
des droits d'accès pour des procédures du système d’exploitation.

                                                                    96
Un domaine peut être associé à:


 Un utilisateur: tous les processus d'un utilisateur sont dans le
même domaine. On commute de domaine quand on change
d’utilisateur.
 Un processus: les différents processus du même utilisateur
peuvent être dans différents domaines. On commute de domaine
quand un processus envoie un message à un autre et attend ensuite
une réponse.
 Une procédure: les différentes procédures peuvent appartenir à
différents domaines. On commute de domaine quand on effectue
un appel à une procédure.


                                                                     97
                 5.3 Matrice d'accès

Le modèle de protection peut être envisagé de façon abstraite
comme une matrice, appelée matrice de droits. Les lignes de
la matrice de droits représentent les domaines, et les colonnes
les objets. Chaque entrée dans la matrice consiste en un
ensemble de droits d’accès.
L'entrée droit (i, j) définit l’ensemble des opérations qu’un
processus, s’exécutant dans le domaine Di, peut appeler sur un
objet Oj.




                                                                  98
 5.4 Implémentation de la matrice de droits

L’implémentation la plus simple de la matrice des droits est une
table globale consistant en un ensemble de triplets ordonnés
<domaine, objet, ensemble de droits>. A chaque fois que l’on
exécute une opération M sur un objet Oj dans le domaine Di, on
cherche dans la table globale un triplet < Di, Oj, Rk > où M  Rk.
Si on trouve ce triplet, on permet à l’opération de continuer.
Sinon, il se produit une situation d’erreur.
Cette implémentation possède plusieurs désavantages: la table est
généralement grande et elle ne peut donc pas être maintenue en
mémoire principale, il est difficile de profiter de groupements
spéciaux d’objets ou de domaines.
                                                                     99
Solutions:


 Liste d’accès aux objets
 Liste de capacités des domaines
 Un mécanisme de clés et verrous




                                    100
5.5 Sécurité

 erreurs de programmation (d'un utilisateur, ou du système lui-
même) qui se propagent au système (du fait de contrôles
insuffisants ou mal effectués)
 mauvais fonctionnement du matériel
 opérateur, concepteur ou réalisateur malveillant ou peu
scrupuleux (quand il s'agit d'informations financières!).




                                                                   101
Authentification
Les mots de passe peuvent être générés par le système ou
sélectionnés par les utilisateurs. Le problème commun à cet
approche consiste à garder secret le mot de passe.


Menaces contre les programmes
 Le cheval de Troie
 Porte de contournement




                                                              102
Menaces contre les systèmes
 Ver
 Virus


Surveillance de menaces
 Le système peut contrôler des formes suspectes d’activité pour
détecter une violation de sécurité.
 Une liste de contrôle enregistre l’heure, l’utilisateur et tous les
types d'accès à un objet.



                                                                        103

				
DOCUMENT INFO
Shared By:
Categories:
Tags:
Stats:
views:5
posted:8/15/2011
language:French
pages:103