Presentation PDF

Systèmes temps réel et systèmes embarqués
Systèmes d’exploitation
Jacques Gangloff, Loı̈c Cuvillon
Telecom Physique Strasbourg
23 novembre 2016
Jacques Gangloff (TPS) Systèmes temps réel et systèmes embarqués Année scolaire 2016-2017 1 / 54
Plan
Plan
1 Introduction
Bibliographie
Définition
Historique
Concepts de base
Architectures de systèmes d’exploitation
2 Processus
Introduction
Communication inter-processus (IPC)
Ordonnancement (scheduling)
Introduction
Plan
1 Introduction
Bibliographie
Définition
Historique
Concepts de base
2 Processus
Introduction
Introduction Bibliographie
A. Tannenbaum et A. Woodhull
Operating systems – Design and implementation
Prentice Hall 2006, troisième édition.
A. Tannenbaum
Modern operating systems
Prentice Hall, deuxième édition.
Introduction Définition
Définition
Un système d’exploitation (Operating System ou OS en anglais) est un
programme réalisant les fonctions élémentaires suivantes :
Gestion des ressources physiques de l’ordinateur (temps cpu, mémoire,
périphériques)
Protection de l’intégrité des données stockées et exécutées (en mémoire,
sur les unités de stockage)
Assurer un niveau d’abstraction du matériel pour l’utilisateur
Introduction Historique
La préhistoire
1642 – La Pascaline
Blaise Pascal invente en 1642 une machine à calculer mécanique réalisée
à l’aide d’engrenages. Elle permettait de réaliser des additions et des sous-
tractions. Environ 50 exemplaires furent fabriqués, mais ce fut un échec com-
mercial en raison d’un prix de revient élevé. En mémoire de sa contribution à
l’histoire de l’informatique, Pascal donna son nom à un langage de program-
mation.
La pascaline – musée des arts et métiers – Paris
1822 – Babbage & Lovelace

Charles Babbage invente la machine à différence destinée à faire des calculs
polynomiaux à l’aide de différences finies, puis la machine analytique qui jette
les bases de l’informatique moderne. Il invente ainsi les concepts de machine
séquentielle, de séparation des données et des codes d’exécution, de bran-
chement conditionnel, de boucles d’exécution et de périphérique d’impression.
Il collabore avec la mathématicienne Ada Lovelace qui écrit pour sa machine
ce qui est considéré comme le tout premier programme informatique : un algo-
rithme de calcul des nombres de Bernoulli. Pour des raisons technologiques
(elle devait peser 13 tonnes et était constituée de 25 000 pièces), il ne pourra
jamais terminer sa machine. Elle fut néanmoins achevée après sa mort et per-
mit de réaliser des calculs avec une précision de 31 chiffres significatifs.
La machine de Babbage Ada Lovelace
L’antiquité
1945-1955 – Relais et tubes à vide
À cette époque les ordinateurs sont constitués de relais et/ou d’amplificateurs
à base de tubes à vide (par exemple l’ENIAC, 30 tonnes, 17 500 tubes à vide,
1500 relais, maximum 5 jours sans panne). Alan Turin invente la machine qui
porte son nom et avec elle la notion d’algorithme. John Von Neumann donne
son nom à l’architecture moderne des ordinateurs : une unité de contrôle, une
unité arithmétique et logique, une mémoire, des entrées-sorties. La notion de
système d’exploitation est toujours inconnue à cette époque.
ENIAC – U.S. Army’s Ballistic Research Laboratory
La renaissance
1955-1965 – La révolution du transistor
L’utilisation du transistor en informatique à partir de 1955 fut une véritable
révolution. Le prix et surtout la fiabilité des ordinateurs s’améliora de manière
drastique. Les ordinateurs de cette époque se nommaient mainframes et
étaient encore réservés aux institutions (par exemple l’IBM 7094 avec en-
viron 128 Ko de mémoire et une fréquence d’horloge inférieure à 1 MHz).
Ils nécessitaient un personnel pléthorique pour sa maintenance. On assiste
au développement d’un embryon de système d’exploitation : les systèmes de
batch.
Dual IBM 7090 – NASA – Projet mercury
L’époque moderne
1965-1980 – La naissance des systèmes d’exploitation

