Aller au contenu principal
Physique, Chimie et Informatique > Terminales Spé. NSI

Les systèmes d'exploitation

Toute machine est dotée d’un système d’exploitation qui a pour fonction de charger les programmes depuis la mémoire de masse et de lancer leur exécution en leur créant des processus, de gérer l’ensemble des ressources, de traiter les interruptions ainsi que les entrées-sorties et enfin d’assurer la sécurité globale du système.

Au programme de la classe de première

Contenus Capacités attendues Commentaire
Systèmes d’exploitation - Identifier les fonctions d’un système d’exploitation.
- Utiliser les commandes de base en ligne de commande.
- Gérer les droits et permissions d’accès aux fichiers.
- Les différences entre systèmes d’exploitation libres et propriétaires sont évoquées.
- Les élèves utilisent un système d’exploitation libre.
- Il ne s’agit pas d’une étude théorique des systèmes d’exploitation.

Au programme de la classe de terminale

Contenus Capacités attendues Commentaire
Composants intégrés d’un système sur puce. Identifier les principaux composants sur un schéma de circuit et les avantages de leur intégration en termes de vitesse et de consommation. Le circuit d’un téléphone peut être pris comme un exemple : microprocesseurs, mémoires locales, interfaces radio et filaires, gestion d’énergie, contrôleurs vidéo, accélérateur graphique, réseaux sur puce, etc.
Gestion des processus et des ressources par un système d’exploitation. - Décrire la création d’un processus, l’ordonnancement de plusieurs processus par le système.
- Mettre en évidence le risque de l’interblocage (deadlock).
- À l’aide d’outils standard, il s’agit d’observer les processus actifs ou en attente sur une machine.
- Une présentation débranchée de l’interblocage peut être proposée.

Documents

Sous-sections de Les systèmes d'exploitation

Physique, Chimie et Informatique > Terminales Spé. NSI > Les systèmes d'exploitation

Système d'exploitation : Principes généraux

Introduction

  1. À l’aide d’un éditeur de texte, écrire le programme Python suivant :
from os.path import getsize
from tkinter.filedialog import askopenfilename

fichier = askopenfilename()
if fichier:
    print("Fichier a pour taille {} octets".format(str(getsize(fichier))))
  1. Exécuter le programme.

  2. À l’aide de la fonction help préciser le rôle des fonctions getsize du module os et askopenfilename du module tkinter.filedialog.

Réponse
  • askopenfilename du module tkinter.filedialog crée une boite de dialogue permettant de sélectionner un fichier.
    Plus précisément, cette fonction retourne une chaîne de caractères contenant le chemin du fichier à ouvrir.
    La chaîne de caractères est vide si aucun fichier n’est sélectionné.
  • getsize du module os retourne la taille en octets du fichier passé en argument.

Ce petit programme permet d’illustrer les différentes fonctionnalités d’un système d’exploitation. Nous allons les découvrir à travers quelques questions.

  1. L’éxécution de ce programme empêche-t-elle d’utiliser en même temps d’autres programmes ?

  2. Le comportement précédent est-il du à un effort particulier du programmeur (vous donc) ?

  3. Le programme précédent est-il toujours utilisable si le fichier se trouve sur une clé USB ? Sur une autre partition du disque dur ?

  4. La durée de réponse du programme dépend-elle de la taille du fichier sélectionné ?

  5. Le fonctionnement du programme dépend-il de la taille de l’écran, du fait d’utiliser une souris ou un pavé tactile ?

  6. Actuellement, sur votre ordinateur, le nombre de programmes en cours d’exécution est :

    1. Plus grand que le nombre de processeurs ;
    2. Égal au nombre de processeurs ;
    3. Inférieur au nombre de processeurs.
  7. Essayer de résumer les quelques fonctionnalités que les questions précédentes ont essayé de faire émerger.

    Réponse
    Info
    • Pendant l’exécution du programme, le système continu de fonctionner, un mécanisme semble donc permettre à plusieurs programmes de s’exécuter en parallèle.

    • Le nombre de programmes qui s’exécute à un instant donné est supérieur au nombre de processeurs présents sur la machine.

    • Tous les composants matériels (stockage, affichage, entrées) sont accessibles sans que le programmeur du programme ait à se préoccuper de quoi que ce soit.

    • Des informations (méta-données) semblent accompagner les fichiers. L’accès à leur taille, par exemple, est indépendant de leur contenu.

Système d’exploitation

À retenir

Un système d’exploitation est un programme ou un ensemble de programmes dont la fonction est la gestion des ressources matérielles et logicielles d’un ordinateur.
Un système d’exploitation permet :

  • l’exécution de processus ;
  • la lecture et l’écriture d’informations ;
  • la manipulation de fichiers ;
  • à plusieurs usagers et processus de se partager les ressources de l’ordinateur « simultanément » ;
  • la communication entre ordinateurs ;
  • …
À retenir

Parmi les différents composants logiciels que l’on trouve dans un système d’exploitation, on identifie :

  • L’ordonnanceur, qui « décide » quel processus est exécuté à un instant donné par un processeur.

  • Le gestionnaire de mémoire, qui répartit la mémoire vive entre les différents processus en cours d’exécution.

  • Le gestionnaire du système de fichiers, qui définit comment sont organiser les informations sur les supports physiques.

  • La pile réseau qui implémente, entre autres, les protocoles tels que Ethernet, IP, TCP, …

  • Le gestionnaire de périphériques qui gère les accès au matériel (carte graphique, disques durs, clavier, souris, écran, imprimante, …)

Physique, Chimie et Informatique > Terminales Spé. NSI > Les systèmes d'exploitation

Système de fichiers

Linux est un logiciel libre

Un logiciel est dit libre si son code est couvert par une licence autorisant :

  • l’utilisation du logiciel ;
  • l’accès public au code source ;
  • la modification et la redistribution publique de ces modifications.

Introduction

Il est possible de commander les systèmes d’exploitation de la famille UniX et leurs dérivés (tels OS X et Linux) grâce à un logiciel appelé shell, en ligne de commandes. À l’ère de l’interface graphique et des écrans tactiles, on peut se demander pourquoi continuer à taper des commandes, processus qui semble beaucoup plus long et nécessite un apprentissage préalable. En fait, une fois les commandes maîtrisées, utiliser la ligne de commande s’avère beaucoup plus efficace pour réaliser des tâches non élémentaires.

Exemple de tâche

Se rendre dans un répertoire contenant une multitude d’images dans différents formats, compter le nombre de celles qui sont au format jpeg et stocker le résultat dans un fichier.

cd /chemin/vers/repertoire; ls -l | grep jpeg | wc -l > nbre_jpg.txt

Essayez de faire le même enchaînement d’opérations depuis une interface graphique, cela prendra sûrement plus de temps.

Invite de commande, commandes et paramètres des commandes

Invite de commande

On appelle Invite de commande le message qui « invite » à entrer une commande dans la console/terminal :

mats@serveur-ubuntu:~$

Ici, il faut comprendre que l’utilisateur mats est connecté à la machine de nom serveur-ubuntu et qu’il se situe, dans l’arborescence des fichiers, dans son dossier personnel (représenté par le symbole ~).

Avertissement

