Vous êtes sur la page 1sur 120
VersionVersion 0.7.1104030.7.110403 2ème 2ème Informatique Informatique Support de Cours Taha BEN SALAH Ecole Nationale
VersionVersion 0.7.1104030.7.110403 2ème 2ème Informatique Informatique Support de Cours Taha BEN SALAH Ecole Nationale
VersionVersion 0.7.1104030.7.110403 2ème 2ème Informatique Informatique Support de Cours Taha BEN SALAH Ecole Nationale
VersionVersion 0.7.1104030.7.110403 2ème 2ème Informatique Informatique Support de Cours Taha BEN SALAH Ecole Nationale
VersionVersion 0.7.1104030.7.110403 2ème 2ème Informatique Informatique Support de Cours Taha BEN SALAH Ecole Nationale
VersionVersion 0.7.1104030.7.110403 2ème 2ème Informatique Informatique Support de Cours Taha BEN SALAH Ecole Nationale
VersionVersion 0.7.1104030.7.110403 2ème 2ème Informatique Informatique Support de Cours Taha BEN SALAH Ecole Nationale
VersionVersion 0.7.1104030.7.110403 2ème 2ème Informatique Informatique Support de Cours Taha BEN SALAH Ecole Nationale

VersionVersion 0.7.1104030.7.110403

2ème2ème InformatiqueInformatique

Support de Cours Taha BEN SALAH Ecole Nationale d'ingénieurs de Sousse

Plan

PARTIE I.

Outils théoriques, architecture avancée des systèmes

d'exploitation

1. Rappel sur l'architecture d'un système d'exploitation

2. Gestion des taches et Ordonnancement

3. Gestion des interruptions

PARTIE II. Systèmes temps réels 6 . Défintions

7 . Caratérisations et performances

8 . Ordonnancmeent Temps réel

9 . Systèmes d’exploitation temps réel

PARTIE III. Cas d'étude : Linux Temps réel

10 . Mise en place 11 . API temps réel

Taha BEN SALAH (2011) v0.7 - ENISO

2

Définition

Système temps réel : un système informatique qui doit réagir à son environnement extérieur à l'intérieur d'un certain nombre de contraintes temporelles

Taha BEN SALAH (2011) v0.7 - ENISO

4

Applications temps réelles

Un système temps réel doit permettre l'exécution temps réelles

Les contraintes temps réelles ne peuvent être garanties par l'application elle même car l'application n'a pas un accès exclusif aux ressources

