Vous êtes sur la page 1sur 128

UNIVERSITE DE M’SILA

FACULTE DES MATHEMATIQUES ET DE L'INFORMATIQUE

Département d'informatique
N°d’ordre :............................

MÉMOIRE
Présenté pour l'obtention du diplôme de Magistère

Spécialité : Informatique

Option : Informatique Répartie et Réseaux Mobiles (IRM)

Ordonnancement Temps Réel des Tâches dans un Système


Industriel par Intégration d’une loi de Régulation Automatique

Par : Mr. HAMID Rabah

Soutenu publiquement le 04 /07/ 2013 devant le jury composé de

Mr. BOUDERAH Brahim Professeur à l’université de M’Sila Président

Mr. LOUDINI Malik Maître de Conférences A à l’ESI Rapporteur

Mr. B BOURAHLA Mustapha Maître de Conférences A à l’université de M’Sila Examinateur

Mr. HIDOUCI Walid Khaled Maître de Conférences A à l’ESI Examinateur

Année universitaire 2012 /2013


Remerciements

Je remercie Dieu le tout puissant, qui m’a donné la force et la patience pour
l’accomplissement de ce travail.

Je tiens à exprimer ma gratitude à monsieur Malik LOUDINI pour son


orientation, supervision et sa patience. Le travail sous sa supervision a été une
expérience de confiance.

Je tiens tout d’abord à exprimer ma reconnaissance envers les membres du jury


pour l’intérêt qu’ils ont porté à ce mémoire en acceptant d’en être examinateurs. Je
remercie Monsieur B. BOUDERAH, d’avoir accepté de présider le jury. Je remercie
également Monsieur M .BOURAHLA et Monsieur M. HIDOUCI, d’avoir accepter la
charge d’évaluer en qualité d’examinateurs les travaux réalisés.

Je tiens à remercier et aussi à exprimer ma gratitude à monsieur ABBAS Akli


pour son effort, et sa guidance. Je le remercie pour son aide et sa disponibilité.

Enfin, je tiens à remercier tous ceux qui ont contribué de près ou de loin à
l’aboutissement de ce travail.
Dédicaces

A ma famille
et mes amis
Sommaire

Liste des figures ................................................................................................................................. I


Liste des tableaux ........................................................................................................................... III
Résumé : ...............................................................................................................................................V
Introduction générale ..................................................................................................................... 1
Chapitre I Ordonnancement Temps Réel des Tâches ....................................................... 3
I. 1 Introduction .................................................................................................................................. 4
I. 2 Contrôle des procédés .................................................................................................................. 4
I. 2. 1 Les procédés à dynamique lente........................................................................................................... 5
I. 2. 2 Les procédés à dynamique rapide ........................................................................................................ 5
I. 3 Les systèmes temps réels .............................................................................................................. 6
I. 3. 1 L’exécutif temps réel ............................................................................................................................. 6
I. 3. 2 Classification des systèmes temps réel ................................................................................................. 7
I. 4 Ordonnancement des systèmes de tâches temps réel ............................................................... 10
I. 5 Modélisations des tâches temps réel ........................................................................................ 11
I. 5. 1 Modélisation des tâches périodiques ................................................................................................ 11
I. 5. 2 Modélisation des tâches non périodiques .......................................................................................... 13
I. 6 Classes des problèmes d’ordonnancement temps réel .............................................................. 15
I. 7 Contexte d’ordonnancement ...................................................................................................... 16
I. 8 Approches d’ordonnancement ................................................................................................... 18
I. 8. 1 Approche en ligne ............................................................................................................................... 18
I. 8. 2 Approche hors ligne ............................................................................................................................ 19
I. 9 Algorithmes de l'approche en ligne ............................................................................................ 19
I. 9. 1 Algorithmes à priorité statique........................................................................................................... 19
I. 9. 2 Algorithmes à priorité dynamique ...................................................................................................... 21
I. 10 Limite de l’ordonnancement classique ..................................................................................... 23
I. 10. 1 Connaissance des paramètres temporels ......................................................................................... 23
I. 10. 2 Politique d’affectation des priorités ................................................................................................. 24
I. 10. 3 Environnement dynamique............................................................................................................... 24
I. 11 Conclusion ................................................................................................................................. 25
Chapitre II Ordonnancement par commande de rétroactive .................................. 26
II. 1 Introduction ............................................................................................................................... 27
II. 2 Lois de commande ..................................................................................................................... 27
II. 3 Le feedback scheduling .............................................................................................................. 28
II. 4 Les travaux sur feedback scheduling ......................................................................................... 28
II. 5 Le feedback scheduler d’Eker et all. .......................................................................................... 31
II. 5. 1 L’architecture du feedback scheduler proposée par EKer. ................................................................ 32
II. 5. 2 Formulation du problème.................................................................................................................. 33
II. 6 Le feedback scheduler de Cervin et Eker ................................................................................... 33
II. 7 Le feedback scheduler de Cervin et all ...................................................................................... 36
II. 7. 1 EDF Vs Feedback scheduling ............................................................................................................ 36
II. 7. 2 Limite de l’étude ................................................................................................................................ 36
II. 8 Control server Model de Cervin .............................................................................................. 37
II. 9 Le feedback scheduling de Xia et all. ......................................................................................... 38
II. 9. 1 Modèles de tâches............................................................................................................................. 38
II. 9. 2 Description du feedback scheduler de Xia ......................................................................................... 39
II. 9. 3 Gestion de la surcharge ..................................................................................................................... 39
II. 10 Fuzzy feedback scheduling ...................................................................................................... 40
II. 11 Conclusion................................................................................................................................ 42
Chapitre III Présentation de la logique floue et de la commande floue. ................... 26
III. 1 Introduction.............................................................................................................................. 44
III. 2 Logique classique et logique floue ........................................................................................... 44
III. 3 Concepts et définitions............................................................................................................. 46
III. 3. 1 Sous ensembles flous (SEFs) ............................................................................................................. 46
Sommaire

III. 3. 2 Opérations sur les sous ensembles flous (SEFs) ............................................................................... 48


III. 3. 3 Variables linguistiques ..................................................................................................................... 49
III. 3. 4 Relations floues ................................................................................................................................ 50
III. 3. 5 Proposition floue .............................................................................................................................. 51
III. 4 Commande Floue ..................................................................................................................... 54
III. 4. 1 Description générale d’un contrôleur flou ....................................................................................... 56
III. 4. 2 Base de connaissances ..................................................................................................................... 58
III. 4. 3 Mise en forme des entrées ............................................................................................................... 58
III. 4. 4 Interface de fuzzification.................................................................................................................. 58
III. 4. 5 Procédure d’inférence ...................................................................................................................... 60
III. 4. 6 Interface de défuzzification.............................................................................................................. 61
III. 4. 7 Mise en forme de la sortie ............................................................................................................... 64
III. 5 Conclusion ................................................................................................................................ 64
Chapitre VI Approche incluant un contrôle rétroactif flou pour l'ordonnancement
régulé des tâches temps réel. .................................................................................................... 65
IV. 1 Introduction ............................................................................................................................. 65
IV. 2 Le problème d’ordonncement par rétroaction ........................................................................ 65
IV. 3 Modélisation ............................................................................................................................ 68
IV. 3. 1 Modélisation temporelle des tâches ................................................................................................ 68
IV. 3. 2 Autres paramètres temporelle des tâches ....................................................................................... 69
IV. 4 Les critères de performances ................................................................................................... 70
IV. 5 Ordonnancement par rétroaction se basant sur le rééchelonnement des périodes .............. 73
IV. 6 Ordonnancement par rétroaction se basant sur la logique floue............................................ 76
IV. 6. 1 Architecture...................................................................................................................................... 76
IV. 6. 2 Conception du régulateur d’ordonnancement flou .......................................................................... 78
IV. 7 Conclusion ................................................................................................................................ 87
Chapitre V Implémentation et Résultats............................................................................... 88
V. 1 Introduction ............................................................................................................................... 89
V. 2 L’environnement de développement et de simulation............................................................. 89
V. 3 Extension de TrueTime .............................................................................................................. 92
V. 3. 1 Implémentation de générateur aléatoire de durées d’exécution ...................................................... 93
V. 3. 2 Implémentation du régulateur d’ordonnancement ( feedback scheduler)........................................ 93
V. 3. 3 Implémentation de l’estimateur ........................................................................................................ 94
V. 3. 4 Implémentation du contrôleur PID ................................................................................................... 94
V. 3. 5 Implémentation du régulateur d’ordonnancement flou................................................................... 95
V. 4 Description du système ............................................................................................................. 95
V. 4. 1 Description de procédés .................................................................................................................... 95
V. 4. 2 Description des tâches de contrôle .................................................................................................... 96
V. 4. 3 Modèle temporel des tâches de contrôle ......................................................................................... 97
V. 4. 4 Modèle temporel de la tâche régulateur d’ordonnancement ........................................................... 97
V. 5 Simulations ................................................................................................................................ 97
V. 5. 1 Politique d’ordonnancement DM ...................................................................................................... 98
V. 5. 2 Politique d’ordonnancement EDF .................................................................................................... 107
V. 6 Conclusion ............................................................................................................................... 109
Conclusion générale ...................................................................................................................110
Liste des figures

Liste des figures

Figure 1. Schéma général d'un procédé contrôlé ...................................................................................... 4


Figure 2 Schéma d’ordonnancement d'une tâche périodique .........................................................13
Figure 3 . L'architecture d'un système de commande par rétroaction ..........................................27
Figure 4 Architecture du feedback scheduler de Eker...........................................................................32
Figure 5. Structure du feedback scheduler .................................................................................................34
Figure 6. Architecture du feedback scheduling de XIA ..........................................................................39
Figure 7.Classification des températures d’une pièce en deux sous ensembles ..........................45
Figure 8. Représentation de l'âge par des sous-ensembles flous ......................................................47
Figure 9. Variables linguistiques (V, T(V), X) pour décrire la température .................................49
Figure 10. Représentation de la relation x approximativement égal à 3......................................50
Figure 11 : Schéma synoptique général d’un CF appliqué à la commande d’un processus..56
Figure 12 : Exemple de fuzzification d’une valeur numérique précise...........................................59
Figure 13: Exemple de fonctions d’appartenance triangulaires.......................................................60
Figure 14 : Illustration de la méthode de raisonnement de Mamdani pour deux règles .......61
Figure 15 : Exemple de défuzzification par la méthode de la hauteur ..........................................62
Figure 16 Exemple d’application des variantes de la méthode de la hauteur ...........................62
Figure 17. Illustration de la défuzification par la méthode du centre de gravité .....................63
Figure 18.Illustration de la défuzzification par la méthode du centre des aires .......................63
Figure 19 Illustration de la défuzzification par la méthode du centre des maxima ................64
Figure 20. Système de contrôle temps réel avec plusieurs tâches concurrentes ........................66
Figure 21. Ordonnancement par rétroaction............................................................................................67
Figure 22. Paramètres temporels des tâches ............................................................................................70
Figure 23. Caractéristiques temporelles de la réponse d'un processus..........................................72
Figure 24 Feedback Scheduler de Antoine Cervin ...................................................................................75
Figure 25. Régulation floue d'ordonnancement de tâches temps réel ...........................................77
Figure 26. Structure interne du régulateur (gestionnaire) d'ordonnancement floue.............78
Figure 27. Les variables d’entrés E et DE (e et de) ..................................................................................80
Figure 28. La variable de sorties R (lambda λ) ........................................................................................80
Figure 29. Les variables d’entrés E et D (e et de).....................................................................................80
Figure 30. La variable de sorties R (lambda λ) ........................................................................................81
Figure 31. Les variables d’entrés E et D (e et de).....................................................................................81
Figure 32. La variable de sorties R (lambda λ) ........................................................................................81
Figure 33. Inférence floue avec des fonctions d'appartenance de forme triangulaire ............82
Figure 34. Inférence floue avec des fonctions d'appartenance en forme de cloche ..................82
Figure 35. Inférence floue avec des fonctions d'appartenance en forme de cloche ..................83
La Figure 36 et Figure 37ci-dessous illustrent les fonctions d'appartennace sous forme
triangulaire..............................................................................................................................................................84
Figure 39. Les variables d’entrés E et D (e et de) avec cinq valeurs linguistiques ....................85
Figure 40. La variable de sorties R (lambda λ) ........................................................................................85
Figure 40. Inférence floue avec des fonctions en forme triangulaire..............................................86
Figure 41. Inférence floue avec des fonctions en forme de cloche ....................................................86
Figure 42. Blocs disponibles dans TrueTime 2.0 beta 4. ......................................................................89
Figure 43. Ordonnancement de trois tâches de contrôle .....................................................................90
Figure 44. Exemple de modèle proposé avec Truetime 2.0 .................................................................90
I
Liste des figures

Figure 45. Performance de contrôle des trois tâches de contrôle ....................................................91


Figure 47. Performance des 3 contrôleurs PID avec des périodes nominales (figure a) et
avec des périodes rééchelonnées (figure b)................................................................................................94
Figure 47. Graphe d’ordonnancement des 4 tâches avec Ci fixe ........................................................98
Figure 48. U et Uref selon l’algorithme de rééchelonnement des périodes ....................................99
Figure 49. Graphe d’ordonnancement des 4 tâches avec Ci variables......................................... 100
Figure 50. U et Uref selon l’algorithme de rééchelonnement des périodes avec Ci variables
.................................................................................................................................................................................... 100
Figure 51. U vs Uref avec 3 valeurs linguistiques et fonctions d'appartenance sous forme
triangulaire........................................................................................................................................................... 101
Figure 52. U vs Uref avec 3 valeur linguistiques et fonctions d'appartenance sous forme de
cloche ....................................................................................................................................................................... 102
Figure 53. U vs Uref avec 3 variables et fonctions d'appartenance en forme trapézoïdale . 102
Figure 54. U vs Uref avec 5 valeurs linguistiques sous forme triangulaire ................................. 103
Figure 55. U vs Uref avec 5 variables et fonctions d'appartenance sous forme de cloche .... 104
Figure 56. U vs Uref sous R-FBS et 3V-FBS-Tri ........................................................................................ 105
Figure 57. U vs Uref sous R-FBS et 5V-FBS-Tri ........................................................................................ 106
Figure 58. U vs Uref sous R-FBS et 5V-FBS-Tri avec EDF et Ci fixes .............................................. 107
Figure 59. U vs Uref sous R-FBS et 5V-FBS-Tri avec EDF et Ci variables ...................................... 108

II
Liste des tableaux

Liste des tableaux

Tableau 1. Paramètres temporals des tâches ...........................................................................................13


Tableau 2 . les termes d’un contexte d’étude d’ordonnancement.....................................................17
Tableau 3. Signifiant des paramètres de performance à étudier .....................................................71
Tableau 4. Base de règles avec trois valeurs linguistiques ..................................................................83
Tableau 5. Base de règles avec cinq valeurs linguistiques...................................................................85
Tableau 6. Les valeurs d’initialisation du PID...........................................................................................96
Tableau 7. Configuration des tâches de contrôle ....................................................................................97
Tableau 8. Comparaison des performances de contrôle avec R-FBS et sans R-FBS .................99
Tableau 9. Performances de contrôle avec ci fixe et variable sous R-FBS.................................. 101
Tableau 10. Performances de contrôle avec 3 valeurs linguistiques et R-FBS ........................ 103
Tableau 11 Performances de contrôle sous 5 valeurs linguistiques en forme triangulaire et
R-FBS ....................................................................................................................................................................... 104
Tableau 12. Performances de contrôle avec 3, 5 valeurs linguistiques et R-FBS avec Ci
variables ................................................................................................................................................................. 106
Tableau 13. Performances de contrôle avec 5V-FBS- Tri et R-FBS avec EDF........................... 108

III
Résumé

:‫ﻣﻠﺨﺺ‬
‫" ( ﻋﻦ ﻁﺮﻳﻖ‬contrôle des procédés" ) ‫ﺑﺪﺃﻧﺎ ﺩﺭﺍﺳﺘﻨﺎ ﻋﻦ ﻁﺮﻳﻖ ﺗﻘﺪﻳﻢ ﻣﻔﺎﻫﻴﻢ ﺍﻟﺘﺤﻜﻢ ﻓﻲ ﺍﻟﻌﻤﻠﻴﺎﺕ‬
‫'( ﻭﻛﺬﻟﻚ ﺍﻟﻤﻔﺮﺩﺍﺕ‬temps réel') ‫ ﺃﻭﻻ ﺑﺘﺴﻠﻂ ﺍﻟﻀﻮء ﻋﻠﻰ ﺍﻟﻤﻔﺎﻫﻴﻢ ﺍﻟﻤﺘﻌﻠﻘﺔ ﺑﺎﻟﻮﻗﺖ ﺍﻟﺤﻘﻴﻘﻲ‬.‫ﺍﻟﻜﻤﺒﻴﻮﺗﺮ‬
‫ ﺍﻷﻭﻟﻲ ﺗﻤﺜﻠﺖ ﻓﻲ ﺟﺪﻭﻟﺔ ﺍﻟﻤﻬﺎﻡ ﻓﻲ‬،‫ ﻗﺪﻣﻨﺎ ﺣﺎﻟﺘﻴﻦ ﻣﻦ ﺍﻟﻔﻦ‬،‫ ﻭﺑﻌﺪ ﺫﻟﻚ‬.‫ﺍﻟﻤﻠﺤﻘﺔ ﻭ ﺫﺍﺕ ﺍﻟﺼﻠﺔ ﺑﻬﺬﺍ ﺍﻷﺧﻴﺮ‬
‫"( ﻭﺍﻟﺜﺎﻧﻴﺔ ﺗﻤﺜﻠﺖ ﻓﻲ‬l’ordonnancement temps réel classique " ) ‫ﺍﻟﻮﻗﺖ ﺍﻟﺤﻘﻴﻘﻲ ﺍﻟﻜﻼﺳﻴﻜﻲ‬
l’ordonnancement régulé ou par contrôle ") ‫ﺟﺪﻭﻟﺔ ﺍﻟﻤﻬﺎﻡ ﻋﻦ ﻁﺮﻳﻖ ﻣﺮﺍﻗﺒﺔ ﺭﺩﻭﺩ ﺍﻟﻔﻌﻞ‬
. ("rétroactif

‫ﻓﻲ ﺍﻗﺘﺮﺍﺡ ﻁﺮﻳﻘﺔ ﻟﺠﺪﻭﻟﺔ ﺍﻟﻤﻬﺎﻡ ﻓﻲ ﺍﻟﻮﻗﺖ ﺍﻟﺤﻘﻴﻘﻲ ﻓﻲ‬،‫ﻭﺃﻳﻀﺎ ﻓﻲ ﻋﻤﻠﻨﺎ ﻣﻬﺘﻤﻮﻥ ﻓﻲ ﺃﻭﻝ ﺍﻷﻣﺮ‬
‫ ﻭﺿﻌﻨﺎ ﻓﻲ ﺗﻔﺎﺻﻴﻠﻬﺎ ﺍﻷﺩﻟﺔ ﻭﻧﻬﺠﻨﺎ ﻓﻴﻤﺎ ﻳﺘﻌﻠﻖ ﺑﺈﺩﺭﺍﺝ ﻋﻨﺼﺮ ﺗﺤﻜﻢ ﺭﺩﻭﺩ ﺍﻟﻔﻌﻞ ﻋﻦ ﻁﺮﻳﻖ‬.‫ﺍﻟﻌﻤﻠﻴﺔ‬
‫ ﻓﻲ ﺍﻟﺨﻄﻮﺓ‬.‫ﺍﻟﻤﻨﻄﻖ ﺍﻟﻀﺒﺎﺑﻲ ﻟﻀﺒﻂ ﺇﻋﺪﺍﺩﺍﺕ ﺍﻟﻤﻬﺎﻡ ﺍﻟﺘﻲ ﺗﺘﻤﻴﺰ ﺏﺍﺧﺘﻼﻑ ﻣﺪﺓ ﺗﻨﻔﻴﺬﻫﺎ ﻋﻠﻰ ﻣﺮ ﺍﻟﺰﻣﻦ‬
‫ ﻭﻛﺬﻟﻚ ﻧﺘﺎﺋﺞ ﺍﻟﻤﺤﺎﻛﺎﺓ ﻭﺍﻟﻌﺮﻭﺽ ﺍﻟﺘﻲ‬TrueTime ‫ ﻭﻗﺪ ﻗﺪﻣﻨﺎ ﻓﻲ ﺗﻔﺎﺻﻴﻞ ﺍﻟﺘﻨﻔﻴﺬ ﻓﻲ ﺑﻴﺌﺔ ﺍﻷﻋﻤﺎﻝ‬،‫ﺍﻟﺜﺎﻧﻴﺔ‬
. ‫ﺗﻢ ﺍﻟﺤﺼﻮﻝ ﻋﻠﻴﻬﺎ‬

.‫ ﺍﻟﻤﻨﻄﻖ ﺍﻟﻀﺒﺎﺑﻲ‬،‫ ﺍﻟﺘﺤﻜﻢ ﺍﻵﻟﻲ ﺍﻟﻘﻮﺍﻧﻴﻦ‬،‫ ﺍﻟﻮﻗﺖ ﺍﻟﺤﻘﻴﻘﻲ ’ﺟﺪﻭﻟﺔ ﺍﻟﺘﺤﻜﻢ‬:‫ﻛﻠﻤﺎﺕ ﺍﻟﺒﺤﺚ‬

Abstract

W
e started our study by presenting concepts related to control process. We
reveal notions related to real time as well as the vocabulary relating
thereto. Then, we presented two states of the art. The first concern the
classical real-time scheduling and the second concern the feedback
scheduling. In our work we are interested in a first step, by proposing a
method for real-time tasks scheduling in a process. We put in evidence the details of our
approach with respect to the inclusion of a fuzzy feedback control to adjust the tasks
parameters which characterized by execution times varying over time. In a second step, we
have presented the details of our implementation done in TrueTime simulator environment
as well as simulation results and performances.

Key words: Real-Time, feedback scheduling, automatic control laws, Fuzzy logic.

IV
Résumé

Résumé :

N
ous avons commencé notre étude par la présentation des différents
concepts relatifs au contrôle des procédés par ordinateur. Nous avons
mis en évidence, des notions ayant trait au temps réel ainsi que le
vocabulaire y afférant. Par la suite, nous avons présenté deux états de
l’art, l’un sur l’ordonnancement temps réel classique et l’autre sur l’ordonnancement
régulé ou par contrôle rétroactif ("feedback scheduling"). Dans notre travail nous nous
sommes intéressés, dans un premier temps, à la proposition d’une méthode pour
l’ordonnancement des tâches temps réel d’un procédé. Nous avons mis en évidence les
détails de notre approche ayant trait à l’inclusion d’un contrôle rétroactif par logique floue
afin d'ajuster les paramètres des tâches caractérisées par la variation de leurs durées
d’exécution dans le temps. Dans un second temps, nous avons présenté les détails de
l’implémentation entreprise sous l’environnement du simulateur TrueTime ainsi que les
résultats de simulation obtenus et les performances réalisées.

Mots clés : Temps réel, ordonnancement régulé, lois de commande automatique,


Logique floue.

V
Introduction générale

Introduction générale

L
es systèmes temps réel sont de plus en plus présents dans notre quotidien et
connaissent actuellement un essor considérable. Ils sont, aujourd'hui, présents
dans de nombreux secteurs d'activités : transport terrestre (automobile,
ferroviaire, etc.) et aérien, spatial, militaire, robotique, télécommunication,
contrôle des systèmes automatisés de production, etc. Ces systèmes sont
caractérisés par une forte interaction avec les procédés contrôlés avec lesquels ils
interagissent .

Le comportement concurrent des événements externes amène à décrire les procédés


comme des systèmes fortement parallèles. Pour cela, l’architecture la mieux adéquate pour
répondre à ce comportement parallèle est une architecture multitâche. Ainsi, au
parallélisme de l’environnement, la réponse est le parallélisme de conception. En plus, ces
systèmes temps réel communiquent avec ces procédés avec une vitesse qui est imposée par
ces derniers. Donc, ils doivent réagir en temps réel par rapport à ces procédés. Cela
implique la nécessité de faire en sorte que le programme (ou la tâche) respecte des
contraintes temporelles inhérentes à l’environnement. Ainsi, ces systèmes temps réel
nécessitent souvent des tâches périodiques de nature stricte (critique) dont le respect des
échéances est à garantir. Ainsi, les systèmes temps réel se distinguent par leur sensibilité
aux fautes temporelles. Dans un contexte d’application concurrente, les tâches qui
s'exécutent (instances ou travail) sur de tels systèmes ne doivent pas seulement fournir un
résultat correct, mais elles doivent également respecter une échéance pour délivrer ce
résultat. A cet effet, l’ordre dans lequel les tâches s’exécutent est crucial au regard des
contraintes temporelles liées à chaque tâche. Pour trouver une séquence d’exécution des
tâches garantissant le respect des contraintes temporelles, on fera appel à l’utilisation de la
théorie de l’ordonnancement qui permet de s’assurer du bon comportement temporel des
tâches concurrentes durant leurs exécutions. Cependant, dans le cas où les durées
d'exécution des tâches sont variables, la théorie d'ordonnancement temps réel classique
soufre de plusieurs limites. Pour cela, de nombreux chercheurs ont proposé d’utiliser la
théorie de commande par rétroaction (feedback control) pour remédier à ces limites.

1
Introduction générale

En effet, cette solution consistera à adapter en temps réel l'ordonnancement grâce à


un contrôleur agissant dans le cadre d’un système asservi en boucle fermée. L'objectif est
d’ajuster les paramètres d'ordonnancement du système en fonction de certaines mesures.

Nous proposons d’étudier l’intégration de la commande automatique par rétroaction


dans la résolution du problème de l’ordonnancement temps réel des tâches dans les
systèmes industriels.

Notre contribution vise à explorer, les techniques offertes par la commande floue afin
d'ajuster les paramètres des tâches sachant que leurs durées d’exécution changent dans le
temps.

Structure du mémoire

La structuration de ce mémoire s'articule autour des chapitres suivants :

Le chapitre I décrit les procédés contrôlés, la notion du temps réel avec le vocabulaire y
afférant tel que : les exécutifs temps réel, les tâches temps réel et les politiques
d'ordonnancement.

Le chapitre II présente un état de l'art des travaux portant sur l’ordonnancement régulé
(feedback scheduling).

Le chapitres III est dédié à la présentation des concepts, définitions et principes de la


logique floue et de la commande floue.

Dans le chapitre IV, nous présenterons notre contribution. Cette contribution vise à
explorer les techniques offertes par la commande floue afin d'ajuster les paramètres des
tâches sachant que leurs durées d’exécution changent dans le temps.

Le chapitre V donne une description du simulateur utilisé afin de valider notre


contribution. les simulations réalisées et les résultats obtenus y sont illustrés.