Le symbole dollar $ final signifie que l’utilisateur mats n’est pas l’administrateur de la machine. Lorsqu’on utilise la machine en tant qu’administrateur, appelé root sous UniX, le symbole terminal est #.

Commandes

L’invite de commande permet d’entrer des commandes. Le comportement de chacune de ces commandes peut être modifié ou précisé à l’aide d’options*.

Le résultat de la commande, la liste de ses options, leur emploi, etc. font l’objet d’une entrée dans la documentation déjà installée sur le système.

man ls   # lecture de la page de documentation de la commande ls
date                # Retourne la date du jour

date +%Y-%m-%d      # Retourne la date du jour dans le format Année-Mois-Jour

ls                  # Liste tous les fichiers et dossiers du dossier courant

ls -l -a -R         # Liste tous les fichiers et dossiers du dossier courant 
                    # avec des options supplémentaires : affichage long de tous les
                    # fichiers (cachés ou pas) récursif

Remarque

Lorsque plusieurs options sont utilisées, il est possible de condenser l’écriture de la commande. Par exemple, la commande ls -l -a -R peut s’écrire : ls -laR. L’ordre de ces options n’a aucune importance.

De nombreuses aide à la saisie existent :

  • Rappel des dernières commandes entrées : utiliser la touche ↑ du clavier.

  • Autocomplétion des commandes :

    • entrer les premiers caractères d’une commande et taper la touche ⇥ deux foix : la liste des commandes commençant par ces caractères apparaît.
    • entrer les premiers caractères d’une commande, si cette chaîne est suffisante pour que le système puisse identifier de façon certaine la commande, un appui sur ⇥ complète la commande.
  • Sélection multiple de fichiers : le caractère *, appelé joker est très utilisé.

ls -l *.jpeg     # liste tous les fichiers dont l'extension est .jpeg    
  • Quelques raccourcis clavier utiles :
    • CTR + L : efface le contenu du terminal
    • CTRL + A : ramène le curseur au début de la commande
    • CTRL + E : ramène le curseur à la fin de la ligne de commandes
    • CTRL + U : supprime tout ce qui est à gauche du curseur
    • CTRL + K : supprime tout ce qui est à droite du curseur
    • CTRL + W : supprimer le premier mot situé à gauche du curseur
    • CTRL + Y : si du texte a été supprimé à l’aide d’une des commandes précédentes, ce texte est copié à l’endroit où se trouve le curseur.

Les fichiers

Qu’est-ce qu’un fichier ?

À retenir

Les fichiers servent à stocker des informations de manière permanente, entre deux exécutions d’un programme.

Rappel

Le contenu des variables disparaît à chaque fin d’exécution d’un programme (ou du bloc d’instructions dans lequel la variable est définie). Les fichiers sont stockés sur des périphériques à mémoire de masse (disquette, disque dur, CD Rom, clé USB, etc.).

À retenir

En informatique, on utilise le terme fichier pour décrire trois notions bien distinctes :

  • Le fichier physique, succession de 0 et de 1 sur un support physique (disque dur, disque optique, etc.).

  • Le fichier logique, objet informatique que nous présente le système d’exploitation. Cet objet est une image du fichier physique. Les fichiers logiques sont organisés sous forme d’une arborescence qui dépend du système d’exploitation utilisé, et sont repérés par un nom auquel on accole une extension (.py pour un fichier source Python, .jpeg pour une image au format JPEG (acronyme de Joint Photographic Experts Group), .exe pour un fichier exécutable, etc.). Généralement, un fichier logique possède des attributs gérés par le système d’exploitation (qui a le droit de le lire, de le modifier, de le détruire, etc.).

  • L’objet qui, dans un langage de programmation, est associé au fichier logique. Nous avons tel objet en Python.

Fichier physique

À retenir

Un périphérique à mémoire de masse stocke simplement des informations binaires (bits). À ce niveau, aucune distinction entre une image, un texte, un son, etc. n’existe : un fichier physique est un regroupement de 0 et de 1, stockés sur ce périphérique.

Info

Un système d’exploitation (Windows, Linux, OS X, FreeBSD, etc.) sait quels blocs physiques il faut réunir pour former un fichier logique (fichier image, fichier texte, fichier son, etc.).

Le nombre de bits qu’un périphérique de masse peut stocker est appelé sa capacité. Un disque d’un téraoctet (symbole To) peut stocker 2402^{40} mots de 8 bits.

Organisation des fichiers logiques en une arborescence

Les fichiers logiques sont organisés sous forme d’une arborescence :

graph TD
A(".") --> B("bin")
A --> C("boot")
A --> D("dev")
A --> E("etc")
A --> F("home")
A --> G("lib")
A --> H("media")
A --> I("root")
A --> J("sbin")
A --> K("tmp")
A --> L("usr")
A --> M("var")
F --> FA("user1")
F --> FB("LLM")
FB --> FBA("student1")
FB --> FBB("student2")
FB --> FBC("student3")
FBB --> FBBA("Documents")
FBB --> FBBB("Images")
FBB --> FBBC("Musique")
FBB --> FBBD("Bureau")
FBB --> FBBE("Téléchargements")
FBB --> FBBF("Vidéos")
FBBA --> FBBAA("NSI")
FBBA --> FBBAB("PC")
Chemin d’un fichier

Repérer un fichier logique dans l’arborescence consiste à donner son chemin dans cette arborescence :

Chemin absolu d’un fichier.
Dans une arborescence, le chemin (absolu) d’un fichier est la liste des noms des nœuds de la branche qui va de la racine de l’arborescence jusqu’au fichier en question.
/home/LLM/student2/Images/chaton.jpeg
Chemin relatif d’un fichier.
Lorsque le chemin qui conduit au fichier ne débute pas au niveau de la racine mais depuis l’endroit dans lequel on se trouve dans l’arborescence, le chemin est dit relatif.
./Images/chaton.jpeg
Info

Dans un chemin relatif . signifie « dossier (ou nœud) courant », .. signifie « dossier (ou nœud) parent », ~ signifie « dossier personnel ».

Peut-on parler du chemin d’un dossier ?

Sous Unix, tout n’est que fichier : en particulier, un dossier est un fichier qui contient la liste des fichiers placés plus bas que lui dans l’arborescence. On exprime donc le chemin d’un dossier de la même façon que celle d’un fichier.

