5.3 Les modes syst`emes
5.3.1 Une abstraction des modes syst`emes
On commence par donner une sp´ecification des modes syst`emes et plus particuli`erement le protocole de changement de modes de mani`ere ind´epen-dante. Cette approche nous permet de nous focaliser sur les probl`emes li´es au changement de mode de mani`ere ind´ependante aux probl`emes d’ordon-nancement et de communications.
Transition de mode atomique
On pr´esente `a ce niveau une simple transition de mode atomique. L’au-tomate de changement de mode est d´efini par un ensemble de constantes : l’ensemble de mode Mode, son mode de d´epart InitialMode, et un ensemble de transition, la fonction NextMode. L’ensemble Event d´efinit l’ensemble des ´ev´enements susceptibles de provoquer un changement de mode. L’ensemble de couples domNextMode repr´esente le domaine de la fonction NextMode. En-fin, la fonction ModeThreads associe `a chaque mode l’ensemble de ses threads actifs.
On utilise seulement deux variables, la premi`ere d´efinit le mode courant (currentMode), et la seconde repr´esente l’ensemble des threads en cours d’ex´ecution (currentThreads). Lors de l’initialisation, ces variables sont ini-tialis´ees respectivement `a la valeur InitialMode et `a un sous ensemble des threads de ce mode initial.
Dans ce mod`ele, la transition de mode est atomique, sur la r´eception d’un ´ev´enement d´eclenchant une transition, on passe dans le mode suivant. L’ensemble des threads en cours d’ex´ecution est aussi modifi´e, ils doivent faire partie de l’ensemble des threads du nouveau mode.
La transition ThreadTransition est une abstraction de l’ordonnance-ment des threads. On consid`ere que les threads du mode courant peuvent ˆetre dans deux ´etats, prˆet ou inactif. Les threads prˆets correspondent au thread en cours d’ex´ecution, en attente de donn´ee partag´ee ou en attente de la ressource processeur dans le mod`ele complet. Les threads du mode courant non pr´esent dans cet ensemble sont en attente d’activation.
module atomicModes constants
Mode, InitialMode, Event, domNextMode, NextMode, Thread, ModeThreads
assume
∧ InitialMode ∈ Mode
∧ domNextMode ⊆ Mode × Event ∧ NextMode ∈ [domNextMode → Mode] ∧ ModeThreads ∈ [Mode → subset Thread ] variables currentMode, currentThreads
5.3. LES MODES SYST `EMES 95
TypeInvariant =∆
∧ currentMode ∈ Mode
∧ currentThreads ∈ subset Thread
Invariant = currentThreads ∈ subset ModeThreads[currentMode]∆ Init =∆
∧ currentMode = InitialMode
∧ currentThreads ∈ subset ModeThreads[currentMode] ModeTransition(evt) =∆
∧ hcurrentMode, evti ∈ domNextMode
∧ currentMode′ = NextMode[currentMode, evt]
∧ currentThreads′ ∈ subset ModeThreads[currentMode′] ThreadTransition =∆
∧ currentThreads′ ∈ subset ModeThreads[currentMode] ∧ unchanged hcurrentModei
Les threads critiques
Dans un mode on peut trouver un ensemble de threads que l’on ne doit pas interrompre `a n’importe quel moment. On doit attendre que ces threads aient tous termin´e leur ex´ecution. On d´efinit pour chaque mode un ensemble de threads critique grˆace `a la fonction CriticalThreads. `A la r´eception d’un ´ev´enement, on commence la transition de mode. Dans un premier temps, on m´emorise juste l’´ev´enement qui a d´eclench´e la transition. Puis lorsque tous les threads critiques ont termin´e leur ex´ecution, on proc`ede au changement de mode proprement dit.
On ajoute une variable currentEvent afin de conserver le nom de l’´ev´e-nement qui a d´eclench´e la transition. Le d´ebut de la transition de mode ne peut avoir lieu que si aucun ´ev´enement n’a ´et´e re¸cu. `A la fin de la transition, le syst`eme redevient sensible aux requˆetes de changement de mode.
module Critical constants
Mode, InitialMode, Event, Thread , NextMode, domNextMode, ModeThreads, Critical
assume
∧ InitialMode ∈ Mode
∧ domNextMode ⊆ Mode × Event ∧ NextMode ∈ [domNextMode → Mode] ∧ ModeThreads ∈ [Mode → subset Thread ] ∧“NoEvent” /∈ Event
∧ Critical ∈ [Mode → subset Thread ]
AllEvent = Event ∪ {“NoEvent”}∆
variables currentMode, currentThreads, currentEvent TypeInvariant =∆
∧ currentMode ∈ Mode
∧ currentThreads ∈ subset Thread ∧ currentEvent ∈ AllEvent
Invariant = currentThreads ∈ subset ModeThreads[currentMode]∆ Init =∆
∧ currentMode = InitialMode
∧ currentThreads ∈ subset ModeThreads[currentMode] ∧ currentEvent =“NoEvent”
StartModeTransition(evt) =∆
∧ hcurrentMode, evti ∈ domNextMode ∧ currentEvent =“NoEvent”
∧ currentEvent′ = evt
∧ unchanged hcurrentMode, currentThreadsi EndModeTransition =∆
∧ currentEvent 6=“NoEvent” ∧ currentEvent′ =“NoEvent”
∧ currentMode′ = NextMode[currentMode, currentEvent] ∧ currentThreads′ ∈ subset ModeThreads[currentMode′] ∧ currentThreads ∩ Critical [currentMode] ⊆ currentThreads′
ThreadTransition =∆
∧ currentThreads′ ∈ subset ModeThreads[currentMode] ∧ unchanged hcurrentMode, currentEventi
Next =∆
∨ ∃ e ∈ Event : StartModeTransition(e) ∨ EndModeTransition
∨ ThreadTransition
Les threads zombies
Certaines activit´es ne peuvent ˆetre arrˆet´ees instantan´ement. `A titre d’exemple, une telle activit´e devra arrˆeter un ´equipement avant de disparaˆıtre. Pour cela, on introduit un nouveau type de threads, les zombies, ces threads ne sont pas critiques, mais ne doivent pas ˆetre arrˆet´es brutalement. On va donc leur permettre de terminer leur ex´ecution dans le nouveau mode. Au mo-ment de la transition de mode, on calcule l’ensemble des zombies actifs.
5.3. LES MODES SYST `EMES 97
L’ensemble des threads actif dans le nouveau mode sera un sous ensemble des threads du nouveau mode plus l’ensemble des zombies actifs. Enfin, on consid`ere que la transition de mode est finie lorsque tous les zombies ont ´et´e supprim´es.
module zombies constants
Mode, InitialMode, Event, Thread , NextMode, domNextMode, ModeThreads, Critical , Zombies
assume
∧ InitialMode ∈ Mode
∧ domNextMode ⊆ Mode × Event
∧ NextMode ∈ [domNextMode → Mode] a mode transition is deterministic ∧ ModeThreads ∈ [Mode → subset Thread ]
∧“NoEvent” /∈ Event
∧ Critical ∈ [Mode → subset Thread ] ∧ Zombies ∈ [Mode → subset Thread ]
∧ ∀ m ∈ Mode : Zombies[m] ∩ ModeThreads[m] = {} AllEvent = Event ∪ {“NoEvent”}∆
variables
currentMode, currentThreads, currentEvent, zombies TypeInvariant =∆
∧ currentMode ∈ Mode ∧ currentEvent ∈ AllEvent
∧ currentThreads ∈ subset ModeThreads[currentMode] ∪ zombies ∧ zombies ∈ subset Zombies[currentMode]
assume
∧ currentEvent 6=“NoEvent”❀ currentThreads ∩ Critical[currentMode] = {} Init =∆
∧ currentMode = InitialMode
∧ currentThreads ∈ subset ModeThreads[currentMode] ∧ zombies = {}
∧ currentEvent =“NoEvent” StartModeTransition(evt) =∆
∧ hcurrentMode, evti ∈ domNextMode ∧ currentEvent =“NoEvent”
∧ currentEvent′ = evt ∧ zombies = {}
∧ unchanged hzombies, currentMode, currentThreadsi EndModeTransition =∆
∧ currentEvent 6=“NoEvent” ∧ currentEvent′ =“NoEvent”
∧ currentMode′ = NextMode[currentMode, currentEvent]
∧ currentThreads ∩ Critical [currentMode] ∈ subset ModeThreads[currentMode′] ∧ zombies′ = currentThreads ∩ Zombies[currentMode′]
∧ currentThreads′ ∈ subset ModeThreads[currentMode′] ∪ zombies′
ThreadTransition =∆
∧ currentThreads′ ∈ subset ModeThreads[currentMode] ∧ zombies 6= {} ⇒ zombies′ ∈ subset zombies
∧ currentThreads′ ∈ subset ModeThreads[currentMode] ∪ zombies′
∧ unchanged hcurrentMode, currentEventi
Pr´eemptions et priorit´es
On veut rendre le protocole pr´esent´e plus flexible :
– les transitions de mode ne sont plus consid´er´ees comme atomiques. On introduit la possibilit´e d’interrompre un changement de mode durant la prise en compte d’une transition de mode ;
– on introduit un ordre sur les transitions de fa¸con `a pouvoir prendre en compte leur importance relative ;
– enfin le traitement associ´e `a un changement de mode ne s’exprime plus uniquement en fonction du mode courant mais en fonction du mode courant et de la transition en cours.
Dans un premier temps, on va modifier le type de la fonction Critical. Dans la premi`ere version de cette fonction, l’ensemble des threads critiques ne d´e-pend que du mode courant. Or il nous parait utile de d´efinir cet ensemble en fonction de l’´ev´enement qui d´eclenche la transition. La taille de cet ensemble dimensionne directement le temps d’attente avant le changement effectif de mode. Plus cet ensemble est r´eduit, plus le changement de mode sera rapide. Or certains changements de modes peuvent ˆetre plus urgents que d’autres. Par exemple, une requˆete de changement de mode r´esultant d’une d´etection de panne mat´erielle devra ˆetre trait´ee plus rapidement qu’un changement de mode pr´evu dans l’ex´ecution du syst`eme.
Enfin, on introduit des priorit´es sur les changements de mode. Ainsi lorsqu’une transition de mode a d´ebut´e, que le syst`eme attend la fin des threads critiques, si une requˆete de changement de mode plus prioritaire arrive la transition de mode est interrompue.
module advanced modes extendsNaturals
constants
5.3. LES MODES SYST `EMES 99
ModeThreads, Critical , Zombies, Priority AllEvent = Event ∪ {“NoEvent”}∆
assume
∧ InitialMode ∈ Mode
∧ domNextMode ⊆ Mode × Event
∧ NextMode ∈ [domNextMode → Mode] a mode transition is deterministic ∧ ModeThreads ∈ [Mode → subset Thread ]
∧“NoEvent” /∈ Event
∧ Critical ∈ [domNextMode → subset Thread ] ∧ Zombies ∈ [Mode → subset Thread ]
∧ ∀ m ∈ Mode : Zombies[m] ∩ ModeThreads[m] = {} ∧ Priority ∈ [AllEvent → Nat]
∧ Priority[“NoEvent”] = 0 ∧ ∀ e ∈ Event : Priority[e] > 0 variables
currentMode, currentThreads, currentEvent, zombies TypeInvariant =∆
∧ currentMode ∈ Mode
∧ currentThreads ∈ subset Thread ∧ zombies ∈ subset Thread
∧ currentEvent ∈ AllEvent Invariant =∆
∧ currentThreads ⊆ (ModeThreads[currentMode] ∪ zombies) ∧ zombies ∩ ModeThreads[currentMode] = {}
∧ zombies ⊆ Zombies[currentMode]
∧ currentEvent 6=“NoEvent”⇒ zombies = {} Init =∆
∧ currentMode = InitialMode
∧ currentThreads ∈ subset ModeThreads[currentMode] ∧ zombies = {}
∧ currentEvent =“NoEvent” StartModeTransition(evt) =∆
∧ hcurrentMode, evti ∈ domNextMode ∧ Priority[evt] > Priority[currentEvent] ∧ currentEvent′ = evt
∧ zombies′ = {}
∧ currentThreads′ = currentThreads \ zombies ∧ unchanged hcurrentModei
currentEvent = ”N oEvent” ∧zombies 6= ∅
currentEvent = ”N oEvent” currentEvent6= ”N oEvent” ∧zombies = ∅ ∧zombies = ∅ StartModeTransition ModeTransition EndModeTransition StartModeTransition StartModeTransition ThreadTransition ThreadTransition ThreadTransition
Normal behavior Wainting for critical threads
Wainting for zombie threads
Fig. 5.6 – Automate de gestion des modes
∧ currentEvent 6=“NoEvent” ∧ currentEvent′ =“NoEvent”
∧ currentMode′ = NextMode[currentMode, currentEvent] ∧ currentThreads ∩ Critical [currentMode, currentEvent]
∈ subset ModeThreads[currentMode′]
∧ zombies′ = currentThreads ∩ Zombies[currentMode′]
∧ currentThreads′ ∈ subset (ModeThreads[currentMode′] ∪ zombies′) ∧ currentThreads ∩ Critical [currentMode, currentEvent] ⊆ currentThreads′
EndModeTransition =∆ ∧ zombies = {}
∧ unchanged hcurrentMode, currentThreads, zombies, currentEventi ThreadTransition =∆
∧ currentThreads′ ∈ subset ModeThreads[currentMode] ∧ if zombies 6= {} then
∧ zombies′ ∈ subset zombies
∧ currentThreads′ ∈ subset (ModeThreads[currentMode] ∪ zombies′) else
∧ currentThreads′ ∈ subset ModeThreads[currentMode] ∧ unchanged hzombiesi
∧ unchanged hcurrentMode, currentEventi
La figure 5.6 repr´esente cette sp´ecification TLA sous la forme d’un au-tomate. Sur cette figure on ne repr´esente que le nom des transitions TLA.