2
Chapitre I
Ordonnancement Temps Réel des Tâches
I. 1 Introduction ........................................................................................................................................... 4
I. 2 Contrôle des procédés ....................................................................................................................... 4
I. 2. 1 Les procédés à dynamique lente ........................................................................................... 5
I. 2. 2 Les procédés à dynamique rapide ........................................................................................ 5
I. 3 Les systèmes temps réels ................................................................................................................. 6
I. 3. 1 L’exécutif temps réel .................................................................................................................. 6
I. 3. 2 Classification des systèmes temps réel............................................................................... 7
I. 4 Ordonnancement des systèmes de tâches temps réel........................................................ 10
I. 5 Modélisations des tâches temps réel ....................................................................................... 11
I. 5. 1 Modélisation des tâches périodiques .............................................................................. 11
I. 5. 2 Modélisation des tâches non périodiques ...................................................................... 13
I. 6 Classes des problèmes d’ordonnancement temps réel ...................................................... 15
I. 7 Contexte d’ordonnancement ........................................................................................................ 16
I. 8 Approches d’ordonnancement .................................................................................................... 18
I. 8. 1 Approche en ligne .................................................................................................................... 18
I. 8. 2 Approche hors ligne ................................................................................................................ 19
I. 9 Algorithmes de l'approche en ligne ........................................................................................... 19
I. 9. 1 Algorithmes à priorité statique .......................................................................................... 19
I. 9. 2 Algorithmes à priorité dynamique .................................................................................... 21
I. 10 Limite de l’ordonnancement classique .................................................................................. 23
I. 10. 1 Connaissance des paramètres temporels .................................................................... 23
I. 10. 2 Politique d’affectation des priorités ............................................................................... 24
I. 10. 3 Environnement dynamique ............................................................................................... 24
I. 11 Conclusion......................................................................................................................................... 25
Chapitre I Ordonnancement Temps Réel des Tâches

I. 1 Introduction

L'
utilisation de l'ordinateur dans les systèmes automatisés a pris une grande
place dans le monde industriel ces deux dernières décennies. L'ordinateur
sous des formes très variées, du contrôleur aux calculateurs industriels, est
installé partout, dont les procédés simples tel que le contrôle d'une caméra,
et dont les procédés complexes tel que le pilotage d'un avion. L'ordinateur
doit garder l'œil sur le procédé contrôlé pour avoir à tout instant son état réel c'est-à-dire
que les réactions doivent se faire dans un temps prédictible ou en d'autres termes en
temps réel, et le fait de perdre l'œil sur le procédé à un instant donné peut amener à des
dégâts considérables tel que le crash d'un avion, ou la perte du contrôle sur un élément
d'un réacteur nucléaire, c'est le cas du temps réel dur (ou strict).

Dans ce chapitre, nous présentons les procédés contrôlés et leurs relations avec
l’ordinateur. Nous présentons aussi la notion du temps réel avec le vocabulaire y afférant
tel que : les exécutifs temps réel, les tâches temps réel et ordonnancement et les deux
grandes approches d'ordonnancement : l’approche en ligne et l’approche hors ligne, ainsi
que quelques algorithmes d’ordonnancement pour chaque approche.

I. 2 Contrôle des procédés

Les procédés informatisés sont généralement constitués de deux éléments essentiels : le


procédé lui-même dont on peut connaître l’état via un ou plusieurs capteurs, et le
contrôleur (ex : calculateur industriel, automate programmable) disposant d'une
application informatique, lisant les informations mises à disposition par les capteurs, et
exécute des portions de codes fonctionnant en parallèle (partage de temps processeur),
appelées tâches. Le rôle du système de contrôle est d’acquérir des informations sur l’état
du procédé afin de le commander via des actionneurs. La Figure 1 montre le schème
général d'un procédé informatisé.
Capteurs

Contrôleur Procédé
Actionneurs

Figure 1. Schéma général d'un procédé contrôlé

4
Chapitre I Ordonnancement Temps Réel des Tâches

La connaissance de la vitesse d'évolution du procédé est très importante lors de la


conception de l'application informatique temps réel (c.à.d. le contrôleur). Pour cela, on
distingue deux types de procédés :les procédés à dynamique lente, et les procédés à
dynamiques rapides [AST 97].

I. 2. 1 Les procédés à dynamique lente

Un procédé à dynamique lente est caractérisé par :

 Son évolution relativement lente par rapport à la vitesse d’exécution des tâches par le
contrôleur.
 La vitesse du contrôleur est sensiblement plus rapide que le procédé physique.
 Le temps séparant deux événements en provenance du procédé est relativement élevé,
comparé à la vitesse d’exécution des tâches par le contrôleur où cette dernière est
considérée comme nulle.
 L'absence des problèmes liés aux exclusions mutuelles. L'ordre d'exécution des tâches
n'est plus important.
 La simplicité de programmation.

I. 2. 2 Les procédés à dynamique rapide

Un procédé à dynamique rapide est caractérisé par :

 La grande fréquence d'apparition d'événements provenant du procédé. Chaque tâche


nécessite une durée d'exécution qui ne peut être négligée.
 L'utilisation impérative, en général, de la technique de préemption(c.à.d. action de
suspendre temporellement une tâche qui utilise le processeur au profit d'une autre
tâche plus prioritaire) pour assurer le pilotage correct du procédé c'est-à-dire que
l'exécution concurrente des différentes tâches du système.
 La prédictibilité de l'application informatique pour que les tâches ne conduisent pas le
procédé en un état indésirable.

Donc, les procédés à dynamique rapide imposent des contraintes temporelles qui
doivent être respectées. Pour un concepteur d’applications temps réels, ces contraintes
sont déduites d'un cahier des charges décrivant le comportement voulu du procédé.

5
Chapitre I Ordonnancement Temps Réel des Tâches

L'ordre d'exécution des tâches temps réels (Ordonnancement) sur le ou les processeurs
est très important pour assurer le respect des différentes contraintes temporelles.

I. 3 Les systèmes temps réels

Les systèmes temps réel sont des systèmes numériques, réactifs, parce qu'ils réagissent
continuellement aux stimuli venant de leur environnement considéré comme externe au
système. Ces systèmes permettent l'implantation d'applications temps réel où le respect
des contraintes temporelles est la principale contrainte à satisfaire [KAR 09].Un tel
système pour qu'il fonctionne correctement doit obligatoirement réagir à chacun des
stimuli qu'il reçoit. La réponse aux stimuli d'entrée ne dépend pas seulement des stimuli
mais aussi de l'état du système quand les stimuli arrivent. L'interface entre un système
temps réel et son environnement est constituée par un ensemble de périphériques d'entrée
appelés capteurs servant à la collecte des signaux émis par l'environnement et de sortie
appelés actionneurs fournissant à l'environnement les commandes du système de contrôle.
La validité des systèmes temps réel ne dépend pas seulement de l’exactitude logique des
calculs (exactitude des traitements) mais aussi de la date à laquelle le résultat est produit
(Exactitude temporelle) [AZZ 04].

Ainsi, un système temps réel doit satisfaire les deux contraintes suivantes :

Exactitude des traitements : calculer les bonnes sorties du système temps réel
(contrôleur) en fonction de ses entrées et de l'état du système physique (procédé).

Exactitude temporelle : les résultats de calcul sont présentés au bon moment (un calcul
juste mais hors délai est un calcul faux). En d'autres termes, un retard est considéré comme
une erreur qui peut entraîner de graves conséquences.

I. 3. 1 L’exécutif temps réel

C'est un système d'exploitation (appelé aussi noyau temps réel ) dans lequel la durée
d'exécution de toute fonction est connue et bien documenté. En général il est caractérisé
par [ATT 97]:

6
Chapitre I Ordonnancement Temps Réel des Tâches

• Le multitâche : c'est une conséquence directe du caractère asynchrone des


événements des procédés physiques contrôlés. Il est important de permettre
l'exécution concurrente de plusieurs tâches.

• L'ordonnancement préemptif : Il existe un ordre de précédence entre les


événements qui doit être respecté par l'ordonnanceur de tâches lors de l'allocation du CPU.

• Disponibilité des outils de communication et de synchronisation rapides et


flexibles : l'exécution concurrente des tâches dans un noyau temps réel impose l'existence
d'outils de communication entre tâches qui soient rapides. Le noyau doit fournir
également un ensemble de mécanismes de synchronisation pour le partage des ressources.

• La gestion des interruptions : le noyau temps réel doit offrir une interface pour
l'interception des interruptions en provenance du monde extérieur.

• Des performance bien fixes (déterministes) : Un noyau temps réel qui permet
d'exécuter constamment une fonction donnée en 50 ms est mieux apprécié qu'un noyau
qui permet d'avoir un temps moyen d'exécution de 10 ms, mais parfois qui prend 75 ms.
Des considérations spéciales sont appréciées : comme l'intégration d'outils de
développement tels Ada et C, la possibilité de supporter certaines architectures.

I. 3. 2 Classification des systèmes temps réel

Les contraintes qui sont imposées par un système temps réel sont relatives au temps,
résultat de l’interaction du système avec son environnement. Et aussi des contraintes
portant sur des ressources à caractères limités et/ou périssables, dont dispose le système,
telles que la mémoire et l’énergie respectivement. À ces contraintes s’ajoutent celles
relatives à la sûreté de fonctionnement et la qualité de contrôle.

a. La contrainte de temps

Un système temps réel communique avec son environnement avec une vitesse qui est
imposée par ce dernier. Il doit prendre certaines décisions ou effectuer certains calculs
dans une durée de temps limitée. Ceci implique des exigences de temps de réponse plus ou
moins fortes selon le domaine d’application visé. Une faute temporelle telle que le
déplacement d’échéance implique des catastrophes dans le système [STA 96].
7
Chapitre I Ordonnancement Temps Réel des Tâches

Compte tenu de l’aspect « respect des contraintes temporelles », on distingue trois types
de systèmes temps réel :

 Système Temps Réel à Contraintes Strictes (dure) (TRCS) : dans cette classe les
tâches sont soumises à des contraintes temporelles strictes. une échéance est associée à
chaque occurrence de tâche (appelée instance). Il serait inadmissible de ne pas
respecter les échéances, car une faute temporelle pourrait être coûteuse au plan
humain ou/et financier.
 Système Temps Réel à Contrainte Relative (souple) (TRCR) : Cette classe de
système temps réel est similaire à la précédente (TRCS). Cependant, le fait de violer
une contrainte temporelle est tolérable, et il entraîne un coût qu'on cherche à
minimiser.
 Système Temps Réel à Contraintes Mixtes (TRCM) : c'est une classe regroupant les
deux classes précédentes i.e. dans un système TRCM on trouve les tâches TRCS et les
tâches TRCR, bien que l'on cherche à éliminer toute faute temporelle pour les
tâches TRCS et de minimiser les fautes temporelles des tâches TRCR .

b. La consommation d’énergie

L’autonomie est un problème majeur pour de nombreux systèmes temps réel en général
dont l’alimentation en énergie est assurée par des batteries, comme par exemple des
assistants intelligents, des robots mobiles, des implants médicaux (pacemaker) ou des
téléphones mobiles. L’augmentation continue des performances et des fonctionnalités de
ces équipements nécessite l’utilisation de composants électroniques fonctionnant à des
fréquences toujours plus élevées et donc consommant de plus en plus d’énergie. Aussi, afin
d’étendre l’autonomie de fonctionnement d’un système temps réel, trois techniques sont
possibles [DEC 03]. La première, consiste à travailler sur la technologie des composants
matériels comme par exemple, augmenter la capacité de stockage des batteries. Quand à la
deuxième, se base sur la réalisation de logiciels à faibles consommations énergétiques par
l’optimisation du code des programmes [NAV 06].La dernière, consiste à utiliser des
techniques dites hybrides basées sur une collaboration entres composants logiciels et
matériels. Dans ce cas, on distingue deux stratégies, la première est la mise en veille du
processeur. La seconde est l’adaptation dynamique de la tension du processeur notée DVS

8
Chapitre I Ordonnancement Temps Réel des Tâches

(pour Dynamic Voltage Scaling), et donc de la fréquence, au besoin courant de l’application


en terme de performance [TIW 94]. Cette dernière stratégie touche principalement
l’ordonnancement qui doit donc, en fonction de la charge du processeur, décider de la
tension la plus basse permettant d’exécuter les traitements. Vu dans un contexte temps-
réel, le problème de minimisation de la consommation énergétique est d’autant plus
difficile que les contraintes temporelles des applications sont à considérer [WEI 94].

c. La mémoire

La mémoire est une ressource limitée pour de nombreux systèmes temps réel (de
quelques kilo-octets pour une carte à puce à quelques méga-octets pour les téléphones
portables), ce qui fait qu’une bonne utilisation de la ressource mémoire est décisive dans
ces systèmes. Dans ce contexte, une difficulté qui s’ajoute dans les systèmes temps réel est
que la gestion de la mémoire soit compatible avec les contraintes temporelles. Bien que de
nombreux systèmes temps réel se limitent à une gestion statique de la mémoire, quelques
études visent à utiliser des techniques de gestion de la mémoire, comme l’allocation et la
libération dynamique de la mémoire [PUA 02].

d. La sûreté de fonctionnement

On désigne par sûreté de fonctionnement d’un système son aptitude à délivrer un


service de confiance justifiée[LAP 04]. On distingue trois entraves à la sûreté de
fonctionnement [GIR 06]: la faute, l'erreur et la défaillance. Une faute est un défaut dans un
composant du système informatique (élément matériel ou logiciel). Une erreur est une
manifestation d'une faute. Une défaillance est un événement qui survient lorsque le service
délivré dévie du service correct, suite à la propagation d'une erreur dans le système.

Certains systèmes temps réel doivent pouvoir remplir leurs fonctions malgré la
présence de fautes. Pour cela, le développement de système garantissant une sûreté de
fonctionnement repose sur l’utilisation conjointe des nombreux moyens suivants [GIR 06] :

 La prévention des fautes : afin d’empêcher l'occurrence ou l'introduction de fautes ;


 La prévision des fautes : sert à estimer la présence, le taux futur et les conséquences
possibles des fautes;

9
Chapitre I Ordonnancement Temps Réel des Tâches

 L’élimination des fautes : sert à réduire le nombre et la sévérité des fautes ;


 La tolérance aux fautes : sert à délivrer des services malgré la présence de fautes.

e. Qualité de Contrôle (QdC)

La Qualité de Contrôle peut être jugée à partir du dépassement dans le cas d’une
réponse à un échelon, de la précision, de la marge de phase, du temps de montée, du temps
de réponse. Un critère de QdC pourra être une combinaison de ces critères.

Considérons une loi de commande établie en temps continu et discrétisée ou établie


directement à temps discret ; la fréquence d’échantillonnage à une influence importante
sur la Qualité de Contrôle. Une limite inférieure de cette fréquence est donnée par le
théorème de Shannon, mais des règles empiriques permettent la détermination de la
période d’échantillonnage h, par exemple dans notre travail nous utiliserons une règle
donnant la période d’échantillonnage h en fonction de la pulsation propre du système
bouclé wn [AST 97]

I. 4 Ordonnancement des systèmes de tâches temps réel

Les systèmes temps réel se distinguent par leurs sensibilités aux fautes temporelles.
Dans un contexte d’application concurrente, où les tâches qui s'exécutent (instances ou
travail) sur de tels systèmes ne doivent pas seulement fournir un résultat correct, mais
elles doivent également respecter une échéance pour délivrer ce résultat. A cet effet, l’ordre
dont lequel les tâches s’exécutent est crucial au regard des contraintes temporelles liées à
chaque tâche. Par exemple, prenons une application composée de 4 tâches indépendantes,
celle-ci peut être exécutée sur un processeur de 24 façons (séquences) différentes. Or si le
résultat de l’application est le même quelque soit la façon dont les tâches ont été exécutées
(tâches indépendantes), le comportement temporelle vas varier considérablement, ce qui
peut empêcher certaines tâches de respecter leurs contraintes temporelles. Pour trouver
une séquence d’exécution de tâches garantissant le respect des contraintes temporelles,
nous ferons appel à l’utilisation de la théorie de l’ordonnancement qui permet de s’assurer
du bon comportement temporel des tâches concurrentes durant leurs exécutions.

L’ordonnancement est le mécanisme permettant de choisir la tâche qui va être exécutée


par le processeur à un instant donné. L’algorithme qui va effectuer ce choix est appelé
10
Chapitre I Ordonnancement Temps Réel des Tâches

l’ordonnanceur (scheduler en anglais). Il existe deux manières d’appeler cet ordonnanceur


: appels à intervalle régulier (par exemple à chaque unité de temps) ou bien appels basés
sur des évènements comme l’arrivée, la fin d’exécution ou l’échéance d’un travail.

A chaque fois qu’il est appelé, l’ordonnanceur va choisir l’instance ou le travail (job en
anglais) d’une tâche qui doit être exécuté au moment de l’appel, si celui-ci existe bien
entendu, car il est probable qu’aucun travail ne soit disponible à cet instant, le processeur
restera alors oisif. Chaque élection d’une nouvelle tâche s’accompagne d’un changement de
contexte, permettant de passer de l’exécution de l’ancienne tâche à la nouvelle. Cette
succession d’élection permet la construction d’une séquence d’ordonnancement [PAI 06].

La problématique de l’ordonnancement dans les systèmes temps réel consiste à définir


une politique adéquate d’attribution des ressources (processeur, …) aux différentes tâches
de l’application garantissant le respect des contraintes temporelles et éventuellement des
d'autres contraintes. En d’autres termes, c’est de définir une politique permettant la
construction d’une séquence d’ordonnancement valide (où toutes les contraintes
considérées sont respectées) de l’ensemble des tâches à exécuter. Cette construction
nécessite, d'une part, la modélisation des tâches, et d'autre part, la définition d'un
algorithme d'ordonnancement. Ce dernier utilise la connaissance sur les tâches afin de
définir la séquence temporelle de leurs exécutions.

I. 5 Modélisations des tâches temps réel

Les tâches temps réel peuvent être périodiques, apériodiques ou sporadiques.

I. 5. 1 Modélisation des tâches périodiques

Une tâche Ti est dite périodique si elle est activée à intervalle de temps régulier. Les
différents paramètres qui sont sur le schéma de la Figure 2 décrivent le modèle d'une tâche
périodique donné par le modèle de Liu et layland [LIU 73]. Les désignations des différents
termes sont groupées dans les définitions suivantes :

Définitions :

Les quatre paramètres suivants, supposés de type entier, caractérisent une tâche temps
réel :

11
Chapitre I Ordonnancement Temps Réel des Tâches

Ti (ri, 0, Ci, Di, hi) (1)

où ri, 0 : est la date de réveil de la premier instance de la tâche Ti.

Ci :est la charge processeur maximale (notée WCET : Worst Case Execution Time)
nécessaire pour accomplir l'exécution d'une occurrence de la tâche Ti .

Di :est le délai critique (échéance) alloué à une tâche pour se terminer après chacune de
ses activations.

hi :est la période d'activation de la tâche Ti, c est-à-dire qu'après chaque hi unités de temps
à partir de ri, 0 ,une occurrence(on dit aussi requête ou instance) aura lieu.

D'après les précédents paramètres, on déduit les paramètres suivants:

 La date de la kième activation de la tâche Ti est :

r i, k = ri, 0 + (k -1) hi (2)

 La kième échéance de Ti est :

di,k =ri,k + Di = ri, 0 + (k-1) hi +Di (3)

 La charge processeur d'une tâche Ti est :

Ui=Ci / hi (4)

La charge processeur d'un système de n tâches S = { Ti (ri, 0, Ci, Di, hi),...} est :

Us= ∑𝑛𝑛𝑖𝑖=1 𝐶𝐶𝑖𝑖 /ℎ𝑖𝑖 (5)

 La date de début d’exécution ( si, k): est la date à laquelle l’instance de la tâche Ti, k
dispose pour la première fois du la CPU.
 La date de terminaison (ei, k ): est la date à laquelle Ti, k se termine.
 Le temps de réponse Tresp (Ti, k):

Tresp (Ti,k) = ei, k - ri, k (6)

12
Chapitre I Ordonnancement Temps Réel des Tâches

Si Tresp ( Ti, k) dépasse le délai critique, alors une faute temporelle est produite.

D’autres paramètres sont donnés par le tableau suivant:

Paramètre Signifiant Formule


Lio Latence d’entrée-sortie Lio(Ti, k) = Tresp - Ls = ei, k - si, k

Ls Latence d’échantillonnage Ls (Ti, k)= si, k - ri, k

Tresp Temps de réponse de tâches Tresp (Ti, k)= ei, k - ri, k = Ls +Lio

C(t) Le temps d’exécution restant C(t)=Ci - Cexé


d(t) Le délai critique dynamique d(t)=di, k – t

L(t) La laxité dynamique L(t) = D(t) – C(t) = di, k - t – C(t)

Tableau 1. Paramètres temporales des tâches


1 ère activation hi, 0 2 ième activation hi, 1

Di Di

t
ri, 0 di, 0 ri, 1 di, 1 ri, 2
Ci
Avec 0≤C i≤ Di ≤ hi
Ci
Figure 2 Schéma d’ordonnancement d'une tâche périodique

Les tâches temps réel sont dites indépendantes, lorsqu'elles sont définies uniquement
par leurs paramètres temporels. Dans le cas où les tâches communiquent, des contraintes
de précédences sont alors rajoutées à la définition du système. La notion de partage de
ressource est aussi importante et nécessite une certaine politique d'exclusion mutuelle et
de gestion des accès concurrents.

I. 5. 2 Modélisation des tâches non périodiques

Les tâches non périodiques sont réparties en deux catégories. Les tâches sporadique et
apériodique.

13
Chapitre I Ordonnancement Temps Réel des Tâches

a. Les tâches sporadiques

Une tâche est dite sporadique si son activation est non régulière (fonction de l’arriver ou
non d’un événement non périodique) [PAI 06], mais tout en ayant la possibilité de définir
un temps minimal entre deux activations successives de la tâche. L’activation des tâches
sporadique est contrainte par un délai minimal et non par une période. Une tâche
sporadique Tsi, peut être caractérisée par trois paramètres temporels suivants

(Csi, Dsi, hsi) (7)

Où :

Csi :est la durée d’exécution de la tâche sporadique Ti ;

Dsi :est son échéance ou le délai critique (temps réel stricte) ;

hsi :est le temps minimal entre deux activations successives.

Les tâches sporadiques, sont utilisées dans les systèmes temps réel asynchrones, et il est
difficile de valider un système composé de tâches sporadiques, à cause de l'irrégularité
dans l'activation des tâches, c’est-à-dire lorsque les dates de réveil des tâches sont à priori
inconnues. Cependant, la connaissance du temps minimal permettra de périodiser ces
tâches par l’utilisation de serveur périodique de sporadique.

b. Les tâches apériodiques

En ce qui concerne les tâches apériodiques, sont caractérisées par le fait qu’elles
peuvent demander à être exécutées à n'importe quel moment, sans avoir de temps minimal
d'invocation [KIM 80]. Le seul paramètre connu est la durée d’exécution Ca de la tâche. La
date de réveil est aléatoire étant donné que l’instant de l’exécution de la tâche dépend du
contexte d’évolution du procédé et ne peut pas être connu à priori. De plus, le temps entre
deux instances d’une tâche apériodique est inconnu ou il est connu en moyenne. Elles sont
donc à contrainte relative ou faible. Leurs exécutions est prises en compte dans un travail
de fond, c’est à dire dans les temps laissés libres par les tâches à contraintes strictes
(tâches périodiques), soit prises par des serveurs d’apériodiques.

14
Chapitre I Ordonnancement Temps Réel des Tâches

I. 6 Classes des problèmes d’ordonnancement temps réel

Dans cette section sont indiquées les caractéristiques liées aux systèmes cibles de
l'ordonnancement ou à l'ordonnancement lui-même. Ces caractéristiques forment les
paramètres du problème d'ordonnancement qu'on cherche à résoudre.

 Monoprocesseur vs multiprocesseur: l’ordonnancement est de type


monoprocesseur si toutes les tâches ne peuvent s'exécuter que sur un seul et même
processeur. Si plusieurs processeurs sont disponibles dans le système,
l'ordonnancement est multiprocesseur.
 Distribué vs centralisé : Lorsqu'un système est multiprocesseur, l'ordonnancement
est distribué si les décisions d'ordonnancement sont prises par un algorithme
localement en chaque nœud. Il est centralisé lorsque l'algorithme d'ordonnancement
pour tout le système, est déroulé sur un processeur privilégié.
 Hors ligne vs en ligne : Un ordonnancement hors-ligne signifie que la séquence
d'ordonnancement est prédéterminée à l'avance : dates de début d'exécution des
tâches, de préemption et de reprise éventuelles. En pratique, l'ordonnancement prend
la forme d'un plan hors ligne (ou statique), exécuté de façon répétitive (on parle aussi
d'ordonnancement cyclique). Un ordonnancement en ligne correspond au déroulement
d'un algorithme qui tient compte des tâches effectivement présentes dans la file
d'ordonnancement (run-queue en anglais) lors de chaque décision d'ordonnancement.
 Préemptif vs non préemptif : L'ordonnancement est préemptif lorsque les
préemptions sont autorisées. On peut remarquer que dans le cas des ordonnanceurs
monoprocesseur, la problématique de la synchronisation sur ressource n'existe pas en
non-préemptif puisque il ne peut pas y avoir de concurrence sur l'accès aux ressources
en l'absence de préemption.
 Optimal vs non optimal : Par définition, un algorithme d'ordonnancement optimal
parmi une classe donnée de solution au problème (ordonnancement hors ligne, en
ligne, distribué...), est tel que si un système de tâches est ordonnançable par au moins
un algorithme de la même classe, alors le système est ordonnançable par l'algorithme
d'ordonnancement optimal considéré. En conséquence, si une configuration n'est pas
ordonnançable par un algorithme optimal d'une classe donnée, alors il ne l'est par
aucun algorithme de la même classe.

15
Chapitre I Ordonnancement Temps Réel des Tâches

I. 7 Contexte d’ordonnancement

Les contextes d’étude d’ordonnancement servent à définir au mieux les problèmes


d’ordonnancement et les solutions proposées [PAR 02], ces contextes sont formalisés par la
notation suivante :

X=|architecture |réveil, charge, délai critique, période, préemption, précédences,


ressources|

Un contexte est constitué d’une suite d’éléments nommé termes. Pour chaque terme du
contexte correspond un certains nombre de valeurs possibles. Ces termes et leurs valeurs
possibles sont énumérés dans le Tableau 2 suivant :

16
Chapitre I Ordonnancement Temps Réel des Tâches

Terme Valeurs possibles Sémantique


p=1:m=1 Un système monoprocesseur centralisé

p:m=1 Un système multiprocesseur centralisé


Architecture
p=1:m m systèmes monoprocesseurs répartis

p:m m systèmes multiprocesseurs répartis


ri=0 Tâches simultanées
Réveil
ri Certaines tâches sont différées
Ci=1 Tâches de durée unitaire
Charge
Ci Tâches de durée quelconque
Di=Pi Tâches à échéance sur requête
Échéance
Di Tâches de délai critique quelconque
Pi Tâches périodiques
Période
Ø Tâches non périodiques
prmpt (ou Ø) Tâches préemptibles

noprmpt Tâches non préemptibles


Préemption
prmptnoprmpt Des tâches ont des portions de code non préemptibles
Ø Pas de précédences

Pfn Précédences en forme normale


Précédences
Prec Précédences quelconques
Ø Pas de ressources critiques
Ressources
Res Ressources en exclusion mutuelle

Tableau 2 . les termes d’un contexte d’étude d’ordonnancement

Tel que, p : désigne le nombre de processeurs par site ; m : dénote le nombre de site.
17
Chapitre I Ordonnancement Temps Réel des Tâches

Par exemple, le contexte X=|p=1,m=1|ri=0,Ci, Di=Pi, Pi| dénote l’étude des systèmes de
tâches indépendantes préemptibles périodiques simultanées, de charge quelconque, à
échéance sur requête, en environnement monoprocesseur.

Remarque : dans ce rapport nous nous plaçons dans le contexte de monoprocesseur.

I. 8 Approches d’ordonnancement

Dans cette section on donne l’état de l’art des algorithmes d’ordonnancement en


précisant à chaque fois les contraintes qui sont prises en compte ainsi que les conditions
d’ordonnançabilité si celles-ci existent.