Quelques commandes de déplacement dans l’arborescence des fichiers et de manipulation des fichiers

  • pwd (print working directory) : affiche le chemin absolu de l’endroit où l’on se trouve dans l’arborescence du système de fichiers.

  • which nom_commande : affiche le chemin absolu de l’emplacement de la commande nom_commande dans le système de fichiers.

  • ls : liste le contenu du dossier courant.

    • Options utiles :
      • a (all) : les fichiers cachés sont inclus dans l’affichage ;
      • l (long) : affiche toutes les informations (droits, types, etc.) ;
      • F: ajoute un / à la fin des noms des dossiers afin de les mettre en évidence ;
      • h (human readable) : utilisé avec l’option l exprime les tailles en multiples d’octets ;
      • S : trie le résultat final par taille des fichiers décroissante ;
      • t : trie les fichiers par date de dernière modification ;
      • r : renverse l’ordre de tri des deux paramètres précédents ;
      • R (recursive) : affiche le contenu des sous-dossiers.
  • cd (change directory) : permet de se déplacer dans l’arborescence. Le chemin passé en argument peut être absolu ou relatif.

  • du (disk usage) : donne la taille occupée par les répertoires situés plus bas dans l’arborescence que le point d’où est lancée la commande.

    • Options utiles :
      • h (human readable) : les tailles sont affichées en multiples d’octets ;
      • a : les dossiers et les fichiers sont pris en compte ;
      • s : seul le résultat final est affiché.
  • cat : affiche le contenu d’un fichier texte à l’écran.

  • less : affiche le contenu d’un fichier texte à l’écran, page par page. Taper sur la touche Espace pour passer à la page suivante, la touche b pour passer à la page précédente et la touche q pour quitter.

  • touch : permet de créer un fichier vide (ou de mettre à jour la date de modification).

  • mkdir (make directory) : crée le dossier dont le nom est passé en argument.

    • Option utile :
      • p : créé un sous-dossier et tous les sous-dossiers intermédiaires si nécessaire.
  • cp (copy) : copie un fichier ailleurs dans l’arborescence.

    • Option utile :
      • r : permet de copier un dossier et les fichiers contenus dans ce dernier.
  • mv (move) : déplace un fichier ou un dossier dans l’arborescence.

  • mv : renomme un fichier ou un dossier.

  • rm (remove) : supprime un fichier.

    • Options utiles :
      • i : demande confirmation avant toute action ;
      • f (force) : la suppression est effectuée quoi qu’il arrive ;
      • v (verbose) : affiche toutes les informations ;
      • r (recursive) : supprime un dossier et tout son contenu.
  • rmdir (remove directory) : supprime un dossier vide.

Méta-données d’un fichier logique

La commande ls -l permet d’obtenir un certain nombre d’informations sur les fichiers (ou dossiers) :

ubuntu@serveur-ubuntu:~/Images$ ls -lh t2png-2.gif
-rw-rw-r-- 1 ubuntu ubuntu 74K Dec  9 18:40 t2png-2.gif
ubuntu@serveur-ubuntu:~$ ls -lh
total 4.0K
drwxrwxr-x 2 ubuntu ubuntu 4.0K Dec  9 18:41 Images

On peut décomposer cette sortie de la sorte :

- rw- rw- r-- 1 ubuntu ubuntu 74K Dec 9 18:40 t2png-2.gif
1 2 3 8 4 6 7 8 9 10
À retenir
  1. Type de fichier : - ordinaire, d répertoire, l lien symbolique.
  2. Droits de l’utilisateur propriétaire (généralement le créateur du fichier) : rwx droits de lecture (read), d’écriture (write) et d’exécution (execute) si programme.
  3. Droits du groupe propriétaire (généralement celui du créateur du fichier) : rwx droits de lecture (read), d’écriture (write) et d’exécution (execute) si programme.
  4. Droits de tous les utilisateurs de l’ordinateur : rwx droits de lecture (read), d’écriture (write) et d’exécution (execute) si programme.
  5. Nombre de liens « durs ». C’est le nombre de noms de fichiers qui référencent ce fichier.
  6. Identifiant du propriétaire du fichier.
  7. Identifiant du groupe propriétaire du fichier.
  8. Taille du fichier en octets.
  9. Date de dernière modification du fichier.
  10. Nom du fichier.

Travail

Notions de base

  1. Soit l’invite de commande suivante :
toto@einstein:~/Documents/Photos    

Quelles informations nous fournit cette invite de commande ?

  1. Comment rappeler la dernière commande saisie au clavier ?

  2. Un programme exécutable est-il un fichier spécial ?

  3. Les extensions des fichiers ont-elles une signification particulière sous Linux ?

  4. Dans la liste suivante, indiquer les chemins absolus :

~/Documents
/usr/local/bin
/home/LLM/hpotter
./Bureau/Classes/Terminale/hpotter
../01_Travail 
  1. Où que l’on se situe dans le système de fichiers, quel est l’effet de la commande :
cd ~    
  1. Pour lister de manière récursive tous les fichiers — sans exception — présents dans /usr, quelle commande faut-il taper ?

  2. Dans un répertoire contenant une multitude de fichiers, comment afficher la liste détaillée des fichiers, les derniers modifiés apparaissant en dernier dans cette liste (en bas de l’écran) ?

  3. Pour créer le plus simplement possible, dans son dossier personnel, des sous-dossiers formant le chemin suivant : programmes/python/backup, il faut taper :

mkdir programmes/python/backup
mkdir -p programmes/python/backup
mkdir programmes; cd programmes; mkdir python; cd python; mkdir backup
mkdir -p programmes python backup
  1. Une fois les sous-dossiers de la question précédente créés, la commande qui suit supprime-t-elle le sous-dossier python.
cd programmes; rmdir python    
  1. Pour déplacer un répertoire et son contenu dans un sous-répertoire, quelle commande taper ?
mv repertoire_a_deplacer sous-repertoire/
cp -r repertoire_a_deplacer sous-repertoire/
  1. Quel est l’effet de la commande rm -rf / exécutée en tant que simple utilisateur ?
    1. Tout le système de fichier est détruit.
    2. Aucun effet car l’utilisateur n’a pas le droit de supprimer la racine du système de fichiers.
    3. Une erreur est retournée car seul l’administrateur a le droit d’utiliser cette commande.
    4. Tous les fichiers et répertoires de l’utilisateur sont supprimés.

Manipulations de base dans le système de fichiers

Depuis votre dossier personnel, créez un dossier NSI et entrez dans ce dossier.

  1. Affichez votre position dans le système de fichiers.
  2. Créez la structure suivante en deux commandes :
|-----dossier1
|        |-----dossier3
|-----dossier2
|        |-----dossier4
         |-----dossier5
  1. Déplacez-vous dans le répertoire dossier1 en utilisant un chemin absolu et créez-y le fichier vide fichier1.
  2. Copiez le fichier fichier1 dans le répertoire dossier3 en utilisant un chemin relatif.
  3. Déplacez-vous dans le dossier dossier2 en utilisant un chemin relatif.
  4. Copiez le fichier fichier1 dans le répertoire dossier5 en le renommant fichier2.
  5. Déplacez le fichier fichier2 dans le répertoire dossier4 en le renommant fichier3.
  6. Supprimez le fichier fichier1 du répertoire dossier3.
  7. Retournez dans votre dossier personnel et supprimez tous les fichiers et dossiers qui viennent d’être créés.

À la recherche du texte perdu

Le répertoire MetaCaracteres vous est fourni. Avec la commande ls MetaCaracteres, vous constaterez alors que ce répertoire contient de très nombreux fichiers. Les méta-caractères permettent de définir des motifs à partir desquels une sélection des éléments affichés peut être effectuée.

Motifs possibles
  • * : représente n’importe quelle suite de caractères (vide ou non) ;

  • ? : représente n’importe quel caractère (exactement un) ;

  • [liste de caractères] : représente n’importe quel caractère de la liste (exactement un). La liste peut-être un intervalle (a-z par exemple), le code ASCII des caractères est pris en considération pour définir les caractères appartenant à l’intervalle ;

  • [^liste de caractères] : représente n’importe quel caractère qui n’est pas dans la liste (exactement un).

