Continue multitache

programmation-multitaches-temps-reel/main.tex

@@ -61,7 +61,7 @@
             \item Par simulation (simulateur RTFSim).
             \item Par techniques hybrides.
         \end{itemize}
-        
+
     \subsection{Contraintes temporelles}
 
         Elles peuvent être strictes~: le dépassement d'une échéance conduit à un état grave.
@@ -144,4 +144,74 @@
         Dans un système multi-tâches, de nombreux processus attendent qu'un évènement se produise.
         Ils n'ont pas besoin du processeur, mais doivent pouvoir l'obtenir en priorité.
 
+        \paragraph{Types d'ordonnancement}
+
+            \begin{itemize}
+                \item Souples
+                \item Strictes
+                    \begin{itemize}
+                        \item Dynamique
+                        \item Statique
+                    \end{itemize}
+            \end{itemize}
+
+        Le rôle d'un ordonnanceur temps réel est de vérifier la faisabilité du système.
+        Il garantit que l'arrivée d'une nouvelle tâche, acceptée par l'ordonnanceur, sera ordonnançable.
+
+        \paragraph{Priorités}
+
+            Les ordonnanceurs peuvent être à priorité fixe (chaque tâche conserve sa priorité durant toute sa durée de vie), ou à priorité dynamique (la priorité d'une tâche peut changer pendant son exécution).
+            Les ordonnanceurs à priorité fixe sont plus répandus.
+
+            Les priorités peuvent être déterminées selon~: l'échéance relative (D~: durée), la période (T~: échéance) ou l'importance de la tâche (P).
+
+            On peut alors avoir~:
+
+            \begin{itemize}
+                \item Rate Monotonic (RM) ---
+                    La tâche ayant la plus petite période est la plus prioritaire.
+                \item Deadline Monotonic (DM) ---
+                    La tâche ayant la plus petite échéance relative est la plus prioritaire.
+                \item Highest Priority First (HPF) ---
+                    Les priorités sont attribuées aux tâches selon leur importance.
+            \end{itemize}
+
+            Exemples d'ordonnanceurs à priorités dynamiques~:
+
+            \begin{itemize}
+                \item La tâche peut changer de priorité à chacune de ses activations, selon un des paramètres variables suivants~:
+                    \begin{itemize}
+                        \item D (échéance absolue)
+                        \item T (période)
+                        \item C (temps d'exécution restant)
+                    \end{itemize}
+                \item Earliest Deadline First (EDF) ---
+                    La tâche la plus proche de son échéance absolue aura la priorité la plus élevé.
+                    C'est l'ordonnanceur le plus optimal.
+                \item Least Laxity First (LLF) ---
+                    La tâche la plus prioritaire est celle de moindre laxité (différence entre l'échéance absolue et l'instant de terminaison de la tâche si on l'exécute totalement).
+            \end{itemize}
+
+        \paragraph{Analyse de faisabilité}
+
+            Calcul de la charge du processeur (U = CPU Utilization), le temps processeur nécessaire à l'exécution des tâches~:
+
+            \begin{align*}
+                U = \sum_{i=1}^n \frac{C_i}{T_i} \leq 1
+                \quad \text{avec}
+                \left\{
+                \begin{array}{l}
+                    C \text{ le coût de la tâche } \\
+                    T \text{ la période de la tâche } \\
+                \end{array}
+                \right.
+            \end{align*}
+
+            Dans le cas d'un ordonnanceur à priorités fixes (Rate Monotonic), la charge maximale est inférieure à 1.
+            Elle dépend du nombre de tâches dans le système~:
+
+            \begin{align*}
+                U = \sum_{i=1}^n \frac{C_i}{T_i} \leq U_{RM} \quad \text{avec} \quad U_{RM} = n (2^{\frac{1}{n}} - 1)
+            \end{align*}
+
 \end{document}