Les algorithmes d’ordonnancement temps réel sont classés selon la somme des
informations qu’ils requièrent pour effectuer la planification des tâches. On distingue ainsi
les algorithmes de l’approche en ligne et les algorithmes l’approche hors ligne.

I. 8. 1 Approche en ligne

L’approche en ligne utilise un algorithme qui est directement implanté et exécuté par
l’ordonnanceur. À l’exécution des primitives de l’exécutif temps réel, l’ordonnanceur
intervient et choisit la tâche à affecter au processeur. Ces décision d’affectation sont prisent
généralement en fonction des priorités des tâches, A l’ origine, la politique d’attribution de
priorités utilisée était empirique (externe ou hors ligne), où le concepteur était chargé
d’allouer à la main une priorité à chacune des tâches du système. L’algorithme
d’ordonnancement se contentant de calculer, à chaque réveil ou fin d’une tâche, la priorité
maximale. Puis des algorithmes de calcul des priorités en fonction des paramètres
temporels des tâches déclenchées à l’instant t ont été proposés. Ces algorithmes se
répartissent en deux catégories, les algorithmes d’ordonnancement à priorités statiques et
ceux à priorités dynamiques. L'ordonnancement lors de l'exécution du système s'effectue
avec la politique HPF (Highest Priority First) priorité la plus élevée d'abord. La décision
consiste à sélectionner parmi les tâches éligibles la tâche qui a la priorité la plus forte. En
cas d’égalité parmi les tâches prêtes de plus haute priorité, le choix de la tâche à exécuter
est fait arbitrairement parmi les ex-æquo.

Une priorité statique est une priorité qui ne varie pas au cours de la vie de la tâche. Ce
principe est simple mais il réduit les possibilités d’adaptation de la politique
18
Chapitre I Ordonnancement Temps Réel des Tâches

d’ordonnancement à l’évolution du système contrôlé. Pour les politiques


d'ordonnancement dynamique, les priorités relatives des tâches peuvent changer. On
constate que dans le cas d’ordonnancement à priorités statiques, les priorités sont
attribuées aux tâches alors que dans le cas des algorithmes dynamiques les propriétés sont
attribuées aux instances de tâches.

I. 8. 2 Approche hors ligne

Ces algorithmes sont utilisés pour la génération d’une séquence d’ordonnancement


valide à répéter à l’infini périodiquement avec une période égale à la période d’étude du
système sur la base de tous les paramètres temporels de tâches. Cette séquence est connue
avant l’exécution des tâches sera implémenté dans une table consultable par un
ordonnanceur simplifié que l’on appelle séquenceur. Dans ce cas on parle d’algorithme
d’ordonnancement hors ligne.

Les méthodes de constructions de séquences d’ordonnancement reposent généralement


sur une analyse exhaustive de toutes les séquences possibles pour en extraire une
particulière valide du point de vue temporel. Par conséquent, ces méthodes souffrent d’une
complexité élevée. En contre partie, l’étude exhaustive permet de parcourir l’ensemble des
solutions possibles ce qui permet d’offrir une puissance d’ordonnancement maximale. De
plus, le fait de remplacer un ordonnanceur par un séquenceur, permet d’alléger le
processeur en surcoût d’ordonnancement, tout en fiabilisant l’exécution de l’application
qui n’est alors plus assujettie aux phénomènes d’instabilité. Cependant, cette approche ne
permet pas d’ordonnancer les tâches sporadiques et apériodiques.

I. 9 Algorithmes de l'approche en ligne

Les algorithmes en ligne sont basés sur une politique d’attribution de priorités en
fonction des paramètres temporelles des tâches. Selon la politique d’attribution de priorité
aux tâches temps réel, on distingue deux catégories, les algorithmes à priorités statiques et
à priorités dynamiques.

I. 9. 1 Algorithmes à priorité statique

Les algorithmes à priorités statiques se basent sur les connaissances a priori de toutes
les caractéristiques temporelles des tâches. Ces algorithmes calculent les priorités de

19
Chapitre I Ordonnancement Temps Réel des Tâches

chaque tâche initialement et ne varient pas au cours du temps. Nous présentons dans ce
qui suit les principaux algorithmes à priorités statiques dans un contexte monoprocesseur.

a. L'algorithme Rate Monotonic RM

L’algorithme Rate Monotonic [LUI 73] noté RM suppose qu'un certain nombre
d'hypothèses sont respectées :

 Toutes les tâches sont périodiques ;


 Les tâches sont indépendantes les unes des autres, c'est-à-dire que la requête d'une
tâche ne dépend pas de l'initialisation ni de la terminaison d'une autre tâche ;
 Les échéances des tâches sont égales a leurs périodes (Di = hi) et elles peuvent être
préemptées ;
 Le temps d'exécution de chaque tâche est connus et constant d'une période à une
autre ;

Sous ces hypothèses, l'algorithme Rate Monotonic attribue à chaque tâche une priorité
inversement proportionnelle à sa période.

Liu et all ont donné une condition suffisante d’ordonnancement mais non nécessaire.
Cette condition stipule que pour un ensemble de n tâches périodiques soit ordonnançable,
dans le contexte précédent, il faut que le facteur d'utilisation du processeur induit U
vérifier la relation :

𝐶𝐶
U=�∑𝑛𝑛𝑖𝑖=1 ℎ𝑖𝑖 � ≤ 𝑛𝑛 ∗ ( √2 − 1) (8)
𝑛𝑛

𝑖𝑖

b. L'algorithme (DM) Deadline Monotonic

Cet algorithme a été proposé par Leung et Whiteheaden en 1982 [LEU 82] pour des
tâches à échéances inférieurs aux périodes (Di ≤ hi). Cet algorithme est basé sur une
affectation de priorités inversement proportionnelles aux délais critiques des tâches. Ainsi,
une tâche ti de délai critique Di sera plus prioritaire qu’une tâche tj de délai critique Dj si Di
< Dj. L’algorithme DM est optimal pour le modèle du liu et layland [LIU 73].

20
Chapitre I Ordonnancement Temps Réel des Tâches

Une condition suffisante d’ordonnancement d’une configuration de n tâches périodiques


avec DM est:

𝐶𝐶
𝑈𝑈 = �∑𝑛𝑛𝑖𝑖=1 𝐷𝐷𝑖𝑖 � ≤ 𝑛𝑛 ∗ ( √2 − 1) (9)
𝑛𝑛

𝑖𝑖

I. 9. 2 Algorithmes à priorité dynamique

Pour palier aux problèmes des limites théoriques de charge processeur imposées aux
algorithmes d'ordonnancement RM et DM, qui sont optimaux chacun dans un contexte
particulier. Des algorithmes d’ordonnancement à priorités dynamiques ont été proposés.
Ces algorithmes diffèrent des algorithmes précédemment étudiés puisqu’ils affectent aux
tâches des priorités variantes au cours de la vie de l’application temps réel. En d'autres
termes, Une même tâche (et parfois une même instance de tâche) peut recevoir des
priorités différentes durant la vie de l’application. La priorité est ici est fonction du temps
et dépend de l’état instantané du système. Cependant, les détracteurs de ces algorithmes
leurs attribuent des limites, liées à leurs complexités de mise en œuvre, qui sont dues à la
surcharge du processeur (overhead en anglais). En effet, les priorités doivent être
recalculées à chaque réveil ou terminaisons d’une tâche, mais ce calcul est linéaire en
temps en fonction du nombre de tâches [PAR 02].

Nous présentons ici les deux principaux algorithmes d’ordonnancement à priorités


dynamiques, Earliest Deadline et Least Laxity dont la complexité est linéaire en le nombre
de tâches.

a. L' algorithme Earliest Deadline first EDF

L'algorithme Earliest Deadline noté EDF est inspiré des travaux en ordonnancement job
shop apparus dans [JAC 55,MCN 59] , lesquels le principe de l’exécution des tâches les plus
urgentes est mis en évidence. Ceci a permis à Liu et Layland [LUI 73] d’adapter ce résultat
au contexte temps réel. Le principe d’Earliest Deadline est basé sur les échéances des
tâches actives à chaque instant. Donc, la tâche la plus prioritaire est celle dont l’échéance
absolue est la plus proche. Et à tout instant, c'est la tâche ayant la plus haute priorité qui
s'exécute (ordonnancement préemptif). La priorité de chaque tâche est recalculée

21
Chapitre I Ordonnancement Temps Réel des Tâches

dynamiquement à chaque modification de l'état du système (arrivée ou terminaison d'une


tâche). En cas d’égalité, c’est la plus ancienne dans la file d’attente qui est choisie.

L’algorithme Earliest Deadline est optimal dans le contexte |1|ri, Ci, Di, Pi|. Cet algorithme
permet d’accepter un plus grand nombre de configurations que RM et DM, parce que, au
lieu de prendre en compte dans la priorité de chaque tâche l’écart fixe entre la date de
réveil de la tâche et l’échéance de la tâche (ou période, si les tâches sont à échéance sur
requête), il prend pour critère dynamique de priorité le temps restant jusqu’à l’échéance.
C’est-à-dire, à l’instant t, la priorité peut être calculée à partir du délai critique dynamique
d(t).

Comme pour les algorithmes à priorités statiques, il est primordial de dégager des
conditions analytiques par lesquelles on est certain qu’une configuration de tâches donnée
est ordonnançable ou non par EDF. Liu et all, ont mis en évidence une condition nécessaire
et suffisante d’ordonnancement d’une configuration de n tâches dans le contexte |1|ri=0, Ci,
Di=Pi, Pi| pour EDF qui est la suivante :

𝐶𝐶
U=�∑𝑛𝑛𝑖𝑖=1 ℎ𝑖𝑖 � ≤ 1 (10)
𝑖𝑖

b. L'algorithme LLF (Least Laxity First)

Cet algorithme se base sur la laxité. L’algorithme LLF a été introduit par Mok et
Dertouzos [MOK 78,MOK 83]. LLF est basé sur une affectation dynamique de priorités aux
instances de tâches au cours de leurs exécutions en fonction de la laxité dynamique L(t) qui
représente le temps restant avant la prochaine occurrence de la date de réveil d’une tâche.
La tâche à exécuter à un instant t est celle dont la laxité dynamique est la plus petite, c’est à
dire celle dont l’exécution peut être la moins retardée. D’après la définition de LLF, le calcul
des priorités doit être effectué à chaque modification de laxité, donc à chaque exécution
d’une unité de temps (contre tout réveil de tâche pour EDF), ce qui engendre un surcoût
processeur conséquent avec la génération d’un nombre important de changements de
contexte.

22
Chapitre I Ordonnancement Temps Réel des Tâches

L’algorithme LLF est optimal dans le cas de tâches indépendantes à échéances


inférieures ou égales aux périodes [MOK 83]. LLF n’est toutefois pas très intéressant en
monoprocesseur comparé à EDF qui engendre moins de changements de contexte [PAI 06].

Malgré la flexibilité des algorithmes dynamiques (permettant de prendre en compte


l'arrivée imprévue d'événements) et leur optimalité, ces algorithmes consomment
beaucoup de temps système (recalcule les priorités des tâches).

I. 10 Limite de l’ordonnancement classique

Les approches et algorithmes présenté précédemment soufre de plusieurs limites [SIM


06] qui sont résumées dans ce qui suit :

I. 10. 1 Connaissance des paramètres temporels

Les algorithmes d’ordonnancement présentés précédemment supposent que l’on


connaisse au départ la valeur des paramètres temporels des tâches. Cependant, La
détermination de la durée d’exécution des tâches est un problème difficile [SIM06]. Cette
durée dépend évidement du langage hôte et de la machine cible. Pour une machine et un
compilateur donné, cette durée dépend également du contexte, et est de plus en plus
difficile à déterminer avec les processeurs modernes utilisant des caches et/ou des pipe-
lines. Les branchements conditionnels dans le code génèrent également des durées
d’exécution variables (potentiellement une durée par branche).

En plus, l’incertitude sur la durée d’exécution des tâches peut également provenir de
l’algorithme lui même. On cite en particulier les processus de vision, où la durée de
traitement dépend de la richesse et de la complexité de la scène observée, et les
algorithmes de planification de trajectoires fournissent un exemple de processus où la
valeur d’un critère de qualité de services peut être calculée en fonction de la précision du
résultat, et donc plus ou moins explicitement en fonction de la durée de calcul effectuée.

Enfin, on remarque que même une connaissance de la durée d’exécution au pire cas ne
garantit pas forcément l’obtention d’un ordonnancement fiable [SIM 06].

23
Chapitre I Ordonnancement Temps Réel des Tâches

I. 10. 2 Politique d’affectation des priorités

Les politiques d’affectation des priorités étudiées dans la littérature (RM, DM, EDF. . . )
présentent un certain caractère d’optimalité, e.g. utilisation maximale du CPU, donc du
point de vue de l’informatique et en dehors de tout contexte applicatif. Or, une application
de commande ordonnancée ¨en aveugle¨ selon une de ces méthodes peut exhiber un
comportement médiocre, alors qu’un découpage de l’algorithme et une affectation de
priorité suivant des notions d’urgence ou d’importance relatives, dépendant du contexte
applicatif, peut conduire à obtenir des performances de l’application (stabilité, faible erreur
de poursuite. . . ) beaucoup plus satisfaisants.

I. 10. 3 Environnement dynamique

Ces derniers années, une nouvelle catégorie d’application temps réel s’exécutants dans
un environnement ouvert sont rapidement réalisées. Des activités, répétitives ou non, dont
la durée d’exécution dépend de l’environnement et qui n’est pas connue a priori
(planification, traitement d’images...) ; des lois de commande périodiques multi-cadences,
où on peut affecter des caractéristiques temporelles (période, priorité...) différentes à
certaines parties de l’algorithme pour en augmenter l’efficacité ;

D’autre part, dans la littérature classique concernant l’ordonnancement temps réel, les
algorithmes (par exemple la politique d’affectation des priorités) sont étudiés séparément
du contexte applicatif [COT 00]. Cette démarche peut conduire a préconiser un
ordonnancement ¨optimal¨ du point de vue par exemple de l’utilisation de la ressource de
calcul mais inefficace du point de vue du contrôle de l’application qui est tout de même le
point de départ.

24
Chapitre I Ordonnancement Temps Réel des Tâches

I. 11 Conclusion

L'ordonnancement d'un système de tâches contrôlant des procédés ne doit pas les
conduire a des états indésirables : en d'autres termes, la séquence d'ordonnancement
des tâches exécutées par le ou les processeurs doit être valide.

Dans ce chapitre nous avons présenté un état de l’art sur les systèmes temps réel. Nous
avons commencé par donner des définitions concernant les procédés ainsi que les
contraintes temporelles et matérielles. Puis nous avons présenté l’ordonnancement des
systèmes de tâches temps réel. Ensuite nous avons présenté les différentes conditions
d’ordonnançabilité et les algorithmes d’ordonnancement associés.

Dans le chapitre suivant nous présentons un état de l’art sur l’ordonnancement par
commande de rétroactive (l’ordonnancement régulé ou le feedback scheduling).

25
Chapitre II
Ordonnancement par commande
rétroactive
II. 1 Introduction ....................................................................................................................................... 27
II. 2 Lois de commande .......................................................................................................................... 27
II. 3 Le feedback scheduling ................................................................................................................. 28
II. 4 Les travaux sur feedback scheduling ....................................................................................... 28
II. 5 Le feedback scheduler d’Eker et all. ......................................................................................... 31
II. 5. 1 L’architecture du feedback scheduler proposée par EKer...................................... 32
II. 5. 2 Formulation du problème ................................................................................................... 33
II. 6 Le feedback scheduler de Cervin et Eker ............................................................................... 33
II. 7 Le feedback scheduler de Cervin et all .................................................................................... 36
II. 7. 1 EDF Vs Feedback scheduling ............................................................................................ 36
II. 7. 2 Limite de l’étude ...................................................................................................................... 36
II. 8 Control server Model de Cervin .............................................................................................. 37
II. 9 Le feedback scheduling de Xia et all. ........................................................................................ 38
II. 9. 1 Modèles de tâches ................................................................................................................... 38
II. 9. 2 Description du feedback scheduler de Xia .................................................................... 39
II. 9. 3 Gestion de la surcharge ........................................................................................................ 39
II. 10 Fuzzy feedback scheduling........................................................................................................ 40
II. 11 Conclusion ....................................................................................................................................... 42
Chapitre II : Ordonnancement par commande rétroactive

II. 1 Introduction

L
es applications temps réel dédiées au contrôle des procédés offrent un
support opérationnel à des lois de commande automatique. La qualité des lois
de commande est basée sur des hypothèses de régularité d’exécution du
support d’exécution temps réel sous-jacent. Cependant, les tâches sont
soumises à une irrégularité (gigue temporelle), suite à leur ordonnancement,
et à d’autres charges de traitement. Les techniques de feedback scheduling
permettent de réduire l’impact de l’imperfection du système d’exécution sur la
qualité de la commande.

II. 2 Lois de commande

Le procédé dynamique à contrôler est muni de capteurs et d'actionneurs qui sont


connectés à l'unité de calcul (contrôleur). L'exécution du contrôleur est composée de 3
phases : l'acquisition des mesures, le calcul de la nouvelle commande et la mise à jour de
l'actionneur. Ces trois opérations sont parfaitement périodiques et synchronisées
conduisant à une période constante et une latence entre la mesure et la mise à jour de la
commande nulle ou constante.
Références

Contrôleur

Capteur Actionneur

Procédé
Figure 3 . L'architecture d'un système de commande par rétroaction

Dans ce contexte, la loi de commande, c'est à dire l'algorithme qui calcule la nouvelle
commande en fonction des mesures et des références, est conçue par l'usage d'une des
nombreuses méthodes de synthèse de contrôleurs (Commande Floue, commande
optimale, Contrôleur PID, commande robuste, ...). Le correcteur peut être obtenu
directement en temps discret ou via la discrétisation d'un correcteur à temps continu.
Dans les deux cas les approches traditionnelles supposent l'échantillonnage
parfaitement périodique et la latence entrée/sortie nulle ou constante.

27
Chapitre II : Ordonnancement par commande rétroactive

La période d'échantillonnage est choisie en fonction de la dynamique du procédé et


des objectifs visés en boucle fermée. Pour cela, il existe des critères empiriques et
notamment celui d' Åström et Wittenmark, [AST 97]:

0.1≤ ωn * h ≤0.6 (11)

Où h est la période d'échantillonnage et wn la bande passante de la boucle fermée. Ce


critère, plus conservatif que le critère de Shannon, garantit une marge de phase
minimale.

La loi de commande est implémentée soit sur un gros calculateur dont les ressources
peuvent être partagées avec d'autres activités, soit sur un micro calculateur dédié à cette
fonction. Dans le premier cas l'usage d'un système d'exploitation temps réel multitâches
se généralise, facilitant l'écriture de programmes concurrents. Dans le second cas le
développement de solutions sur mesure est souvent suffisant.

II. 3 Le feedback scheduling

Le feedback scheduling consiste à adapter en temps réel l'ordonnancement grâce à un


contrôleur agissant dans le cadre d’un système asservi en boucle fermée. Dans ce cas,
l’ordonnanceur avec le système de tâches sont vus comme étant des procédés à
contrôler. L'objectif est d’ajuster les paramètres d'ordonnancement du système en
fonction de certaines mesures. Cette technique permet de réduire l’impact de
l’imperfection du système d’exécution sur la qualité de la commande.

II. 4 Les travaux sur le feedback scheduling

Depuis le rapprochement entre les communautés des systèmes temps réel et de


l’automatique, des approches basées sur une optimisation hors ligne et en ligne on vu le
jour dans le souci d’étudier conjointement la commande et l’ordonnancement lors de la
conception d’un contrôle par un ordinateur. Nous allons particulièrement nous
intéresser ici, aux approches basées sur une optimisation en ligne.

Cervin [CER 99] propose une décomposition en deux parties des tâches de contrôle :
une sous-tâche qui contient seulement les opérations immédiatement nécessaires pour

28
Chapitre II : Ordonnancement par commande rétroactive

le calcul de la nouvelle commande (Calculate Output) et une sous-tâche (Update State)


qui contient le reste des opérations pour la mise à jour de l’état interne du correcteur,
afin de réduire les délais de calcul et la gigue d’échantillonnage pour avoir une meilleure
qualité dans la commande. Pour les tâches de contrôle, il propose une heuristique qui
attribut les priorités aux sous-tâches en fonction de la politique d’ordonnancement
choisie tout en maintenant l’ordonnançabilité. Cette approche est plus performante
qu’un contrôleur mono tâche.

Eker et all [EKE 00] passent à l’usage d’un ordonnancement adaptatif ou régulé
permettant de compenser dynamiquement les dégradations de la commande. Ces
résultats permettent d’adapter la période des contrôleurs au taux d’occupation du
processeur. Il s’est principalement intéressé aux contrôleurs linéaires quadratiques
(LQ). L’optimisation de la période de plusieurs contrôleurs LQ est résolue
analytiquement par l’usage des fonctions de coût linéaire ou quadratique en la période.
Il montre qu’une simple dilatation des périodes nominales, en fonction de l’utilisation
souhaitée du processeur, conserve l’optimalité de l’ordonnancement. Cela permet ainsi
d’ajuster en ligne, les périodes en fonction de l’utilisation du processeur tout en
optimisant la performance des commandes.

Cervin et all. [CER 00] proposent un nouveau mécanisme de feedback scheduling


dans le contexte de la conception conjointe ordonnancement des tâches de contrôle. Ils
se sont particulièrement intéressés ici aux contrôleurs hybrides les durées d’exécution
changent brusquement entre différents mode de fonctionnement. La solution qu’ils
proposent est de garder l’utilisation du processeur à un niveau toujours acceptable, pour
éviter la surcharge et distribuer les ressources de façon efficace entre les différentes
tâches du système. Pour cela ils s’appuient sur le rééchelonnement linéaire des périodes
nominales.

Cervin et all , [CER 02] proposent une régulation de l’ordonnancement de plusieurs


lois de commande. La période des lois de commande est modifiée en ligne en réponse à
une variation de la charge processeur. La conception du régulateur repose sur les
travaux de [EKE 00] . Leurs résultats montrent qu’un choix convenable des périodes
nominales (fréquences nominales) et un simple rééchelonnement des périodes

29
Chapitre II : Ordonnancement par commande rétroactive

nominales en respectant les contraintes d’utilisation du processeur permettent d’avoir


des périodes d’échantillonnage optimales et par là de bonne performance totale des
contrôleurs.

Un point significatif est introduit par Cervin après ses travaux de thèse [CER 03], qui
consiste à affiner le modèle de tâches classique afin de prendre en compte les latences
d’entrées/sorties constantes et les gigues d’échantillonnage lors de la mesure de la
performance globale des contrôleurs. Ce modèle a été baptisé « Control server model »
et il est dans la plus part du temps associé à un serveur de commande introduit par
Cervin et Eker [CER 05] qui permet de diviser un processeur en plusieurs processeurs
virtuels. Chaque processeur virtuel se voit attribuer une quantité limité de ressources
qu’il ne peut pas dépasser. Les échanges d’entrées/sorties s’effectuent à des instants
prédéfinis ce qui rend la latence d’entrée/sortie constante.

Sename et all [SEM 03] proposent une approche basée sur le feedback scheduling
pour contrôler les systèmes avec des délais de communication inconnus. Ces résultats
montrent que l’on peut calculer une commande par retour d’état pour stabiliser un
système ayant un délai inconnu mais borné. Ils s’appuient pour cela sur le scheduler
proposé par Cervin et all [CER 02].et un autre contrôleur appelé « contrôleur de
processus » responsable de la gestion des incertitudes temporelles (préemption, durée
d’exécution des contrôleurs, délais induits par le réseau…). Ils se sont particulièrement
intéressés au contrôle des systèmes à temps discret qui modélisent facilement les délais
inconnus.

Simon et all [SIM 05] montrent la relation entre la performance de commande d’un
système en boucle fermé et les incertitudes temporelles (périodes, latence, gigue) dues à
l’exécution des programmes sur la ressource de calcul (conception conjointe
commande/ordonnancement). Ils proposent d’adapter l’ordonnanceur temps réel lui
même en s’appuyant sur des techniques de commande en boucle fermée, pour
augmenter la robustesse des contrôleurs faces à ses incertitudes temporelles
d’exécution.

30
Chapitre II : Ordonnancement par commande rétroactive

De nombreux travaux se sont intéressés à l’analyse des performances des contrôleurs


en se basant sur des fonctions de coût qui ne dépendaient que de la période
d’échantillonnage. Sachant que les délais dans les boucles de contrôle ont un impact
considérable sur les performances des contrôles, il devient très important de les prendre
en compte dans la modélisation des systèmes de contrôle. Certains travaux se sont
intéressés à la modélisation de ses délais, mais l’approche utilisée était plus du ressort
de l’automatique que de l’ordonnancement temps réel [SEM 03, SIM 05] . D’autres
auteurs se sont intéressés à ses délais en s’appuyant cette fois-ci sur des approches
d’ordonnancement temps réel, les travaux les plus porteurs sont ceux de Bini et Cervin
[BIN 08] , où ils se sont intéressés au problème d’affectation des périodes aux tâches de
contrôle, de façon à maximiser les performances des contrôleurs. Dans leur approche,
l’évaluation des performances des contrôleurs dépend en grande partie de la période
d’échantillonnage et du délai. Ils s’appuient sur les résultats de Bini et Baruah [BIN 07]
pour trouver une approximation des délais afin de calculer les fonctions de coût et par la
suite ils formulent le problème d’affectation de ressources comme Eker [EKE 00] .

Les travaux présentés précédemment reposent sur une qualité de commande (QdC)
qui est indirectement déterminer par les temps d’exécution et les périodes des tâches
qui sont ajustés de manière dynamique en ligne afin d’assurer l’ordonnançabilité des
tâches de contrôles. Les performances de ses approches reposent fortement sur la
formulation exacte de la relation entre les paramètres temporels et l’indice de
performance des contrôleurs qui est souvent un travail difficile.

Ainsi les travaux de Xia et all [XIA 06] utilisent une approche directe qui prend les
décisions d’ordonnancement en se basant sur des informations en continu sur les
performances de chaque contrôleur. Ses résultats ont permis de mettre en œuvre un
nouveau modèle de tâches et un feedback scheduling basé sur ce modèle pour gérer de
façon efficace les surcharges processeurs tout en maximisant la performance globale des
contrôleurs.

II. 5 Le feedback scheduler d’Eker et all.

Eker et all dans leurs travaux [EKE 00] ont étudié la façon de distribuer les
ressources de calcul à un ensemble de contrôleurs linéaires quadratiques de façon à
31
Chapitre II : Ordonnancement par commande rétroactive

optimiser les performances totales du système. Ils s’appuient pour cela sur des fonctions
de coût linéaires quadratiques, qu’ils vont par la suite utiliser comme indicateur de
performance pour les différents contrôleurs. Ils posent le problème d’allocation des
ressources comme un problème d’optimisation, le résultat de ce problème sera utilisé
par une routine d’optimisation (feedback scheduler) pour l’allocation des ressources.

II. 5. 1 L’architecture du feedback scheduler proposée par EKer.