Exemples

ls img*.jpg       # liste tous les noms de fichiers qui commencent par img et se terminent par .jpg avec 0 ou plusieurs caractères entre les deux motifs.
ls img?.jpg       # liste tous les noms de fichiers qui commencent par img et se terminent par .jpg avec exactement un caractère entre les deux motifs.
ls img[1234].jpg  # liste img1.jpg, img2.jpg, img3.jpg, img4.jpg s'ils existent.
ls [^abc]*        # liste tous les noms de fichiers qui ne commencent ni par a, ni par b, ni par c.
ls [^A-Z]*        # liste tous les noms de fichiers qui ne commencent pas par une majuscule.
ls img?*[23].jpg  # liste tous les noms de fichiers qui commencent par img, se terminent par .jpg avec entre un ou plusieurs caractères suivis d'un 2 ou d'un 3.
Exercice

Donner la signification de chacun des motifs suivants :

  1. *.jpg
  2. [0-9]*[a-z]
  3. *.???
  4. *[^A-Z]*
  5. ?????
  6. ?*?
  7. *[^.]???

Tester les réponses dans un terminal. Pour ce faire, créer dans un dossier un certain nombre de fichiers vides à l’aide de la commande touch nom_fichier (utiliser tous les noms possibles et imaginables).

Réponses
  1. Tous les noms qui se terminent par .jpg.
  2. Tous les noms qui commencent par un chiffre et se terminent par une lettre en minuscule.
  3. Tous les noms qui possèdent une extension (après le .) composée de trois caractères exactement.
  4. Tous les noms qui en contiennent aucune lettre en majuscule.
  5. Tous les noms formés de cinq caractères.
  6. Tous les noms formés d’au moins deux caractères.
  7. Tous les noms formés d’au moins quatre caractères et dont le quatrième caractère en partant de la droite n’est pas un point.

Dossier compressé à télécharger
  1. Déterminez les éléments du répertoire MetaCaracteres dont le nom correspond à chacun des motifs suivants et expliquez brièvement les caractéristiques des éléments affichés.
Prompt$ ls * 
Prompt$ ls ? 
Prompt$ ls [a-c]?
Prompt% ls [ac]?
Prompt% ls [a-c]*
Prompt% ls *.txt
  1. L’énoncé de cette question se trouve dans le fichier MetaCaracteres/questionTP1.txt. La commande cat suivie d’un nom de fichier vous permettra d’afficher le contenu du fichier, et donc de pouvoir le lire et de suivre les indications que vous y trouverez.
Physique, Chimie et Informatique > Terminales Spé. NSI > Les systèmes d'exploitation

Gestion des processus et des ressources

L’objectif de ce document est d’essayer de faire comprendre les idées mises en œuvre lors de l’écriture des système d’exploitation afin qu’un nombre de programmes plus important que le nombre de processeurs puisse fonctionner « simultanément ».

L’ordonnanceur

Rappel sur l’exécution d’un programme

À retenir
  • Un programme est un fichier contenant une suite d’instructions écrites en langage machine. C’est une suite d’octets que le processeur est capable de décoder et d’exécuter.

  • Actions du système d’exploitation au lancement d’un programme :

    • Le contenu du fichier contenant le programme est copié dans la mémoire vive (RAM), à une certaine adresse aa.
    • Le système d’exploitation écrit l’adresse aa dans le registre IP (instruction pointer).
  • Au cycle d’horloge du processeur suivant, ce dernier lit l’instruction qui se trouve dans le registre IP et l’exécute. Par la suite, il exécute la deuxième instruction puis les suivantes.

Remarque
L’exécution d’une instruction par le processeur se décompose en en plusieurs sous-étapes : le chargement (récupération de l’instruction en mémoire), le décodage (quelle action est codée par la suite d’octets) et l’exécution.

Interruptions

La description précédente est correcte mais incomplète : elle laisse penser qu’une fois un programme lancé le processeur se focalise sur son exécution, au détriment de l’exécution de tout autre programme.

À retenir

Une interruption est un signal envoyé au processeur lorsqu’un évènement se produit.

Il existe plusieurs types d’interruptions :

  • les interruptions générées par le matériel (un disque dur signale qu’il a fini d’écrire un octet, une carte réseau signale qu’une trame vient d’arriver, …)

  • les interruptions d’horloges générées par le processeur (historiquement toutes les 55 ms\pu{55 ms}, toutes les 100 ns\pu{100 ns} de nos jours).

Lorsqu’un processeur reçoit une interruption il interrompt son exécution à la fin de l’instruction courante et exécute un programme se trouvant à une adresse prédéfinie.
Ce programme, le gestionnaire d’interruption, reçoit une copie des valeurs courante des registres, ainsi qu’un code numérique lui permettant de savoir quel est le type de l’interruption qui a stoppé le processeur.

Info

On utilise les interruptions, principalement dans deux buts :

  • permettre des communications non bloquantes avec des périphériques externes ;

  • commuter entre les tâches dans un ordonnanceur.

Les interruptions constituent le fondement de l’exécution concurrente des programmes.

Vocabulaire

À retenir
Exécutable
Fichier binaire contenant des instructions en langage machine directement exécutables par le processeur de la machine.
Processus
Instance du programme en cours d’exécution. Un système d’exploitation identifie généralement les processus par un numéro unique.
Un processus est décrit par :
  • L’ensemble de la mémoire allouée par le système d’exploitation pour l’exécution du programme (instructions codées et données manipulées, qu’elles soient contenues dans la pile ou sur le tas) ;

  • L’ensemble des ressources utilisées par le programme (fichiers ouverts, connexions réseau, etc.) ;

  • Les valeurs stockées dans tous les registres du processeur.

Thread ou tâche
Éxécution d’une suite d’instructions démarrée par un processus. Deux processus sont l’exécution de deux programmes différents (traitement de texte et navigateur web, par exemple). Deux threads sont l’exécution concurrente de deux suites d’instructions d’un même processus (téléchargement d’une page web et affichage d’une page web).
Exécution concurrente
Deux processus ou threads s’exécutent de manière concurrente s’ils se partagent l’accès à un processeur. Ils ne s’exécutent donc pas au même moment.
Exécution parallèle
Deux processus ou threads s’exécutent en parallèle s’ils s’exécutent au même instant. Plusieurs processeurs dans l’ordinateur sont donc nécessaires à une exécution parallèle.
Avertissement

Les processus sont isolés par le système d’exploitation, ils ne partagent pas la même zone de la mémoire alors que les threads issus d’un même processus peuvent accéder aux variables globales du programme et occupent le même espace mémoire.

Nom Description
PID Process ID, l’identifiant numérique du processus
État L’état dans lequel se trouve le processus
Registres La valeur des registres lors de la dernière interruption
Mémoire Zone mémoire (plage d’adresses) allouée par le processus lors de son exécution
Ressources Liste des fichiers ouverts, connexions réseau en cours d’utilisation, etc.

Informations pour la description d’un Processus.

Ordonnanceur du système d’exploitation

À retenir

Le système d’exploitation utilise des interruptions pour « reprendre la main » et décider quel programme en cours d’exécution doit avoir accès au processeur.

