Continue cours temps réel

programmation-multitaches-temps-reel/main.tex

@@ -219,7 +219,7 @@
             Les tests ne prennent pas en considération le coût système.
             Une solution est de déterminer le coût système par des tests, et d'intégrer le coût dans la faisabilité.
 
-            Calcul ddu temps de réponse d'une tâche (avec une priorité fixe et $D \leq T$)~:
+            Calcul du temps de réponse d'une tâche (avec une priorité fixe et $D \leq T$)~:
 
             \begin{align*}
                 r_i^{n+1} = C_i + \sum_{j \in hp(i)} \left\lceil\frac{r_i^n}{T_j}\right\rceil C_j \quad \text{avec } r_i^0 = C_i
@@ -276,6 +276,18 @@
                 r_i = \max_{a \in A} (r_i(a))
             \end{align*}
 
+        \paragraph{Temps réel --- ordonnanceur préemptif vs.\ non préemptif}
+
+            La condition nécessaire et suffisante pour un système temps réel est~:
+            \begin{equation*}
+                \forall i : Z_i \leq D_i
+            \end{equation*}
+
+            Pour cela il y a deux manières de calculer la faisabilité, en fonction de si l'ordonnanceur est préemptif ou \textcolor{red}{non}~:
+            \begin{equation*}
+                Z_i^n = C_i + \sum_{j\in \mathrm{hp}(i)} \left\lceil\frac{r_i^{n-1}}{T_j}\right\rceil \cdot C_j \,\textcolor{red}{+ \max_{k\in\mathrm{lp}(i)}(C_k)}
+            \end{equation*}
+
     \subsection{Optimalité}
 
         On dit qu'un ordonnanceur est optimal lorsqu'il trouve une solution d'ordonnancement à chaque fois que cette solution existe.
@@ -310,4 +322,39 @@
         Le protocole d'héritage de priorité (Priority Inheritance Protocol, PIP) vise à éviter les blocages.
         Si une tâche de basse priorité détient le verrou sur une ressource demandée par une tâche plus prioritaire, il faut élever la priorité de la première tâche au niveau de la tâche prioritaire jusqu'à ce qu'elle libère la ressource.
 
+        \paragraph{Protocole}
+
+            Lorsqu'une tâche $\tau_i$ demande une ressource $R_k$, on a l'une des situations suivantes~:
+
+            \begin{itemize}
+                \item $R_k$ est libre, $\tau_i$ prend la ressource.
+                \item $R_k$ n'est pas libre (détenue par une tâche moins prioritaire).
+            \end{itemize}
+
+            Le plus mauvais cas de blocage est la somme du blocage direct et du blocage par héritage de priorité.
+
+        \paragraph{PIP --- limites}
+
+            \begin{itemize}
+
+                \item Interblocages (deadlock) ---
+                    Le protocole PIP ne permet pas d'éviter le problème d'interblocage.
+
+                \item Chaîne de blocage (blocking chain) ---
+                    Une tâche peut être bloquée autant de fois que le nombre de sections critiques qu'elle utilise.
+
+            \end{itemize}
+
+        \paragraph{PCP --- Protocole de priorité plafond}
+
+            Le PCP (Prority Ceiling Protocol) permet d'éviter l'interblocage ainsi que la chaîne de blocage.
+            Le protocole est plus simple que PIP mais difficilement implémentable.
+
+            Lorsqu'une tâche demande une ressource, elle se bloque lorsque~:
+
+            \begin{itemize}
+                \item La ressource n'est pas libre (détenue par une tâche moins prioritaire)
+                \item La ressource est libre mais la priorité plafond d'une autre ressource en utilisation est plus grande que la priorité de la tâche.
+            \end{itemize}
+
 \end{document}