Le modèle de tâches utilisé par Eker et all pour modéliser les contrôleurs est
différent du modèle de tâches classique en ce sens que les tâches ont plusieurs modes de
fonctionnement avec des durées d’exécution différentes et parfois des périodes
différentes. A chaque contrôleur est associée une fonction de coût qui indique sa
performance. L’objectif du feedback scheduler est d’optimiser la performance totale des
contrôleurs, tout en maintenant la charge de travail à un niveau désiré. Lors de
l’exécution des tâches modélisant les contrôleurs, certaines tâches peuvent demander
plus de ressources pour leur exécution (durée d’exécution augment) du fait du passage
d’un mode de fonctionnement à l’autre, occasionnant ainsi une surcharge de processeur,
entrainant des violations d’échéance pour certaines tâches. Grace au feedback
scheduler, dont l’architecture est décrite ci-après (Figure 4) un ajustement en ligne des
périodes ou des fréquences d’échantillonnage des contrôleurs est effectué pour
maintenir toujours l’ordonnançabilité du système sous la contrainte d’ordonnancement.

Contrôleur
d'admission
Feedback
Load reference scheduling

Execution Statistics Ressource allocation

Exécutif temps réel(Kernel)

Tâche 1
(Task1] Tâche 2
(Task2]
Events

Figure 4 Architecture du feedback scheduler de Eker

32
Chapitre II : Ordonnancement par commande rétroactive

Dans cette architecture, les deux modules importants sont : le feedback scheduler qui
est chargé d’ajuster les intervalles d’échantillonnage afin de contrôler la charge du
système et de maintenir l’ordonnançabilité du système ; le contrôleur d’admission
(admission controller) qui est sensé calculer la charge de travail référence.

Les tâches et le feedback scheduler communiquent via le contrôleur d’admission en


utilisant les requêtes (request) et des évènements (events). Lorsqu’une tâche a besoin
de plus de temps pour s’exécuter, elle envoie une requête au contrôleur d’admission, et
attend l’accord de ce dernier pour augmenter son temps d’exécution, cet accord sera
ainsi donné par un évènement approprié (events) émanant du contrôleur d’admission.
Le contrôleur d’admission va donc recalculer la charge de travail référence et l’envoyer
au feedback scheduler. Pour l’ajustement en ligne des périodes, le scheduler a également
besoin des statistiques d’exécution (durée d’exécution des tâches, charge du système),
toutes ses informations contribuent à l’allocation des ressources de façon à optimiser les
performances globales du système.

II. 5. 2 Formulation du problème

Soit n le nombre de tâches du système, hi intervalle d’échantillonnage de chaque tâche


ti, Ci sa durée d’exécution. Chaque tâche est associée à une fonction de coût Ji(hi) (par
exemple l’erreur absolue. Cf. Tableau 3) qui indique sa performance en fonction de
l’intervalle d’échantillonnage. Le problème d’optimisation est donc formuler de la façon
suivante :

𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀 𝐽𝐽 = ∑𝑛𝑛𝐼𝐼=1(𝐽𝐽𝑖𝑖(ℎ𝑖𝑖) ) (12)

∑𝑛𝑛𝐼𝐼=1(𝐽𝐽𝑖𝑖(ℎ𝑖𝑖) ) ≤= 𝑈𝑈𝑈𝑈𝑈𝑈𝑈𝑈 (13)

Où Uref est taux d’utilisation désrée.

II. 6 Le feedback scheduler de Cervin et Eker

Le modèle de tâches utilisé par Cervin et Eker [CER 00] est le même que celui
présenté précédemment établi par [EKE 00]. Chaque tâche est caractérisée dans son
mode de fonctionnement par une période nominale ou minimale hnomi. Le feedback
scheduler dont l’architecture globale est présentée à la Figure 5 est implémenté sous la
33
Chapitre II : Ordonnancement par commande rétroactive

forme d’une tâche périodique ou sporadique et va donc assigné les périodes


d’échantillonnage au contrôleur en se basant sur la mesure des durées d’exécution.

Ceci nécessite donc que le système d’exploitation temps réel sous-jacent aura le
pouvoir de mesurer les durées d’exécution des travaux.

Mode changes

Uref
Feedback Tâche Ordonnancer
de
scheduler contrôle (RM,EDF, etc.)

Figure 5. Structure du feedback scheduler

Pendant l’exécution, lorsqu’une tâche termine son exécution, le scheduler reçoit des
informations sur le contexte de cette tâche (durée d’exécution, taux d’occupation du
processeur). Il reçoit également des informations sur les tâches de contrôle (grâce au
mode changes) à propos de leur changement de mode, afin de maintenir la charge
processeur U autour d’une valeur proche de charge processeur consigne ou désiré Uref.
Généralement le choix la charge désirée ou consigne Uref est guidé par l’automatique,
surtout que les conditions suffisantes d’ordonnancement dans le cas d’un
ordonnancement à priorités fixes (RM) et le cas d’un ordonnancement à priorités
dynamiques (EDF) ne sont pas valides dans ce contexte, car l’hypothèse de connaissance
des durées d’exécution et de la fixation des périodes est violée.

Le feedback scheduler est mis en œuvre sous la forme d’une tâche périodique, non
préemptible à priorité maximale, de période hfbs, ayant un temps d’exécution constant
Cfbs. La période du feedback scheduler doit être convenablement choisie, car une période
trop faible va donner un bon contrôle d’ordonnancement mais avec une consommation
des ressources (CPU) très élevées, et une période trop grande consommera moins les
ressources mais la réponse du feedback scheduler aux perturbations de charges du
processeur sera ralentie.

34
Chapitre II : Ordonnancement par commande rétroactive

Quand le travail d’une tâche τi se termine, l’estimateur du temps d’exécution Ĉi est


mis à jour sur la base du dernier temps d’exécution mesuré Ci :

Les estimateurs sont initialisés arbitrairement à la période de chaque tâche hi,nom

𝐶𝐶̂𝑖𝑖 (𝑘𝑘) = 𝜆𝜆 ∗ 𝐶𝐶̂𝑖𝑖 (𝑘𝑘 − 1) + (1 − 𝜆𝜆) ∗ 𝑐𝑐𝑖𝑖 (14)

Où λ : paramètre d’oubli compris entre 0 et 1

Si λ = 1, le résultat sera très lisse (constant), mais la réponse du contrôleur sera très
ralentie, si λ = 0, le contrôleur détectera très vite les surcharges.

On calcule ainsi l’estimateur de la charge de travail du processeur noté Û :

Û = ∑ Ĉi/hi, nom (15)

Si Û ≤ Uref alors toutes les tâches s’exécutent avec leurs périodes nominales.

Si Û > Uref alors toutes les tâches s’exécutent avec une période égale à (hi,nomi * Û / Uref ).

Le changement de mode

Le rôle du feedforward (mode changes) est d’informer le feedback scheduler du


moindre changement de mode au niveau des contrôleurs, et ceci s’opère en trois
phases :

• Le contrôleur s’exécute à une fréquence beaucoup plus élevée que le scheduler et


c’est lui qui doit informer le scheduler lorsqu’une condition de changement de mode est
détectée ; si le changement de mode augmente la charge du système, le contrôleur
pourrait retarder la commutation d’une ou de plusieurs périodes d’échantillonnage
pendant que le scheduler recalcule les nouvelles périodes.

• Le feedback scheduler a besoin de garder certaines informations (périodes


nominales hi,nomi des tâches dans différents mode de fonctionnement) sur les différents
modes de commutation afin de bien calculer les nouvelles périodes d’échantillonnage.

35
Chapitre II : Ordonnancement par commande rétroactive

• Les informations sur le mode permettent au feedback scheduler d’exécuter


séparément les estimateurs du temps d’exécutions dans différents modes, tout en
ajustant à chaque fois le paramètre d’oubli.

II. 7 Le feedback scheduler de Cervin et all

En 2002 Cervin et all [CER 02] ont repris les travaux d’Eker et all réalisés en 2000 et
ses travaux réalisés en 2000. Dans ce travail ils se sont particulièrement intéressés aux
contrôleurs linéaires. Les deux résultats importants qui ressortent sont les suivants :

• La résolution du problème d’optimalité posé par Eker et all. [EKE 00] en s’appuyant
sur les approximations des fonctions de coût par des fonctions linéaires ou quadratiques
étaient équivalent au rééchelonnement linéaire des périodes ou des fréquences
d’échantillonnage qui est présenté dans Cervin et all [CER 00].

• Ils ont également montré qu’en basculant vers un ordonnancement de type EDF
avec un système constamment en surcharge, on peut avoir un contrôle de bonne qualité.

II. 7. 1 EDF Vs Feedback scheduling

Cervin a montré que la performance globale des contrôleurs sous un


ordonnancement EDF en boucle ouvert était bonne malgré le fait que le système soit
constamment en surcharge et que toutes les échéances des tâches sont manquées.

II. 7. 2 Limite de l’étude

Constaté par Markus [MAR 10], l’utilisation du feedback scheduler provoque des
phénomènes transitoires dans l’ordonnancement. Les deux phénomènes principalement
constatés sont :

• La surcharge transitoire par réduction des périodes ;

• La surcharge transitoire par augmentation du temps d’exécution. Il a été constaté


que dans une situation où, une tâche change de période d’échantillonnage (période plus
courte), cette tâche est touchée par des phénomènes de famine du à l’inversion de
priorité et de l’apparition de sous-systèmes en surcharge bloquant potentiellement des
tâches. Ainsi il a été montré que l’introduction du feedback scheduler réduisait le
36
Chapitre II : Ordonnancement par commande rétroactive

nombre de travaux en attente sous différent politique d’ordonnancement améliorant


ainsi la qualité de la commande.

II. 8 Control server Model de Cervin

Le modèle de tâches classique utilisé en théorie de l’ordonnancement temps réel n’est


pas un support approprié pour la co-conception ordonnancement/contrôle. Compte
tenu du fait que le moindre changement sur les paramètres d’une tâche peut donner des
résultats imprédictibles en termes de latence et de gigue et par suite inférer sur les
performances globales des contrôleurs. Les algorithmes d’ordonnancement basés sur ce
modèle comme RM, EDF, etc… ne permettent pas de réduire la latence et les gigues lors
de l’exécution d’un système, de surcroit les surcharges processeurs.

Un nouveau modèle de tâches a vu le jour à l’issue des travaux de Cervin et Eker [CER
05]. Le but de ce modèle est de faciliter la co-conception des applications de contrôle
temps réel. En particulier il doit être capable :

 D’assurer l’indépendance entre les tâches ;


 D’assurer des courtes latences d’entrées/sorties ;
 De minimiser les gigues d’échantillonnage;
 De fournir une interface simple en la mise en œuvre du contrôleur et de
l’ordonnancement temps réel.

L’utilisation de ce modèle de tâche « Control Server (CS Task) » suppose que, le


système d’exploitation sous-jacent utilise une politique d’ordonnancement EDF et que
les CS tâches doivent être associées aux tâches de contrôle ou à d’autres activités
périodiques avec des exigences fortes en matière d’entrées/sorties.

Le problème d’allocation optimale des ressources basées sur le feedback scheduling


comme décrit ci-dessus ne prend pas en compte les latences et les gigues dans la
modélisation des boucles de contrôle. Le CS model vient ainsi apporter une souplesse
dans la co-conception ordonnancement/contrôle, car prenant en compte les latences et
les gigues dans la mise en œuvre des contrôleurs. De plus l’utilisation du CBS (Constant
Bandwith Server) associé à chaque tâche assure que, les tâches de contrôle ne

37
Chapitre II : Ordonnancement par commande rétroactive

consommeront jamais plus de ressources que ce qui a été alloué à leur CBS associé. Cette
propriété peut ainsi être considérée comme une boucle interne dans la structure du
feedback scheduling.

II. 9 Le feedback scheduling de Xia et all.

Dans leur étude Xia et all [XIA 05, XIA 06 , XIA 08] considèrent un processeur
embarqué aux ressources de calcul limitées, les tâches de contrôle indépendantes
munies de paramètres temporels présentant des incertitudes. Deux types de paramètres
temporels présentent des incertitudes : la période et la durée d’exécution.

II. 9. 1 Modèles se tâches

L’idée de base derrière de ce modèle de tâches est d’associer les décisions


d’ordonnancement en fonction de la dynamique des procédés contrôlés. En particulier le
modèle doit refléter les caractéristiques suivantes :

Il doit fournir les paramètres temporels de base qui permettent l’utilisation des
algorithmes d’ordonnancement classiques ;

Il doit prendre en compte la dynamique des processus contrôlés, afin qu’il puisse être
utilisé à des fins de contrôle.

Il doit faciliter l’intégration contrôle/ordonnancement. Chaque tâche dans ce modèle


est donc caractérisée par les trois paramètres suivants :

Ci le temps d’exécution ;

Ti la période (L’échéance relative est égale à la période);

Uri = wi*ei l’urgence (nouvel paramètre).

Où, l’erreur ei est définie comme étant la différence absolue entre la réponse désirée
et la réponse courante du processus contrôlé correspondant, le poids wi correspond à
une criticité relative de la boucle de contrôle, l’idée de base derrière l’utilisation de ses
poids est que les boucles de contrôle peuvent jouer des rôles différents dans une
application de contrôle. Ils sont définis hors ligne et ne change plus pendant l’exécution
38
Chapitre II : Ordonnancement par commande rétroactive

de l’application. Dans l’utilisation de ce modèle, une augmentation de l’urgence signifie


que les performances du contrôleur se dégradent et vise versa

II. 9. 2 Description du feedback scheduler de Xia

L’algorithme d’ordonnancement utilisé en se basant sur ce modèle de tâches est le


MUF (Maximum Urgency First). Cet algorithme utilise le paramètre d’urgence comme
priorité, en d’autre termes la tâche qui possède la plus grande urgence Ur se voit
attribuée la plus haute priorité et la tâche qui possède la plus petite urgence se voit
attribuée la plus faible priorité.

Dans l’architecture proposée dans leur approche ( Figure 6) l’urgence des


tâches est mise à jour en fonction de la performance du processus contrôlé
correspondant. on peut constater que, ni la période, ni la durée d’exécution des travaux
n’intervient dans la politique d’ordonnancement des tâches de contrôle, ce qui rend
donc l’impact due à leurs incertitudes quasi nulle.

Urgency Update

Scheduler
Contrôleur #1 Processus # 1

CPU
Processus # n
Contrôleur #n

Figure 6. Architecture du feedback scheduling de XIA

II. 9. 3 Gestion de la surcharge

Généralement dans les systèmes temps réel en situation de surcharge, les tâches de
priorité faible sont placées dans une file d’attente. Deux situations peuvent survenir lors
de l’arrivée d’une nouvelle instance d’une tâche dans le système :

1. L’instance courante est en cours d’exécution et n’a pas fini son travail ;

39
Chapitre II : Ordonnancement par commande rétroactive

2. L’instance courante est encore entrain d’attendre le CPU et n’a pas encore
démarrée son exécution.

Dans l’approche proposée par Xia et all, il n’y a qu’une seule instance d’une tâche
active dans le système à tout moment. Dans la situation 1, la nouvelle instance sera tout
simplement sautée ou perdue et dans la situation 2 l’instance courante sera écrasée ou
remplacée par la nouvelle.

En autant certaines instances, considérée comme des échantillonnages manqués, les


situations de surcharge peuvent convenablement être gérées.

Combiné à l’algorithme MUF l’effet de sauter les instances pour les tâches de priorité
faible est bénéfique pour les tâches de priorité haute (urgence les plus élevées) car les
ressources disponibles pourront être allouées dynamiquement entre ses tâches de
priorités hautes. Seules les tâches de priorités faibles (urgence les plus basses)
souffriront des sauts d’instances, le facteur d’utilisation de ses tâches pourra être réduit
dans le temps, augmentant ainsi les ressources pour les tâches d’urgence élevées.

II. 10 Fuzzy feedback scheduling

Dans Xia et all [XIA 05], une approche basée sur la régulation floue est proposée pour
diminuer le temps d’exécution(à l’aide du calcul hors ligne d’une table de décision) mais
aussi pour gérer de manière efficace l’incertitude sur les temps d’exécution et plus
généralement sur l’utilisation effective du système. Le problème considéré est de
concevoir un gestionnaire en sachant que le système d’exploitation ne permet pas
d’obtenir les temps d’exécution des travaux (qui peuvent varier), mais seulement une
estimation imprécise Ũ de l’utilisation récente.

La régulation floue est une technique permettant d’intégrer de l’expérience humaine


dans le fonctionnement du régulateur en permettant d’expliquer son fonctionnement de
manière « floue » ; elle repose sur la logique floue (cf. chapitre VI) où la valeur de vérité
d’une proposition n’est pas seulement binaire (vrai ou faux), mais peut être nuancée (pas
tout fait vrai). D’après les auteurs, ce genre de régulation est particulièrement adapté

40
Chapitre II : Ordonnancement par commande rétroactive

aux situations où les informations utilisées par le régulateur sont entachées


d’imprécisions.

L’idée de Xia et all. est de développer un régulateur basé sur la régulation floue qui
prend en entrée une erreur e = Ũ - Uref ainsi que la différence Δe entre l’erreur
courante et l’erreur à l’exécution précédente du gestionnaire (ce qui rappelle le terme
dérivatif d’une loi de réglage PID). La sortie du régulateur est un facteur α à appliquer
pour rééchelonner toutes les périodes linéairement à l’instar du facteur Ũ /Uref utilisé
par Cervin et all [CER 00]:

hi= α * hi

Les auteurs utilisent une méthode particulière de conception de régulateur flou qui
consiste à calculer en hors ligne les correspondances et les fonctions d’appartenance
nécessaires à son fonctionnement. Cela nécessite une limitation a priori des valeurs que
peuvent prendre les entrées e et Δe ; il est ainsi par exemple choisi de limiter ces entrées
aux intervalles [-0.3, 0.3]. Il n’est pas dit comment le régulateur se comporterait au cas
où une des valeurs dépasserait ses bornes ; toutefois, nous pourrions imaginer
simplement employer un facteur de saturation pour projeter toute valeur hors de
l’intervalle sur la borne la plus proche. L’intervalle [0.5, 1.5] est fixé pour les valeurs
produites en sortie.

Cependant, les travaux de Xia [XIA 05] n’explorent pas d’une part toutes les
techniques offertes par la théorie de la commande floue et d’autre par ne compare pas
les résultats obtenus avec ceux obtenus par d’autres méthodes de commande par
rétroaction de l’ordonnanceur comme la méthode de rééchelonnement des périodes de
Cervin. En plus, Feng Xia, premièrement suppose que les durées d'exécutions des tâches
sont fixes et ne variées pas dans le temps et deuxièmement utilise que la politique
d’ordonnancement à priorité fixe (RM [LUI 73]) et n’expérimente pas d’autres politiques
comme ceux à priorité dynamique (e.g EDF[LUI 73])).

41
Chapitre II : Ordonnancement par commande rétroactive

II. 11 Conclusion

Le feedback scheduling est une approche de l’ordonnancement temps réel


permettant de tenir compte de l’évolution imprévisible des tâches dont le
système et de s’y adapter. Les tâches-régulateur, implantations de régulateurs
numériques sous forme de tâches temps réel, forment une famille particulière
de traitements pouvant afficher des besoins évoluant dans le temps, par
exemple en nécessitant brusquement plus de temps de calcul ou des périodes
plus serrées afin de satisfaire les besoins liés aux procédés dont ils sont
responsables. Les approches traditionnelles de la communauté temps réel, basées
sur des pires temps d’exécution et des périodes fixes, ne sont pas adaptées à de
telles circonstances car peuvent mener en moyenne à une mauvaise utilisation
des ressources. Le feedback scheduling consiste à utiliser une boucle de rétroaction
pour ajuster au fil du temps l’ordonnancement de sorte à optimiser les
performances de la régulation mais pouvant aussi améliorer l’utilisation des
ressources, ce qui est d’intérêt dans des systèmes embarqués à puissance de calcul
limitée.

42
Chapitre III
Présentation de la logique floue et de la
commande floue.
III. 1 Introduction ..................................................................................................................................... 44
III. 2 Logique classique et logique floue .......................................................................................... 44
III. 3 Concepts et définitions ................................................................................................................ 46
III. 3. 1 Sous ensembles flous (SEFs)............................................................................................. 46
III. 3. 2 Opérations sur les sous ensembles flous (SEFs)....................................................... 48
III. 3. 3 Variables linguistiques........................................................................................................ 49
III. 3. 4 Relations floues...................................................................................................................... 50
III. 3. 5 Proposition floue ................................................................................................................... 51
III. 4 Commande Floue ........................................................................................................................... 54
III. 4. 1 Description générale d’un contrôleur flou .................................................................. 56
III. 4. 2 Base de connaissances ........................................................................................................ 58
III. 4. 3 Mise en forme des entrées ................................................................................................. 58
III. 4. 4 Interface de fuzzification.................................................................................................... 58
III. 4. 5 Procédure d’inférence ......................................................................................................... 60
III. 4. 6 Interface de défuzzification............................................................................................... 61
III. 4. 7 Mise en forme de la sortie.................................................................................................. 64
III. 5 Conclusion ........................................................................................................................................ 64
Chapitre III : Présentation de la logique floue et de la commande floue

III. 1 Introduction

D
ans le fonctionnement de l'esprit humain, les incertitudes sont
particulièrement remarquables. La capacité d’établir des classes d’éléments
de la nature ayant des propriétés analogues est très naturelle chez
l’homme. Il sait déterminer l’âge approximatif d’un individu en l’observant.
Il sait aussi rendre compte de données vagues «Large ouverture»,
imprécises «de 3 à 5 m», mal définies «massif altéré», dont la validité n’est pas absolue
«dans 85% des cas», soumises à une incertitude «très probable». Il est tout aussi naturel à
l’homme de traiter des données affectées d’incertitude, inhérentes à l’univers ou dues à
sa méconnaissance de certains facteurs, que d’utiliser des critères subjectifs, donc
imprécis [COX 94]. Le souci d’automatiser ou d’assister de façon automatique les actions
humaines, naturellement empiriques et empreintes d’imprécisions, dans le cadre d’une
aide à la décision ou du contrôle par exemple, renforce l’intérêt des scientifiques pour
l’approche floue et justifie son intense développement au cours de ces dernières années.
C'est pour les possibilités qu’elle offre la gestion de l’incertitude et l’imprécision, que
nous nous sommes intéressés à la logique floue.

Les bases théoriques de la logique floue ont été formulées en 1965 par le professeur
Lotfi A. Zadeh, de l’Université de Berkeley en Californie[ZAD 65] . Il a introduit la notion
de sous-ensemble flou pour répondre aux problèmes auxquels sont confrontés de
nombreux systèmes complexes, qui doivent traiter des informations qui sont de nature
imparfaite. Son concept de base est de graduer l’appartenance à un ensemble, c’est un
moyen efficace pour prendre en compte l’imprécision dans la connaissance et de
formaliser le processus de raisonnement humain. De nombreuses applications basées
sur la logique floue sont développées dans divers domaines, dans lesquelles aucun
modèle déterministe n’existe ou n’est pratiquement implémentable. Ainsi que dans des
situations pour lesquelles l’imprécision sur les données rend le contrôle par des
méthodes classiques impossible.

III. 2 Logique classique et logique floue

Dans le cadre de la logique classique, une proposition est soit vraie, soit fausse (1
ou 0). Par exemple, la logique classique peut facilement partitionner la température

44
Chapitre III : Présentation de la logique floue et de la commande floue

d’une pièce en deux sous-ensembles, «moins de 15 degrés» et «15 degrés ou plus». La


figure 07 a montre le résultat de cette partition. Toutes les températures de moins de 15
degrés sont alors considérées comme appartenant à l’ensemble «moins de 15 degrés».
On leur affecte une valeur de 1. Toutes les températures atteignant 15 degrés ou plus ne
sont pas considérées comme appartenant à l’ensemble «moins de 15 degrés». On leur
attribue une valeur de 0.

Cependant, le raisonnement humain s’appuie fréquemment sur des


connaissances ou des données inexactes, incertaines ou imprécises. Une personne
placée dans une pièce dont la température est soit de 14.95 degrés ,soit de 15.05 degrés,
ne fera certainement pas de distinction entre ces deux valeurs. Cette personne sera
pourtant capable de dire si la pièce est «froide» ou «chaude», sans pour cela utiliser de
température limite ni de mesure précise. La logique floue permet de définir des sous-
ensembles, comme «froid» ou «chaud», en introduisant la possibilité pour une valeur
d’appartenir plus ou moins à chacun de ces sous-ensembles.

La logique floue permet de faire intervenir les notions d’imprécision et


d’incertitude dans un système. Cela permet par exemple de faire intervenir une
température «d’environ 15 degrés» dans un contrôleur flou. L’incertitude et
l’imprécision peuvent également être prises en compte dans le cadre de la logique floue
quand on utilise une connaissance issue d’un expert humain. Comment pourrait-on
utiliser avec des outils standards une connaissance humaine du genre : «il pleut souvent
en hiver» ?

Froid Chaud Chaud


1 1 Froid
0,706

0,5 0,5

0,172
0 0
15 45 45
0 1 Température
Température 0 5
(a) Deux sous-ensembles selon la logique classique (b) Deux sous-ensembles selon la logique floue

Figure 7.Classification des températures d’une pièce en deux sous ensembles


45
Chapitre III : Présentation de la logique floue et de la commande floue

III. 3 Concepts et définitions

Dans cette section, nous présentons les concepts et nous donnons les principales
définitions concernant la théorie de la logique floue.

III. 3. 1 Sous ensembles flous (SEFs)

La notion de sous-ensembles flous à pour but de permettre des gradations dans


l'appartenance d'un élément à une classe, c’est-à-dire d'autoriser un élément à
appartenir plus ou moins à une classe prédéfinie, «plus la surface d’un appartement se
rapproche de 200𝑚𝑚2, plus son appartenance à la classe des grands apparentements est
forte». Cette notion permet l'utilisation de catégories aux limites mal définies «Large»,
de situations intermédiaires entre le tout et le rien «presque ouvert», le passage
progressif d’une propriété à une autre «passage de peu profond à profond», l’utilisation
de valeurs approximatives «environ 12 mètres».

Cette présentation évite l'utilisation arbitraire de limites rigides à des classes et


répond au besoin de présenter des connaissances imprécises, soit parce qu’elles sont
exprimées en langage naturel «on utilise aussi le terme variable linguistique», soit parce
qu’elles sont obtenues avec des instruments d’observations qui produisent des erreurs
de mesure.

Définition : Étant donné un ensemble de référence X, on peut indiquer les éléments


de X qui appartiennent à une certaine classe de X et ceux qui n’y appartiennent pas. Cette
classe est alors un sous-ensemble de X. Si l’appartenance de certains éléments de X à une
classe n’est pas absolue, on peut indiquer avec quel degré chaque élément appartient à
cette classe. Celle-ci est alors un sous-ensemble flou de X [BOU 95].

Définition : Un sous-ensemble flou A dans un univers du discours X est caractérisé


par sa fonction d’appartenance 𝜇𝜇𝐴𝐴 (𝑥𝑥) qui associe à chaque élément x de X une valeur
dans l’intervalle des nombres réels [0, 1].

µA : X → [ 0,1]

46
Chapitre III : Présentation de la logique floue et de la commande floue

Ainsi un sous-ensemble flou A dans X peut être représenté par un ensemble de


couples ordonnés :

=A {x, u A ( x); x ∈ X , u A ∈ [ 0,1]} (16)

Exemple : Pour évaluer la hauteur (H) d'une personne en utilisant des termes
linguistiques, nous devons leurs associer des fonctions de représentation. Nous
présentons dans cet exemple, l'évaluation de la hauteur (H) d'une personne selon la
logique floue. Pour cela, nous pouvons utiliser les mots, PETIT et GRAND. La
représentation de PETIT et GRAND se fait au moyen de deux fonctions qui calculent
l'appartenance de chaque personne à l'ensemble floue PETIT et/ou GRAND. Ainsi, une
personne qui mesure 1m63 appartient en même temps au sous-ensemble flou PETIT et
au sous-ensemble flou GRAND avec un degré de 0,7 (pour PETIT) et de 0,3(pour
GRAND). Un sous-ensemble peut être représenté graphiquement par un trapèze ou une
fonction plus complexe. La Figure 8 présente une forme de représentation.