Exemple

  1. Le processus « traitement de texte » a accès au processeur. Il est en cours d’exécution.

  2. Une interruption d’horloge se déclenche.

  3. Le code du gestionnaire d’interruption est appelé. Il reçoit comme arguments les valeurs de tous les registres avant le déclenchement de l’interruption (donc tout ce qui concerne le processus ayant accès au processeur).

  4. Le gestionnaire d’interruption sauvegarde ces valeurs à un endroit particulier de la mémoire.

  5. Le gestionnaire d’interruption choisit dans la liste des processus un processus en attente, par exemple celui correspondant à un navigateur web.

  6. Il restaure les valeurs des registres qu’il avait sauvegardés lors de la dernière interruption du navigateur web.
    Parmi ces registres, il y a en particulier IP, le pointeur d’instruction, qui contient l’adresse de la prochaine instruction à exécuter.

  7. Le gestionnaire d’interruption a fini son travail et « rend la main ». Le processeur exécute le code du processus lié au navigateur web jusqu’à la prochaine interruption.

Info

On appelle commutation de contexte l’action d’interrompre un processus et de sauvegarder son état. C’est l’ordonnanceur qui est en charge de cette tâche.
Afin de pouvoir décider à quel processus donner la main, l’ordonnanceur utilise une structure de données telle qu’une file pour stocker la liste des processus et ainsi partager les tâches.

États d’un processus

Info

Les interruptions ne se limitent pas aux interruptions d’horologes, un processus peut être en attente d’une action d’un utilisateur, de la réception d’une trame, du résultat de la recherche d’une information sur un disque dur, etc. Un processus peut donc être interrompu et mis en attente par le système d’exploitation qui favorise alors d’autres processus.

À retenir

La plupart des systèmes d’exploitation définissent différents états pour les processus :

Nouveau
État d’un processus en cours de création. Le système d’exploitation vient de copier le code exécutable en mémoire.
Prêt
Le processus est dans la file des processus à exécuter et attend d’être choisi par l’ordonnanceur.
En exécution
Le processus est en train d’être exécuté.
En attente
Le processus est en interrompu et en attente d’un évènement externe (entrée/sortie, allocation mémoire, etc).
Terminé
Le processus est terminé. Le système d’exploitation est en train de désallouer les ressources que le processus utilisait.
> Cycle de vie d'un processus
Info

Les états Nouveau et Terminé sont temporaires. Normalement l’état d’un processus varie entre Prêt, En attente et En exécution.

L’ordonnancement

Plusieurs processus peuvent donc être dans l’état prêt : comment choisir celui qui sera élu ?

À retenir

L’ordonnanceur (scheduler) classe les processus prêts dans une file et le répartiteur (dispatcher) alloue quant à lui un processeur à l’élu dans le cas d’une architecture multiprocesseur.

Info

Il existe plusieurs politiques d’ordonnancement dont le choix va dépendre des objectifs du système.
Quelques exemples :

  • Premier arrivé, premier servi : simple, mais peu adapté à la plupart des situations.

  • Plus court d’abord : très efficace, mais il est la plupart du temps impossible de connaître à l’avance le temps d’exécution d’un processus.

  • Priorité : le système alloue un niveau de priorité aux processus (SCHED_FIFO sur Linux). Cependant des processus de faible priorité peuvent ne jamais être élus.

  • Tourniquet : un quantum de temps est alloué à chaque processus (SCHED_RRsous Linux). Si le processus n’est pas terminé au bout de ce temps, il est mis en bout de file en état prêt.

  • Un système hybride entre tourniquet et priorité qu’on retrouve dans les systèmes Unix.

Commandes Unix de gestion des processus

Info

ps (process status) est la commande de base pour lister tous les processus en cours. Options utiles :

  • a: tous les processus ;
  • u : nom des utilisateurs qui ont lancé le processus ;
  • x : fait aussi apparaître les processus qui n’ont pas été lancés depuis la ligne de commande.
ubuntu@serveur-ubuntu:~$ ps aux
USER         PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
root           1  1.0  0.6 169776 13280 ?        Ss   06:56   0:07 /sbin/init
root           2  0.0  0.0      0     0 ?        S    06:56   0:00 [kthreadd]
root           3  0.0  0.0      0     0 ?        I<   06:56   0:00 [rcu_gp]
root           4  0.0  0.0      0     0 ?        I<   06:56   0:00 [rcu_par_gp]
root           6  0.0  0.0      0     0 ?        I<   06:56   0:00 [kworker/0:0H-kblockd]
root           9  0.0  0.0      0     0 ?        I<   06:56   0:00 [mm_percpu_wq]
.............................................
.............................................
ubuntu      8421  0.0  0.1  11476  3284 pts/0    R+   07:08   0:00 ps aux

La colonne STAT l’état du processus :

  • R (Running ou Runnable) : le processus est dans l’état Prêt ou En exécution.
  • S(Sleeping) : le processus est En attente.
Info

top permet en temps réel les processus en cours.

ubuntu@serveur-ubuntu:~$ top

top - 07:12:34 up 15 min,  1 user,  load average: 0.00, 0.05, 0.14
Tasks: 113 total,   1 running, 111 sleeping,   1 stopped,   0 zombie
%Cpu(s):  0.0 us,  0.2 sy,  0.0 ni, 99.8 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
MiB Mem :   1983.9 total,    678.0 free,    142.0 used,   1163.9 buff/cache
MiB Swap:      0.0 total,      0.0 free,      0.0 used.   1648.7 avail Mem 

    PID USER      PR  NI    VIRT    RES    SHR S  %CPU  %MEM     TIME+ COMMAND                    
    935 ubuntu    20   0   14808   6048   4564 S   0.3   0.3   0:00.18 sshd                       
   8441 ubuntu    20   0   11864   4088   3424 R   0.3   0.2   0:00.03 top                        
      1 root      20   0  169776  13280   8796 S   0.0   0.7   0:07.13 systemd                    
      2 root      20   0       0      0      0 S   0.0   0.0   0:00.01 kthreadd                   
      3 root       0 -20       0      0      0 I   0.0   0.0   0:00.00 rcu_gp                     
      4 root       0 -20       0      0      0 I   0.0   0.0   0:00.00 rcu_par_gp                 
      6 root       0 -20       0      0      0 I   0.0   0.0   0:00.00 kworker/0:0H-kblockd       
      9 root       0 -20       0      0      0 I   0.0   0.0   0:00.00 mm_percpu_wq    

Le processus qui monopolise le plus le processeur apparaît dans la première ligne.

À retenir

Un système d’exploitation en fonctionnement est constitué par un ensemble de processus. Au démarrage de la machine, un processus père est lancé (historiquement c’est le processus init ou systemd sur Linux). Son rôle est par la suite de démarrer tous les autres processus.

Info

La hiérarchie des processus peut être visualisée grâce à la commande pstree.