Les contraintes temps réelles doivent être garanties par le système (d'exploitation) temps réel

Taha BEN SALAH (2008) v1.0 - ENISO

Applications temps réelles

Un système temps réel permet l'exécution d'une application temps réelle ou non temps réelle

Une application temps réelle ne peut s'exécuter que sur un système temps réel

Taha BEN SALAH (2008) v1.0 - ENISO

Contraintes temporelles

Les contraintes temporelles impose une réponse du système avant un certain délai

Il est difficile de respecter ce délai pour les raisons suivantes

Non déterminisme

Ordonnancement des taches

Synchronisation entre taches

Interruptions

Taha BEN SALAH (2008) v1.0 - ENISO

Non déterminisme

Difficile de savoir quelle est la durée minimale d'exécution de la tache pour savoir si cela vérifie les contraintes : à la charge du développeur de définir un délai raisonnable

Un boucle dont le nombre d'itérations est dynamique permet de montrer la difficulté de prédire le temps d'exécution (en négligeant les I/O)

Taha BEN SALAH (2008) v1.0 - ENISO

Ordonnancement des taches

L'ordonnancement est d'autant plus difficile car la durée de la tache n'est « jamais » minimale puisqu'il faut en parallèle exécuter d'autres taches

Il faut

éviter la famine

garantir les contraintes de priorité

garantir les contraintes temporelles

Les contraintes temporelles doivent être garanties par le système

Taha BEN SALAH (2008) v1.0 - ENISO

Synchronisation des taches

S'il y a synchronisation entre certaines taches

donc certaines ressources sont partagées

les ressources sont dites critiques car ne peuvent être utilisées en même temps par plusieurs taches

alors le temps d'exécution d'une tache dépend aussi de celle des autres taches dont elle dépend

==> la prédiction du temps d'exécution devient « impossible »

Les contraintes temporelles doivent être bien étudiées par le développeur qui doit prendre en considération les ressources partagées

Taha BEN SALAH (2008) v1.0 - ENISO

Les interruptions

Toute tache en cours d'exécution peut être interrompue momentanément pour des raisons propres au système.

Les interruptions rendent difficile la garantie des contraintes temporelles

Taha BEN SALAH (2008) v1.0 - ENISO

Système temps réel

Pour concevoir un système temps réel il est important de connaitre l'architecture des systèmes d'exploitation

Pour rendre un OS temps réel, il faut agir sur deux aspects

Gestion des taches

Gestion des interruptions

Taha BEN SALAH (2008) v1.0 - ENISO

Architecture matérielle

Architecture matérielle Taha BEN SALAH (2011) v0.7 - ENISO

Taha BEN SALAH (2011) v0.7 - ENISO

Système d'exploitation

Le système d’exploitation est l’ensemble des programmes qui se chargent de résoudre les problèmes relatifs à l’exploitation de l’ordinateur en garantissant

Une gestion efficace, fiable et économique des ressources physiques de l’ordinateur (notamment les ressources critiques tels que processeur, mémoire…)

Présenter une machine virtuelle permettant l’interaction avec les utilisateurs en leur présentant une machine plus simple à exploiter que la machine réelle

Taha BEN SALAH (2011) v0.7 - ENISO

Système d'exploitation

Un système d'exploitation est le garant de

La gestion des ressources

Ressources logicielles

mémoire virtuelle, processus, fichiers

Ressources matérielles

Mémoire centrale,disque, processeur, imprimantes,

La transparence (par rapport à l'accès aux ressource)

Toute utilisation d'une ressource DOIT passer par le système d'exploitation

Taha BEN SALAH (2011) v0.7 - ENISO

Organisation d'un OS

Le système d'exploitation est constitué de

Un noyau

Des extensions du systèmes (dits modules)

Des applications utilitaires

Utilitaires de développement : outils de chargement, de débuggage, éventuellement de compilation

Utilitaires End User (utilisation finale) : éditeur de texte …

Utilitaires de suivi et optimisations (monitoring)

Taha BEN SALAH (2011) v0.7 - ENISO

Le Noyau

Le noyau est la partie d'un système d'exploitation qui est commune et nécessaire à tous les autres programme.

C'est la partie du système d'exploitation qui est chargée mais jamais déchargée.

Elle est responsable de charger le reste des partie du système d'exploitation

Taha BEN SALAH (2011) v0.7 - ENISO

Le Noyau

Le noyau est responsable de

Gestion de la mémoire

Mémoire centrale

Mémoire virtuelle

Gestion des fichiers

Gestion de taches

Gestion des processus

Gestion des threads

Gestion des périphériques (Entrées/Sorties)

Gestion des interruptions

Taha BEN SALAH (2011) v0.7 - ENISO

OS ou Noyau

On parlera souvent d'un OS en ciblant le noyau et vise versa car le noyau est la partie la plus importante d'un OS

Taha BEN SALAH (2011) v0.7 - ENISO

Noyau : Caractéristiques fondamentales

Mono- tâche (DOS)

A tout instant, un seul programme est exécuté; un autre programme ne démarrera, sauf conditions exceptionnelles, que lorsque le premier sera terminé.

Multi- tâches (Windows, Unix, Linux , VMS)

Plusieurs processus (i. e. un «programme» en cours d’exécution) peuvent s’exécuter simultanément (systèmes multi- processeurs) ou en quasi- parallélisme (systèmes à temps partagé)

mono- session (Windows 98,2000)

Au plus un utilisateur à la fois sur une machine. Les systèmes réseaux permettent de différencier plusieurs utilisateurs, mais chacun d’eux utilise de manière exclusive la machine (multi- utilisateurs, mono- session)

multi- sessions (Windows XP, Unix, Linux, VMS)

Plusieurs utilisateurs peuvent travailler simultanément sur la même machine.

Taha BEN SALAH (2011) v0.7 - ENISO

Autre classifications

Architecture du noyau

l'interaction avec les utilisateurs

Interaction avec d'autres machines (réseau)

Mobilité

Taha BEN SALAH (2011) v0.7 - ENISO

Architecture du noyau

Monolithique

Un seul bloc définit à la compilation

Modulaire

Certaines parties du système (par exemple la gestion d'un système de fichier particulier comme NTFS ou FAT) sont chargées dynamiquement. Le système est conçu donc en terme de modules chargés par une partie structurante de l'OS qui garantit un socle unifié

Micro Noyau

Seule une petite partie du noyau est définie à la compilation. Tous les gestionnaires et parties de l'OS sont chargés par ce « micro kernel Loader »

Taha BEN SALAH (2011) v0.7 - ENISO

l'interaction avec les utilisateurs

Système très Interactif

Noyau de type « desktop » : les applications « graphiques » sont en quelque sorte prioritaires pour avoir un temps de réponse humainement acceptable

Système peu interactif

Noyau de type « server » : les application en taches de fond sont prioritaires

Noyau de type « temps réel » interactif : la priorité est calculée en terme de contraintes temporelles

Taha BEN SALAH (2011) v0.7 - ENISO

l'interaction avec les utilisateurs

Système non interactif

Sans contraintes temporelles : système embarqué

Avec contraintes temporelles

Système temps réel industriel

Taha BEN SALAH (2011) v0.7 - ENISO

Interaction avec d'autres machines

Accès nommé au réseau

Système réseau : toute application doit connaitre la machine avec qui elle pourra communiquer

Accès transparent par rapport au réseau

Système distribué : toute application voit toutes les machines comme si c'était une seule machine

Taha BEN SALAH (2011) v0.7 - ENISO

Mobilité

Système sédentaire

Pas de mobilité

Système nomade

Mobilité réduite, pas d'utilisation pendant la mobilité (Laptop)

Gestion de plusieurs configurations (réseau)

Système mobile

Utilisation pendant la mobilité

Matériel plus sophistiqué, moins performant, plus exotique (propriétaire) : Win CE, Androide, IOS,

Taha BEN SALAH (2011) v0.7 - ENISO

Mode noyau / Mode utilisateur

La transparence est instaurée en s'assurant que tout programme doit passer parle système d'exploitation Ceci st réalisé en définissant deux modes d'exécution

Mode utilisateur

Mode noyau

Taha BEN SALAH (2011) v0.7 - ENISO

Mode noyau / Mode utilisateur

Espace User Appli Appli Lance l'exécution d'une appli Module noyau Interrup Logicielle Handler : Trappes
Espace User
Appli
Appli
Lance l'exécution d'une appli
Module noyau
Interrup Logicielle Handler : Trappes (routine)
Espace Noyau
Interruption Matérielle Handler
noitucéxe
Processeur
Périph / Device
Périph / Device
Notification de l'appli

Taha BEN SALAH (2011) v0.7 - ENISO

Mode utilisateur

C'est le mode dans lequel tout programme (sauf le noyau) s'exécute

Dans le mode utilisateur, plusieurs privilèges ne sont pas accordés au programme. Il n'est donc pas possible de

Lancer certaines instructions processeur

halt du processeur, désactivation des interruption …

Accéder en lecture et/ou écriture à certaines zones mémoire critiques

Zones tampon (buffer) des périphériques

Zones noyau (dans laquelle le noyau est chargé)

Taha BEN SALAH (2011) v0.7 - ENISO

Mode noyau

C'est le mode dans lequel le noyau s'exécute avec tous les privilèges

Dans ce mode le noyau peut

Accéder à toutes les zones mémoire Exécuter toutes les instrcutions

Taha BEN SALAH (2011) v0.7 - ENISO

Passage d'un mode à un autre

User Mode → Kernel Mode

Faute/Exception (interruption matérielle liée au processeur)

Erreur dans l'UAL qui engendre une exception

Défaut de page

Opérateur (instruction) invalide

Opérandes (param d'une instruction) invalide

Interruption matérielle (Entrée/Sortie)

Provenant d'un périphérique

Trappe/Routine Système (interruption logicielle)

Appel Système

Taha BEN SALAH (2011) v0.7 - ENISO

Passage d'un mode à un autre

User Mode → Kernel Mode

Dans le cas d'un appel système (interruption logicielle)

Dépend de l'architecture matérielle

Résulte en la modification d'un drapeau (flag) dans un régistre particulier définit par deux bits (appelé ring mode)

00 (donc 0) : mode noyau

11 (donc 3 binaire) : mode utilisateur

Les deux autres modes sont souvent non utilisés (linux et windows)

Taha BEN SALAH (2011) v0.7 - ENISO

Ring Mode

Ring Mode Taha BEN SALAH (2011) v0.7 - ENISO (ring 3) mode utilisateurs (applications) (ring 2)

Taha BEN SALAH (2011) v0.7 - ENISO

(ring 3) mode utilisateurs (applications) (ring 2) pilote périphérique (non utilisé) (ring 1) pilote périphérique (non utilisé)

(ring 0) mode noyau

Passage d'un mode à un autre

Dans le cas d'un appel système (interruption logicielle)

Intel X86 (avant INTEL Pentium Pro+)

Aucun mécanisme fourni

Il faut simuler une exception (fault) en remplissant certain régistres

Ex : dans le cas de MS DOS, utiliser l'interruption I21 qui fait ce traitement

Pour retourner au user mode : instruction « IRET »

Intel X86 (INTEL Pentium Pro+ et plus)

Instructions :

SYSENTER (User Mode → Kernel Model)

SYSEXIT (Kernel Model → User Mode)

Taha BEN SALAH (2011) v0.7 - ENISO

Passage d'un mode à un autre

Dans le cas d'un appel système (interruption logicielle)

AMD K6-2+

Instructions :

SYSCALL (User Mode → Kernel Model)

SYSRET (Kernel Model → User Mode)

Taha BEN SALAH (2011) v0.7 - ENISO

Définitions

Une tache est la représentation mémoire d'un traitement en cours d'exécution

On distingue souvent les processus et les thread

Un système multi-taches permet l'exécution simultanées de processus

Taha BEN SALAH (2011) v0.7 - ENISO

Processus

Un processus est une unité d’exécution (la plus petite entité que dont on peut lancer l'exécution par un user) qui représente un programme en cours d'exécution

Un processus est défini par une zone mémoire qui lui est propre qui contient

Les métadonnées sur le process (segment U)

Les variable globale/statiques initialisées (segment Data)

Les variable globale/statiques non initialisées (segment BSS)

Le code à exécuter (segment text)

La pile (LIFO): contient les variables locales des « Frames »

Le tas: contient le résultat des « malloc »

Taha BEN SALAH (2011) v0.7 - ENISO

Processus

Deux processus ne partagent pas de mémoire et utilisent des mécanismes de IPC (inter process communication) pour dialoguer.

Un process est décrit dans le segment U par (cas unix):

PID :nombre identifiant un processus. Utilisé pour l'administration du processus par le noyau.

lors de la commande fork il y a attribution d'un PID

lors de la commande exec on garde le même PID.

PPID :identité du processus père (créateur).

UID, EUID, SUID : identifiant(s) du (des) propriétaire(s).

UID : UID réel (UID du créateur c'est à dire du processus père).

EUID :UID effectif.

SUID :UID sauvegarde.

GID, EGID, SGID : identifiant(s) du groupe.

GID : GID réel (GID du créateur c'est à dire du processus père).

EGID :GID effectif.

SGID :GID sauvegarde.

tty : terminal d'attachement.

pri :priorité (nice)

s :état du processus (endormi, en attente, en exécution, etc.)

stime :date de lancement du processus

time :temps écoulé d'utilisation d'unité centrale

size :taille de la mémoire allouée.

Taha BEN SALAH (2011) v0.7 - ENISO

Etat d'un process

Prêt création Actif Zombie Destruction Bloqué
Prêt
création
Actif
Zombie
Destruction
Bloqué

Taha BEN SALAH (2011) v0.7 - ENISO

Diagramme d'état Unix

Diagramme d'état Unix Taha BEN SALAH (2011) v0.7 - ENISO

Taha BEN SALAH (2011) v0.7 - ENISO

Thread

Un thread est une fonction (flux d'exécution) en cours d'exécution au sein d'un même process

Un process contient au moins un thread appelé « Thread Main», il est associé à la fonction main

Un thread est une construction de codage qui n'affecte pas l'architecture de l'application.

Les threads d'un même process partagent les mêmes données (même Tas : variables dynamique , même Text, même BSS et même Data) mais ont

chacun sa propre Pile et son propre état (en corus

d'exécution, bloqué

)

Taha BEN SALAH (2011) v0.7 - ENISO

Thread

Le modèle de communication en thread d'un même processus est simple : via des variables paratagées (globales)

Taha BEN SALAH (2011) v0.7 - ENISO

Etat d'un thread

le même que celui du process Prêt création Actif Zombie Destruction Bloqué
le même que celui du process
Prêt
création
Actif
Zombie
Destruction
Bloqué

Taha BEN SALAH (2011) v0.7 - ENISO

Ordonnancement

L’Ordonnanceur (planificateur, scheduler) est la partie (un programme) du système responsable de régler les état des processus (Prêt,Actif,…etc.) et de gérer les transitions entre ses états

C’est l’allocateur du processeur aux différents processus

Il alloue le processeur au processus en tête de file des Prêts

Taha BEN SALAH (2011) v0.7 - ENISO

Ordonnancement

Objectifs

Maximiser l’utilisation du processeur

Présenter un temps de réponse acceptable

Vérifier les contraintes temps réelles

Respecter l’équité entre les processus

Taha BEN SALAH (2011) v0.7 - ENISO

Principes d’ordonnancement

Les principaux principes d'ordonnancement sont les suivantes :

Ordre d'arrivée : le premier servi est le premier arrivé (Au

supermarché, à la poste,

),

Urgence : le premier servi est celui dont le besoin d'accès rapide à la ressource est le plus grand. Par exemple, les pompiers sont prioritaires à un carrefour. Dans un système temps réel, l'urgence est accordée à la tache avec l'échéance la plus proche

Importance : le premier servi est celui dont l'accès à la ressource est le plus important. Par exemple, une personne âgée est prioritaire dans l'accès aux places assises dans les transports en commun

Taha BEN SALAH (2011) v0.7 - ENISO

L’Ordonnanceur

2 catégories

Ordonnancement coopératif

Ordonnancement préemptif

Taha BEN SALAH (2011) v0.7 - ENISO

Ordonnancement coopératif

Ordonnancement jusqu’à achèvement

Les processus élu garde le contrôle jusqu’à épuisement du temps qui lui a été alloué même si des processus plus prioritaires on atteint la liste des Prêts

Non applicable en temps réél

Taha BEN SALAH (2011) v0.7 - ENISO

Ordonnanceur Préemptif

Avec réquisition

Le principe de réquisition (préemption) consiste à décider, en fonction de certains critères, de remettre en file d'attente un processus avant la fin de son exécution.

L’Ordonnanceur peut interrompre un processus en cours d’exécution si un nouveau processus de priorité plus élevée est inséré dans la file des Prêts

Taha BEN SALAH (2011) v0.7 - ENISO

Ordonnanceur Préemptif

Un processus peut être interrompu si

Un processus plus prioritaire (échéance plus courte en Temps réél) arrive : calcul dynamique de l'échéance

Une interruption logicielle : initiée par le processus

Une interruption matérielle : initiée par le matériel

Dans certains système même une interruption matérielle peut être interrompue par une autre interruption

Taha BEN SALAH (2011) v0.7 - ENISO

Système réentrant

Le système est réentrant si

Toutes les routines système sont ré-entrantes

i.e. Les routines système (des interruptions) sont interruptibles

Cas particulier : Les interruptions sont interrompues par d'aitres interruptions

Une routine n'est pas ré-entrante si

Elle fait appel à une autre routine non réentrante

Elle fait appel à des variables globales non statiques (modifiables)

Elle modifie le code de la routine elle même (self-modifying)

Taha BEN SALAH (2011) v0.7 - ENISO

Système réentrant

T1

T3

T2

process

Système réentrant T1 T3 T2 process Interruption 1 Interruption 2 Délai théorique : T1 + T2
Système réentrant T1 T3 T2 process Interruption 1 Interruption 2 Délai théorique : T1 + T2
Système réentrant T1 T3 T2 process Interruption 1 Interruption 2 Délai théorique : T1 + T2
Système réentrant T1 T3 T2 process Interruption 1 Interruption 2 Délai théorique : T1 + T2

Interruption 1

Interruption 2

réentrant T1 T3 T2 process Interruption 1 Interruption 2 Délai théorique : T1 + T2 Délai
réentrant T1 T3 T2 process Interruption 1 Interruption 2 Délai théorique : T1 + T2 Délai
réentrant T1 T3 T2 process Interruption 1 Interruption 2 Délai théorique : T1 + T2 Délai

Délai théorique : T1 + T2

Délai effectif: T1 + T2 + T3

Mode user

Mode noyau

Remarquons que l'on n'est entrain d'étudier qu'une seule tache. Le problème devient plus compliqué avec plusieurs taches à la fois

Taha BEN SALAH (2011) v0.7 - ENISO

Définition

Système temps réel : un système informatique qui doit réagir à son environnement extérieur à l'intérieur d'un certain nombre de contraintes temporelles

Taha BEN SALAH (2011) v0.7 - ENISO

56

Les types de temps-réel

Temps-réel mou : un retard dans l’obtention du résultat n’est pas dramatique (distributeur de billets)

Temps-réel dur : un retard dans l’obtention du résultat le rend inutile (détection de missile)

Temps-réel ferme : un retard, s’il arrive très peu souvent, peut être toléré (téléphonie)

Temps-réel hybride

Taha BEN SALAH (2011) v0.7 - ENISO

57

Global System for Mobile Communications

Extension POSIX

IEEE 1003.1b-1993 : Interface de programmation (API) temps réel. Ajout du support de programmation temps réel au standard précédent. On parle également de POSIX.4.

IEEE 1003.1c-1995 : Interface de programmation (API) pour le multithreading.

Taha BEN SALAH (2011) v0.7 - ENISO

59

Introduction

Un noyau temps réel est le minimum logiciel pour pouvoir faire du temps réel :

Ordonnanceur

gestion de tâches

communications inter-tâches

Un système plutôt limité mais performant.

Taha BEN SALAH (2011) v0.7 - ENISO

60

Un exécutif temps réel possède un noyau temps réel complété de modules/bibliothèques pour faciliter la conception de l' application temps réel :

gestion mémoire,

gestion des E/S,

gestion de timers,

gestion d' accès réseau,

gestion de fichiers.

Taha BEN SALAH (2011) v0.7 - ENISO

Lors de la génération de l'exécutif, on choisit à la carte les bibliothèques en fonction des besoins de l'application temps réel.

Pour le développement, on a besoin d'une machine hôte et de son environnement de développement croisé (compilateur C croisé, utilitaires, debugger) ainsi que du système cible dans lequel on va télécharger (par liaison série ou par le réseau) l'application temps réel avec l'exécutif.

Taha BEN SALAH (2011) v0.7 - ENISO

Un système d'exploitation temps réel est le cas particulier où l' a confusion entre le système on hôte et le système cible qui ne font plus qu' On a donc ici un environnement de un. développement natif.

Taha BEN SALAH (2011) v0.7 - ENISO

VxWorks

Le plus utilisé dans l'industrie.

Il est développé par la société :LQG 5LYHU (http ://www.windriver.com) qui a également racheté les droits du noyau temps réel pSOS, un peu ancien mais également largement utilisé.

VxWorks est fiable, à faible empreinte mémoire, totalement configurable et porté sur un nombre important de processeurs (PowerPC, 68K, CPU32, ColdFire, MCORE, 80x86, Pentium, i960, ARM, StrongARM, MIPS, SH, SPARC, NECV8xx, M32 R/D, RAD6000, ST 20, TriCore).

Un point fort de VxWorks a été le support réseau (sockets,

disponible dès 1989 au développeur

commandes r

NFS, RPC

)

,

bien avant tous ses concurrents.

VxWorks est également conforme à POSIX 1003.1b.

Taha BEN SALAH (2011) v0.7 - ENISO

VxWorks

Le plus utilisé dans l'industrie.

Il est développé par la société :LQG 5LYHU (http ://www.windriver.com) qui a également racheté les droits du noyau temps réel pSOS, un peu ancien mais également largement utilisé.

VxWorks est fiable, à faible empreinte mémoire, totalement configurable et porté sur un nombre important de processeurs (PowerPC, 68K, CPU32, ColdFire, MCORE, 80x86, Pentium, i960, ARM, StrongARM, MIPS, SH, SPARC, NECV8xx, M32 R/D, RAD6000, ST 20, TriCore).

Un point fort de VxWorks a été le support réseau (sockets,

disponible dès 1989 au développeur

commandes r

NFS, RPC

)

,

bien avant tous ses concurrents.

VxWorks est également conforme à POSIX 1003.1b.

Taha BEN SALAH (2011) v0.7 - ENISO

QNX

Développé par la société canadienne QNX Software (http ://www.qnx.com)

QNX est un système temps réel de type UNIX. Il est conforme à POSIX, permet de développer directement sur la plateforme cible

Intègre l'environnement graphique Photon, proche de X window System

Taha BEN SALAH (2011) v0.7 - ENISO

ΜCOS / μCOS 2

Développé par le Canadien Jean J. Labrosse

Destiné à des environnements de très petite taille construits autour de micro-contrôleurs.

Il est maintenant disponible sur un grand nombre de processeurs et peut intégrer des protocoles standards comme TCP/IP (µC/IP) pour assurer une connectivité IP sur une liaison série par PPP.

Il est utilisable gratuitement pour l'enseignement (voir http ://www.ucos-ii.com)

Taha BEN SALAH (2011) v0.7 - ENISO

Windows CE

Annoncé avec fracas par Microsoft comme le système d'exploitation embarqué qui tue.

Windows CE et ses cousins comme Embedded Windows NT n' pour l'instant pas détrôné les systèmes embarqués traditionnels Victime d' réputation de fiabilité approximative,

Windows CE CE est pour l'instant cantonné à l'équipement de nombreux assistants personnels ou PDA.

Taha BEN SALAH (2011) v0.7 - ENISO

Lynx OS

LynxOS est développé par la société LynuxWorks http ://www.lynuxworks.com qui a modifié son nom de part son virage vers LINUX avec le développement de Blue Cat

Ce système temps réel est conforme à la norme POSIX.

Taha BEN SALAH (2011) v0.7 - ENISO

Nucleus

Nucleus est développé par la société Accelerated Technology Inc (http ://www.acceleratedtechnology.com).

Il est livré avec les sources et il n' pas de royalties à payer pour la resitribution

Taha BEN SALAH (2011) v0.7 - ENISO

eCOS

Acronyme pour (Embeddable Configurable Operating system)

Initialement développé par la société Cygnus figure emblématique et précurseur de l'open source professionnel,

Aujourd'hui rattachée à la société Red Hat Software.

Ce système est adapté aux solutions à très faible empreinte mémoire et profondément enfouies.

Son environnement de développement est basé sur LINUX et la chaîne de compilation GNU avec conformité au standard POSIX.

Taha BEN SALAH (2011) v0.7 - ENISO

RT Linux

Linux n'est Temps réél mais des pré- configuration de noyaux (rt-kernel) permettent de bénéficier d'un système temps réél (presque dur)

Elles ajoutent

Des patchs dits « préemptifs » permettant d' améliorer le comportement du noyau LINUX en réduisant les temps de latence de ce dernier.

Changement de l'ordonnanceur

Taha BEN SALAH (2011) v0.7 - ENISO

Versions RT Linux communotaires

Real-Time Application Interface (RTAI), developpée par Université polytechnique de Milan (www.aero.polimi.it/~rtai/)

RTL, developpée par New Mexico Tech et maintenue par FSM Labs, Inc., avec une version libre sous www.rtlinux.org.

Taha BEN SALAH (2011) v0.7 - ENISO

Le noyau temps réél, ses composants et l'application temps réelle doivent s'exécuter dans l'espace mémoire noyau en temps que modules noyau.

Taha BEN SALAH (2011) v0.7 - ENISO

Utilisation de Open Suse en RT

Installation d'une distribution standard

Mise à jour du noyau (via Yast) pour installer le noyau temps réél.

Taha BEN SALAH (2011) v0.7 - ENISO

Dans un environnement de Test, il est préférable de réaliser les développements sur une machine virtuelle

On utilisera VirtualBox : un émulateur de machines Open Source

Taha BEN SALAH (2011) v0.7 - ENISO

Principe de RT Linux ( et RTAI)

Remplacer l'ordonnanceur par défaut

Intercepter les interruption timer et interruptions externes

Execute les parties temps réélles

Ensuite exécute les process dans le temps qui reste

Taha BEN SALAH (2011) v0.7 - ENISO

Les taches Temps réélles sont des modules

S'éxéutent en mode priviligié

=> comme les drivers

Pas d'accès possible au primitives user comme le terminal et les I/O Fichiers

=> Dans une grande appli, nécessité de séparer l'appli en deux parties :un process user et une tache RT

Communication entre mode user et mode noyau via mémoire partagée ou pipes.

Taha BEN SALAH (2011) v0.7 - ENISO

En language C, le point d'entrée est la fonction main.

Dans un module, le point d'entrée est

init_module()

Le lancement du module se fait lors de son chargement avec la commande

Insmod

Taha BEN SALAH (2011) v0.7 - ENISO

Le point de sortie d'un module est

cleanup_module()

Elle est appelée lors du déchargement du module par la commande

rmmod

Taha BEN SALAH (2011) v0.7 - ENISO

Source du premier module

/* hello.c */

#include <linux/kernel.h> #include <linux/module.h> MODULE_LICENSE("GPL"); int init_module(void)

{

printk("Hello world!\n"); /* printk = kernel printf*/ return 0;

}

void cleanup_module(void)

{

printk("Goodbye world!\n"); return;

}

Taha BEN SALAH (2011) v0.7 - ENISO

Compliation

Création d'un make file (appelé kbuild)

Appel de la comand make

Taha BEN SALAH (2011) v0.7 - ENISO

Complation

# Kbuild file

ifeq ($(KERNELRELEASE),)

# Assume the source tree is where the running kernel was built

# You should set KERNELDIR in the environment if it's elsewhere KERNELDIR ?= /lib/modules/$(shell uname -r)/build

# The current directory is passed to sub-makes as argument PWD := $(shell pwd)

modules:

$(MAKE) -C $(KERNELDIR) M=$(PWD) modules modules_install:

$(MAKE) -C $(KERNELDIR) M=$(PWD) modules_install

clean:

rm -rf *.o *~ core .depend .*.cmd *.ko *.mod.c .tmp_versions .PHONY: modules modules_install clean else

# called from kernel build system: just declare what our modules are

obj-m := hello.o endif

Taha BEN SALAH (2011) v0.7 - ENISO

make -f Kbuild

insmod hello.ko

rmmod hello.ko

Printk ecrit dans

system log file /var/log/messages.

Taha BEN SALAH (2011) v0.7 - ENISO

> dmesg -c >& /dev/null

> insmod hello.ko

> dmesg -c

Hello world!

> rmmod hello.ko

> dmesg -c

Goodby world!

Taha BEN SALAH (2011) v0.7 - ENISO

Multi taches

Création de thread

Les pthread (posix thread : pthread_create) ne sont plus applicable

Création de thread noyau

Utilisés dans les module

Lancement à partir de init_module

Traitement en asynchrone (non bloquant)

Taha BEN SALAH (2011) v0.7 - ENISO

Multi taches

Un thread noyau se distingue du pthread par

S'exécute en mode noyau

N'est pas associé à un process

Identifié avec un pid

Taha BEN SALAH (2011) v0.7 - ENISO

Liste des threads

ps ax

Exemple de résultat

2977

?

S

0:02 hald-addon-storage: polling /dev/sdc (every 2 sec)

2981

?

S

0:02 hald-addon-storage: polling /dev/sdd (every 2 sec)

2982

?

S

0:02 hald-addon-storage: polling /dev/sdg (every 2 sec)

2983

?

S

0:02 hald-addon-storage: polling /dev/sdh (every 2 sec)

2984

?

S

0:05 hald-addon-storage: polling /dev/sr0 (every 2 sec)

2985

?

S

0:01 hald-addon-storage: polling /dev/sdf (every 2 sec)

Taha BEN SALAH (2011) v0.7 - ENISO

Fonction à éxécuter

int thread_function(void *data);

Retour

0 : si pas d'erreur

!=0 : core erreur (comme les processà

Paramètres

data : de n'importe quel type (void *) entrée pour la fonction

Taha BEN SALAH (2011) v0.7 - ENISO

Création d'un thread

struct task_struct *kthread_create( int (*threadfn)(void *data), void *data, const char *namefmt, …

);

Retour:

Structure de données définissant le thread thread bloqué, il faut appeler wake_up_process()

Taha BEN SALAH (2011) v0.7 - ENISO

Création d'un thread

struct task_struct *kthread_run( int (*threadfn)(void *data), void *data,

const char *namefmt,

Retour:

);

Structure de données définissant le thread

Taha BEN SALAH (2011) v0.7 - ENISO

Création d'un thread

int kthread_stop(struct task_struct *thread); Retour:

Structure de données définissant le thread

Taha BEN SALAH (2011) v0.7 - ENISO

Associer à un processeur

void kthread_bind( struct task_struct *k, unsigned int cpu );

Taha BEN SALAH (2011) v0.7 - ENISO

Kernel-rt (PREEMPT RT)

#include <linux/kernel.h> #include <linux/module.h> #include <linux/kthread.h> #include <linux/delay.h> MODULE_LICENSE("GPL");

int my_thread_function(void * data){

int x=100;

for(i=0;i<x;i++){

int i;

printk("Hello world : thread %d !\n",i); ssleep(1);

}

printk("Exit!\n");

return 0;

}

int init_module(void){ printk("Hello world!\n"); /* printk = kernel printf, to the console */ kthread_run(my_thread_function,NULL,"my_kernel_thread"); return 0;

}

void cleanup_module(void){ printk("Goodbye world!\n"); return;

}

Taha BEN SALAH (2011) v0.7 - ENISO

Création du thread

#include <pthread.h> int pthread_create(pthread_t * thread, pthread_attr_t * attr, void * (*thread_code)(void *), void * arg); thread : structure de données contenant les données du thread attr : structure de données contenant les attribut de création du thread thread_code : la fonction à exécuter par le thread arg : les arguments éventuels à passer à la fonction

Taha BEN SALAH (2011) v0.7 - ENISO

Création du thread

pthread_attr_t thread_attr;

if (pthread_attr_init (&thread_attr) != 0) {

fprintf (stderr, "pthread_attr_init error");

exit (1);

}

if (pthread_attr_setdetachstate (&thread_attr, PTHREAD_CREATE_DETACHED) != 0) {

fprintf (stderr, "pthread_attr_setdetachstate error");

exit (1);

}

Taha BEN SALAH (2011) v0.7 - ENISO

#include <stdio.h> #include <stdlib.h> #include <pthread.h>

void *my_thread_process (void * arg)

{

 

int i; pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL); for (i = 0 ; i < 5 ; i++) { printf ("Thread %s: %d\n", (char*)arg, i); sleep (1); pthread_testcancel ();

}

}

Taha BEN SALAH (2011) v0.7 - ENISO

main (int ac, char **av)

{

 

pthread_t th1, th2; void *ret; if (pthread_create (&th1, NULL, my_thread_process, "1") < 0) { fprintf (stderr, "pthread_create error for thread 1\n"); exit (1);

}

sleep (2); if (pthread_cancel (th1) != 0) { fprintf (stderr, "pthread_cancel error for thread 1\n"); exit (1);

}

(void)pthread_join (th1, &ret);

}

Taha BEN SALAH (2011) v0.7 - ENISO

#include <rtl.h> #include <time.h> #include <pthread.h> pthread_t thread; void * thread_code(void){ pthread_make_periodic_np(pthread_self(), gethrtime(), 1000000000); while (1){ pthread_wait_np (); rtl_printf("Hello World\n");

}

return 0;

}

int init_module(void) { return pthread_create(&thread, NULL, thread_code, NULL);

}

void cleanup_module(void) {

pthread_delete_np(thread);

}

Taha BEN SALAH (2011) v0.7 - ENISO

Initialisation du thread

int pthread_make_periodic_np(pthread_t thread, hrtime_t start_time, hrtime_t period);

Taha BEN SALAH (2011) v0.7 - ENISO

Synchronisation avec

Mutex

Testandset

Sémaphore

Taha BEN SALAH (2011) v0.7 - ENISO

#include <stdio.h> #include <stdlib.h> #include <pthread.h>

static pthread_mutex_t my_mutex; static int tab[5];

Taha BEN SALAH (2011) v0.7 - ENISO

void *read_tab_process (void * arg)

{

 

int i;

pthread_mutex_lock (&my_mutex); for (i = 0 ; i != 5 ; i++) printf ("read_process, tab[%d] vaut %d\n", i, tab[i]); pthread_mutex_unlock (&my_mutex); pthread_exit (0);

}

Taha BEN SALAH (2011) v0.7 - ENISO

void *write_tab_process (void * arg){ int i; pthread_mutex_lock (&my_mutex); for (i = 0 ; i != 5 ; i++) {

tab[i] = 2 * i; printf ("write_process, tab[%d] vaut %d\n", i, tab[i]);

sleep (1); /* Relentit le thread d'ecriture

*/

}

pthread_mutex_unlock (&my_mutex);

pthread_exit (0);

}

Taha BEN SALAH (2011) v0.7 - ENISO

main (int ac, char **av){ pthread_t th1, th2; void *ret; pthread_mutex_init (&my_mutex, NULL); if (pthread_create (&th1, NULL, write_tab_process, NULL) < 0) { fprintf (stderr, "pthread_create error for thread 1\n"); exit (1);

}

if (pthread_create (&th2, NULL, read_tab_process, NULL) < 0) { fprintf (stderr, "pthread_create error for thread 2\n");

exit (1);

}

(void)pthread_join (th1, &ret);

(void)pthread_join (th2, &ret);

}

Taha BEN SALAH (2011) v0.7 - ENISO

P/V (proberen/verhogen)

Puis-je /Vas-y wait/release

acquire/release

down/up

pend/post

Taha BEN SALAH (2011) v0.7 - ENISO

P(){

while(s==0){/*wait*/}

s

:= s-1

}

V(){

s

:= s+1

}

Taha BEN SALAH (2011) v0.7 - ENISO

Taha BEN SALAH (2011) v0.7 - ENISO

#include <stdio.h>

#include <stdlib.h>

#include <pthread.h>

#include <semaphore.h>

static sem_t my_sem; int the_end;

Taha BEN SALAH (2011) v0.7 - ENISO

void *thread1_process (void * arg){ while (!the_end) { printf ("Je t'attend !\n"); sem_wait (&my_sem);

}

printf ("OK, je sors !\n"); pthread_exit (0);

}

Taha BEN SALAH (2011) v0.7 - ENISO

void *thread2_process (void * arg){ register int i; for (i = 0 ; i < 5 ; i++) { printf ("J'arrive %d !\n", i); sem_post (&my_sem); sleep (1);

}

the_end = 1; sem_post (&my_sem); /* Pour debloquer le dernier sem_wait */ pthread_exit (0);

}

Taha BEN SALAH (2011) v0.7 - ENISO

main (int ac, char **av){ pthread_t th1, th2; void *ret; sem_init (&my_sem, 0, 0); if (pthread_create (&th1, NULL, thread1_process, NULL) < 0) { fprintf (stderr, "pthread_create error for thread 1\n"); exit (1);

}

if (pthread_create (&th2, NULL, thread2_process, NULL) < 0) { fprintf (stderr, "pthread_create error for thread 2\n"); exit (1);

}

(void)pthread_join (th1, &ret); (void)pthread_join (th2, &ret);

}

Taha BEN SALAH (2011) v0.7 - ENISO