µ (H )
Petite Grande
1

1m 1m 1 Taille
(m)

Figure 8. Représentation de l'âge par des sous-ensembles flous

La notion de Sous ensemble flou (SEF) permet :

- la gradation de l’appartenance d’une variable à une classe définie, donc la description de


situations intermédiaires entre le tout ou rien,
- l’utilisation de catégories aux limites mal définies (comme “petits” ou “grands”),
- un passage progressif d’une propriété à une autre (passage de “petits” à “grands”),
- l’utilisation de valeurs approximatives (“environ 1.80 m ”).

47
Chapitre III : Présentation de la logique floue et de la commande floue

III. 3. 2 Opérations sur les sous ensembles flous (SEFs)

Supposons que A et B sont deux sous-ensembles flous définis dans un univers du


discours X par les fonctions d’appartenance μA et μB . On peut définir des opérations
ensemblistes telles que l’égalité, l’inclusion, l’intersection, l’union et le complément
grâce à des opérations sur les fonctions d’appartenance [MIZ 89].

Egalité : A et B sont dits égaux, propriété que l’on note A = B, si leurs fonctions
d’appartenance prennent la même valeur en tout point de X :

∀x ∈ X u A ( x) =u A ( x) (17)

Inclusion : A est dit inclus dans B, propriété que l’on note A⊂ B, si tout élément x de X
qui appartient :

∀x ∈ X u A ( x) ≤ u A ( x) (18)

Intersection : L’intersection de A et B, que l’on note A∩B, est le sous-ensemble flou


constitué des éléments de X affectés du plus petit des deux degrés d’appartenance μA et
μ B.

( x ) min ( u A ( x ) , uB ( =
∀x ∈ X u A∩ B= x )) u A ( x ) ∧ uB ( x ) (19)

Union : L’union de A et B, que l’on note A∪ B, est le sous-ensemble flou constitué des
éléments de X affectés du plus grand des deux degrés d’appartenance μA et μB :

( X ) max( u A ( x ) , uB =
∀x ∈ X u A∪ B= ( x ) ) u A ( x ) ∨ uB ( x ) (20)

Complément : Le complément de A, que l’on note 𝐴𝐴∁, est le sous-ensemble flou de X


constitué des éléments x lui appartenant d’autant plus qu’ils appartiennent peu à A :

∀x ∈ X u AC ( x ) = 1 − u A ( x ) (21)

48
Chapitre III : Présentation de la logique floue et de la commande floue

III. 3. 3 Variables linguistiques

Toutes les variables que l'on considère, en physique ou en économie, par exemple,
prennent une valeur unique de leur ensemble de définition X dans une situation donnée.
Néanmoins, les conditions d’observations ne permettent pas toujours de connaître
parfaitement cette valeur unique. Donc, une variable linguistique sert à modéliser les
connaissances imprécises ou vagues sur une variable dont la valeur précise peut être
inconnue.

Définition : Une variable linguistique est un triplet (V, X, Tv), dans lequel : V est une
variable définie sur un ensemble de référence X. L'ensemble Tv = {A1, A2, …}, fini ou
infini, contient des sous-ensembles flous normalisés de X, utilisables pour caractériser V.
Selon l'utilisation qui doit être faite, le nombre d’éléments de Tv est plus ou moins grand
[BOU 95].

Exemple : Afin de décrire la température d’une pièce par une variable linguistique, on
peut utiliser l’ensemble des termes suivants : T(V) = {froid, tiède, chaud}. En considérant
que l’univers du discours est l’intervalle [0, 45], on peut définir les termes linguistiques
comme suit : «froid» est «une température environ inférieure à 10 degrés», «tiède» est
«une température d’environ 17 degrés» et «chaud» est «une température environ
supérieure à 24 degrés». Ces termes peuvent être caractérisés par les fonctions
d’appartenance représentées sur la figure 09 . N’importe quelle fonction d’appartenance,
par exemple la fonction «froid», définit un nombre flou.

Variables linguistiques

T(x) Froid Tiède Chaud

0,5

0
5 10 15 20 25 30 35 40 Degrés
Figure 9. Variables linguistiques (V, T(V), X) pour décrire la température

49
Chapitre III : Présentation de la logique floue et de la commande floue

III. 3. 4 Relations floues

Une relation floue est un concept qui permet de définir un sous-ensemble flou sur un
univers du discours qui est un produit cartésien, tout en tenant compte des relations qui
relient les univers du discours initiaux. La fonction d’appartenance définissant ce sous-
ensemble flou ne se résume pas forcément à une simple combinaison de fonctions
d’appartenance définissant des sous-ensembles flous dans les univers du discours
initiaux.

Définition : Une relation floue R sur les univers de références X1, X2,..., Xn est définie
comme un ensemble floue du produit cartésien X1 × X2 × ... × Xn ayant la fonction
d'appartenance μR.

Rx {(( x1 , x2 , . . . , xn ), ur ( x1 , x2 , . . . , xn )) | ( x1 , x2 , . . . , xn ) ∈ X}. (22)

Où 𝜇𝜇𝑅𝑅 (𝑥𝑥1 , 𝑥𝑥2 , . . .,𝑥𝑥𝑛𝑛 ) est une fonction de mappage :

uR ( x1 , x2 , . . ., xn ) : x1 × x 2 × . . . × x n → [ 0, 1] (23)

Exemple : La relation floue R : "approximativement égal à" peut être définie sur ℛ ×
1
ℛ par la fonction : μℛ (x, y) = 1+ (x−y)2

0 1 2 3 4 5
6

Figure 10. Représentation de la relation x approximativement égal à 3

50
Chapitre III : Présentation de la logique floue et de la commande floue

La différence entre une relation floue et une relation classique (exacte) est que pour
la première, toute valeur d'appartenance dans l'intervalle [0,1] est permise alors que
pour la seconde, seules les valeurs 0 et 1 sont permises.

III. 3. 5 Proposition floue

La connaissance experte est souvent traduite avec des règles du type “Si ‹prémisse›
alors ‹conclusion›”. L’une des principales caractéristiques de la logique floue vient du fait
que ces règles, appelées aussi règles d’inférence, sont susceptibles de représenter
l’imprécis, si les prémisses et les conclusions sont exprimées avec des mots du langage
naturel.

En logique floue, il existe deus familles de règles d’inférence :

- Les règles simples :

“Si u est A alors v est B”

- Les règles graduelles :

“Souvent Si u est A , alors v est B”

“Plus u est A , plus v est B”…

avec A et B des SEFs définis sur leurs univers de discours respectifs U et V , u et v


eux variables floues prenant leurs valeurs linguistiques dans U et V .

Cette représentation suppose que les prémisses sont des contraintes sur les variables,
et que la conclusion est calculée à travers un processus de propagation des contraintes
comprenant trois étapes [ZAD 88] :

 l’implication floue
 l’inférence floue
 l’agrégation des règles.

51
Chapitre III : Présentation de la logique floue et de la commande floue

c. Implication floue

L’implication floue permet le calcul du degré de vérité d’une proposition floue, c’est-
à-dire la mesure de la conformité de cette proposition avec le contenu de notre
connaissance de la réalité [DUB 85]. On peut aussi dire qu’elle quantifie la force de la
liaison entre la prémisse et la conclusion de la règle. L’implication floue (notée ⇒ ) est
une généralisation de l’implication classique.

Soient la prémisse P = “ u est A”, la conclusion Q = “ v est B” et la règle R : P ⇒ Q : “Si u


est A alors v est B”. Alors, le produit cartésien (traduction mathématique du produit
cartésien) de R: P ⇒ Q , noté aussi R=P × Q, est caractérisé par :

µ R (u, v ) = µ P×Q (u, v ) = imp(µ P (u ), µ Q ( v ) ) , avec u∈U et v ∈V (24)

où imp est l’opérateur du produit cartésien.

Il existe de nombreux et différents opérateurs d’implication floue (près de 40), mais,


les plus souvent utilisés dans le domaine de la commande sont [MIZ 88, BOU 93] :

• l’implication de Mamdani (1974):

µ R (u, v ) = imp(µ P (u ), µ Q ( v ) ) = min(µ P (u ), µ Q ( v ) ) (25)

• l’implication de Larsen (1980):

µ R (u, v ) = imp(µ P (u ), µ Q ( v ) ) = µ P (u ) ⋅ µ Q ( v ) (26)

d. Inférence floue : le modus ponens généralisé

Soit la règle : “Si la puissance de la machine est importante, alors sa consommation en


courant est élevée”. Cette règle doit pouvoir être utilisée pour une machine donnée dont
on connaît précisément la puissance, qui n’est pas forcément typique de la
caractérisation “importante”, et doit également fournir une conclusion relative à sa
consommation en courant si la puissance de la machine n’est que relativement
importante, par exemple. Dans la logique classique, la règle de raisonnement du modus
ponens ne permettrai d’obtenir une conclusion que si l’on savait exactement que la
52
Chapitre III : Présentation de la logique floue et de la commande floue

puissance de la machine considérée est importante. Il faut donc modifier le modus


ponens pour atteindre la souplesse de raisonnement souhaitée.

Le modus ponens trouve son équivalent (sa généralisation) flou dans le cadre du
raisonnement approximatif sous la forme du modus ponens généralisé [ZAD 88]. Ce
dernier permet de traiter, dans un même cadre, des connaissances exprimées de façon
symbolique et des données purement numériques, tout en tenant compte de l’aspect
graduel des caractérisations floues (si la donnée est très proche de la prémisse de la
règle, la conclusion est très proche de la conséquence de la règle).

Etant donné une règle R et des informations relatives au fait observé (P), la
conclusion (Q) est déterminée à partir de la loi de composition ○, en appliquant le
modus ponens généralisé :

µ Q (v ) = µ PoR (v ) = sup u ∈ U {T[µ P (u ), µ R (v )]} (27)

Voici une présentation formelle simple du modus ponens et de sa généralisation le


modus ponens généralisé :

Logique classique Logique floue

Règle R : Si u est A alors v est B Si u est A alors v est B

Assertion (fait observé) P : u est A u est A′

___________________ ___________________

Déduction Q: v est B v est B′

Le SEF inféré B ′ se déduit de A′ à travers la règle R :

µ B′ ( v ) = µ A′oR ( v ) = sup{T[µ A′ (u ), µ R (u, v )]}= sup{T[µ A′ (u ), imp(µ A (u ), µ B ( v ) )]} (28)


u ∈U u ∈U

Dans le domaine de la commande, c’est l’opérateur de Zadeh qui est le plus


couramment utilisé :

53
Chapitre III : Présentation de la logique floue et de la commande floue

µ B′ ( v ) = sup min[µ A′ (u ), µ R (u, v )] = sup min[µ A′ (u ), imp(µ A (u ), µ B ( v ) )] (29)


u ∈U u ∈U

e. Agrégation des règles

Le raisonnement précédent s’étend aux bases de règles comportant plusieurs


propositions. Ces règles sont généralement (domaine de la commande) reliées par
l’opérateur OU. Chaque règle est traitée séparément et les ensembles inférés, à partir de
chaque proposition, sont agrégés pour définir l’ensemble final.

Formulation pour plusieurs règles élémentaires (les règles Ri sont du type “si u est Ai
alors v est Bi ”) :

Règle floue R : R = (R1 OU R2 … OU Ri … OU Rn)

Assertion (fait observé) P : u est A′


______________________________

Déduction Q : v est B ′

Le SEF inféré B ′ se déduit de A′ à travers la règle R :

µ B′ ( v ) = µ A′oR ( v ) = sup{T[µ A′ (u ), µ R (u, v )]} (30)


u ∈U

avec µ R (u, v ) = µ R 1 OU R 2  OU R n [ 1 2 n
]
(u, v ) =⊥ µ R (u, v ), µ R (u, v ),  µ R (u, v ) . (31)

III. 4 Commande Floue

Habituellement, une loi de commande est élaborée à partir d’une approche


système basée sur l’utilisation des informations disponibles. Mais, dans l’hypothèse de la
non disponibilité ou de la difficulté d’obtention d’un modèle mathématique du processus
à commander, la connaissance ne peut provenir qu’uniquement de mesures des
variables caractéristiques, et d’une description linguistique du fonctionnement du
processus ou de la stratégie de son pilotage utilisée par des experts ou des opérateurs
qualifiés. La connaissance disponible s’exprime alors dans un langage naturel et logique
qu’il convient d’exploiter pour synthétiser une stratégie de commande.

54
Chapitre III : Présentation de la logique floue et de la commande floue

Les approches conventionnelles (classiques) de l’automatique, nécessitant la


disponibilité d’une modélisation mathématique explicite, étant inadaptées à l’utilisation
d’une telle forme de connaissances, les contrôleurs flous (CFs), traduction littérale de la
dénomination anglaise “Fuzzy Controllers”, sont tout à fait recommandés pour ce type
de problématique. En effet, leur loi de commande est exprimée avec des règles
linguistiques et offrent la capacité et la facilité d’intégration de données subjectives [YAG
94, PAS 98].

Une loi (un algorithme) de commande floue consiste en une collection de règles
floues appelée base de règles. Plusieurs solutions peuvent être envisagées pour établir
ces règles [LAC 97]:

• La méthode la plus utilisée pour la commande de systèmes de complexité


importante est l’extraction des connaissances d’opérateurs humains. Elle peut être
obtenue directement sous forme de règles énoncées par des experts dans la
commande du processus ou bien à partir d’un jeu de données entrées-sorties
représentatif du comportement de l’opérateur humain. Pour le second cas, il s’agit
de construire un modèle flou des actions de commande prises par l’opérateur [TAK
85].
• A l’instar de la méthodologie usuelle en automatique conventionnelle, le contrôleur
flou (CF) peut être élaboré sur la base d’un modèle flou du système à commander.
On peut citer essentiellement deux méthodes : celle des règles à conclusion
polynomiale [TAK 85] et celle du modèle d’état flou [TON 80, TOG 85]. L’inversion de
ce modèle conduit directement à un CF. Cependant, l’utilisation de ce modèle inverse
en tant que contrôleur n’est envisageable que lorsque le système à commander est à
minimum de phase. Dans le cas contraire, cela conduirait à une instabilité du
système en boucle fermée. L’utilisation à la fois directe et indirecte [BAV 96] (après
inversion) du modèle flou du processus conduit à des lois de commande floue par
modèle interne ou prédictive [BAB 95].
• Les connaissances des automaticiens sur le comportement des processus vis-à-vis
de certaines classes d’entrées (par, exemple les réponses temporelles) peuvent aussi
être utilisées pour la réalisation de CFs [SUG 85, TAN 87]. Il existe également des
règles d’équivalence entre les contrôleurs classiques de type PID et les CFs [FOU 92,
55
Chapitre III : Présentation de la logique floue et de la commande floue

MIZ 95, MAN 99]. Une table de règles très connue en régulation est celle de Mac
Vicar-Whelan [MAC 76] utilisée avec succès dans plusieurs applications [LOU 07].
Ces contrôleurs sont des versions floues de contrôleurs usuels.

Ayant passé en revue, dans le paragraphe précédent, les principaux concepts et outils
de la théorie des SEFs, nous pouvons à présent procéder au développement des notions
principales constituant la base de conception d’un CF.

III. 4. 1 Description générale d’un contrôleur flou

La structure générale d’un processus à commander via un CF est illustrée par la


figure 11 suivante [LOU 97, ADD 05] :

CONTROLEUR FLOU
Base de
Données
Base de
Connaissances
Base de
Règles

Interface de f Procédure f Interface de


Fuzzification d’Inférence lou Défuzzification

Mise en forme Mise en forme

Consigne

Sortie Processus Commande


Capteur Actionneur
(non floue) (non floue)

Figure 11 : Schéma synoptique général d’un CF appliqué à la commande d’un processus

Ce schéma synoptique met, essentiellement, en évidence les parties constitutives de


base d’un CF [LEE 90a, LEE 90b, PAS 98] :

56
Chapitre III : Présentation de la logique floue et de la commande floue

- La variable caractéristique du processus à commander à savoir sa sortie prélevée et la


consigne définissent les variables d’entrée du CF. La sortie de ce dernier est la
commande à appliquer au processus.
- La base de connaissance est composée d’une base de données et d’une base de règles :
• La base de données regroupe :
 Les SEFs associés aux variables d’entrées (sortie) et leurs partitions sur leurs
univers de discours respectifs régissant l’interface de fuzzification
(défuzzification),
 Les éléments réalisant la mise en forme des entrées (facteurs d’échelle (gains)
pour la normalisation - calcul d’erreur et de variation d’erreur) et de la sortie
(facteurs d’échelle (gains) pour la dénormalisation).
• La base de règles contient des règles de la forme :

“SI (X1 est A1 et X2 est A2) ALORS (Y est B)”

X1, X2 et Y étant des grandeurs physiques caractéristiques du système et du


problème de commande. A1 et A2 sont des labels (valeurs) linguistiques alors que B
peut être une valeur linguistique (contrôleur de type Mamdani) ou algébrique
(contrôleur de type Sugeno).

- La procédure d’inférence traite les données d’entrée floues et les règles de décision
pour inférer les actions (décisions) de commande floue en employant l’implication
floue et les lois d’inférence de la logique floue.

On peut définir et décrire un CF comme étant un système à base de connaissances


particulier, utilisant un raisonnement en profondeur dans une procédure de chaînage
avant des règles (activation des règles par les prémisses). Toutes les règles activables
(prémisses caractérisées par un degré d’appartenance non nul) sont activées. On
considère ensuite “une moyenne” sur le résultat de ces règles pour engendrer une
décision finale.

57
Chapitre III : Présentation de la logique floue et de la commande floue

III. 4. 2 Base de connaissances

La base de connaissances comprend une connaissance du domaine d'application et


des objectifs de la commande prévue. Elle consiste en une “base de données” et une
“base de règles de commande linguistique floue” :

f. Base de données

La base de données fournit les définitions nécessaires utilisées pour définir les règles
de commande linguistique et la manipulation des données floues dans le CF. Cette base
régit le fonctionnement des blocs mise en forme des entrées, interface de fuzzification,
interface de défuzzification et mise en forme de la sortie.

g. Base de règles

La base de règles caractérise les buts et la stratégie de la commande émise par les
experts du domaine au moyen d'un ensemble de règles linguistiques de commande. Elle
comporte une table de décision fournissant les règles de décision de base nécessaires au
déroulement de la procédure ou du mécanisme d’inférence.

III. 4. 3 Mise en forme des entrées

Cette première étape permet le traitement des variables d’entrée du CF, par exemple,
calcul d’erreurs et de variation d’erreurs. L’utilisation d’univers de discours normalisés
(compris entre -1 et 1) nécessite une transformation d’échelle. Elle est réalisée par
l’intermédiaire de facteurs d’échelle (gains de normalisation) transformant les valeurs
des grandeurs physiques des entrées en des valeurs normalisées appartenant à
l’intervalle [-1, 1].

III. 4. 4 Interface de fuzzification

Dans les applications de commande floue, les données observées sont habituellement
physiques (réelles numériques). Or, le traitement de données dans un CF est basé sur la
théorie des SEFs; les données observées nécessitent donc une fuzzification, c’est-à-dire,
une projection des variables physiques réelles sur des SEFs caractérisant les valeurs
linguistiques prises par ces variables avec des degrés d’appartenance à tel ou tel SEF sur
l’univers de discours correspondant (voir exemple de la figure 12).

58
Chapitre III : Présentation de la logique floue et de la commande floue

Ces SEFs sont caractérisés par leurs FAs ayant des formes arbitraires, pouvant être
triangulaires (voir figure 13), trapézoïdales, exponentielles, gaussiennes, … . Il est à
noter que les formes triangulaires sont les plus fréquemment utilisées en commande au
vu de leur facilité de programmation. Par ailleurs, des études comparatives de
commande en boucle fermée ont donné lieu, selon différentes formes de FAs, à des
résultats pratiquement similaires [LAC 97, LOU 07]. Quant à leur nombre, partitionnant
l’univers de discours, il est généralement impair car elles se répartissent
symétriquement autour de zéro (3, 5 et 7 sont des valeurs courantes). L’exemple de la
figure 13 montre une répartition linéaire de 7 FAs de forme triangulaire symétrique
dont chacune est affectée d’une valeur linguistique, avec :

NG: “Négatif Grand” Z :“Zéro” PP: “Positif Petit”

NM: “Négatif Moyen” PM: “Positif Moyen”

NP: “Négatif Petit” PG:“Positif Grand”

µ Vitesse
Degrés
Lente Moyenne
1

µv LENTE
( v1 )

µ v MOYENNE ( v

v 1 : valeur précise Vitesse (Km/h)

Figure 12 : Exemple de fuzzification d’une valeur numérique précise

59
Chapitre III : Présentation de la logique floue et de la commande floue logique floue

µVariable linguistique Valeurs


linguistiques des
fonctions
NG
N P d’appartenance

Univers de
discours
0 1
Variable

Figure 13: Exemple de fonctions d’appartenance triangulaires

III. 4. 5 Procédure d’inférence

Le fonctionnement de ce bloc d’inférence, noyau du CF, repose sur les données


fournies par la base des règles. Le raisonnement type Mamdani est utilisé pour illustrer
la procédure d’inférence correspondante.

Cette méthode se base sur l’utilisation de l’opérateur “min” pou la combinaison des
prémisses et pour l’implication et l’opérateur “max” pour l’agrégation des règles.

Le raisonnement est exposé par deux règles simples :

Si x1 est ZE et x 2 est ZE alors u est ZE

Si x1 est PP et x2 est PP alors u est PP

Pour un couple d’observation ( x1 , x2 ), l’ensemble inféré ( u′ ) est caractérisé par :


0 0

µ u′ (u) = max{min[µ ZE ( x1 ), µ ZE ( x2 ), µ ZE (u)], min[µ PP ( x1 ), µ PP ( x2 ), µ PP (u)]}


0 0 0 0
(32)

Chaque règle est activée séparément et les conclusions sont agrégées pour définir le
SEF de u′ .

Ce raisonnement, facilement généralisable à plusieurs règles, est illustré par la


figure14.

60
Chapitre III : Présentation de la logique floue et de la commande floue logique floue

Figure 14 : Illustration de la méthode de raisonnement de Mamdani pour deux règles

III. 4. 6 Interface de défuzzification

Le résultat de l’agrégation des règles est une décision sous forme d’un SEF caractérisé
par la FA µu′ (u ) . Etant donné que l’organe de commande (actionneur) ne s’accommode
pas d’un tel genre de décision puisqu’il nécessite une grandeur physique bien
déterminée (précise), il est impératif de réaliser la transformation de cette information
floue en une grandeur de commande précise; c’est la phase de défuzzification dont les
informations nécessaires à son exécution sont puisées dans la base de données.

Plusieurs méthodes sont applicables [DRI 93, JAM 93, BUH 94, PAS 98], parmi
lesquelles :

• méthode de la hauteur ou du maximum


• méthode du premier des maxima
• méthode du dernier des maxima
• méthode de la moyenne des maxima
• méthode du centre de gravité
• méthode du centre des aires
• méthode du centre de la plus grande surface
• méthode du centre des maxima

61
Chapitre III : Présentation de la logique floue et de la commande floue logique floue

Dans ce qui suit, nous exposons celles qui sont les plus utilisées en commande.

a. Méthode de la hauteur et ses variantes

La méthode de la hauteur consiste à choisir comme grandeur de commande la valeur


du maximum (voir figure 15).

um = arg{max[µ u′ (u )]} (33)


µ u′

um u

Figure 15 : Exemple de défuzzification par la méthode de la hauteur

Dans le cas où la FA µu′ (u ) a plus d’un maximum, on a le choix entre le premier, le


dernier ou la moyenne des maxima. Une illustration de toutes ces variantes est donnée
par la figure 16.

µ u′

Premier des maxima : um 1

Dernier des maxima : um 2


um1 u m2 u

um + um
Moyenne des maxima um = 1 2
(34)
2

Figure 16 Exemple d’application des variantes de la méthode de la hauteur

Il est à noter que ces méthodes ont l’avantage de ne nécessiter que peu de calculs
mais présentent l’inconvénient de pouvoir engendrer des discontinuités dans la loi de
commande. Ceci explique pourquoi elles ne sont pas fréquemment utilisées en
commande floue.

62
Chapitre III : Présentation de la logique floue et de la commande floue logique floue

b. Méthode du centre de gravité

C’est la méthode la plus utilisée dans les CFs. Elle génère le centre de gravité de
l'espace flou délimité par la distribution de la FA résultante représentant l'action de
commande. Cette méthode procure pratiquement les meilleurs résultats mais elle est
aussi la plus coûteuse en calculs.

µ u′

Aire
comptabilisée

∫ µ (u).u.du u′
0
um = u
(35)
∫ µ (u).du
u
u′

Figure 17. Illustration de la défuzification par la méthode du centre de gravité

c. Méthode du centre des aires

Cette méthode, similaire à la précédente mais plus simple, ne nécessite pas le calcul
de µu′ (u ) . L’idée est de considérer la contribution de chaque aire individuellement.
L’ensemble u′ est alors construit à partir de chaque aire (voir figure 18). A noter que les
aires qui se recouvrent, si elles existent, sont
comptabilisées plus d’une fois. µ u′
Aire
comptabilisée
n

∫ ∑µu.
i =1
ui′ (u ).du
Ai Ai
um = u
n 1 2 (36)
∫∑ u i =1
µ u′ (u ).du 0
u

avec i = 1 à n : le nombre d’aires

Figure 18.Illustration de la défuzzification par la méthode du centre des aires

d. Méthode du centre de la plus grande surface

Cette méthode consiste à calculer le centre de gravité de la plus grande surface.

63
Chapitre III : Présentation de la logique floue et de la commande floue logique floue

e. Méthode du centre des maxima

Le maximum de chaque contribution ( µ k′ ) est déterminé. La commande à appliquer


est leur moyenne pondérée vis-à-vis des degrés d’activation (voir figure 19).

µ u′
µu′1
n
µu1′ (um1 )
∑µ ui′ (u mi ).u mi
um = i =1
n
(37) µu2′ (um2 )
∑µ i =1
ui′ (u mi )

um′ 1 um′ 2 u

avec i = 1 à n : le nombre de maxima

Figure 19 Illustration de la défuzzification par la méthode du centre des maxima

III. 4. 7 Mise en forme de la sortie

Ce dernier bloc du CF, régi par la base des données, permet de transformer
(“dénormaliser”) les valeurs normalisées de la variable de commande en des valeurs en
conformité avec son domaine physique d’application. Il permet aussi d’obtenir des effets
particuliers (proportionnel, intégral, …) [BUH 94].

III. 5 Conclusion

Dans ce chapitre nous avons présenté la théorie de la logique floue. Ensuite, les
différents aspects de l’application de cette théorie dans le domaine de la commande des
systèmes ont été présentés.

nous avons vu l’intérêt de cette approche dans les domaines du contrôle, Cette
dernière permet de tenir compte à la fois des connaissances d’un expert humain, de
l’incertitude et de l’imprécision des données traitées. Les variables linguistiques
permettent aussi de traiter ces deux informations initialement très différentes à l’aide
d’un formalisme unique. Cela va permettre de créé des systèmes intelligent de manière
facile et qui possède des capacités de raisonnement et de prise de décision proche à celle
de l’être humain.

64
Chapitre VI
Approche incluant un contrôle rétroactif
flou pour l'ordonnancement régulé des
tâches temps réel.

IV. 1 Introduction ..................................................................................................................................... 65


IV. 2 Le problème d’ordonncement par rétroaction................................................................... 65
IV. 3 Modélisation .................................................................................................................................... 68
IV. 3. 1 Modélisation temporelle des tâches .............................................................................. 68
IV. 3. 2 Autres paramètres temporelle des tâches................................................................... 69
IV. 4 Les critères de performances .................................................................................................... 70
IV. 5 Ordonnancement par rétroaction se basant sur le rééchelonnement des périodes
......................................................................................................................................................................... 73
IV. 6 Ordonnancement par rétroaction se basant sur la logique floue ............................... 76
IV. 6. 1 Architecture............................................................................................................................. 76
IV. 6. 2 Conception du régulateur d’ordonnancement flou .................................................. 78
IV. 7 Conclusion ........................................................................................................................................ 87
Chapitre IV : Approche incluant un contrôle rétroactif flou pour l'ordonnancement régulé des tâches temps
réel.

IV. 1 Introduction

L
e problème de l’ordonnancement temps réel par rétroaction (appelé aussi
ordonnancement régulé ou adaptatif ; feedback scheduling en anglais) des
tâches en général et celui de la commande par logique floue de
l’ordonnancement temps réel en particulier a été étudié dans la littérature.
Nous citons dans ce cas les travaux de Feng Xia [XIA 05] qui a utilisé la
commande par logique floue pour contrôler l’ordonnanceur des tâches. Cependant, les
travaux de Xia [XIA 05] n’explorent pas d’une part toutes les techniques offertes par la
théorie de la commande floue et d’autre part ne compare pas les résultats obtenus avec
ceux obtenus par d’autres méthodes de commande par rétroaction de l’ordonnanceur
comme la méthode de rééchelonnement des périodes de Cervin. De plus, Feng Xia,
premièrement suppose que les durées d'exécutions des tâches sont fixes et ne varient
pas dans le temps et deuxièmement n'utilise que la politique d’ordonnancement à
priorité fixe (RM [LUI 73]) et n’expérimente pas d’autres politiques comme ceux à
priorité dynamique (e.g EDF [LUI 73]).

Ainsi, notre contribution vise à explorer les techniques offerte par logique floue
(choix des valeurs des variables linguistiques, forme des fonctions d’appartenance et de
base de règles, …) avec des durées d'exécution variables dans le cadre de
l’ordonnancement régulé et de comparer les résultats obtenus avec ceux obtenus avec le
rééchelonnement des périodes de Cervin [CER 03] et l'utilisation de d’autres politiques
comme EDF.

IV. 2 Le problème d’ordonnancement par rétroaction

Comme montré par la Figure 20, on considère un système de contrôle où plusieurs


tâches partagent un processeur. Chaque tâche est responsable du contrôle d’un procédé.
On suppose que toutes les tâches sont périodiques et indépendantes les unes des autres.

65
Chapitre IV : Approche incluant un contrôle rétroactif flou pour l'ordonnancement régulé des tâches temps
réel.

Exécutif à temps réel

Tâches de Tâches de
Contrôle Contrôle
#1 #n

Procédé #1 Procédé #n

Figure 20. Système de contrôle temps réel avec plusieurs tâches concurrentes

Considérons que chaque tâche ti s’exécute avec une période d’échantillonnage hi et


une pire durée d’exécution Ci (WCET). En se basant sur la théorie de l’ordonnancement
temps réel, le facteur d’utilisation du processeur est U=∑𝑛𝑛𝑖𝑖=1 𝐶𝐶𝑖𝑖 /h𝑖𝑖 où n le nombre de
tâches du système. Cependant, dans la pratique et avec une application réelle, les durées
d’exécution des tâches changent. Ce qui implique que la mesure du facture d’utilisation
du processeur U et incertain et imprécise.

En plus, les algorithmes de contrôle sont conçus sans prendre en considération la


disponibilité des ressources de calcul. Dans le système considéré, la nouvelle instance
d’une tâche de contrôle n’est pas autorisée à commencer sont exécution jusqu’à ce que la
précédente instance de la même tâche ait terminé son exécution. La politique
d’ordonnancement considéré peut être par priorité fixe ou variable (dynamique). Dans
ce cas, lorsque les ressources de calcul deviennent insuffisantes, le retard des tâches de
contrôle ayant la plus faible priorité s’accumule vu les préemptions par les tâches de
plus hautes priorités. La performance du contrôle des tâches ayant une faible priorité
sera considérablement dégradée causant l’instabilité du système. Dans ce cas et dans le
but d’avoir une bonne qualité de contrôle (QoC) de chaque tâche, la condition
d’ordonnancement (équation 20) devrait être respecté.

U=(∑𝑛𝑛𝑖𝑖=1 𝐶𝐶𝑖𝑖 /ℎ𝑖𝑖 ) ≤ 𝑈𝑈𝑟𝑟𝑟𝑟𝑟𝑟 (38)

66
Chapitre IV : Approche incluant un contrôle rétroactif flou pour l'ordonnancement régulé des tâches temps
réel.

où Uref est la charge du processeur désirée (souhaitable) et qui doit être fixe dans le
temps et ne dépasse pas la borne donnée par la condition d’ordonnancement utilisée (1
pour EDF et n * ( n
2 - 1 ) pour DM [LEU 82]). Comme la qualité du contrôle d’une tâche

dépend de sa période d’échantillonnage [AST 97]. Ainsi, une courte période permet une
bonne qualité de commande. Cependant, sous la condition d’ordonnancement (cf.
équation 1), un ensemble de tâches faisable de courtes périodes engendre une meilleure
performance de contrôle, mais une surcharge du processeur. Dans ce sens, le rôle du
l’ordonnancement par rétroaction (feedback scheduling en anglais) vise à manipuler les
périodes (cf Figure 21 ) dans le but de mieux utiliser les ressources de calcule (CPU)
disponible et rendre le facteur d’utilisation U du processeur proche de la charge du
processeur désirée Uref même si les durées d’exécution des tâches changent.

Une limite inférieure de cette période (fréquence) est donnée par le théorème de
Shannon, mais des règles empiriques permettent la détermination la limite supérieure
de la période d’échantillonnage h, par exemple dans notre travail nous utiliserons une
règle (cf. équation 39) donnant la période d’échantillonnage h en fonction de la pulsation
propre du système bouclé ωn (bande passante de la boucle fermée) [AST 97]).