ubuntu@serveur-ubuntu:~$ pstree -h
systemd─┬─accounts-daemon───2*[{accounts-daemon}]
        ├─2*[agetty]
        ├─atd
        ├─cron
        ├─dbus-daemon
        ├─irqbalance───{irqbalance}
        ├─multipathd───6*[{multipathd}]
        ├─networkd-dispat
        ├─polkitd───2*[{polkitd}]
        ├─rsyslogd───3*[{rsyslogd}]
        ├─snapd───13*[{snapd}]
        ├─sshd───sshd───sshd───bash─┬─pstree
        │                           └─top
        ├─systemd───(sd-pam)
        ├─systemd-journal
        ├─systemd-logind
        ├─systemd-network
        ├─systemd-resolve
        ├─systemd-timesyn───{systemd-timesyn}
        ├─systemd-udevd
        └─unattended-upgr───{unattended-upgr}

L’exemple précédent montre que l’utilisateur ubuntu a accédé au serveur ubuntu par ssh et a lancé depuis le terminal (en ligne de commande donc) deux commandes qui s’exécutent en parallèle pstree et top. Les processus ont été créés par le processus bash.

Info

kill envoie un signal de terminaison aux processus dont le PID est passé en argument.

ubuntu@serveur-ubuntu:~$ kill 8419

Programmation concurrente

Processus concurrents

Remarque : cette partie nécessite une bonne compréhension des sections 1.4, 1.5 et 1.6 de ce document.

  1. Écrire le programme Python suivant :
from os import getpid

pid = str(getpid())
with open("test.txt", "w") as fichier:
    for i in range(1000):
        fichier.write("{} : {}\n".format(pid, i))
        fichier.flush()
  1. À quoi sert la fonction getpid ?

    Réponse

    La fonction getpid retourne le PID du processus qui la lance.

  2. À quoi sert la fonction flush() ?

    Réponse

    La fonction flush donne un ordre d’écriture immédiate des caractères dans le fichier.

  3. Prévoir ce que doit contenir le fichier.
    Lancer le programme et vérifier la correction de la prédiction.

    Réponse

    Le fichier est constitué de 1000 lignes de la forme PID : i.
    La première ligne est par exemple 418 : 0
    La dernière ligne du même fichier est alors 418 : 999.

  4. Depuis la console (shell), lancer trois fois le programme en une commande, en plaçant l’exécution de ces programmes en arrière plan (c’est le rôle de l’esperluette &).

python nom_prog.py & python nom_prog.py & python nom_prog.py &

Relever les PID des processus.

  1. Examiner le contenu du fichier test.txt et recommencer plusieurs fois l’opération. Quelles remarques peut-on faire ? Essayer de justifier ce comportement.
    Réponse
    • On a l’impression que certaines lignes n’ont été écrites que par certains des processus et le choix du processus qui a écrit la ligne en question semble être aléatoire. Ils semblent s’être réparti les travaux d’écriture alors qu’ils fonctionnent indépendamment les uns des autres !!!

    • Justification. Chaque processus, lors de l’ouverture du fichier, enregistre la position du curseur d’écriture. À chaque écriture de caractères, ce curseur est avancé du nombre de caractères (octets en fait) correspondant.
      Chaque fois qu’un processus est interrompu par l’ordonnanceur, il conserve en mémoire son état, en particulier la position du curseur au moment de l’interruption. Lorsqu’il est à nouveau appelé par la suite il reprend donc depuis cette position… et peut donc écraser les entrées des autres processus si ces derniers étaient plus avancés.

À retenir

Le fonctionnement multitâches d’un système d’exploitation est un avantage la plupart du temps mais soulève des problèmes lorsque des processus partagent des ressources car un processus ne sait pas qu’il est interrompu et reprend son travail dans l’état même dans son état au moment de l’interruption sans prendre en compte ce l’action des autres processus sur la ressource partagée.

Interblocage

Exemple 1

Trois élèves doivent réaliser lors d’un cours de math un travail à l’aide d’une règle et d’une équerre. Le premier élève n’a apporté qu’une règle, le deuxième qu’une équerre et le troisième a oublié toutes ses affaires.

  1. Que devront-ils faire pour réaliser le travail demandé par le professeur ?

  2. Des processus peuvent-ils procéder de la sorte (s’il n’ont pas été programmés pour) ?

Réponses
  1. Les élèves doivent discuter et se mettre d’accord sur une stratégie d’utilisation du matériel.

  2. Un processus d’enregistrement du son qui utilise une carte fonctionne de façon indépendante d’un processus qui diffuse du son à travers cette même carte réseau. Aucun dialogue n’existe entre les deux.

Exemple 2

Sur une route à deux sens, des travaux occupent la moitié de la route. Des véhicules roulant dans les deux sens se sont engagés simultanément et se retrouvent face à face. Plusieurs véhicules les ont suivis ; plus personne ne peut reculer. Le véhicule venant de la gauche occupe la partie de la route dont l’accès serait nécessaire au véhicule venant de la droite et inversement.

Exercice 3

Le même blocage peut intervenir dans un rond-point lorsque le traffic est dense si personne ne souhaite sortir à la première sortie mais plutôt à la sortie en face de l’entrée.

À retenir

On appelle interblocage (deadlock) la situation dans laquelle deux processus se bloquent mutuellement : le premier attend l’accès à une ressource mobilisée par le second qui lui-même attend l’accès à une ressource mobilisée par le premier.
L’origine de l’interblocage est l’accès exclusif à certaines ressources.

Exemple d’interblocage
  • Un processus p1p_1 possède un accès exclusif à la ressource R1R_1 alors qu’un processus p2p_2 possède un accès exclusif à une ressource R2R_2.

  • Le processus p1p_1 a alors besoin d’un accès à la ressource R2R_2 avant de pouvoir libérer R1R_1. Comme la ressource R2R_2 est occupée, ce processus est placé dans l’état En attente.

  • Le processus p2p_2 passe dans l’état En exécution et essaie d’accéder à la ressource R1R_1, sans avoir encore libéré R2R_2. Comme R1R_1 n’a pas encore été libéré par p1p_1, la ressource n’est pas accessible et p2p_2 est placé En attente.

  • Le processus p1p_1 passe dans l’état En exécution et essaie d’accéder à la ressource R2R_2. cette dernière n’est pas accessible et p1p_1 est placé En attente.

  • Le processus p2p_2 passe dans l’état En exécution et essaie d’accéder à la ressource R2R_2. cette dernière n’est pas accessible et p2p_2 est placé En attente.

  • ….

Illustration d’une situation d’interblocage en Python

  1. Écrire le programme suivant :
import threading


def hello(n):
    for i in range(5):
        print("Je suis le thread {} et ma valeur est {}".format(n, i))
    print("Fin du Thread {}".format(n))


for n in range(4):
    t = threading.Thread(target=hello, args=[n])
    t.start()
  1. Étudier le programme. Expliquer le rôle des deux dernières lignes.

    Réponse

    Ce programme utilise des threads pour réaliser l’exécution en parallèle de la fonction hello.

  2. Exécuter le programme. L’affichage est-il surprenant ?

    Réponse

    Comme pour les processus, les threads alternent leur exécution en fonction des commutations de contexte. L’ordre dans lequel sont démarrés les threads ne donne aucune indication sur l’ordre dans lequel ils peuvent se terminer.

  3. Écrire le programme suivant :

import threading

COMPTEUR = 0


def incr():
    global COMPTEUR
    for c in range(100000):
        v = COMPTEUR
        COMPTEUR = v + 1


