Introduction aux systèmes
temps réel
Iulian Ober
IRIT
[email protected]
Sommaire
Généralités
Caractéristiques récurrentes des STR
Types de problèmes soulevées
Programmation des STR
Prog. concurrente
Synchronisation et communication
Facultés temporelles
IUT Blagnac Introduction aux Systèmes Temps Réel 2
Synchronisation et communication
le comportement d’un prog. concurrent dépend de la
synchronisation et de la communication entre ses
tâches
Synchronisation = satisfaction de contraintes sur
l’entrelacement des actions de plusieurs tâches
(e.g., action A de la tâche P s’exécute uniquement
après action B de R)
Communication = passage d’informations d’une tâche à
une autre
concepts liés
la communication est basée sur une mémoire
commune ou sur le passage de messages
IUT Blagnac Introduction aux Systèmes Temps Réel 3
Éviter l’interférence
l’exécution indivisible des séquences
d’instructions qui accèdent à des variables
partagées est nécessaire:
P1 P2
x=5
mov AX, x mov AX, x
section inc AX inc AX
section
critique critique
mov x, AX mov x, AX
x=7 ?
hypothèse : « mov x, AX » est indivisible !
(hypothèse pas valable pour les données structurées)
IUT Blagnac Introduction aux Systèmes Temps Réel 4
2 types de synchronisation
Exclusion mutuelle
assurance pour une tâche que l’exécution d’une
séquence d’instructions se fait sans interférence
la séquence d’instructions s’appelle section critique
Attente conditionnelle
une tâche doit exécuter une action uniquement
après une autre action d’une autre tâche
exemple : un tampon fini ⇒ deux attentes cond.
Consommateur Producteur
fin début
IUT Blagnac Introduction aux Systèmes Temps Réel 5
Exigences pour les sections critiques
1. Exclusion mutuelle
2. Compétition constructive
les tâches ne s'empêches pas réciproquement
d'entrer
les tâches ne s'invitent pas réciproquement à entrer
à l'infini
3. Indépendance
si une tâche est plus lente (dans sa partie non
critique) cela n'a pas d'effet sur l'entrée des autres
tâches dans leur sections critiques
4. Équité
une tâche ne peut être retardée à l'infini à l'entrée
de sa section critique
IUT Blagnac Introduction aux Systèmes Temps Réel 6
Synchro avec attente active
utiliser une variable partagée comme un
drapeau
Consommateur : attente active
while (tamponVide) {}
//…consommation
if(fin>debut) tamponVide=true ;
Producteur :
//…production
tamponVide = false ;
fonctionne pour l’attente conditionnelle,
mais pas facile pour l’exclusion mutuelle
IUT Blagnac Introduction aux Systèmes Temps Réel 7
Exclusion mutuelle avec attente active
fausse solution no. 1
T1: T2:
while(true) { while(true) {
flag1 = true; flag2 = true;
while(flag2){} // attente while(flag1){} // attente
… …
// section critique // section critique
… …
flag1 = false; flag2 = false;
} }
⇒ possibilité d’interblocage !
IUT Blagnac Introduction aux Systèmes Temps Réel 8
Exclusion mutuelle avec attente active
fausse solution no. 2
T1: T2:
while(true) { while(true) {
while(flag2){} // attente while(flag1){} // attente
flag1 = true; flag2 = true;
… …
// section critique // section critique
… …
flag1 = false; flag2 = false;
} }
⇒ pas d’exclusion mutuelle !
IUT Blagnac Introduction aux Systèmes Temps Réel 9
Exclusion mutuelle avec attente active
fausse solution no. 3
T1: T2:
while(true) { while(true) {
while(tour == 2){} while(tour == 1){}
… …
// section critique // section critique
… …
tour = 2; tour = 1;
Sec. Non-critique… Sec. Non-critique…
} }
⇒ les tâches doivent revenir à la section critique
au même rythme
IUT Blagnac Introduction aux Systèmes Temps Réel 10
Algo de Peterson (1981)
T1: T2:
while(true) { while(true) {
flag1 = true; flag2 = true;
tour = 2; tour = 1;
while(tour==2 && flag2); while(tour==1 && flag1);
… …
// section critique // section critique
… …
flag1 = false; flag2 = false;
} }
IUT Blagnac Introduction aux Systèmes Temps Réel 11
Exclusion mutuelle avec test_and_set
Suppose une opération atomique test_and_set(b)
si b = 0 alors b:=1; return 0;
sinon return 1;
T1: T2:
while(true) { while(true) {
while(test_and_set(b)); while(test_and_set(b));
… …
// section critique // section critique
… …
b:=0; b:=0;
} }
disponible sur certains processeurs
le même résultat peut être obtenu avec une opération
atomique swap(b1,b2). Comment?
IUT Blagnac Introduction aux Systèmes Temps Réel 12
Éviter l’attente active: sémaphores
mécanisme de synchronisation composé de
une variable entière n
une file d’attente f
si n > 0 alors n est le nombre de tâches qui peuvent
passer par le sémaphore avant qu’il devienne rouge
si n = 0, alors les tâches qui essayent de passer se
rangent dans la file f et deviennent suspendues
(attente passive)
n et f sont accédées uniquement par 2 opérations:
WAIT (ou P) = la tâche courante essaye de passer
si n> 0 alors n=n–1 et retour immédiat
sinon suspension dans la file f
SIGNAL (ou V) = la tâche courante libère le sémaphore
si f non vide, choix d’une tâche suspendue pour reprise
si f vide, n=n+1
IUT Blagnac Introduction aux Systèmes Temps Réel 13
toujours l’attente active…
Propriété : WAIT et SIGNAL doivent être
non-préemptibles
cas monoprocesseur ⇒ désactiver les interruptions
cas multiprocesseur avec mémoire partagée
⇒ exclusion mutuelle avec test_and_set
Conclusion : on a toujours une attente active
pour l’exclusion mutuelle entre P et V
mais la durée de l’attente est très courte et ne
dépend pas des tâches utilisateur
IUT Blagnac Introduction aux Systèmes Temps Réel 14
Attente conditionnelle avec sémaphore
var consyn : sémaphore (* initalisé à 0 *)
tâche T1: tâche T2:
… …
instruction X; instruction A;
wait(consyn); signal(consyn);
instruction Y; instruction B;
… …
Dans quelle ordre s’exécutent les instructions?
IUT Blagnac Introduction aux Systèmes Temps Réel 15
Exclusion mutuelle avec sémaphore
var mutex : sémaphore (* initalisé à 1 *)
tâche T1: tâche T2:
… …
instruction X; instruction A;
wait(mutex); wait(mutex);
instruction Y; instruction B;
signal(mutex); signal(mutex);
instruction Z; instruction C;
… …
Dans quelle ordre s’exécutent les instructions?
IUT Blagnac Introduction aux Systèmes Temps Réel 16
Deadlock
var X,Y : sémaphore (* initalisé à 1 *)
tâche T1: tâche T2:
… …
wait(X); wait(Y);
wait(Y); wait(X);
// instruction protégées
// instruction protégées
…
…
⇒ attente cyclique !
IUT Blagnac Introduction aux Systèmes Temps Réel 17
Sémaphores : conclusion
mécanisme puissant mais de bas-niveau
si une tâche oublie une opération de
sémaphore ça peut mener tout le système au
deadlock
⇒ utilisation de constructions plus structurées
IUT Blagnac Introduction aux Systèmes Temps Réel 18
Régions Critiques Conditionnelles (CCR)
grouper les données partagées dans des ressources
une CCR est une portion de code en exclusion mutuelle
sur une ressource
… l’entrée dans une CCR peut être gardée par une
condition sur la ressource
resource buf : Buffer
tâche Prod: tâche Cons:
… …
region buf when buf.size < N do region buf when buf.size > 0 do
… …
end region end region
IUT Blagnac Introduction aux Systèmes Temps Réel 19
Moniteurs
Objectif: grouper les régions critiques (pour une
ressource) dans un seul endroit du code
les régions critiques
→ procédures d’un module (le moniteur)
→ les appels sont sérialisés
les variables partagées
→ cachées par le moniteur
→ accessibles uniquement par les procédures
IUT Blagnac Introduction aux Systèmes Temps Réel 20
Exemple
monitor buffer;
export prod, cons;
…variables…
procedure prod (D : Data);
...
end;
procedure cons (var D : Data);
...
end; attente conditionnelle dans le moniteur
begin - par des sémaphores (!)
- par des variables « condition » (dans
… instructions d’initialisation
moniteurs de Hoare, 1974)
end;
IUT Blagnac Introduction aux Systèmes Temps Réel 21
Exemple, avec conditions
monitor buffer;
export prod, cons;
Condition ≠ sémaphore
…variables… wait bloque toujours la
nonvide, nonplein : condition; procedure
wait libère le moniteur
procedure prod (D:Data)
while(n=size) then wait(nonplein);
... Problème : que fait signal?
signal(nonvide)
end;
? termine la procédure
appelante
procedure cons (var D : Data) ? libère le moniteur
while(n=0) then wait(nonvide);
...
? ne libère pas le moniteur
signal(nonplein);
end;
begin
… instructions d’initialisation
end;
IUT Blagnac Introduction aux Systèmes Temps Réel 22
Moniteurs en POSIX
typedef ... pthread_mutex_t;
typedef ... pthread_cond_t;
int pthread_mutex_init(pthread_mutex_t *mutex,…);
int pthread_cond_init(pthread_cond_t *cond,…);
int pthread_mutex_lock(pthread_mutex_t *mutex);
int pthread_mutex_trylock(pthread_mutex_t *mutex);
int pthread_mutex_timedlock(pthread_mutex_t *mutex, const
struct timespec *abstime);
int pthread_mutex_unlock(pthread_mutex_t *mutex);
int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t
*mutex);
int pthread_cond_timedwait(pthread_cond_t *cond,
pthread_mutex_t *mutex, const struct timespec *abstime);
int pthread_cond_signal(pthread_cond_t *cond);
int pthread_cond_broadcast(pthread_cond_t *cond);
IUT Blagnac Introduction aux Systèmes Temps Réel 23
Moniteurs en Java
Java fournit un concept de moniteur dans le contexte
des objets ou de classes
Chaque objet ou classe (les classes sont des objets!) a
par défaut un mutex (lock)
pas directement accessible
bloqué/débloqué par l’appel à des méthodes étiquetées
synchronized
bloqué/débloqué par l’entrée dans un bloc
synchronized(obj) {
…
}
⇒ les méthodes synchronisées ont accès exclusif à leur
objet
⇒ les méthodes non synchronisées peuvent s’exécuter à
tout moment
IUT Blagnac Introduction aux Systèmes Temps Réel 24
Exemple
public class IntegerBuffer
{
…
public synchronized void write(int i)
{
…
};
public synchronized int read()
{
…
};
}
IUT Blagnac Introduction aux Systèmes Temps Réel 25
Synchronisation (cont.)
public synchronized int read() {
…
}
est équivalent à:
public int read() {
synchronized(this) {
…
}
}
class S {
private static int i;
public synchronized int read() {
… // i n’est pas protégé ici
synchronized (this.getClass()) {
… // i est protégé
}
}
public synchronized static int readS() {
… // i est protégé
}
}
IUT Blagnac Introduction aux Systèmes Temps Réel 26
Wait et Notify
pour la synchronisation conditionnelle on a
(dans java.lang.Object) :
public void wait() throws InterruptedException,
IllegalMonitorStateException;
public void notify() throws IllegalMonitorStateException;
public void notifyAll() throws IllegalMonitorStateException;
ne peuvent être appelées que si le thread
détient le lock
…sinon ⇒ IllegalMonitorStateException
IUT Blagnac Introduction aux Systèmes Temps Réel 27
Wait et Notify
wait suspend le thread et libère le lock
notify réveille un thread (quelconque), mais ne
libère pas le lock. Le thread réveillé doit
attendre que le lock soit libéré
notifyAll réveille tous les threads en wait
un thread peut être réveillé aussi par
thread.interrupt()
(mais le réveil est plus brutal ⇒ InterruptedException)
IUT Blagnac Introduction aux Systèmes Temps Réel 28
Synchronisation conditionnelle
entre notify et la reprise (sortie de wait)
une méthode peut avoir été exécutée par un
autre thread
⇒ même si cond=true au moment de notify,
il se peut que cond=false après la sortie de wait
Conclusion:
a la sortie d’un wait, on doit toujours re-évaluer
la condition:
while(cond==false) wait();
IUT Blagnac Introduction aux Systèmes Temps Réel 29
Exemple du tampon fini
public class BoundedBuffer {
private int buffer[];
private int first;
private int last;
private int numberInBuffer = 0;
private int size;
public BoundedBuffer(int length) {
size = length;
buffer = new int[size];
last = 0;
first = 0;
};
IUT Blagnac Introduction aux Systèmes Temps Réel 30
Exemple du tampon fini
public synchronized void put(int item)
throws InterruptedException
{
while (numberInBuffer == size) wait();
last = (last + 1) % size ;
numberInBuffer++;
buffer[last] = item;
notify();
};
public synchronized int get() throws InterruptedException
{
while (numberInBuffer == 0) wait();
first = (first + 1) % size ; // % is modulus
numberInBuffer--;
notify();
return buffer[first];
};
} Blagnac
IUT Introduction aux Systèmes Temps Réel 31
Appels imbriqués et moniteurs
public class A { public class B {
B b = new B(); public synchronized void n() {
public synchronized void m() { while(…) wait();
b.n() };
}; …
… }
}
est-ce que le lock de a est libéré par le wait
dans b ??
réponse Java, POSIX : non
⇒ bloque les appels vers a !
réponse Modula-1 : intérdit
autres…
IUT Blagnac Introduction aux Systèmes Temps Réel 32
Objets protégés
combine les avantages des moniteurs et des
CCR
exclusion mutuelle automatique pour les opérations
attente conditionnelle par gardes placées sur les
opérations
N'existent pas en Java… exemple Ada:
accès en lecture
protected type Bounded_Buffer is
(multiples)
function GetNum return Integer;
entry Get (Item : out Data_Item);
entry Put (Item : in Data_Item); accès en écriture
private (excl. mut.)
Num : Integer;
…
end Bounded_Buffer;
IUT Blagnac Introduction aux Systèmes Temps Réel 33
Objets protégés: exemple
protected body Bounded_Buffer is
entry Get (Item : out Data_Item)
when Num /= 0 is condition de garde
begin (barrière)
…
Num := Num - 1;
end Get;
quand est-ce qu-on doit
entry Put (Item : in Data_Item) évaluer la barrière?
when Num /= Buffer_Size is
begin
…
Num := Num + 1;
end Put;
function GetNum return Integer is
begin
return Num;
end GetNum;
IUTend Bounded_Buffer;
Blagnac Introduction aux Systèmes Temps Réel 34
Communication et
synchronisation par messages
Communication et synchronisation
par messages
tâche 1 tâche 2
envoi message
reception message
Question principale: le modèle de synchronisation
(i.e., qui attend qui?)
IUT Blagnac Introduction aux Systèmes Temps Réel 36
Message asynchrone
tâche 1 tâche 2
envoi message
reception message
T1 continue
l’exécution
⇒ nécessite un tampon pour stocker les
messages !
IUT Blagnac Introduction aux Systèmes Temps Réel 37
Message synchrone
tâche 1 tâche 2
envoi message
T1 reception message
suspendu
pas besoin de tampon
a.k.a. rendez-vous
IUT Blagnac Introduction aux Systèmes Temps Réel 38
Appel de procédure distante (RPC)
tâche 2
envoi message
T1 reception message
suspendu exécution procédure
return
a.k.a rendez-vous étendu (Ada)
peut être implémenté par 2 échanges de
messages (synchrone ou asynchrone)
IUT Blagnac Introduction aux Systèmes Temps Réel 39
Pouvoir d’expression
le RDV peut être implémenté par des messages
asynchrones:
tâche 1 tâche 2
… ⇒ nécessité de pouvoir
… attendre
envoi async(M) réception en
plusieurs messages (M)même
réception(Ack) temps envoi async (Ack)
… … en fonction du
⇒ réponse appropriée
message reçu
la communication asynchrone peut être implémentée
par des RDV : tâche tampon
loop select tâche 2
tâche 1 accept M; …
… envoi sync (lireM)
envoi sync(M) accept lireM -> reception (M)
… envoi sync(M) …
end
IUT Blagnac Introduction aux Systèmes Temps Réel 40
Support langage
Langages avec messages typés : Ada, SDL,
UML, …
en général, une file de messages par tâche
t1
t0
tk
POSIX: support pour files de messages non-
typés
mq_open, mq_close, mq_unlink
mq_send, mq_receive: bloquant si file pleine/vide (sauf
parametrage)
plusieurs producteurs/consommateurs par file
t1 t’1
tk t’n
IUT Blagnac Introduction aux Systèmes Temps Réel 41
Résume (synchronisation et communication)
principaux types de synchronisation : exclusion
mutuelle et attente conditionnelle
section critique : partie de code qui doit s’exécuter en
exclusion mutuelle
mécanismes de synchronisation :
algos basés sur l’attente active et la mémoire partagée
sémaphores
régions critiques conditionnelles
moniteurs
attente dans les moniteurs → variables « condition »
POSIX : sémaphores, moniteurs (mutex), conditions
Java : moniteurs/conditions dans le contexte objet
IUT Blagnac Introduction aux Systèmes Temps Réel 42
Résume (communication par messages)
Formes:
message asynchrone (pas d’attente à l’envoi)
message synchrone (attente – synchronisation)
appel de procédure distante
Attente sélective: capacité d’une tâche à attendre
plusieurs types de messages en même temps
Propriété des files de messages
IUT Blagnac Introduction aux Systèmes Temps Réel 43
Sommaire
Généralités
Caractéristiques récurrentes des STR
Types de problèmes soulevées
Programmation des STR
Prog. concurrente
Synchronisation et communication
Facultés temporelles
IUT Blagnac Introduction aux Systèmes Temps Réel 44
Besoins en facultés temporelles
Interface avec les notions liées au temps
accéder à des horloges pour mesurer le passage du
temps
retarder un processus jusqu’à un moment ultérieur
programmer une temporisation (time-out) pour
traiter l’absence d’un événement
Représentation des exigences temporelles
spécification des périodes des tâches
spécification des échéances (deadline)
IUT Blagnac Introduction aux Systèmes Temps Réel 45
La notion de temps
Propriétés du domaine du temps:
ordre total et strict
∀x, y, z : ( x < y ∧ y < z ) ⇒ x < z
∀x, y : x < y ∨ y < x ∨ x = y
∀x : not ( x < x )
dense : ∀x, y : x < y ⇒ ∃z : ( x < z < y )
Exemple : nombre réels
IUT Blagnac Introduction aux Systèmes Temps Réel 46
Types de données et opérations
« Temps absolu »
identifie de manière unique chaque moment
exemple : Date : Heure
autre exemple : nombre de millisecondes depuis
1/1/1970 0h GMT (Java)
« Durée relative »
désigne la distance entre deux moments
exemples d’opérateurs usuels :
+ : Temps × Durée → Temps
– : Temps × Durée → Temps
– : Temps – Temps → Durée
* : Integer × Durée → Durée
maintenant : → Temps
tick : → Durée
…
IUT Blagnac Introduction aux Systèmes Temps Réel 47
Le temps en Java
java.lang.System.currentTimeMillis donne le nombre de
millisecondes depuis 1/1/1970 GMT
utile pour initialiser un objet java.util.Date
IUT Blagnac Introduction aux Systèmes Temps Réel 48
Le temps en RT Java
HighResolutionTime
equals(time : HighResolutionTime) : boolean
set(millis : long)
absolute(clock : Clock, dest : AbsoluteTime) : AbsoluteTime
AbsoluteTime Relat iveTime
add(delta : RelativeTime) : AbsoluteTime add(time : RelativeTime) : RelativeTime
substract(time : AbsoluteTime) : RelativeTime substract(time : RelativeTime) : RelativeTime
substract(delts : RelativeTime) : AbsoluteTime
IUT Blagnac Introduction aux Systèmes Temps Réel 49
Le temps en RT Java
public abstract class Clock
{
public Clock();
public static Clock getRealtimeClock();
public abstract RelativeTime getResolution();
public AbsoluteTime getTime();
public abstract void getTime(AbsoluteTime time);
public abstract void setResolution(RelativeTime resolution);
}
IUT Blagnac Introduction aux Systèmes Temps Réel 50
Le temps en POSIX
type clockid_t
constante CLOCK_REALTIME identifie l’horloge
temps réel
(donne le temps relatif à 1/1/1970 0h GMT)
struct timespec : temps relatif ou absolu
quelques fonctions:
int clock_gettime(clockid_t clock_id, struct timespec *tp);
int clock_settime(clockid_t clock_id, const struct timespec *tp);
int clock_getres(clockid_t clock_id, struct timespec *res);
int nanosleep(const struct timespec *rqtp, struct timespec *rmtp);
IUT Blagnac Introduction aux Systèmes Temps Réel 51
Besoins en facultés temporelles
Interface avec les notions liées au temps
accéder à des horloges pour mesurer le passage du
temps
retarder un processus jusqu’à un moment ultérieur
programmer une temporisation (time-out) pour
traiter l’absence d’un événement
Représentation des exigences temporelles
spécification des périodes des tâches
spécification des échéances (deadline)
IUT Blagnac Introduction aux Systèmes Temps Réel 52
Retarder un processus
objectif : retarder sans occuper le processeur
Java :
Thread :
static void sleep(long millis, int nanos)
javax.realtime.RealtimeThread :
public static void sleep(Clock clock, HighResolutionTime time)
Le délai est un minimum, pas un maximum !
granularité de l’horloge
en attente ordonnancement
processus
appel à sleep() délai passé temps
reprend
exécution
IUT Blagnac Introduction aux Systèmes Temps Réel 53
Accumulation des déviations (drift)
exemple : exécuter une action toutes les 5ms
while(true) {
// action – durée 1ms
Thread.sleep(4);
}
0 1 5 6+ε1 10+ε1
5+ε1
10 +ε1 +ε2
IUT Blagnac Introduction aux Systèmes Temps Réel 54
Pour éliminer le cumul
AbsoluteTime top;
RelativeTime delta = new RelativeTime(5,0);
Clock c = Clock.getRealtimeClock();
while(true) {
top = c.getTime(); // (A)
// action – durée quelconque (<5)
top.add(delta); // (B)
javax.realtime.RealtimeThread.sleep(c,top);
}
diminuer la valeur de delta du temps d’exécution de (A) et (B)
IUT Blagnac Introduction aux Systèmes Temps Réel 55
Besoins en facultés temporelles
Interface avec les notions liées au temps
accéder à des horloges pour mesurer le passage du
temps
retarder un processus jusqu’à un moment ultérieur
programmer une temporisation (time-out) pour
traiter l’absence d’un événement
Représentation des exigences temporelles
spécification des périodes des tâches
spécification des échéances (deadline)
IUT Blagnac Introduction aux Systèmes Temps Réel 56
Temporisation des synchronisations
Besoin: limiter le temps qu’une tâche peut
être bloquée en attente d’une
communication / synchronisation
Exemples:
si les données du capteur de température ne sont pas
disponibles au bout de 100ms, signaler la panne
si le consommateur ne libère pas une place dans le buffer
au bout de 100ms, annuler l’écriture en cours
⇒ ces temporisations sont liées aux primitives de
synchronisation
IUT Blagnac Introduction aux Systèmes Temps Réel 57
Exemple POSIX
if(sem_timedwait(&sem, &time) < 0) {
if(errno == ETIMEDOUT)
… // temps expiré
} else {
… // sémaphore bloqué
}
IUT Blagnac Introduction aux Systèmes Temps Réel 58
Exemple Java
RelativeTime delta=…;
AbsoluteTime t0;
Clock rtc = Clock.getRealtimeClock();
…
t0 =rtc.getTime();
while(!cond) {
HighResolutionTime.waitForObject(this, delta)
if(rtc.getTime().substract(t0).compareTo(delta) >= 0) {
// cause : temps expiré
} else {
// cause : notify
}
}
IUT Blagnac Introduction aux Systèmes Temps Réel 59
Temporisation des actions
Besoin : limiter la durée d’exécution d’une
action
Exemple :
Calculer par un algo itératif la valeur approximative
d‘une variable V. Arrêter le calcul au bout de 10ms.
⇒ une forme d’« interruption »
IUT Blagnac Introduction aux Systèmes Temps Réel 60
Actions interruptibles en RT Java
interface javax.realtime.Interruptible {
void run(AsynchronouslyInterruptedException e)
throws AsynchronouslyInterruptedException;
void interruptAction(AsynchronouslyInterruptedException e)
}
class javax.realtime.Timed {
Timed(HighResolutionTime completionTime);
public boolean doInterruptible(Interruptible logic);
…
}
IUT Blagnac Introduction aux Systèmes Temps Réel 61
Besoins en facultés temporelles
Interface avec les notions liées au temps
accéder à des horloges pour mesurer le passage du
temps
retarder un processus jusqu’à un moment ultérieur
programmer une temporisation (time-out) pour
traiter l’absence d’un événement
Représentation des exigences temporelles
spécification des périodes des tâches
spécification des échéances (deadline)
…
IUT Blagnac Introduction aux Systèmes Temps Réel 62
Besoins
Identifier les éléments à caractériser
un bloc de code
une fonction
une tâche
un scénario impliquant plusieurs tâches
(contraintes de-bout-en-bout)
Donner les caractéristiques gros-grain d’exécution
arrivée périodique, apériodique, sporadique
Caractériser finement l’aspect temporel
période ou temps minimum entre arrivées
temps d’exécution au pire cas
échéance relative ou absolue
temps d’attente maximum pour une ressource
…
Associer des actions (handler) pour le cas où les spécifications
ne sont pas respectées
IUT Blagnac Introduction aux Systèmes Temps Réel 63
La réalité
Ce type d’information est supporté dans
peu de langages de programmation
de nombreux langages de spécification et
modélisation
mais sans support réel pour l’implémentation
Une exception (qui confirme la règle) : RT Java
class javax.realtime.RealtimeThread {
RealtimeThread(SchedulingParameters scheduling,
ReleaseParameters release,
MemoryParameters memory,
MemoryArea area,
ProcessingGroupParameters group,
java.lang.Runnable logic)
…}
IUT Blagnac Introduction aux Systèmes Temps Réel 64
Exemple RT Java (cont.)
class PriorityParameters extends SchedulingParameters {
PriorityParameters(int priority)
…}
class PeriodicParameters extends ReleaseParameters {
PeriodicParameters(HighResolutionTime start,
RelativeTime period, RelativeTime cost,
RelativeTime deadline, AsyncEventHandler overrunHd,
AsyncEventHandler missHd)
…
IUT Blagnac Introduction aux Systèmes Temps Réel 65
Facultés temporelles – résumé
besoins :
accès à des horloges
retarder une tâche
temporisations
spécification des caractéristiques temporelles des
tâches
tolérance aux fautes temporelles :
détection du dépassement d’échéance
détection du dépassement de temps CPU
détection du non-respect des lois d’arrivée
…
IUT Blagnac Introduction aux Systèmes Temps Réel 66