0.1≤ ωn * h ≤0.6 (39)

Figure 21. Ordonnancement par rétroaction


67
Chapitre IV : Approche incluant un contrôle rétroactif flou pour l'ordonnancement régulé des tâches temps
réel.

Notre contribution vise à explorer, premièrement, les techniques offertes par la


commande de la logique floue (fezzy feedback scheduling noté F-FBS) afin de calculer les
périodes des tâches sachant que leurs durées d’exécution changent dans le temps tout
en comparant les résultats avec ceux obtenus avec l’algorithme de rééchelonnement des
périodes de Cervin [CER 03] (noté R-FBS). Deuxièmement, d’utiliser, pour les cas
précédents F-FBS et R-FBS, les deux politiques d’ordonnancement, la politique à priorité
fixe DM et la politique à priorité dynamique EDF.

Notre contribution concerne aussi l’implémentation dans l’outil TrueTime d’un


générateur de durées d’exécutions des tâches.

IV. 3 Modélisation

Nous introduisons dans cette section les différents modèles que nous utilisons dans la
suite de cette étude.

IV. 3. 1 Modélisation temporelle des tâches

Nous considérons que le système est constitué par des tâches périodiques. Pour
modéliser les tâches périodiques, nous nous basons sur le modèle qui a été proposé par
Liu et Layland [LUI 73]. Dans ce modèle, une tâche périodique ti est modélisée par les
quatre paramètres chronologiques de base suivants :

ti = (ri,0, Ci, Di, hi, 0 ) (40)

Où hi,0 est sa période d’exécution nominale.

ri, 0 est la date de la première activation ou réveil et son nème réveil sera à l’instant :

ri, n= ri, 0+n* hi,0 (41)

Ci = Ci, max est sa durée d’exécution (ou capacité) au pire cas (WCET). Nous précision
ici que les tâches peuvent s’exécutées avec des durées inférieurs à leurs WCET (ci,n ≤ Ci,
max). Dans le but d’avoir ces durées, nous utiliserons par la suite un générateur aléatoire
de durées d’exécution.

68
Chapitre IV : Approche incluant un contrôle rétroactif flou pour l'ordonnancement régulé des tâches temps
réel.

Di est le délai critique ou échéance relative associée à ti, c'est-à-dire le délai maximum
acceptable pour son exécution. L’échéance absolue di, k de sa kème instance est calculée
comme suit :

di, k = ri, n + Di = ri, 0 + k* hi, 0 +Di (42)

On appelle tâches à départ simultané lorsqu’elles ont la même première date de réveil
(généralement ri, 0=0). Dans le cas contraire, on parle de tâches à départ déféré. Si
l'échéance d'une requête correspond à la date de réveil de la requête suivante (di, k=hi, 0 ),
alors la tâche est dite à échéance sur requête, dans le cas contraire, la tâche est dite à
échéance avant requête. Dans la suite, nous considérons que toutes les tâches sont à
échéance sur requête et à départ simultané.

Lorsque une tâche donnée s’exécute, elle effectue la lecture des consignes (noté I), le
calcul de la commande (noté Cc) et enfin l’envoi de la commande (noté O).

IV. 3. 2 Autres paramètres temporels des tâches

Idéalement, les tâches de contrôle doivent s’exécuter avec une parfaite


périodicité, et doivent avoir zéro retard entre la lecture des consignes et l’envoi des
commandes. Cependant, ceci ne peut être réalisable en application vu que l’exécution et
l’ordonnancement des tâches engendrent des latences. La Figure 22 ci-dessous montre
les paramètres temporels des tâches. On assume qu’une tâche ti de contrôle est activée
périodiquement à ri, k =k hi où hi est la période nominale d’échantillonnage de la tâche de
contrôle (contrôleur). Les dates de début d’exécution et fin d’exécution d’une tâche ti
notées si,k et ei,k respectivement, de la k ième instance d’une tâche ti (cf. Figure 20).
Cependant, cette tâche peut être mise en attente par d’autres tâches plus prioritaires et
son début d’exécution sera retardé pendant une durée Ls (Ls = si, k - ri, k) du temps. Cette
durée Ls est appelé latence d’échantillonnage du contrôleur. Les politiques
d’ordonnancement dynamiques (EDF) induits des variations en cette mesure. La gigue
d’échantillonnage Js d’une tâche est calculée par la différence de la latence maximale et la
latence minimale de toutes les instances d’une tâche.

Js = Lsmax - Lsmin (43)

69
Chapitre IV : Approche incluant un contrôle rétroactif flou pour l'ordonnancement régulé des tâches temps
réel.

Après le début de l’exécution d’une tâche, elle peut être préemptée (tâche 2 de la
Figure 22 ) par d’autres tâches plus prioritaires. La durée séparant le début (lecture des
consignes) et la fin (envoi de la commande) d’exécution est la latence d’entrée sortie
notée Lio (Lio = ei, k - si, k ). La variation des durées d’exécution d’une tâche fait varier cette
mesure. La gigue d’entrée sortie est calculée par :

Jio = Liomax – Liomin (44)

Le dernier paramètre est le temps de réponse noté Tresp égale a la durée séparant
l’activation de la tâche et sa fin d’exécution, ce temps est calculé aussi comme suit :

Tresp= ei, k - ri, k = Ls +Lio (45)

h1, k-1

Tâche 1 t

r1, k-1 r1, k

h2, k-1
Lio

LS
Tâche 2 t

r2, k-1 si, ei,k r2, k


k

TResp

Figure 22. Paramètres temporels des tâches

Les différentes gigues sur les latences, d’échantillonnage « Ls », d’entrées-sorties


« Lio » et de temps de réponse des tâches « Tresp » sont comparées par rapports à leurs
influences sur les coûts de performances en question.

IV. 4 Les critères de performance

Les critères de performance de la commande sont basés soit sur la valeur de la


commande et de la sortie de système contrôlé en utilisant une fonction coût croissante,

70
Chapitre IV : Approche incluant un contrôle rétroactif flou pour l'ordonnancement régulé des tâches temps
réel.

𝑇𝑇𝑇𝑇𝑇𝑇𝑇𝑇
tel que 𝐽𝐽𝑦𝑦𝑦𝑦 = ∫0 𝑢𝑢2 + 𝑦𝑦 2 𝑑𝑑𝑑𝑑, où Tsim représente la durée de la simulation, soit sur une
autre fonction prenant en compte l’aspect erreur sur la sortie et la référence, tel que
𝑇𝑇𝑇𝑇𝑇𝑇𝑇𝑇
𝐽𝐽𝑦𝑦𝑦𝑦 = ∫0 |𝑟𝑟 − 𝑦𝑦| 𝑑𝑑𝑑𝑑. La deuxième variante peut être plus utile que la première
quand il s’agit de la dégradation des performances. L’utilité de la première fonction du
coût est qu’elle gère bien la commande « u » en terme de dépassement et du coup
l’énergie appliquée.

Dans le Tableau 3, nous donnons les significations et la formule de chaque Paramètre


affiché.

Paramètre Signifiant Formule


Lio Latence d’entrée-sortie Lio = Tresp - Ls = ei, k - si, k
Ls Latence d’échantillonnage Ls = si, k - ri, k

Tresp Temps de réponse de tâches Tresp= ei, k - ri, k = Ls +Lio

Jio Gigue d’entrée-sortie : Valeur max(Lio) - Max(Lio)-Min(Lio)


Valeur min(Lio)
Js Gigue d’échantillonnage : Valeur max (Ls)- Max(Ls)-Min(Ls)
Valeur min (Ls)
Juy Coût à base de la sortie et la commande 𝐽𝐽𝑦𝑦𝑦𝑦 = ∫0
𝑇𝑇𝑇𝑇𝑇𝑇𝑇𝑇
𝑢𝑢2 + 𝑦𝑦 2 𝑑𝑑𝑑𝑑

Jry Coût à base de l’erreur entre la sortie et la 𝑇𝑇𝑇𝑇𝑇𝑇𝑇𝑇


𝐽𝐽𝑟𝑟𝑟𝑟 = ∫0 (𝑟𝑟 − 𝑦𝑦)2 𝑑𝑑𝑑𝑑 ou bien
référence
𝑇𝑇𝑇𝑇𝑇𝑇𝑇𝑇
𝐽𝐽𝑟𝑟𝑟𝑟 = � 𝑎𝑎𝑎𝑎𝑎𝑎(𝑟𝑟 − 𝑦𝑦) 𝑑𝑑𝑑𝑑
0

Tableau 3. Signifiant des paramètres de performance à étudier

Sans perte de généralité, dans les cas de dépassement d’échéance les algorithmes
d’ordonnancement utilisés, tels que DM ou EDF, peuvent tuer l’instance de la tâche en
question.

71
Chapitre IV : Approche incluant un contrôle rétroactif flou pour l'ordonnancement régulé des tâches temps
réel.

Figure 23. Caractéristiques temporelles de la réponse d'un processus

D’autres métriques sont utilisées pour mesurer la performance du contrôle, on a


recourt à différentes caractéristiques de la sortie du processus contrôlé (procédé).
Celles-ci sont typiquement définies dans le domaine temporel sur la réponse. La Figure
23 ci-dessus illustre ces caractéristiques sur la réponse indicielle d'un processus.

Dépassement (M) : exprime en pourcentage dans quelle mesure la sortie y (t) va


dépasser sa référence r(t) avant de l'atteindre.

M=maxt≥0 (y(t)-r(t))/r(t)*100 (%) (46)

Temps de réponse (TR) : En fonction de la précision exigée, le temps de réponse du


procédé (notion différente du temps de réponse de tâches) est le temps au bout duquel
la sortie du procédé pénètre dans le couloir de plus ou moins 5% de la référence sans en
sortir.

Temps de montée (TM) : temps nécessaire à la sortie du processus pour atteindre


un certain pourcentage de sa référence (nous considérerons ici 95%). Notons qu'on
définit également dans certains ouvrages comme le temps pour que la sortie passe de
10% à 90% de la référence.

Dans la suite et durant les simulations nous mesurerons le dépassement et le temps


de réponse.

72
Chapitre IV : Approche incluant un contrôle rétroactif flou pour l'ordonnancement régulé des tâches temps
réel.

IV. 5 Ordonnancement par rétroaction se basant sur le rééchelonnement


des périodes

Dans l’ordonnancement régulé (Feedback Scheduler) de Cervin [CER 03], la durée


d’exécution est elle-même la mesure utilisée dans la boucle. Un filtre passe bas avec un
facteur d’oubli lambda λ dans (0, 1) est ainsi utilisé pour estimer la prochaine durée
d’exécution sur laquelle on doit se baser pour calculer le facteur d’utilisation du
processeur. Le paramètre lambda λ permet de lisser l’estimateur dans le temps : s’il est
élevé, l’estimateur prendra plus de temps pour s’adapter à un changement soutenu du
temps d’exécution de la tâche, tandis que s’il est faible, il sera très sensible à des
changements transitoires. Par exemple, si λ=1 le résultat sera très lisse (constant) mais
la réponse du contrôleur (FBS) sera trop ralenti, si λ=0 le FBS détectera très vite la
surcharge mais sera soumis a des variations très fréquentes de charge. Ainsi, si le filtre, a
λ=0.1, fait vieillir les anciennes estimations, l’estimation de la durée d’exécution est
comme suit :

𝐶𝐶̂𝑖𝑖 (0) = h𝑖𝑖,0

𝐶𝐶̂𝑖𝑖 (𝑘𝑘) = 𝜆𝜆 ∗ 𝐶𝐶̂𝑖𝑖 (𝑘𝑘 − 1) + (1 − 𝜆𝜆) ∗ 𝑐𝑐𝑖𝑖 (47)

où : les ci sont les durées d’exécutions réelles des tâches et 𝐶𝐶̂𝑖𝑖 (0) est l’initialisation
arbitraire de l’estimateur de chaque tâche à sa période nominale.

Ainsi, lorsqu’une instance k de la tâche ti termine l'exécution, elle renvoie sa durée


d’exécution ci qui sera utilisée pour estimer la prochaine durée d’exécution 𝐶𝐶̂𝑖𝑖𝑘𝑘 puis le
� comme suit :
facteur d’utilisation 𝑼𝑼


 n
Ci
u = ∑i =1 hnomi
(48)

Pour contourner la surcharge processeur Cervin utilise un rééchelonnement des


périodes nominales avec un paramètre α >1 (appelé facteur de rééchelonnement)
calculé selon la borne de Lu et Layland [LUI 73] pour EDF et selon la borne de Leung et
all [LEU 82] pour DM:

73
Chapitre IV : Approche incluant un contrôle rétroactif flou pour l'ordonnancement régulé des tâches temps
réel.

� /𝑈𝑈𝑟𝑟𝑟𝑟𝑟𝑟
α= 𝑼𝑼 (49)

Tel que 𝑈𝑈𝑟𝑟𝑟𝑟𝑟𝑟 l’utilisation désirée des tâches sur laquelle le gestionnaire peut agir et
elle est calculée comme suit :

Uref = U borne - U gestion - U autres (50)

Où :

U borne égale à la borne d’ordonnancement utilisée (si EDF égale à 1 sinon à


n *( n
2 - 1 ) pour DM) ou bien à la charge maximale désirée des tâches de contrôle. U

gestion est la charge d’exécution du Feedback Scheduler (gestionnaire) qui doit aussi
occuper le processeur et enfin U autres représentent l’utilisation des éventuelles autres
tâches non gouvernées par le Feedback Scheduler et sur lesquelles il n’agit pas.

Algorithme de rééchelonnement des périodes :

L’algorithme procède comme suit :


𝑈𝑈
Si ∝= 𝑈𝑈 ≤ 1 alors
𝑟𝑟𝑟𝑟𝑟𝑟

Toutes les tâches s’exécutent avec leurs périodes nominales h𝑖𝑖,0 ;

Sinon

Toutes les périodes des tâches sont recalées jusqu’à 𝑈𝑈𝑟𝑟𝑟𝑟𝑟𝑟 comme suit :

ℎ𝑖𝑖 = 𝛼𝛼 ∗ h𝑖𝑖,0 (51)

Où chaque tâche ti s’exécutera avec sa nouvelle période hi

La Figure 24 ci-dessous schématise l’ordonnancement régulé basé sur le


rééchelonnement des périodes.

74
Chapitre IV : Approche incluant un contrôle rétroactif flou pour l'ordonnancement régulé des tâches temps
réel.

Figure 24 Feedback Scheduler de Antoine Cervin

Remarque :

Nous remarquons que l’algorithme, présenté ci-dessus, utilise la période nominale


h𝑖𝑖,0 à chaque fois pour estimer le facteur d’utilisation�
𝑼𝑼.

Pour cela, nous proposons de calculer les nouvelles périodes on se basant sur les
précédentes périodes au lieu d’utiliser à chaque fois la période nominale comme suit :

ℎ𝑖𝑖, 𝑘𝑘 = 𝛼𝛼 ∗ h𝑖𝑖, 𝑘𝑘−1 (52)

Nous remarquons aussi que le changement des périodes concerne toutes les tâches
de contrôle que soit dans les travaux de Cervin [CER 03] ou de Xia [XIA 07]. Cependant,
ce changement peut mettre une tâche ou plus dans une configuration donnant en
conséquence de mauvaises performances de fonctionnement. Nous envisagerons pour
cela de proposer une solution permettant de prendre en considération l’influence
rééchelonnement sur de la qualité de contrôle.

Notre troisième remarque concerne l’initialisation arbitraire de l’estimateur de


chaque tâche à sa période nominale. Dans ce cas nous proposons d’initialiser

75
Chapitre IV : Approche incluant un contrôle rétroactif flou pour l'ordonnancement régulé des tâches temps
réel.

l’estimateur d’une tâche à sa pire durée d’exécution (WCET) dans le but de faire
converger rapidement l’estimateur.

𝐶𝐶̂𝑖𝑖 (0) = WCET𝑖𝑖

𝐶𝐶̂𝑖𝑖 (𝑘𝑘) = 𝜆𝜆 ∗ 𝐶𝐶̂𝑖𝑖 (𝑘𝑘 − 1) + (1 − 𝜆𝜆) ∗ 𝑐𝑐𝑖𝑖 (53)

La quatrième remarque concerne le contrôleur PID discret utilisé dans les tâches de
contrôle. Le contrôleur PID utilisé par Cervin est le suivant :

P(k)=K * (r(k)-y(k))

I(k+1)=I(k)+K*h*(r(k)-y(k))/Ti

D(k)=ad*D(k-1)+bd*(y(k-1)-y(k))

U(k)= P(k)+ I(k)+ D(k)

Où ad=Td/(N*h+ Td) et bd=N*K*Td/(N*h+ Td)

Notre remarque, dans ce cas, concerne l’utilisation de la période nominale de la tâche


noté h dans le PID. Ainsi, Cervin n’utilise pas les nouvelles périodes issues de
l’algorithme de rééchelonnement dans le PID. Nous nous montrions l'effet d'utiliser les
nouvelles périodes dans le chapitre 5 (implémentation et résultats, cf. V. 3. 4).

IV. 6 Ordonnancement par rétroaction se basant sur la logique floue

Dans cette partie nous développons notre contribution qui vise à explorer les
techniques offerte par logique floue (choix des valeurs des variables linguistiques, Base
de règle, …) dans le cadre de l’ordonnancement régulé.

IV. 6. 1 Architecture

Comme expliqué plus haut, l’ordonnancement par rétroaction (feedback scheduling)


est utilisé pour ajuster dynamiquement les périodes d’échantillonnage de toutes les
tâches de contrôle. L’ordonnanceur par rétroaction (appelé aussi feedback scheduler)
est implémenté comme une tâche périodique de plus haute priorité s’exécutant en

76
Chapitre IV : Approche incluant un contrôle rétroactif flou pour l'ordonnancement régulé des tâches temps
réel.

concurrence avec les autres tâches du contrôle des procédés (nous supposons que
chaque tâche contrôle un procédé donné). Ainsi, soit hi, n la période de la tâche ti à la nème
activation du feedback scheduler. Pour chaque instant d’activation du feedback
scheduler, les périodes des tâches de contrôle sont calculées comme suit :

hi, n+1= α n * hi, n (54)

où αn est le facteur de rééchelonnement des périodes déterminé suivant la technique


de la logique floue (Fuzzy logic). L’architecture de d’ordonnancement régulé par logique
floue schématisée par la Figure 25 ci-dessous.
h1
Usp e Tâches #1
Régulation flou U
d'ordonnancement n
hn CPU
de des tâches temps
réel
Tâches #n

Figure 25. Régulation floue d'ordonnancement de tâches temps réel

De point de vue de la théorie de contrôle, l’ordonnanceur peut être vu comme le


procédé à contrôler. Les sorties de ce procédé (ordonnanceur) est le facteur d’utilisation
U des tâches contrôlant les procédés physiques. Le contrôleur flou compare cette valeur
à la valeur désirée Uref puis décide d’une manière intelligente (intelligence artificielle)
quel est le facteur de rééchelonnement αn des périodes à appliquer.

Comparativement aux travaux de Feng Xia [XIA 05] qui suppose que les durées
d'exécutions sont fixes, dans notre étude nous supposons que les durées sont variables
et pour cela nous proposons de calculer le facteur d’utilisation des tâches de contrôle 𝑈𝑈
par l'utilisation de l’estimateur de durées d’exécution proposé par Cervin mais nous
initialiserons l’estimateur de chaque tâches à sa durée d’exécution au pire cas (WCET)
soit :

𝐶𝐶̂𝑖𝑖 (0) = WCET𝑖𝑖

𝐶𝐶̂𝑖𝑖 (𝑘𝑘) = 𝜆𝜆 ∗ 𝐶𝐶̂𝑖𝑖 (𝑘𝑘 − 1) + (1 − 𝜆𝜆) ∗ 𝑐𝑐𝑖𝑖 (55)

77
Chapitre IV : Approche incluant un contrôle rétroactif flou pour l'ordonnancement régulé des tâches temps
réel.

Ainsi, à chaque fin d’exécution d’une tâche, nous mettons à jour son estimateur. Lors
du réveil du gestionnaire d’ordonnancement floue (fuzzy feedback scheduler), on calcule
le facteur d’utilisation U des tâches 𝑈𝑈 = ∑ 𝐶𝐶̂𝑖𝑖𝑘𝑘 / h𝑖𝑖, 𝑘𝑘 . Ce dernier sera en suite utilisé
pour déduire les deux variables ek et den : en (erreur actuelle) représente la différence
entre Uref et U (en = Uref – U), den représente la différence entre l’erreur actuelle et
l’erreur précédente (den= en – en-1). Ces deux valeurs constituent les entrées aux deux
variables linguistiques E et DE du régulateur (gestionnaire) d’ordonnancement floue. La
sortie de ce mécanisme est le facteur de rééchelonnement des périodes αn qui est
représenté par variable linguistique R.

IV. 6. 2 Conception du régulateur d’ordonnancement flou

La structure interne du gestionnaire (régulateur) d’ordonnancement floue est


représentée par la Figure 26 ci-dessous. Ce gestionnaire semblable aux autres
contrôleurs floue qu’on trouve dans le domaine du contrôle des procédés en général .
Il est constitué de quatre modules : le fuzzificateur, la base de règles, le mécanisme
d’inférence et le défuzzificateur.

Figure 26. Structure interne du régulateur (gestionnaire) d'ordonnancement floue.

Après le choix des variables linguistiques, la suite de la conception vise à