th = []
for n in range(4):
    t = threading.Thread(target=incr, args=[])
    t.start()
    th.append(t)

for t in th:
    t.join()
print("Valeur finale : {}".format(COMPTEUR))
  1. Expliquer le rôle de l’instruction global COMPTEUR.

    Réponse

    COMPTEUR est une variable globale, accessible depuis une fonction mais non modifiable.
    Pour outrepasser ce comportement, il faut utiliser le mot clé globla. On peut alors modifier la valeur de la variable depuis la fonction.

  2. Expliquer le rôle de l’instruction t.join().

    Réponse

    Attend que le fil d’exécution se termine. Ceci bloque le fil appelant jusqu’à ce que le fil dont la méthode join est appelée se termine – soit normalement, soit par une exception non gérée – ou jusqu’à ce que le délai optionnel timeout soit atteint.

  3. Exécuter le programme. L’affichage est-il surprenant ?

    Réponse

    Comme on a démarré 4 threads et que chacun d’eux effectue 100 000 tours de boucles, on pouvait s’attendre à ce que la valeur finale soit égale à 400 000. Ce n’est pas le cas.

  4. Expliquer la valeur finale obtenue.

    Réponse

    Lorsqu’un thread est interrompu par la commutation de contexte, son état est conservé. Lorsque ce thread reprend son travail, il utilise la valeur de COMPTEUR lors de son arrêt et ne prend pas en compte les incrémentations réalisées par les autres threads alors qu’il était dans l’état En attente.

Info

Un verrou est un objet que l’on peut essayer d’acquérir. Si on est le premier à faire cette demande, on acquiert le verrou. On peut le rendre à tout moment. Si en revanche quelqu’un d’autre détient le verrou, on est bloqué jusqu’à ce que ce verrou soit libéré.

  1. Écrire le programme suivant :
import threading

verrou = threading.Lock()
COMPTEUR = 0


def incr():
    global COMPTEUR
    for c in range(100000):
        verrou.acquire()
        v = COMPTEUR
        COMPTEUR = v + 1
        verrou.release()


th = []
for n in range(4):
    t = threading.Thread(target=incr, args=[])
    t.start()
    th.append(t)

for t in th:
    t.join()
print("Valeur finale : {}".format(COMPTEUR))
  1. Expliquer pourquoi on obtient bien maintenant la valeur 400000.

  2. Écrire le programme suivant :

import threading

verrou1 = threading.Lock()
verrou2 = threading.Lock()


def f1():
    verrou1.acquire()
    print("Section critique 1.1")
    verrou2.acquire()
    print("Section critique 1.2")
    verrou2.release()
    verrou1.release()


def f2():
    verrou2.acquire()
    print("Section critique 2.1")
    verrou1.acquire()
    print("Section critique 2.2")
    verrou1.release()
    verrou2.release()


t1 = threading.Thread(target=f1, args=[])
t2 = threading.Thread(target=f2, args=[])
t1.start()
t2.start()
  1. Quelle situation essaie-t-il d’illustrer ? Justifier la réponse.

  2. Exécuter le programme plusieurs fois. La situation prévue à la question précédente intervient-elle vraiment ? Pourquoi ?

  3. Ajouter les lignes

for i in range(100000):
    continue

au dessous de l’instruction print("Section critique 1.1").
Expliquer pourquoi le comportement du programme a été modifié.

À retenir

À retenir

Les systèmes d’exploitation multitâches sont la norme. Ils permettent d’exécuter de façon concurrente plusieurs programmes. L’exécution d’un programme s’appelle un processus. C’est le système d’exploitation, et en particulier l’ordonnanceur, qui determine quel processus s’exécute à un instant donné. Le fait pour un processus d’être interrompu s’appelle une commutation de contexte. Plusieurs processus s’exécutant de façon concurrente peuvent s’interbloquer s’ils attendent un accès à une même ensemble de ressources en accès exclusif. Les threads ou processus légers sont des « sous-processus » s’exécutant de manière concurrente. L’accès à des ressources par plusieurs threads peut être protégé par des verrous.

Physique, Chimie et Informatique > Terminales Spé. NSI > Les systèmes d'exploitation

Gestion des processus et des ressources : Annales

Exercice 1

Dans un bureau d’architectes, on dispose de certaines ressources qui ne peuvent pas être utilisées simultanément par plus d’un processus, comme l’imprimante, la table traçante, le modem. Chaque programme, lorsqu’il s’exécute, demande l’allocation des ressources qui lui sont nécessaires. Lorsqu’il a fini de s’exécuter, il libère ses ressources.

Programme 1 Programme 2 Programme 3
- demander (table traçante)
- demander (modem)
- exécution
- libérer (modem)
- libérer (table traçante)
- demander (modem)
- demander (imprimante)
- exécution
- libérer (imprimante)
- libérer (modem)
- demander (imprimante)
- demander (table traçante)
- exécution
- libérer (table traçante)
- libérer(imprimante)

On appelle p1p_1, p2p_2 et p3p_3 les processus associés respectivement aux programmes 1, 2 et 3.

  1. Les processus s’exécutent de manière concurrente.
    Justifier qu’une situation d’interblocage peut se produire.
Réponse
  • Pour passer à l’état exécution, le processus p1 doit pouvoir accéder au modem alors que celui-ci est monopolisé par le processus p2. Il doit donc attendre que p2 libère le modem.
  • Pour passer à l’état exécution, le processus p2 doit pouvoir accéder à l’imprimante alors que celle-ci est monopolisée par le processus p3. Il doit donc attendre que p3 libère l’imprimante.
  • Pour passer à l’état exécution, le processus p3 doit pouvoir accéder à la table traçante alors que celle-ci est monopolisée par le processus p1. Il doit donc attendre que p1 libère la table traçante, ce qu’il ne fera pas car il est bloqué, dans l’attente d’un accès au modem.

La situation décrite constitue donc bien un interblocage.

  1. Modifier l’ordre des instructions du programme 3 pour qu’une telle situation ne puisse pas se produire. Aucune justification n’est attendue.
Réponse

Il faut que le processus p2 puisse achever sa tache et libérer le modem pour que p1 puisse s’executer. Comme p3 a aussi besoin de la table traçante, comme p1, il faut faire en sorte qu’il soit immédiatement bloqué sans monopoliser aucune ressource :

Programme 3
- demander (table traçante)
- demander (imprimante)
- exécution
- libérer (table traçante)
- libérer(imprimante)

L’imprimante n’est alors plus bloquée par p3, ce qui permet à p2 de s’exécuter complètement et de libérer les ressources que p1 peut alors utiliser. Pour finir, une fois p1 terminé, p3 peut s’exécuter.

  1. Supposons que le processus p1p_1 demande la table traçante alors qu’elle est en cours d’utilisation par le processus p3p_3. Parmi les états suivants, quel sera l’état du processus p1p_1 tant que la table traçante n’est pas disponible :
    a. élu
    b. bloqué
    c. prêt
    d. terminé
Correction

Le processus sera bloqué.

Exercice 2

Un constructeur automobile utilise des ordinateurs pour la conception de ses véhicules. Ceux-ci sont munis d’un système d’exploitation ainsi que de nombreuses applications parmi lesquelles on peut citer :

  • un logiciel de traitement de texte ;
  • un tableur ;
  • un logiciel de Conception Assistée par Ordinateur (CAO) ;
  • un système de gestion de base de donnée (SGBD).