Apparition des circuits intégrés (IBM 360)
Apparition de la notion de multiprogramming (OS/360)
Apparition de l’un des premiers systèmes d’exploitation à temps partagé :
CTSS (Compatible Time-Sharing System). Invention du concept de shell.
IBM 360
1965-1980 – La naissance des systèmes d’exploitation

Invention de l’ancêtre de tous les systèmes d’exploitation : MULTICS
(MULTiplexed Information and Computing Service) par le MIT, les
Laboratoires Bell et General Electrics. Apports de MULTICS :
I Multi-tâches, multi-utilisateurs
I Système d’invite de commande à la base du shell actuel
I Notion d’anneaux permettant d’isoler l’exécution du code entre utilisateurs
I Segmentation et mémoire virtuelle
I Système de fichiers hiérarchisé, nom longs, liens symboliques, fichiers
périphériques
Apparition d’UNIX : 2 principales versions, System V et BSD. Plus tard,
IEEE a développé une norme pour rendre le développement sous UNIX
compatible : POSIX.
L’époque contemporaine
1980-nos jours – La démocratisation
Miniaturisation des circuits intégrés
INTEL commercialise le 8086 en 1980 tandis que Motorola sort le 6502
Apparition de l’IBM PC (Personal Computer) équipé du système
d’exploitation MS/DOS et du langage de programmation Microsoft BASIC
Apparition du Macintosh : interface graphique utilisant des fenêtres et la
souris comme pointeur
Windows 1.0 : pâle tentative de copie de l’interface d’Apple par Microsoft
IBM PC
1980-nos jours – La démocratisation

Invention de Xwindows par le MIT en 1984
Développement de Windows NT (partenariat Microsoft-IBM initié en
1990) qui a conduit à Windows XP (NT 5.1), Windows Vista (NT 6.0),
Windows 7 (NT 6.1), Windows 8 (NT 6.2), Windows 8.1 (NT 6.3) et
Windows 10 (NT 10.0/6.4).
Naissance de Linux en 1991, UNIX-like compatible POSIX, open-source,
multi-plateformes. Aujourd’hui Linux équipe la plupart des systèmes
embarqués dont tous les téléphones Android.
Apparition de MAC OSX dérivé d’un UNIX BSD 4,4 compatible POSIX.
Invention du concept de systèmes d’exploitation distribués.
Invention du concept des Netbooks (Ordinateurs disposant d’une
configuration matérielle légère reliés à un système de stockage distribué.
Ex : Chromebook).
Introduction Concepts de base
Concepts de base
Le Noyau (Kernel)
Programme réalisant toutes les fonctions du système d’exploitation
En général, le noyau a le degré de privilège maximum pour l’accès aux
ressources matérielles
Le système d’exploitation (Operating Systems ou OS) est constitué du
noyau et de diverses applications périphériques
Les processus (processes)

Programme en exécution
Contexte d’un processus :
I Espace d’adressage propre contenant le code exécutable, les données, une
pile
I Liste de zones mémoire accessibles
I Registres : compteur d’instruction, compteur de pile, indexes, registres de
calcul en virgule flottante (Floating Point Unit ou FPU), ...
Dans la plupart des systèmes d’exploitation, les informations relatives à
la gestion du processus sont stockées dans la table des processus
(process table)
Les processus sont lancés par exemple au moyen d’un interpréteur de
commande (shell). Sous UNIX, le premier processus lancé au moment
du démarrage est un script nommé init
Un processus peut créer un ou plusieurs processus enfant(s) (child
process)
Les processus peuvent communiquer ou se synchroniser entre eux : on
parle de communication inter-processus (Inter-Process Communication
ou IPC)
Le mode utilisateur (user) et le mode noyau (kernel)