déterminer l’envers du discours, les valeurs significatives et les fonctions
d’appartenances de chaque variable linguistique E, DE et R. Ceci, nous permettra par la
suite de mettre en place la base de règles.

78
Chapitre IV : Approche incluant un contrôle rétroactif flou pour l'ordonnancement régulé des tâches temps
réel.

a. Enivres du discours

L’enivres de discours des variables linguistiques E, DE est (-0.5, -0.4, -0.3,-0.2, -


0.1, 0, 0.1, 0.2, 0.3, 0.4, 0.5) et celui de la variable R est (0.5, 0.6, 0.7, 0.8, 0.9, 1, 1.1, 1.2,
1.3, 1.4, 1.5).

b. Fonctions d'appartenance

Les fonctions d'appartenance peuvent être symétriques et distribuées de manière


équidistante. Une forme est définie symétrique lorsque les fonctions d'appartenance
sont symétriques par rapport à x=0. Par contre, la forme est définie équidistante lorsque
les maxima des fonctions d'appartenances des différents ensembles sont écartées de
manière équidistante. Le plus souvent, on utilise pour les fonctions d'appartenances des
formes trapézoïdales ou triangulaires. Pour notre étude, nous avons choisi d’explorer
trois types de fonctions d’appartenance à savoir les fonctions d'appartenance sous
formes triangulaires, cloches (Gaussiennes) et trapézoïdales.

c. Valeurs linguistiques

Nous proposons d’étudier 2 cas : dans le premier, nous utiliserons trois valeurs
significatives pour chaque variable linguistique E, DE et R. Puis 5 valeurs. Pour chaque
cas, nous proposerons aussi les fonctions d’appartenance et la base de règles
correspondante.

d. Utilisation de trois valeurs linguistiques (3V-FBS)

Les valeurs significatives des variables linguistiques d’entrées sont les mêmes pour
les variables E et DE, qui sont N (négative), ZE (zéro) et P (positive). Quant aux valeurs
de la variable de sortie R sont NR (négative), ZR (zéro) et PR (positive).

1. Fonctions d'appartenance sous forme triangulaire (3V-FBS-Tri)

La Figure 27 et Figure 28 données ci-dessous illustrent les fonctions d' appartenance


sous forme triangulaire.

79
Chapitre IV : Approche incluant un contrôle rétroactif flou pour l'ordonnancement régulé des tâches temps
réel.

Figure 27. Les variables d’entrées E et DE (e et de)

Figure 28. La variable de sorties R (lambda λ)

2. Fonction d'appartenance sous forme de cloche (3V-FBS-cloch)

La Figure 29 et Figure 30 ci-dessous illustrent les fonctions d'appartennace sous


forme cloche.

Figure 29. Les variables d’entrées E et D (e et de)


80
Chapitre IV : Approche incluant un contrôle rétroactif flou pour l'ordonnancement régulé des tâches temps
réel.

Figure 30. La variable de sorties R (lambda λ)

3. Fonction d'appartenance en forme trapézoïdale (3V-FBS-trapéz)

La Figure 31 et Figure 32 données ci-dessous illustrent les fonctions d' appartenance


sous forme trapézoïdale.

Figure 31. Les variables d’entrées E et D (E et DE)

Figure 32. La variable de sorties R (lambda λ)

81
Chapitre IV : Approche incluant un contrôle rétroactif flou pour l'ordonnancement régulé des tâches temps
réel.

Motivation

Nous avons envisagé d’étudier les trois types de forme pour les fonctions
d'appartenances car nous avons remarqué que pour la même valeur de l’erreur (e=0.5
et de=0) dans les trois types, nous obtenons (figure 33, 34 et 35) des valeurs différentes
pour R (λ=0.63, 0.607 et 0.674)

Figure 33. Inférence floue avec des fonctions d'appartenance de forme triangulaire

Figure 34. Inférence floue avec des fonctions d'appartenance en forme de cloche
82
Chapitre IV : Approche incluant un contrôle rétroactif flou pour l'ordonnancement régulé des tâches temps
réel.

Figure 35. Inférence floue avec des fonctions d'appartenance en forme trapézoïdale

4. Base de règles

Nous donnons dans le tableau ci-dessous la base de règles utilisée avec 3 valeurs
linguistiques avec les trois types de fonctions linguistiques.

E
R
N ZE P
N PR PR ZR
DE ZE PR ZR NR
P ZR NR NR

Tableau 4. Base de règles avec trois valeurs linguistiques

e. Utilisation de cinq valeurs linguistiques (5V-FBS)

Dans le cas de cinq valeurs linguistiques pour les variables E et DE, nous utilisons les
valeurs GN (grande négative), N (négative), ZE (zéro), P (positive) et P (grande positive).

83
Chapitre IV : Approche incluant un contrôle rétroactif flou pour l'ordonnancement régulé des tâches temps
réel.

Quant aux valeurs de la variable de sortie R les valeurs sont GNR (grande négative R),
NR (négative R), ZR (zéro R), PR (positive R) et GPR (grand positive)

1. Fonctions d'appartenance de forme triangulaire (5V-FBS-Tri)

La Figure 36 et Figure 37 ci-dessous illustrent les fonctions d'appartennace sous forme


triangulaire.

Figure 36 Les variables d’entrées E et D (e et de) avec cinq valeurs linguistiques

Figure 37. La variable de sorties R (lambda λ) avec cinq valeurs linguistiques

2. Fonctions d'appartenance de forme cloche (5V-FBS- cloch)

La Figure 38 et Figure 39 ci-dessous illustrent les fonctions d'appartennace sous


forme cloche.

84
Chapitre IV : Approche incluant un contrôle rétroactif flou pour l'ordonnancement régulé des tâches temps
réel.

Figure 38. Les variables d’entrées E et D (e et de) avec cinq valeurs linguistiques

Figure 39. La variable de sorties R (lambda λ)

3. Base de règles

Nous donnons dans le tableau ci-dessous la base de règles utilisée avec 5 valeurs
linguistiques avec les trois types de fonctions linguistiques.

DE
R
GN N ZE P GP
GN GPR GPR GPR GPR ZR
N GPR PR PR PR NR
E ZE PR PR ZR ZR NR
P PR ZR NR NR GNR
GP ZR NR GNR GNR GNR

Tableau 5. Base de règles avec cinq valeurs linguistiques

85
Chapitre IV : Approche incluant un contrôle rétroactif flou pour l'ordonnancement régulé des tâches temps
réel.

Figure 40. Inférence floue avec des fonctions en forme triangulaire

Figure 41. Inférence floue avec des fonctions en forme de cloche

86
Chapitre IV : Approche incluant un contrôle rétroactif flou pour l'ordonnancement régulé des tâches temps
réel.

IV. 7 Conclusion

Dans ce chapitre ,nous avons étudié le problème d’ordonnancement par rétroaction


et nous avons présenté la modélisation des tâches et les critères de performances que
nous utiliserons dans la suite de notre étude. Par la suite, nous avons étudié le problème
d'ordonnancement par rétroaction se basant sur le rééchelonnement des périodes où
nous avons relevé quelques remarques visant à améliorer les résultats obtenus pour ce
problème. Puis, nous avons étudié le problème d'ordonnancement par rétroaction se
basant sur la logique floue, où nous avons présenté une architecture du régulateur flou
et une conception pour ce régaleur que nous comptons implémenter dans le chapitre qui
suit.

87
Chapitre V
Implémentation et Résultats

V. 1 Introduction....................................................................................................................................... 89
V. 2 L’environnement de développement et de simulation ..................................................... 89
V. 3 Extension de TrueTime ................................................................................................................. 92
V. 3. 1 Implémentation de générateur aléatoire de durées d’exécution ......................... 93
V. 3. 2 Implémentation du régulateur d’ordonnancement ( feedback scheduler) ..... 93
V. 3. 3 Implémentation de l’estimateur ....................................................................................... 94
V. 3. 4 Implémentation du contrôleur PID ................................................................................ 94
V. 3. 5 Implémentation du régulateur d’ordonnancement flou ........................................ 95
V. 4 Description du système................................................................................................................. 95
V. 4. 1 Description des procédés .................................................................................................... 95
V. 4. 2 Description des tâches de contrôle .................................................................................. 96
V. 4. 3 Modèle temporel des tâches de contrôle ....................................................................... 97
V. 4. 4 Modèle temporel de la tâche régulateur d’ordonnancement ................................ 97
V. 5 Simulations ........................................................................................................................................ 97
V. 5. 1 Politique d’ordonnancement DM...................................................................................... 98
V. 5. 2 Politique d’ordonnancement EDF ..................................................................................107
V. 6 Conclusion ........................................................................................................................................109
Chapitre V : Implémentation et Résultats

V. 1 Introduction

D
ans ce chapitre, nous détaillons les simulations qui ont été menées afin
d’évaluer les propositions décrites précédemment. nous y présentons aussi
les résultats expérimentaux réalisés afin de comparer entre les approches
étudiées dans le cadre de notre étude.

Nous commençons par présenter l’environnement de simulation. Puis, nous


présentons les résultats obtenus ainsi que l’analyse qui a été faite.

V. 2 L’environnement de développement et de simulation

Dans le but de comparer les différentes approches présentées, nous avons utilisé
le simulateur TrueTime qui est une boîte à outils MATLAB/Simulink développée à
l’Université de Lund et dont l’objectif est de faciliter la modélisation de régulateurs
embarqués et distribués. TrueTime est en libre téléchargement sur la page Web de
l’Université de Lund (http://www.control.lth.se/truetime). La figure 42 ci-dessous
présente les différents objets de cette boite à outils.

Figure 42. Blocs disponibles dans TrueTime 2.0 beta 4.

Cet outil fournit une librairie open source dédiée au domaine de temps réel et
composé des composants suivants :

 Un noyau temps réel,


 Réseau TrueTime ;
 Nœud émetteur et un nœud récepteur ;
 Réseau sans fil (réseau de capteurs, d’antenne, etc.) ;
89
Chapitre V : Implémentation et Résultats

 Réseau d’ultrason
 Une batterie ;

TrueTime a été développé, notamment dans le but d’offrir aux concepteurs la


possibilité de simuler des calculateurs monoprocesseurs disposant d’un exécutif temps
réel. Les tâches de contrôle peuvent être modélisées par des fonctions Matlab ou C++.
Cet outil permet aussi d’analyser l’ordonnançabilité et affiche les états
d’ordonnancement (runing, preempted, sleeping) des tâches simulées (figure 43),
affiche les sorties concernant les performances des contrôles (figure 44).

Figure 43. Ordonnancement de trois tâches de contrôle

Figure 44. Exemple de modèle proposé avec Truetime 2.0 [CER 09]

90
Chapitre V : Implémentation et Résultats

La Figure 44 illustre un modèle Simulink proposé en guise d’exemple avec TrueTime


et qui forme la base de notre étude. Trois servomoteurs (DC Servo) sont asservis par un
calculateur monoprocesseur (TrueTime Kernel) où un exécutif temps réel ordonnance
trois tâches-régulateur concurrentes, chacune pilotant un des moteurs via une loi de
réglage de type PID. [CER 03]

Dans la suite, ti désignera la tâche gouvernant le ie moteur.

Au niveau fonctionnel, chacune de ces tâches a le comportement suivant : dès qu’un


travail démarre, il effectue un échantillonnage du signal de sortie du servomoteur
concerné, calcule la commande puis transmet celle-ci au procédé.

Les graphiques de la Figure 45 illustrent de manière qualitative la performance de


régulation si le système est ordonnancé par DM ; les traits roses y représentent la
consigne fournie par un générateur de signaux à laquelle les régulateurs doivent faire
tendres le signal de sortie, représentés par les traits jaunes, des servomoteurs asservis.

Figure 45. Performance de contrôle des trois tâches de contrôle

91
Chapitre V : Implémentation et Résultats

V. 3 Extension de TrueTime

TrueTime offre une gamme de fonctionnalités de base limitées par les primitives qu’il
définit et son modèle de tâches. Dans le but d’intégrer les travaux portants sur le
feedback scheduling, il était nécessaire de voir s’il était possible d’étendre facilement le
modèle de tâches et d’intégrer des primitives supplémentaires au simulateur. Ces
recherches ont abouti à l’implémentation du fuzzy feedback scheduler d’une part et du
feedback scheduler de Cervin et all (à rééchelonnement linéaire) d’autre part. De par sa
licence de logiciel libre, TrueTime 2.0 était un candidat de choix pour accueillir des
médications. Il est programmé en C++ et il est donc recommandé pour l’étendre d’avoir
de bonnes bases dans ce langage.

Pour ajouter de nouvelles fonctionnalités à TrueTime, il y a essentiellement deux


choses distinctes à faire :

Modifier le cœur de TrueTime pour ajouter les fonctionnalités désirées (modification


du modèle de tâches, ajout de traitements supplémentaires, etc.) ;

Créer de nouvelles primitives MATLAB s’il y a lieu afin que les modèles créés avec
Simulink puissent s’en servir.

La 1re étape est bien entendu la plus ardue et il est difficile de donner des
recommandations générales à ce sujet puisque finalement, on n’est limité que par le
langage. Il est chaleureusement recommandé de se plonger dans le code source de
TrueTime pour découvrir comment il fonctionne de manière sommaire.

La 2e étape est beaucoup plus aisée ; pour créer de nouvelles primitives, il suffit en
effet le plus souvent de faire un copier-coller d’une primitive déjà définie et d’ensuite
l’adapter.

Dans la suite de cette section, nous décrivons les différentes implémentations qui
sont faites dans TrueTime

92
Chapitre V : Implémentation et Résultats

V. 3. 1 Implémentation du générateur aléatoire de durées d’exécution

Dans le but de simuler la variation des durées d’exécution des tâches avec un
régulateur d’ordonnancement soit par le rééchelonnement des périodes ou bien par la
logique floue, nous avons implémenté un générateur aléatoire de durées d’exécutions
pour chaque tâche suivant la loi uniforme. Ainsi, la durée d’exécution d’une instance
d’une tâche est générée suivant la loi uniforme dans l’intervalle (0. 5, Wcet) ms
(milliseconde). Dans le but d’avoir les mêmes valeurs pour les différentes simulations,
nous initialisons le générateur avec une même valeur (c.-à-d. srand(0)) avant le début de
chaque simulation.

V. 3. 2 Implémentation du régulateur d’ordonnancement ( feedback scheduler)

Une classe FBS incorporant les paramètres du feedback scheduler a été conçue (dans
le fichier fbs.h) et une instance de celle-ci a été ajoutée au noyau temps réel de TrueTime
(modélisé par la classe RTSys dans ttkernel.h). Le fichier initfbs.cpp comprend la
majorité du code concernant la logique du feedback scheduler. La fonction
FBSCodeFcn() n’est autre que la code fonction du scheduler et qui applique l’algorithme
décrit précédemment

Une nouvelle primitive a été créée : ttInitFBS. Les fichiers matlab/ttInitKernel.cpp


contiennent le code du point d’entrée mexFunction () appelé par MATLAB, qui après
validation des données donne le contrôle aux fonctions de travail contenues dans initfbs.

ttInitFBS() : initialisation du feedback scheduler

Cette primitive permet d’indiquer que le calculateur utilise le feedback scheduler et


paramètre ce dernier. Elle ne peut être appelée que dans la fonction d’initialisation du
calculateur dans le fichier troiservoinit.cpp. Si elle n’est pas appelée, il fonctionnera
comme un calculateur TrueTime traditionnel.

Syntaxe : ttInitFBS(period, execTime, Uref, type)

Les quatre paramètres sont obligatoires et définissent respectivement la période, le


temps d’exécution, la consigne (en termes d’utilisation) du feedback scheduler et le type
de régulateur d’ordonnancement à utiliser (floue ou rééchelonnement de périodes).
93
Chapitre V : Implémentation et Résultats

V. 3. 3 Implémentation de l’estimateur

Pour implémenter la logique des estimateurs, comme le suggère Cervin dans sa thèse
[CER03], nous avons pensé à la création d’un finish hook personnalisé pour
implémenter les estimateurs puisqu’en effet, ils doivent être mis à jour à chaque fois
qu’une instance d’une tâche se termine. Le fichier fbshooks.cpp contient le finish hook
personnalisé qui tient à jour l’estimateur comme il se doit pour ensuite appeler le hook
par défaut (cette pratique est recommandée pour ne pas briser le fonctionnement
d’autres primitives de TrueTime). Il est à noter que ce hook personnalisé n’est activé
que si le système est paramétré pour utiliser le feedback scheduler : concrètement, c’est
l’appel à la primitive ttInitFBS() qui provoquera l’activation du finish hook .

V. 3. 4 Implémentation du contrôleur PID

Nous avons implémenté un système de trois tâches de contrôle dans l’outil Truetime
dans lequel nous avons intégré le feedback scheduling. Nous avons simulé le système
sans l’intégration des nouvelles périodes rééchelonnées dans le PID (figure a ci-
dessous), et puis avec l’utilisation avec le même système des nouvelles périodes
rééchelonnées ℎ𝑖𝑖, 𝑘𝑘 dans le PID (figure b)

Figure 46. Performance des 3 contrôleurs PID avec des périodes nominales (figure a) et
avec des périodes rééchelonnées (figure b)

94
Chapitre V : Implémentation et Résultats

D’après ces deux figures (a et b), nous concluions que les périodes utilisées dans
l’action intégrale et l'action dérivée du PID devrais correspondre à la période de la tâche
de contrôle utilisatrice de ce PID. Ainsi, dans la suite, nous considérons que les tâches
implémentent un PID discret sous la forme ci-dessous :

P(k)=K * (r(k)-y(k))

I(k+1)=I(k)+K*hk *(r(k)-y(k))/Ti

D(k)=ad*D(k-1)+bd*(y(k-1)-y(k))

U(k)= P(k)+ I(k)+ D(k)

Le détail est donné dans la section description du système (cf. V.4).

V. 3. 5 Implémentation du régulateur d’ordonnancement flou

Pour implémenter le régulateur d’ordonnancement flou (fuzzy feedback scheduling)


nous avons utilisé la même classe FBS définie précédemment. Dans le fichier initfbs.cpp,
qui contient le code concernant la logique du feedback scheduler, l’erreur (en = Uref – U)
et la différence entre l’erreur actuelle et l’erreur précédente (den= en – en-1) est transmise
au module d’inférence floue que nous avons conçu a l’aide de l’éditeur fuzzy du MatLab.
La sortie de ce mécanisme est le facteur de rééchelonnement des périodes αn.

Notons qu’à chaque fin d’exécution d’une tâche, nous mettons à jour son estimateur.
Lors du réveil du régulateur d’ordonnancement flou (fuzzy feedback scheduler), il
calcule le facteur d’utilisation U des tâches 𝑈𝑈 = ∑ 𝐶𝐶̂𝑖𝑖𝑘𝑘 / h𝑖𝑖, 𝑘𝑘 .

V. 4 Description du système
Dans cette section nous donnons la description du système.

V. 4. 1 Description de procédés

Nous reprenons l’exemple de trois moteurs (DC servo) comme modèle de procédé.
Chaque procédé est représenté par la fonction de transfert dans le domaine continu
suivant :

95
Chapitre V : Implémentation et Résultats

1000
𝐺𝐺(𝑠𝑠) = 𝑆𝑆(𝑆𝑆+1) (56)

Note : nous avons choisi une même représentation d’un système physique (c.-à-d. la
même fonction de transfère) afin de pouvoir comparer la qualité de contrôle de ces
systèmes l’une au autres.

V. 4. 2 Description des tâches de contrôle

Les tâches implémentent un PID discret sous la forme ci-dessous :

P(k)=K * (r(k)-y(k))

I(k+1)=I(k)+K*hk *(r(k)-y(k))/Ti

D(k)=ad*D(k-1)+bd*(y(k-1)-y(k))

U(k)= P(k)+ I(k)+ D(k)

Où ad=Td/(N* hk + Td) et bd=N*K*Td/(N* hk + Td)

Ce PID inclut dans TrueTime en guise d’exemple comporte un filtre passe bas dans la
partie dérivative. Les valeurs d’initialisation du PID sont :

Paramètre Valeur

K (gain proportionnel) 0.96

Ti 0.12

Td 0.05

β (beta) 0.5

N 10

hk hi, k (période k de la tâche i)

Iold 0

yold 0

Tableau 6. Les valeurs d’initialisation du PID

96
Chapitre V : Implémentation et Résultats

V. 4. 3 Modèle temporel des tâches de contrôle

Dans le but de simuler notre système, nous avons utilisé trois tâches de contrôle où
chaque tâche implémente un correcteur PID décrit précédemment et dont les
caractéristiques temporelles (en milliseconde) sont les suivantes :

Tâches ri Ci=wcet Di hi

t1 0 1 3 3

t2 0 1 4 4

t3 0 1 5 5

Tableau 7. Configuration des tâches de contrôle

Dans le cas de tâches à durées d’exécutions variables nous avons généré les durées
dans l’intervalle (0. 5, Wcet).

V. 4. 4 Modèle temporel de la tâche régulateur d’ordonnancement

Nous avons utilisé une tâche FBS dont les caractéristiques sont :

Tâche Période execTi Uref


FBS 10 1 Uref = U borne - U

n
Où Uref =1- UFBS si la politique d’ordonnancement utilisée est EDF et Uref = n*(√2 − 1) -
UFBS si c’est DM qui utilisée. UFBS : est la charge induite par le gestionnaire (tâche
feedback scheduler) égale à execTime/ period= 0.001/0.01.

V. 5 Simulations

Les simulations décrites ici sont faites sur base de TrueTime 2.0 beta 4 dans lequel
nous avons étendu précédemment. Pour pouvoir simuler le système nous avons utilisé
l’ensemble des tâches décrites précédemment. Nous effectuons les simulations dans le
cas d’ordonnancement avec DM et EDF dans le cas de durées d’exécutions fixes et
variables.

97
Chapitre V : Implémentation et Résultats

V. 5. 1 Politique d’ordonnancement DM

Dans cette section nous explorons la politique d'ordonnancement DM (Deadline


Monotonic) proposé par Leung et all [LEU 82]. Cette politique est basée sur une
affectation de priorités inversement proportionnelles aux délais critiques des tâches.

a. Simulation avec le régulateur d’ordonnancement par rééchelonnement des


périodes (R-FBS)
1. Les durées d’exécutions sont fixes (Ci = Ci, max)

La Figure 47 ci-dessous montre l'ordonnancement de trois tâches de contrôle avec la


tâche feedback scheduling de 0 à 0.2 ms.

Tâche FBS

Tâche 3

Tâche 2

Tâche 1
0 0.02 0.04 0.06 0.08 0.1 0.12 0.14 0.16 0.18 0.2

Figure 47. Graphe d’ordonnancement des 4 tâches avec Ci fixe

La Figure 48 ci-dessous montre le changement de la charge du processeur U


comparativement à la charge souhaitée Uref. D'après ce graphe nous dirons que la charge
du processeur s'adapte rapidement (dé la 2ème exécution du FBS) à la charge désirée.

98
Chapitre V : Implémentation et Résultats

0.8
Uref
0.78 FBS cervin

0.76

0.74
U vs Ur

0.72

0.7

0.68

0.66

0.64
0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1
Temps

Figure 48. U et Uref selon l’algorithme de rééchelonnement des périodes

Dépassement temps réponse


Erreur abs Js Jio
% du procédé
Tâches
Sans Avec Sans Avec Sans Avec Sans Avec Sans Avec
FBS FBS FBS FBS FBS FBS FBS FBS FBS FBS
Tâche 1 75.53 63.90 0.0000 0.0010 0.0000 0.001 10.26 10.09 0.831 0.831
Tâche 2 56.14 47.53 0.0010 0.0020 0.0000 0.002 9.65 9.62 0.829 0.833
Tâche 3 45.25 38.46 0.0020 0.0028 0.0000 0.003 10.06 9.92 0.830 0.838
moyenne 58.98 49.96 0.001 0.0019 0.0000 0.002 9.99 9.88 0.830 0.834

Tableau 8. Comparaison des performances de contrôle avec R-FBS et sans R-FBS

D'après le tableau ci-dessus, nous dirons que l'utilisation de régulateur


d'ordonnancement (feedback scheduling) permet de démineur l'erreur entre la consigne
et la sortie du système contrôlé. Nous remarquons aussi que l'utilisation de FBS diminue
le taux de dépassement mais augmente le temps de réponse du procédé. Cependant,
l'utilisation de la tâche FBS de priorité supérieur augmente la gigue d'échantillonnage et
la gigue d'entrée-sortie.

99
Chapitre V : Implémentation et Résultats

2. Les durées d’exécutions variables (Ci ∈(0. 5, Wcet) ms générée aléatoirement)

Le graphe de la Figure 49 montre l'ordonnancement de trois tâches de contrôle et une


tâche régulateur d'ordonnancement.

Tâche FBS

Tâche 3

Tâche 2

Tâche 1

0 0.02 0.04 0.06 0.08 0.1 0.12 0.14 0.16 0.18 0.2

Figure 49. Graphe d’ordonnancement des 4 tâches avec Ci variables

La Figure 50 montre le changement de la charge du processeur U comparativement à


la charge souhaitée Uref.

0.72
Uref
0.7 FBS cervin

0.68

0.66

0.64
U vs Ur

0.62

0.6

0.58

0.56

0.54

0.52
0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1
Temps

Figure 50. U et Uref selon l’algorithme de rééchelonnement des périodes avec Ci


variables

D'après le graphe ci-dessous nous dirons que l'algorithme de rééchelonnement des


périodes n'adapte pas la charge processeur à la charge désirée si U inferieur à Uref .

100
Chapitre V : Implémentation et Résultats

Erreur abs Js Jio Dépassement % temps réponse du procédé


d’exécution
Durée
Val moy Val moy Val moy Val moy Val moy

Ci fixes 49.96 0.0019 0.002 9.88 0.834

Ci variables 54.84 0.0018 0.0028 9.97 0.833

Tableau 9. Performances de contrôle avec ci fixe et variable sous R-FBS

D’après ci-dessus nous dirons que l'utilisation de régulateur d'ordonnancement (R-


FBS) lorsque les durées sont variables augmente l'erreur entre la consigne et la sortie du
système contrôlé, la gigue d'échantillonnage, le taux de dépassement. Nous remarquons
aussi que l'utilisation du R-FBS offre le même temps de réponse du procédé ainsi que
gigue d'entrée-sortie.

b. Simulation avec un régulateur flou d’ordonnancement


1. Les durées d’exécutions sont fixes (Ci = Ci, max)

 Utilisation de trois valeurs linguistiques

Nous avons simulé le système décrit précédemment avec le régulateur flou


d’ordonnancement dont les fonctions d’appartenance sont soit sous forme triangulaire
Figure 51 (3V-FBS-Tri), de cloche Figure 52 (3V-FBS-cloch) ou trapézoïdale Figure 53
(3V-FBS-trapéz). Les figures ci-dessous (51, 52 et 53) montrent le changement de la
charge du processeur U comparativement à la charge souhaitée Uref.

0.8

0.78

0.76
Uref
0.74
U (3V-FBS-Tri)
U vs Uref

0.72

0.7

0.68

0.66

0.64
0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1
Temps

Figure 51. U vs Uref avec 3 valeurs linguistiques et fonctions d'appartenance sous forme
triangulaire
101
Chapitre V : Implémentation et Résultats

0.8

0.78

0.76
Uref
0.74
U (3V-FBS-cloch)
U vs Uref

0.72

0.7

0.68

0.66

0.64
0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1
Temps

Figure 52. U vs Uref avec 3 valeur linguistiques et fonctions d'appartenance sous forme
de cloche

0.8

0.78