Chaque ordinateur est équipé des périphériques classiques : clavier, souris, écran et est relié à une imprimante réseau.

Ce constructeur automobile intègre à ses véhicules des systèmes embarqués, comme par exemple un système de guidage par satellites (GPS), un système de freinage antiblocage (ABS).
Ces dispositifs utilisent des systèmes sur puces (SoC : Système on a Chip).

  1. Citer deux avantages à utiliser ces systèmes sur puces plutôt qu’une architecture classique d’ordinateur.
Réponse
  • Une grande partie de l’énergie est perdue lors des transferts des données entre les composants. Comme tous les composants d’un SoC sont connectés entre eux sur des distances très petites, et de manière interne sans câblage énergivore, les gains d’énergie sont très importants.
  • La faible consommation énergétique implique aussi une très faible perte de chaleur qui évite de recourir à un ventilateur pour refroidir la puce. Les SoC sont donc silencieux.
  • Le prix d’un système sur puce est très petit si on le compare à celui d’une carte mère rassemblant les mêmes composants (automatisation du processus de fabrication).
  • Le circuit d’un SoC est conçu de manière globale, tant pour la partie hardware que pour celle des programmes intégrés dans les différents composants qui leur permettent d’assurer leurs fonctions. Cette vue d’ensemble du système, sans aucune possibilité d’ajouter ou changer les composants, est un avantage important pour garantir la sécurité du système.

Un ingénieur travaille sur son ordinateur et utilise les quatre applications citées au début de l’énoncé.
Pendant l’exécution de ces applications, des processus mobilisent des données et sont en attente d’autres données mobilisées par d’autres processus.
On donne ci-dessous un tableau indiquant à un instant précis l’état des processus en cours d’exécution et dans lequel D1D_1, D2D_2, D3D_3, D4D_4 et D5D_5 sont des données.
La lettre MM signifie que la donnée est mobilisée par l’application ; la lettre AA signifie que l’application est en attente de cette donnée. Lecture du tableau : le logiciel de traitement de texte mobilise (M)(M) la donnée D1D_1 et est en attente (A)(A) de la donnée D2D_2.

D1D_1 D2D_2 D3D_3 D4D_4 D5D_5
Traitement de texte M A - - -
Tableur A - - - M
SGBD - M A A -
CAO - - A M A
  1. Montrer que les applications s’attendent mutuellement.
    Comment s’appelle cette situation ?
Réponse

Les application SGBD et CAO attendent mutuellement la Donnée D3D_3. Il y a donc un interblocage. D2D_2, D4D_4 et D5D_5 ne pourront pas être libérées. Le traitement de texte ne pourra obtenir D2D_2. Le tableur ne pourra obtenir D5D_5.

Ce constructeur automobile possède six sites de production qui échangent des documents entre eux. Les sites de production sont reliés entre eux par six routeurs AA, BB, CC, DD, EE et FF.
On donne ci dessous les tables de routage des routeurs AA à FF obtenus avec le protocole RIP :

  1. Déterminer à l’aide de ces tables le chemin emprunté par un paquet de données envoyé du routeur AA vers le routeur FF.
Réponse

A→B→E→FA \ce{->} B \ce{->} E \ce{->} F.

On veut représenter schématiquement le réseau de routeurs à partir des tables de routage. Recopier sur la copie le schéma ci-dessous :

  1. En s’appuyant sur les tables de routage, tracer les liaisons entre les routeurs.
Correction

Exercice 3

Les états possibles d’un processus sont : prêt, élu, terminé et bloqué.

  1. Expliquer à quoi correspond l’état élu.
Réponse

Un processus dans l’état élu est un processus qui a accès au processeur. Il est donc en cours d’exécution.

  1. Proposer un schéma illustrant les passages entre les différents états.
Réponse

Cf. Cours.

On suppose que quatre processus C1C_1, C2C_2, C3C_3 et C4C_4 sont créés sur un ordinateur, et qu’aucun autre processus n’est lancé sur celui-ci, ni préalablement ni pendant l’exécution des quatre processus.

L’ordonnanceur, pour exécuter les différents processus prêts, les place dans une structure de données de type file. Un processus prêt est enfilé et un processus élu est défilé.

  1. Parmi les propositions suivantes, recopier celle qui décrit le fonctionnement des entrées/sorties dans une file :
    • Premier entré, dernier sorti
    • Premier entré, premier sorti
    • Dernier entré, premier sorti
Réponse

Une file est une structure de données dans laquelle la donnée la plus ancienne sort la première. La réponse est donc : Premier entré, premier sorti.

On suppose que les quatre processus arrivent dans la file et y sont placés dans l’ordre C1C_1, C2C_2, C3C_3 et C4C_4.

  • Les temps d’exécution totaux de C1C_1, C2C_2, C3C_3 et C4C_4 sont respectivement 100 ms\pu{100 ms}, 150 ms\pu{150 ms}, 80 ms\pu{80 ms} et 60 ms\pu{60 ms}.
  • Après 40 ms\pu{40 ms} d’exécution, le processus C1C_1 demande une opération d’écriture disque, opération qui dure 200 ms\pu{200 ms}. Pendant cette opération d’écriture, le processus C1C_1 passe à l’état bloqué.
  • Après 20 ms\pu{20 ms} d’exécution, le processus C3C_3 demande une opération d’écriture disque, opération qui dure 10 ms\pu{10 ms}. Pendant cette opération d’écriture, le processus C3C_3 passe à l’état bloqué.

Sur la frise chronologique les états du processus C2C_2 sont donnés.

  1. Recopier la frise et la compléter avec les états des processus C1C_1, C3C_3 et C4C_4.
Réponse

On trouvera ci- dessous deux programmes rédigés en pseudo-code.
Verrouiller un fichier signifie que le programme demande un accès exclusif au fichier et l’obtient si le fichier est disponible.

Programme 1 Programme 2
- Verrouiller fichier_1
- Calculs sur fichier_1
- Verrouiller fichier_2
- Calculs sur fichier_1
- Calculs sur fichier_2
- Calculs sur fichier_1
- Déverrouiller fichier_2
- Déverrouiller fichier_1
- Verrouiller fichier_2
- Verrouiller fichier_1
- Calculs sur fichier_1
- Calculs sur fichier_2
- Déverrouiller fichier_1
- Déverrouiller fichier_2
  1. En supposant que les processus correspondant à ces programmes s’exécutent simultanément (exécution concurrente), expliquer le problème qui peut être rencontré.
Réponse
  • P1P_1 verrouille le fichier_1 et P2P_2 verrouille le fichier_2.
  • P1P_1 attend le fichier_2 avant de pouvoir effectuer les calculs (et donc libérer le fichier_1).
  • P2P_2 attend le fichier_1 avant de pouvoir effectuer les calculs (et donc libérer le fichier_2). Il existe donc une situation d’interblocage.
  1. Proposer une modification du programme 2 permettant d’éviter ce problème.
Réponse

Il faut inverser les 2 premières actions pour le programme 2 :

  • Verrouiller fichier_1
  • Verrouiller fichier_2