Un processeur moderne a plusieurs modes de fonctionnement (rings)
Dans le mode superviseur ou mode noyau ou mode kernel (ring 0) le
processeur a accès à toutes les ressources sans restriction. Le code du
noyau d’un système d’exploitation est exécuté dans ce mode.
Dans le mode utilisateur ou user (ring > 0, dépend de l’OS), le
processeur teste en permanence les permissions de ce qu’il exécute et
génère des interruptions logicielles (exceptions) en cas d’infraction. Les
processus utilisateurs sont exécutés dans ce mode.
Les niveaux de protection d’un processeur
Les fichiers (files)

Système de rangement et labellisation des données indépendant du
matériel.
Rangement dans une arborescence de répertoires (directories)
Association d’un nom de fichier et d’attributs (type de fichier, propriétaire,
groupe d’utilisateur, droits en lecture/écriture, attributs spéciaux)
Le système de fichier (filesystem) gère le stockage physique des fichiers
en maximisant la robustesse et la performance
Les fichiers spéciaux permettent un interfaçage simple avec le système
d’exploitation ou le matériel
Les tuyaux (pipes) sont des fichiers spéciaux permettant l’échange
d’information entre processus
Les appels système (system calls)

Interface entre le noyau et les processus
Mécanisme de très bas niveau souvent en langage machine (assembly
code) : intégré dans une bibliothèque de fonctions (library)
Le mécanisme des interruptions logicielles est utilisé pour passer le
contrôle au noyau.
Les différentes catégories d’appels système (liste non exhaustive) :
I Gestion des processus (réplication de processus (fork), attente passive de
fin d’exécution d’un processus enfant (waitpid), lancement de nouveau
processus (exec), ...
I Gestion des signaux (sigaction)
I Gestion du système de fichier (création de fichier (creat), lecture (read),
écriture (write), ...
I Gestion des volumes de stockage (association (mount), dissociation
(unmount), ...
I Gestion des gestionnaires de périphérique (ioctl)
I ...
L’interpréteur de commandes (shell)

Interface primaire entre un utilisateur et le système
L’utilisateur saisit la commande au clavier après l’invite de commande
(prompt)
La sortie par défault (stdout) de la commande se fait sous forme de texte
dans la fenêtre du shell
Les sorties peuvent être redirigées soit vers un fichier ou en entrée d’un
autre processus (stdin)
Introduction Architectures de systèmes d’exploitation
Systèmes monolithiques
Tout le code du noyau tourne dans le ring 0, gestionnaires de
périphériques (drivers) compris
Ces systèmes n’utilisent que 2 modes de fonctionnement (ring) du
processeur : le ring 0 pour le noyau et le ring 1 pour les processus
utilisateur.
Le code du noyau est très volumineux
Robustesse moindre : plus de code tourne en mode superviseur
Réactivité meilleure : le protocole d’accès au matériel est le plus simple
possible
Exemple : linux du type monolithique modulaire (les drivers peuvent être
chargés à la demande).
Systèmes à couches (layered systems)

Ce système est organisé en plusieurs niveaux imbriqués qui
correspondent à plusieurs rings du processuer
Dans le sens du plus au moins privilégié : distribution du temps
processeur (Computer Processing Unit ou CPU), gestion de la mémoire,
communication homme-processus, gestion des entrées-sorties
(Inputs/Outputs ou IOs), programmes utilisateurs
Cette architecture logicielle est renforcée par le matériel : le pentium
supporte au moins 4 rings
MULTICS est la seule implémentation de cette architecture à l’heure
actuelle
Machines virtuelles (virtual machines)

Idée : faire tourner plusieurs systèmes d’exploitation sur la même
machine
Deux approches :
I Virtualisation complète : l’OS invité peut fonctionner sans modification dans
l’OS hôte.
I Paravirtualisation : l’OS invité doit être modifié pour pouvoir tourner dans
l’OS hôte. Il présente à celui-ci un accès standardisé au matériel via un
hyperviseur.
Exemples de machines virtuelles

Machine virtuelle MSDOS sous Windows : le partage des ressources est
géré au niveau du noyau de Windows. On est proche du concept de
paravirtualisation.
VMWare : virtualisation complète. Un module noyau doit être chargé pour
gérer le partage des ressources.
VirtualBox : virtualisation complète. Un module noyau permet de gérer
les accès au matériel. Exploitation des fonctions d’accélération matérielle
de la virtualisation.
Dosbox sous linux : on parle plutôt d’émulation, car le matériel est accédé
au moyen des mécanismes classiques disponibles dans l’espace user.
Xen (paravirtualiseur) : un hyperviseur offre aux systèmes d’exploitation
invités une interface normalisée avec le matériel.
Adeos (paravirtualiseur) : un nano-noyau (hyperviseur) permet le partage
de ressources matérielles par plusieurs systèmes d’exploitation
concurrents, y compris plusieurs instances d’un même système. Xenomai
et RTAI, 2 systèmes temps-réel basés sur linux sont des clients de adeos.
Micro-noyau
Idée : mettre le moins de code possible dans le noyau et déporter le
maximum de code en mode protégé. Cette architecture est aussi appelée
micro-noyau (microkernel)
Ce système est beaucoup plus robuste qu’un système monolithique, car
le nombre de lignes de code en mode supervisuer est très réduit
Les drivers sont déportés en mode utilisateur. S’ils commettent une
action interdite, ils peuvent être tués (killed) et relancés. Ce système est
donc tolérant aux fautes.
Les drivers accèdent au matériel via un mécanisme logiciel de protection
d’où une perte de réactivité
Exemple : Mach, Minix, Windows (de type micro-noyau enrichi, car
certaines fonctions très sollicitées sont mises dans le noyau)
Systèmes temps-réel
Le noyau permet de respecter des contraintes temporelles fortes
Réactivité par rapport aux interruptions matérielles
Création de tâches périodiques avec une fluctuation de la période (jitter)
minimale
Exemples : VXWorks (micro-noyau temps-réel), QNX (micro-noyau
temps-réel UNIX-like), Xenomai (monolithique modifié avec micro-noyau
sous-jacent tournant sur une machine virtuelle nano-noyau adeos)
Processus
Plan
1 Introduction
Bibliographie
Définition
Historique
Concepts de base
2 Processus
Introduction
Processus Introduction
Introduction
Définitions
Processus : séquence d’instructions exécutées par le processeur.
Sur un système multitâches, l’illusion du parallélisme est donnée en
réalisant un multiplexage temporel de la ressource CPU et en la
distribuant entre les différents processus suivant une loi appelée
ordonnancement (scheduling).
Les processus ne sont pas tous égaux. Certains sont prioritaires et
doivent être traités rapidement, car ils servent par exemple au bon
fonctionnement du système d’exploitation.
Chaque processus fonctionne de manière cloisonnée par rapport aux
autres. Le contexte d’un processus est l’état courant du matériel
(processeur principalement) lorsque ce processus est en cours
d’exécution.
Le découpage temporel du temps CPU entre les différents processus
implique une commutation de contexte du matériel pour sauvegarder le
contexte courant du processus en cours de suspension et la restauration
du contexte du processus sur le point d’être réveillé.
Création d’un processus

Les 3 situations de création d’un processus :
I Initialisation du système
I Création d’un processus enfant par un processus existant
I Création d’un processus par un utilisateur
Lors du démarrage d’un système, un programme bien précis est lancé
qui est chargé du lancement de tous les processus nécessaires au bon
fonctionnement du système. Sous UNIX, ce programme s’appelle init.
Certains processus actifs en permanence lorsque le système est en
marche s’appellent des démons (daemons). Ils servent à effectuer des
tâches de service telles que la gestion des tâches d’impression, la
gestion des connexions externes, la gestion de la fenêtre de login sous
Xwindows, ...
Fin d’un processus

Les 4 situations d’arrêt d’un processus :
I Sortie normale sans erreur (volontaire)
I Sortie normale avec erreur (volontaire)
I Le processus commet une erreur fatale (involontaire)
I Le processus est tué par un autre processus (involontaire)
Les 2 premières situations de sortie volontaire sont provoquées par une
instruction spécifique du processus (exit sous UNIX) avec un code de
sortie qui correspond soit à une sortie normale soit à une sortie avec
erreur.
Les 2 dernières situations sont provoquées par le système d’exploitation
qui arrête immédiatement le processus en cours soit parce qu’il a
commis une infraction soit parce qu’un autre utilisateur ayant des droits
plus élevés a envoyé un appel système de type kill.
Hiérarchie des processus

Lorsqu’un processus parent crée un ou plusieurs processus enfant(s), les
enfants restent liés d’une certaine manière aux parents.
Comme les enfants peuvent eux-mêmes donner naissance à des
enfants, on peut avoir toute une arborescence ou hiérarchie de
processus liés entre eux.
Il est possible d’envoyer un signal à une hiérarchie de processus.
Lorsqu’un processus enfant s’arrête, le parent en est informé.
Exemple : commande pstree sous UNIX.
Etat des processus

En cours d’exécution (running) : le CPU exécute le processus à cet
instant
Prêt (ready) : le processus attend que le CPU ait fini d’exécuter d’autres
processus
Bloqué (blocked) : le processus est en attente d’un événement externe
Les processus légers (threads)

Les threads partagent le même espace d’adressage, donc les mêmes
variables et le même code. Seuls les registres du processeur diffèrent.
Les threads peuvent être gérées dans l’espace user ou par le kernel.
Les threads impliquent de gérer certains nouveaux problèmes :
I Accès simultané à un même fichier : que se passe-t-il si un thread ferme le
fichier alors que l’autre est en train de le lire ?
I Allocation dynamique : si un thread a besoin de plus de mémoire en même
temps qu’un autre ?
I Si un thread commet une erreur, affiche la valeur de errno et qu’à ce
moment-là un autre thread commet une erreur.
I ...
Processus Communication inter-processus (IPC)
Communication inter-processus
Introduction
Comment communiquer des données entre processus ?
Comment synchroniser la transmission des données ?
Comment éviter les situations de blocage ?
Comment gérer l’accès concurrent à des ressources communes ?
Situation de compétition (race condition)

Deux processus ou plus écrivent puis lisent des données et le résultat
dépend de quel processus a été le premier.
Exemple : compétition entre 2 threads
Section critique (critical section)

Pour éviter les situations de compétition, il faut définir une section critique
Les conditions pour réaliser une section critique :
I Il ne peut y avoir plus d’un processus dans sa section critique en même
temps
I Un processus en dehors de sa section critique ne peut bloquer un autre
processus
I Aucun processus ne peut bloquer en permanence pour entrer dans sa
section critique
Exclusion mutuelle avec attente active (mutual exclusion with

busy waiting)
Alternance stricte résolue avec un verrou rotatif (spin lock)
Algorithme de Peterson (attente active) : résolution de la compétition
entre 2 threads
Instruction processeur
Alternance stricte
while( 1 ) {
while( turn != 0 );
/* section critique */
/* ... */
turn = 1;
/* section non critique */
/* ... */
}
while( 1 ) {
while( turn != 1 );
/* section critique */
/* ... */
turn = 0;
/* section non critique */
/* ... */
}
Algorithme de Peterson
flag[0] = flag[1] = turn = 0;
P0: flag[0] = 1;
turn = 1;
while( flag[1] && turn == 1 );
// do nothing
// critical section
...
// end of critical section
flag[0] = 0;
P1: flag[1] = 1;
turn = 0;
while( flag[0] && turn == 0 );
// do nothing
// critical section
...
// end of critical section
flag[1] = 0;
Instruction processeur i86 : XCHG

LOCK: ; mutex pointer is in EBX; clobbers EAX
XOR EAX, EAX ; EAX = 0
XCHG EAX, [EBX] ; atomic exchange
AND EAX, EAX ; test if EAX = 0
JZ LOCK ; if we got a zero, spin-wait
RET
UNLOCK: ; mutex pointer is in EBX

MOV [EBX], 1 ; release the lock
RET
Problème d’inversion de priorité

Considérons 2 processus H de priorité haute et B de priorité basse qui
partagent un accès à une ressource commune
La stratégie d’ordonnancement fait que H est placé en mode
running dès qu’il est ready
Supposons que B soit dans une section critique et qu’à ce moment H

passe du mode blocked au mode ready.
H est donc mis en mode running et B est mis en mode ready. Or H
veut accéder à la section critique et bloque donc sur le mécanisme
d’exclusion mutuelle sans aucun espoir que B passe en mode
running et libère le verrou.
Sommeil et réveil d’un processus (Sleep and wakeup)

Pour éviter les attentes actives, utilisation de sleep et wakeup.
Sémaphore
Méthode classique pour accéder à une ressource commune
Le sémaphore est un compteur qui est initialisé à la valeur du nombre de
ressources partagées à protéger
Lorsqu’il n’y a qu’une seule ressource à partager, on parle de sémaphore
binaire ou mutex
Sémaphores : exemple du producteur-consommateur

BufferSize = 3;
semaphore mutex = 1; // access to critical section

semaphore empty = BufferSize; // number of empty slots
semaphore full = 0; // number of full buffer slots
Producer() {
int widget;
while (TRUE) { // loop forever

make_new(widget); // create a new widge
down(&empty); // decrement the empty semaphore
down(&mutex); // enter critical section
put_item(widget); // put widget in buffer
up(&mutex); // leave critical section
up(&full); // increment the full semaphore
}
}
Sémaphores : exemple du producteur-consommateur

Consumer() {
int widget;
while (TRUE) { // loop forever

down(&full); // decrement the full semaphore
down(&mutex); // enter critical section
remove_item(widget);// take a widget
up(&mutex); // leave critical section
up(&empty); // increment the empty semaphore
consume_item(widget);// consume the item
}
}
Mutex
Un mutex est un cas particulier d’un sémaphore qui n’aurait que 2 états :
0 ou 1
Un mutex est typiquement utilisé lorsqu’il faut protéger une section
critique
Moniteurs (monitors)
Ensemble de procédures, variables, structures de données regroupées
dans un objet spécial appelé moniteur
Les processus externes au moniteur peuvent appeler les procédures du
moniteur, mais une seule procédure du moniteur ne peut être active à la
fois
La synchronisation est gérée par le compilateur qui sait que le moniteur
est une structure spéciale. C’est le compilateur qui rajoute les
mécanismes de synchronisation adéquats.
Transmission de message (message passing)

Transmission de messages inter-processus
Les fonctions send et receive permettent de passer des messages en
garantissant l’intégrité des données
Processus Ordonnancement (scheduling)
Ordonnancement
Introduction
Partage du temps CPU entre les processus. Le passage d’un processus
à un autre s’appelle la commutation de processus. C’est l’ordonnanceur
du noyau qui effectue cette commutation.
La prise de décision des commutations s’effectue de manière périodique
(tic du système)
Deux principaux types de comportements des processus : processus
dédiés aux entrées-sorties et processus dédiés aux calculs
Quand commuter les processus : quand un processus se termine, quand
un processus bloque sur une entrée/sortie, un sémaphore ...
Éventuellement : quand un nouveau processus est créé, quand une
interruption matérielle intervient.
Différents objectifs d’ordonnancement : équité, veiller à ce qui la politique
d’ordonnancement soit respectée, équilibre. Pour les systèmes
interactifs : temps de réponse court, ergonomie adaptée aux attentes des
utilisateurs. Pour les systèmes temps-réel : respect strict des délais,
déterminisme.
Ordonnancement FCFS ou FIFO

First Come First Served : les processus sont démarrés dans l’ordre où ils
sont lancés et tournent jusqu’à ce qu’ils bloquent
Inconvénient : pas adapté aux systèmes interactifs
Ordonnancement round robin

Chaque processus obtient un quantum de temps CPU. L’ordonnanceur
distribue de manière cyclique ces quantums aux processus.
Exemple de Pb : avec un quantum de 100ms, si 10 utilisateurs appuient
simultanément sur une touche du clavier, les 10 processus
correspondants vont être réveillés successivement et consommer leur
quantum. Le dernier utilisateur servi devra attendre 1s.
Ordonnancement par priorité (priority scheduling)

Tous les processus ne sont pas égaux : certains doivent être traités
prioritairement
Avec un ordonnancement par priorité, le système donne toujours la main
à la tâche de plus haute priorité
La priorité peut être modifiée dynamiquement à chaque période de
l’ordonnanceur pour éviter qu’un seul processus n’occupe tout le temps
CPU
Ordonnancement garanti (guaranteed scheduling)

Garantit un partage équitable du temps CPU entre utilisateurs ayant une
même priorité
Le système conserve un historique du temps CPU cumulé de tous les
processus afin de réaliser l’équilibre
Ordonnancement par lotterie (lottery scheduling)

L’ordonnancement garanti est difficile à implémenter.
Une des solutions consiste à tirer au sort quel processus a droit au CPU
Plus un processus est prioritaire, plus il dispose de tickets parmi
l’ensemble des tickets soumis au tirage aléatoire
Ordonnancement de processus léger (thread scheduling)

L’ordonnancement des threads n’est possible que pour les threads noyau
Il est possible de définir une politique d’ordonnancement des threads
différente de celle des processus
Ordonnancement temps-réel (real-time scheduling)

Doit être déterministe en temps
Les tâches périodiques doivent être réveillées avec une périodicité
parfaite (erreur < 100 microsecondes)
Le temps de réponse aux interruptions doit être le plus court possible.

Langue

Presentation PDF

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Presentation PDF

Transféré par

Droits d'auteur :

Formats disponibles

Systèmes temps réel et systèmes embarqués

Jacques Gangloff, Loı̈c Cuvillon

Telecom Physique Strasbourg

La pascaline – musée des arts et métiers – Paris

1822 – Babbage & Lovelace

La machine de Babbage Ada Lovelace

ENIAC – U.S. Army’s Ballistic Research Laboratory

Dual IBM 7090 – NASA – Projet mercury

1965-1980 – La naissance des systèmes d’exploitation

1965-1980 – La naissance des systèmes d’exploitation

1980-nos jours – La démocratisation

Les processus (processes)

Le mode utilisateur (user) et le mode noyau (kernel)

Les niveaux de protection d’un processeur

Les fichiers (files)

Les appels système (system calls)

L’interpréteur de commandes (shell)

Architectures de systèmes d’exploitation

Systèmes à couches (layered systems)

Machines virtuelles (virtual machines)

Exemples de machines virtuelles

Création d’un processus

Fin d’un processus

Hiérarchie des processus

Etat des processus

Les processus légers (threads)

Situation de compétition (race condition)

Section critique (critical section)

Exclusion mutuelle avec attente active (mutual exclusion with

Instruction processeur i86 : XCHG

UNLOCK: ; mutex pointer is in EBX

Problème d’inversion de priorité

Supposons que B soit dans une section critique et qu’à ce moment H

Sommeil et réveil d’un processus (Sleep and wakeup)

Sémaphores : exemple du producteur-consommateur

semaphore mutex = 1; // access to critical section

while (TRUE) { // loop forever

Sémaphores : exemple du producteur-consommateur

while (TRUE) { // loop forever

Transmission de message (message passing)

Ordonnancement FCFS ou FIFO

Ordonnancement round robin

Ordonnancement par priorité (priority scheduling)

Ordonnancement garanti (guaranteed scheduling)

Ordonnancement par lotterie (lottery scheduling)

Ordonnancement de processus léger (thread scheduling)

Ordonnancement temps-réel (real-time scheduling)

Vous aimerez peut-être aussi