0.76
Uref
0.74
U (3V-FBS-trapez)
U vs Uref

0.72

0.7

0.68

0.66

0.64
0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1
Temps

Figure 53. U vs Uref avec 3 variables et fonctions d'appartenance en forme trapézoïdale

Discussion :

Nous remarquons que le régulateur flou d’ordonnancement avec la fonction


d’appartenance sous forme triangulaire donne de bons résultats en termes d’adaptation
de la charge de processeur à la charge désirée en comparaison avec le cas d’utilisation
des fonctions de cloche et trapézoïdale

Dans ce qui suit, nous comparons entre les cas précédents de point de vue
performances de contrôle en se basant sur les critères cités précédemment.

102
Chapitre V : Implémentation et Résultats

temps réponse
Erreur abs js Jio Dépassement %
Méthode du procédé

Val max Val moy Val max Val moy Val max Val moy Val max Val moy Val max Val moy

3V-FBS- Tri 64.67 50.76 0.0027 0.0019 0.003 0.002 10.18 10.09 0.838 0.834
3V-FBS-
65.21 51.07 0.0028 0.0019 0.004 0.0023 10.13 9.81 0.837 0.834
cloch
3V-FBS-
66.85 52.20 0.0028 0.0019 0.004 0.0023 10.47 9.98 0.836 0.834
trapéz
R-FBS
63.90 49.96 0.0028 0.0019 0.003 0.002 10.09 9.88 0.838 0.834
(Cervin)

Tableau 10. Performances de contrôle avec 3 valeurs linguistiques et R-FBS

D'après le Tableau 10 ci-dessus nous dirons que l'utilisation da la fonction sous


forme triangulaire donne des résultats proches de ceux donnés par l'algorithme R-FBS
comparativement à ceux da la fonction sous forme cloche et trapézoïdale.

 Utilisation de cinq variables linguistiques

Nous avons simulé par la suite le même système avec la même configuration de
tâches avec l’utilisation de cinq valeurs linguistiques. Le régulateur d’ordonnancement
flou utilise les fonctions d’appartenance sous forme triangulaire Figure 54 (5V-FBS-Tri)
puis sous forme de cloche Figure 55 (5V-FBS-cloch).

0.8

0.78

0.76
Uref
0.74
U vs Uref

U (5V-FBS-Tri)
0.72

0.7

0.68

0.66

0.64
0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1
Temps

Figure 54. U vs Uref avec 5 valeurs linguistiques sous forme triangulaire

103
Chapitre V : Implémentation et Résultats

0.8

0.78

0.76
Uref
0.74
U (5V-FBS-cloch)
U vs Uref

0.72

0.7

0.68

0.66

0.64
0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1
Temps

Figure 55. U vs Uref avec 5 variables et fonctions d'appartenance sous forme de


cloche

Discussion :

Nous remarquons que le régulateur d’ordonnancement flou avec la fonction


d’appartenance sous forme triangulaire de la Figure 54 donne de bons résultats en
termes d’adaptation de la charge de processeur à la charge désirée comparativement
aux résultats obtenus par l’utilisation de fonctions d'appartenance sous forme de cloche
de la Figure 55 et à ceux obtenus suite à l’utilisation de 3 variables linguistiques.

Dans ce qui suit, nous comparons les résultats obtenus de point de vu performances
de contrôle.

temps réponse
Erreur abs js Jio Dépassement %
Méthode

du procédé
Val Val Val Val Val Val Val Val Val Val
max moy max moy max moy max moy max moy
5V-FBS- 64.04 50.06 0.0028 0.0019 0.004 0.0023 10.14 9.86 0.838 0.834
Tri
5V-FBS- 64.22 50.43 0.0029 0.0019 0.003 0.002 10.27 10.23 0.842 0.836
cloch
R-FBS 63.90 49.96 0.0028 0.0019 0.003 0.002 10.09 9.88 0.838 0.834
(Cervin)

Tableau 11 Performances de contrôle sous 5 valeurs linguistiques en forme triangulaire


et R-FBS

104
Chapitre V : Implémentation et Résultats

2. Les durées d’exécutions variables (générées aléatoirement Ci ∈(0. 5, Wcet) ms)

 Utilisation de trois et cinq valeurs linguistiques

Dans le but de montrer les performances du régulateur flou (avec 3 et 5 valeurs


linguistiques) lorsque les durées d'exécutions sont variables (ci sont inférieurs ou égales
aux WCET), nous avons simulé le même système décrit précédemment. Le graphe de la
Figure 56 ci-dessous montre l’adaptation de la charge de processeur U à la charge
désirée Uref avec 3 valeurs linguistiques et les fonctions d'appartenances sous forme
triangulaire. Quant au graphe de la Figure 57 ci-dessous, il montre l’adaptation de la
charge de processeur U à la charge désirée Uref avec 5 valeurs linguistiques avec le même
type de fonctions d'appartenances.

0.72
Uref
0.7 U (R-FBS cervin)
U (3V-FBS-Tri)
0.68

0.66

0.64
U vs Uref

0.62

0.6

0.58

0.56

0.54

0.52
0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1
Temps

Figure 56. U vs Uref sous R-FBS et 3V-FBS-Tri

105
Chapitre V : Implémentation et Résultats

0.72
Uref
0.7 FBS cervin
5V-FBS-Tri
0.68

0.66

0.64
U vs Ur

0.62

0.6

0.58

0.56

0.54

0.52
0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1
Temps

Figure 57. U vs Uref sous R-FBS et 5V-FBS-Tri

D'après les deux graphes ci-dessus, nous dirons que lorsque les durées d'exécutions
sont variables et quelles sont inférieures ou égales aux WCET, un régulateur
d'ordonnancement flou permet de rendre la charge du processeur U proche de la charge
désirée Uref. Nous remarquons aussi que l'algorithme de rééchelonnement des périodes
(R-FBS) n'adapte pas la charge processeur à la charge désirée si U inferieur à Uref.

temps réponse
Erreur abs Js Jio Dépassement %
régulateur

du procédé
Type de

Val Val Val Val Val Val Val Val Val Val
max moy max moy max moy max moy max moy

3V-FBS- Tri 80.90 63.45 0.0024 0.0017 0.0048 0.0029 10.22 10.00 0.832 0.829
5V-FBS- Tri 80.20 63.06 0.0024 0.0017 0.0048 0.0029 11.21 10.52 0.833 0.829
R-FBS
70.05 54.84 0.0025 0.0018 0.0047 0.0028 10.17 9.97 0.837 0.833
(Cervin)

Tableau 12. Performances de contrôle avec 3, 5 valeurs linguistiques et R-FBS avec Ci


variables

106
Chapitre V : Implémentation et Résultats

Le tableau ci-dessus montre que les résultats obtenus avec un régulateur flou ou de
rééchelonnement des périodes ne dégradent pas les performances de contrôle et garde
le système stable.

V. 5. 2 Politique d’ordonnancement EDF

Dans cette section nous nous simulons le système décrit précédemment avec la
politique d'ordonnancement dynamique EDF (Earliest Deadline first). Le principe de
cette politique est basé sur les échéances des tâches actives à chaque instant. Donc, la
tâche la plus prioritaire est celle dont l’échéance absolue est la plus proche. Et à tout
instant, c'est la tâche ayant la plus haute priorité qui s'exécute (ordonnancement
préemptif). La priorité de chaque tâche est recalculée dynamiquement à chaque
modification de l'état du système (arrivée ou terminaison d'une tâche). En cas d’égalité,
c’est la plus ancienne dans la file d’attente qui est choisie.

a. Simulation du régulateur d’ordonnancement avec des durées d’exécutions fixes

Le graphe de la Figure 58 montre l’adaptation de la charge de processeur U à la


charge désirée Uref lors des simulations avec de l'algorithme R-FBS et le régulateur flou
avec 5 valeurs linguistiques et les fonctions d'appartenances sous forme triangulaire.

Uref
U (R-FBS (Cervin))
0.95
U (5V-FBS-Tri)

0.9
U vs Uref

0.85

0.8

0.75

0.7
0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1
Temps

Figure 58. U vs Uref sous R-FBS et 5V-FBS-Tri avec EDF et Ci fixes

107
Chapitre V : Implémentation et Résultats

temps réponse
régulateur Erreur abs Js Jio Dépassement %
du procédé
Type de
Val Val Val Val Val Val Val Val Val Val
max moy max moy max moy max moy max moy

5V-FBS-
83.31 64.96 0.003 0.0023 0.003 0.002 10.41 9.70 0.827 0.826
Tri
R-FBS
75.22 58.49 0.003 0.002 4.3e-14 3.1e-14 10.23 9.64 0.829 0.827
(Cervin)

Tableau 13. Performances de contrôle avec 5V-FBS- Tri et R-FBS avec EDF

De point de vue performance de contrôle et d'après les résultats obtenus dans le


Tableau 13 ci-dessus nous dirons que le régulateur flou 5V-FBS- Tri et R-FBS donnent
des résultats proches des uns des autres et permettent de garder les procédés stables.

b. Simulation du régulateur d’ordonnancement avec des durées d’exécutions


variables

Le graphe de la Figure 59 présente les résultats des simulations que nous avons
obtenus avec la politique d'ordonnancement EDF lorsque les durées d'exécution
variables. Dans ce cas, nous avons simulé le système avec un régulateur R-FBS et le
régulateur flou 5V-FBS-Tri.

1.1
Uref
U (R-FBS (Cervin))
U (5V-FBS-Tri)
1
U vs Uref

0.9

0.8

0.7

0.6

0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1


Temps

Figure 59. U vs Uref sous R-FBS et 5V-FBS-Tri avec EDF et Ci variables

108
Chapitre V : Implémentation et Résultats

D'après les graphes de la Figure 58 et Figure 59, nous dirons que sous la politique
EDF, le régulateur flou calcule les nouvelles périodes des tâches de contrôle qui
donneront une charge de processeur U se rapprochant de la charge désirée Uref
comparativement aux résultats obtenus qui avec un régulateur R-FBS de fait que la
charge U inférieur à la charge désirée.

V. 6 Conclusion

Dans ce chapitre, nous avons présenté l'environnement de simulation TrueTime


lequel nous avons étendu par l'implémentation d'un générateur aléatoire des durées
d'exécutions, d'un régulateur d'ordonnancement (Feedback scheduling) avec un
estimateur, d'un contrôleur PID amélioré utilisable par les tâches de contrôle et d'un
régulateur flou d'ordonnancement. Par la suite, nous avons présenté les différents
simulations et résultats obtenus.

109
Conclusion générale

Conclusion générale

L
es travaux présentés dans ce mémoire ont eu pour objectif essentiel l’étude
du problème d’ordonnancement des tâches par introduction de la commande
automatique rétroactive.

Nous avons consacré une partie de notre travail à l’état de l’art, dans laquelle nous
avons commencé par donner un bref aperçu sur les systèmes temps réel de contrôle.

Nous avons exploré les techniques offertes par logique floue (choix des valeurs des
variables linguistiques, forme des fonctions d’appartenance et de base de règles, …) avec
des durées d'exécution fixes et variables dans le cadre de l’ordonnancement régulé, vu
que d'autres travaux faisant appel à la régulation floue supposent que les durées
d'exécutions sont fixes.

Nous avons comparé les résultats obtenus avec ceux obtenus dans le cas du
rééchelonnement des périodes sous la politique DM et EDF. Par la suite, nous avons
étendu l’outil TrueTime et implémenté les différentes approches que nous avons
proposées.

Nous avons montré que les périodes utilisées dans l’action intégrale et l'action
dérivée du PID devraient correspondre à la période de la tâche de contrôle utilisatrice
de ce PID.

D'après les résultats obtenus, dans le cas d’un régulateur flou ou d’un régulateur par
rééchelonnement des périodes ne dégradent pas les performances de contrôle et
gardent le système stable. Cependant, nous remarquons qu'avec un régulateur flou
l’adaptation de la charge instantanée du processeur U à la charge désirée Uref se fait dans
le cas où la charge U est supérieure ou inférieure à la charge désirée. Cependant, le
régulateur par rééchelonnement des périodes (R-FBS) adapte la charge U à la charge
désirée Uref uniquement si la charge U est supérieure à Uref.

110
Conclusion générale

Le travail que nous avons réalisé dans ce mémoire gagnerait à être étendu dans d’autres
directions intéressantes comme perspectives. Nous planifions, par exemple, d'utiliser
des métaheuristiques telles les algorithmes génétiques pour l’optimisation des
paramètres du régulateur flou d'ordonnancement dont le choix a été empreint de
subjectivité

111
Bibliographies

Bibliographies

[AST 97] K. J. Åström, et B. Wittenmark, "Computer Controlled Systems Information and


systems" sciences series. Prentice Hall, New Jersey, 3rd edition. 1997.

[ATT 97] A. Attoui, "Les systèmes multi - agents et le temps réel ", éditions Eyrolles . 1997.

[AZZ 04] A. Azzedine,"Outil d'analyse et de partitionnement/ordonnancement pour les


systèmes temps-réel embarques" thèse de Doctorat, université de Bretagne sud.
2004.

[BIN 07] E. Bini et S. Baruah, "Efficient computation of response time bounds under
Axed-priority scheduling.In RTNS": Proceedings of the 15th Real-Time and
Network Systems, pages 95-104. 2007.

[BIN 08] E. Bini et A. Cervin, "Delay-Aware Period Assignment in Control Systems" In


Proceedings of the 29th IEEE Real-Time Symposium, Barcelona, Spain,
December. 2008.

[BOU 95] B. Bouchon-Meunier, "La logique floue et ses applications". Addison-Wesley


France. 1995.

[CER 99] A.Cervin, “Improved scheduling of control tasks.” In Proceedingsof the 11th
Euromicro Conference on Real-Time Systems. York, England. 1999.

[CER 00] A. Cervin et J. Eker "Feedback Scheduling of control tasks" In Proceeding of 39th
IEEE Conference on Decision and Control, Sydney, Australia. 2000.

[CER 02] A. Cervin, J.Eker, B. Bernhardsson et K.-E.Årzén : ”Feedback-Feedforward


Scheduling of Control Tasks” Real-Time Systems, 23:1-2, PP 25-33, July. 2002

[CER 03] A. Cervin, "Integrated Control and Real-Time Scheduling" Thèse PHd. s.l.,
Department of Automatic Control - Lund Institute of Technology, Sweden :
Bloms i Lund Tryckeri AB, 2003.

[CER 05] A. Cervin, et J. Eker, "Control-Scheduling Codesign of Real-Time systems: The


Control Server Approch", Journal of embedded Computing, 1:2, pp. 209-224.
2005.

[COT 00] F. Cottet, J. Delacroix, C. Kaiser et Z. Mammeri. "Ordonnancement temps réel".


HERMES Science Publications, Paris. 2000.

112
Bibliographies

[COX 94] E. Cox ,"The fuzzy systems handbook", Academic press, 1994.

[DEC 03] D. Decotigny " Une infrastructure de simulation modulaire pour l'évaluation de
performances de systèmes temps-réel ", thèse de Doctorat, université de Rennes
1. 2003.

[EKE 00] J. Eker, P. Hagander et K.-E. Årzén “A feedback scheduler for real-time control
tasks." Control Engineering Practice, 8:12, pp.1369–1378. 2000.

[GIR 06] A. Girault, "Contributions à la conception sûre des systèmes embarqués sûrs "
HDR à INP de GRENOBLE. 2006.

[JAK 55] J. R. Jackson, " Scheduling a production line to minimize maximum tardiness ",
Research Report UCLA, Management Sciences Research Project, . 1955.

[KAR 09] O. Kermia "Ordonnancement temps réel multiprocesseur de tâches non-


préemptives avec contraintes de précédence, de périodicité stricte et de
latence";/2009;Thèse, Université Paris XI UFR scientifique d'Orsay. 2009.

[KIM 80] K.H. Kim et M. Naghibdadeh, " Prevention of task overruns in real-time
nonpreemptive multiprogramming systems ", Proc. of Perf., p. 267-276. 1980.

[LAP 04] J. C. Laprie. " Sûreté de fonctionnement informatique : concepts de base et


terminologie ", Rapport technique LAAS-CNRS Toulouse. 2004.

[LEU 82] J.Y.-T. Leung, J. Whitehead, "On the complexity of fixed-priority scheduling of
periodic real-time tasks", Performance Evaluation 2(4). PP 237-250 , 1982.

[LIU 73] C. L. Liu,, J.W Layland, "Scheduling algorithms formultiprogramming in a hard


real-time environment", Journal of the ACM, 1973. Vol. 20(1), 40–61.

[MAR 10] L.Markus. "Feedback scheduling", Mémoire de Master en Sciences


Informatiques, Université libre de Bruxelles, 2010.

[MCN 59] R. McNaughton, "Scheduling with deadline and loss functions", Management
Sci., 12(1), pp. 1-12, 1959.

[MOK83] A. K. Mok, "Fundamental design problems for the hard real-time environments",
PhD., MIT, 1983.

[MOK78] A. K. Mok et M. L. Dertouzos. "Multiprocessor scheduling in a hard realtime".


Proceedings of the 7th Texas Conference on Computing Systems, Houston, TX,
1978.

113
Bibliographies

[NAV06] N. Navet et B. Gaujal, "Systèmes temps réel - Ordonnancement, réseaux et


qualité de service ", Edition Hermès - Lavoisier, ISBN10 :2-7462-1304-4. 2006.

[PAI06] S. Pailler " Analyse hors ligne d’ordonnancement d’applications temps réel
comportant des tâches conditionnelles et sporadiques " thèse de Doctorat,
université Poitiers. 2006.

[PAR02] F. Parain " Ordonnancement sous contraintes énergétiques d'applications


multimédia sur une plate-forme multiprocesseur hétérogène" thèse de Doctorat
de l'Université de Rennes 1, France. 2002.

[PUA02 ] I. Puaut "Cache modelling vs static cache locking for schedulability analysis in
multitasking real-time systems ", in 2nd Intl Workshop on worst-case execution
time analysis, in conjunction with the 14th Euromicro Conference on Real-Time
Systems. 2002.

[SEM03] O. Sename, D. Simon et D. Robert “Feedback Scheduling for Real-Time Control


of Systems with Communication Delay”, Proc. ETFA 03, 9th IEEE International
Conference on Emerging Technologies and Factory Automation, Lisbonne.
2003.

[SIM06] D. Simon, O. Sename et D. Robert, "Conception conjointe


commande/ordonnancement et ordonnancement régulé", chapitre 3 du livre
Systèmes Temps réel 2, ordonnancement, réseaux et qualité de service, Hermes .
2006.

[STA 96] Stankovic J. A., Burns A., Jeffay K., Jones M., Koob G., Lee I., J. Lehoczky, J. Liu, A.
Mok, K. Ramamritham, J. Ready, L. Sha & A.V. Tilborg, "Strategic directions in
real-time and embedded systems ", in ACM Computing Surveys, vol.28 N°4,
1996.

[TIW 94] V. Tiwari, S. Malik & A. Wolfe. « Power analysis of embedded software: a first
step towards software power minimization », in IEEE Trans. on Very Large
Scale Integration Systems , Vol. 2, p. 437-445, 1994.

[WEI 94] M. Weiser, A. Demers, B. Welch & S. Shenkar, " Scheduling for reduced CPU
energy ", in Proceedings of Operating System Design and Implementation OSDI,
Usenix Association, Monterey, CA, 1994.

[XIA 05] Xia, Shen, L.P., Liu, Z., Wang, Y.X., Sun. "Fuzzy logic based feedback scheduler for
embedded control systems". Advances in Intelligent Computing Springer
pp.453-462, 2005.

114
Bibliographies

[XIA 06] Xia, F., X. Dai, Y. Sun, and J. Shou : “Control Oriented Direct Feedback
Scheduling” International Journal of Information Technology, vol. 12, No 3, pp.
21-32. 2006.

[XIA 07] F. Xia , G. Tian et Y Sun."Feedback Scheduling: An Event-Driven Paradigm". ACM


SIGPLAN Notices, Vol. 42, No 12, PP.7-14 2007.

[XIA 08] F. Xia and Y. Sun. "Control and Scheduling Codesign", Springer Zheijiang
University Press, 2008.

[ZAD 65] L. A. Zadeh , Fuzzy sets. Information and Control, 8, pp. 338–353. 1965.

115
:‫ﻣﻠﺨﺺ‬
‫ ﺃﻭﻻ‬.‫" ( ﻋﻦ ﻁﺮﻳﻖ ﺍﻟﻜﻤﺒﻴﻮﺗﺮ‬contrôle des procédés" ) ‫ﺑﺪﺃﻧﺎ ﺩﺭﺍﺳﺘﻨﺎ ﻋﻦ ﻁﺮﻳﻖ ﺗﻘﺪﻳﻢ ﻣﻔﺎﻫﻴﻢ ﺍﻟﺘﺤﻜﻢ ﻓﻲ ﺍﻟﻌﻤﻠﻴﺎﺕ‬
‫'( ﻭﻛﺬﻟﻚ ﺍﻟﻤﻔﺮﺩﺍﺕ ﺍﻟﻤﻠﺤﻘﺔ ﻭ ﺫﺍﺕ ﺍﻟﺼﻠﺔ ﺑﻬﺬﺍ‬temps réel') ‫ﺑﺘﺴﻠﻂ ﺍﻟﻀﻮء ﻋﻠﻰ ﺍﻟﻤﻔﺎﻫﻴﻢ ﺍﻟﻤﺘﻌﻠﻘﺔ ﺑﺎﻟﻮﻗﺖ ﺍﻟﺤﻘﻴﻘﻲ‬
‫ﺍﻟﻤﻬﺎﻡ ﻓﻲ ﺍﻟﻮﻗﺖ ﺍﻟﺤﻘﻴﻘﻲ ﺍﻟﻜﻼﺳﻴﻜﻲ‬ ‫ ﺍﻷﻭﻟﻲ ﺗﻤﺜﻠﺖ ﻓﻲ ﺟﺪﻭﻟﺔ‬،‫ ﻗﺪﻣﻨﺎ ﺣﺎﻟﺘﻴﻦ ﻣﻦ ﺍﻟﻔﻦ‬،‫ ﻭﺑﻌﺪ ﺫﻟﻚ‬.‫ﺍﻷﺧﻴﺮ‬
‫"( ﻭﺍﻟﺜﺎﻧﻴﺔ ﺗﻤﺜﻠﺖ ﻓﻲ ﺟﺪﻭﻟﺔ ﺍﻟﻤﻬﺎﻡ ﻋﻦ ﻁﺮﻳﻖ ﻣﺮﺍﻗﺒﺔ ﺭﺩﻭﺩ ﺍﻟﻔﻌﻞ‬l’ordonnancement temps réel classique " )
. ("l’ordonnancement régulé ou par contrôle rétroactif ")

‫ ﻭﺿﻌﻨﺎ ﻓﻲ‬.‫ﻓﻲ ﺍﻗﺘﺮﺍﺡ ﻁﺮﻳﻘﺔ ﻟﺠﺪﻭﻟﺔ ﺍﻟﻤﻬﺎﻡ ﻓﻲ ﺍﻟﻮﻗﺖ ﺍﻟﺤﻘﻴﻘﻲ ﻓﻲ ﺍﻟﻌﻤﻠﻴﺔ‬،‫ﻭﺃﻳﻀﺎ ﻓﻲ ﻋﻤﻠﻨﺎ ﻣﻬﺘﻤﻮﻥ ﻓﻲ ﺃﻭﻝ ﺍﻷﻣﺮ‬
‫ﺗﻔﺎﺻﻴﻠﻬﺎ ﺍﻷﺩﻟﺔ ﻭﻧﻬﺠﻨﺎ ﻓﻴﻤﺎ ﻳﺘﻌﻠﻖ ﺑﺈﺩﺭﺍﺝ ﻋﻨﺼﺮ ﺗﺤﻜﻢ ﺭﺩﻭﺩ ﺍﻟﻔﻌﻞ ﻋﻦ ﻁﺮﻳﻖ ﺍﻟﻤﻨﻄﻖ ﺍﻟﻀﺒﺎﺑﻲ ﻟﻀﺒﻂ ﺇﻋﺪﺍﺩﺍﺕ ﺍﻟﻤﻬﺎﻡ ﺍﻟﺘﻲ‬
TrueTime ‫ ﻭﻗﺪ ﻗﺪﻣﻨﺎ ﻓﻲ ﺗﻔﺎﺻﻴﻞ ﺍﻟﺘﻨﻔﻴﺬ ﻓﻲ ﺑﻴﺌﺔ ﺍﻷﻋﻤﺎﻝ‬،‫ ﻓﻲ ﺍﻟﺨﻄﻮﺓ ﺍﻟﺜﺎﻧﻴﺔ‬.‫ﺗﺘﻤﻴﺰ ﺏﺍﺧﺘﻼﻑ ﻣﺪﺓ ﺗﻨﻔﻴﺬﻫﺎ ﻋﻠﻰ ﻣﺮ ﺍﻟﺰﻣﻦ‬
. ‫ﻭﻛﺬﻟﻚ ﻧﺘﺎﺋﺞ ﺍﻟﻤﺤﺎﻛﺎﺓ ﻭﺍﻟﻌﺮﻭﺽ ﺍﻟﺘﻲ ﺗﻢ ﺍﻟﺤﺼﻮﻝ ﻋﻠﻴﻬﺎ‬

.‫ ﺍﻟﻤﻨﻄﻖ ﺍﻟﻀﺒﺎﺑﻲ‬،‫ ﺍﻟﺘﺤﻜﻢ ﺍﻵﻟﻲ ﺍﻟﻘﻮﺍﻧﻴﻦ‬،‫ ﺍﻟﻮﻗﺖ ﺍﻟﺤﻘﻴﻘﻲ ’ﺟﺪﻭﻟﺔ ﺍﻟﺘﺤﻜﻢ‬:‫ﻛﻠﻤﺎﺕ ﺍﻟﺒﺤﺚ‬

Résumé :

Nous avons commencé notre étude par la présentation des différents concepts relatifs au
contrôle des procédés par ordinateur. Nous avons mis en évidence, des notions ayant trait
au temps réel ainsi que le vocabulaire y afférant. Par la suite, nous avons présenté deux
états de l’art, l’un sur l’ordonnancement temps réel classique et l’autre sur
l’ordonnancement régulé ou par contrôle rétroactif ("feedback scheduling"). Dans notre
travail nous nous sommes intéressés, dans un premier temps, à la proposition d’une
méthode pour l’ordonnancement des tâches temps réel d’un procédé. Nous avons mis en
évidence les détails de notre approche ayant trait à l’inclusion d’un contrôle rétroactif par
logique floue afin d'ajuster les paramètres des tâches caractérisées par la variation de
leurs durées d’exécution dans le temps. Dans un second temps, nous avons présenté les
détails de l’implémentation entreprise sous l’environnement du simulateur TrueTime ainsi
que les résultats de simulation obtenus et les performances réalisées.

Mots clés : Temps réel, ordonnancement régulé, lois de commande automatique,


Logique floue.

Abstract

we started our study by presenting concepts related to control process. We reveal notions
related to real time as well as the vocabulary relating thereto. Then, we presented two
states of the art. The first concern the classical real-time scheduling and the second
concern the feedback scheduling. In our work we are interested in a first step, by
proposing a method for real-time tasks scheduling in a process. We put in evidence the
details of our approach with respect to the inclusion of a fuzzy feedback control to adjust
the tasks parameters which characterized by execution times varying over time. In a
second step, we have presented the details of our implementation done in TrueTime
simulator environment as well as simulation results and performances.

Key words: Real-Time, feedback scheduling, automatic control laws, Fuzzy logic.

Vous aimerez peut-être aussi