QUESTION #1

1) Dans µCOS-II, une tâche peut être à la fois suspendue et retardée.

Vrai. Elle peut se donner un délai par OSTimeDly() et être suspendue plus
tard par une autre tâche via la fonction OSTaskSuspend()

2) La désactivation de l'ordonnanceur garantit la protection d'une ressource

partagée.
Faux. Elle garantit seulement la protection d’une ressource partagée par deux
tâches mais pas pour une ressource partagée par une tâche et une ISR.

3) Il est préférable de faire un PEND sur un mutex plutôt que sur un sémaphore
pour accéder à une ressource dans une ISR.
Faux. Une ISR n’a pas le droit d’être en attente ni d’un sémaphore ni d’un
mutex.

4) Le temps de réponse d'une tâche dans un système foreground/background est

déterministe.
Faux. Il est impossible de prévoir le temps d’exécution de la boucle
background.

5) Dans un contexte de création d’une tâche, il est inutile de se soucier des

interruptions lors de la création de la pile puisque les interruptions ont une pile
qui leur est dédiées.
Faux. Sur certains processeurs, les interruptions utilisent la pile des tâches
pour stocker leurs informations.

6) À des fins de sécurité, il est préférable de demander à une tâche de se

supprimer elle-même plutôt que de la supprimer directement.
Vrai. Si la tâche possède à supprimer possède des ressources, elle pourra les
libérer avant de se supprimer.
QUESTION #2

1) Expliquez pourquoi le temps de retour (recouvrement) d'une interruption est

plus long sur un noyau préemptif que sur un noyau non préemptif.

Le temps de retour est plus long car le noyau doit vérifier si une tâche plus
prioritaire est prête à être exécutée.

2) Expliquez pourquoi le fait de porter la fréquence de l'horloge système à une

trop grande valeur entraîne une perte de performance.

À une fréquence trop élevée, le système passera son temps à traiter le tick
d’horloge. L’application se déroulera presque uniquement au niveau
interruption.

3) Expliquez pourquoi les appels malloc() et free() sont à proscrire pour gérer
dynamiquement la mémoire dans un RTOS (2 raisons).

- Le temps pour trouver un bloc libre est inconstant, donc non

déterministe (et par conséquent pas souhaitable)
- Après un certain temps, la mémoire se retrouve fragmentée, ce qui peut
causer des problèmes de recherche

4)

a)
 b)

5) Soit la table OSRdyTbl[8] à un temps donné :

7 6 5 4 3 2 1 0
[0]
0 0 0 0 0 0 0 0
[1]
0 0 0 0 0 0 0 0
[2]
0 0 0 1 0 0 0 0
[3]
0 1 0 0 0 1 0 0
[4]
0 0 0 0 0 0 0 0
[5]
0 0 0 0 1 0 0 0
[6]
0 1 0 0 0 0 0 0
[7]
0 0 0 0 0 0 0 0
OSRdyTbl[8]

a) Donnez la valeur de l’octet OSRdyGrp.

0 1 1 0 1 1 0 0
 b) À l'aide de la table OSUnMapTbl[] (en annexe), expliquez comment
µCOS-II détermine la tâche la plus prioritaire à être exécutée.

µCOS-II examine le vecteur OSRdyGrp pour déterminer l’index (la

ligne) de OSRdyTbl qui contient la tâche la plus prioritaire (dans notre
cas, la ligne 2. Nous avons OSRdyGrp = 01101100 = 0x6C et
OSRdyTbl[2] = 00010000 = 0x10. µCOS-II utilise ces valeurs dans la
table OSUnMapTbl pour trouver 2 valeurs, X et Y. Nous avons :

Y = OSUnMapTbl[0x6C] = 2
X = OSUnMapTbl[0x10] = 4

La priorité de la tâche est égale à Y >> 3 + X = Y * 8 + 4 = 20

c) Pourquoi µCOS-II procède-t’il par cette méthode?

Le temps pour déterminer la priorité est constant et déterministe

(souhaitable dans un RTOS)

6) Expliquez pourquoi, dans le cadre du port de µCOS-II sur un processeur X, il

est risqué de démarrer la minuterie entre les appels de fonction OSInit() et
OSStart(). De quelle façon faut-il procéder pour démarrer la minuterie de
façon sécuritaire?

Le fait de démarrer la minuterie avant le multi-tâches (OSStart()) peut poser

un problème si un tick d’horloge survient avant que le démarrage du multi-
tâches soit accompli. µCOS-II se trouve alors dans un état instable et l’ISR
qui traite le tick d’horloge peut alors engendrer un malfonctionnement du
système.

7) Soient les tables OSRdyTbl[8] et OSEventTbl[8] à un temps donné :

7 6 5 4 3 2 1 0 7 6 5 4 3 2 1 0
[0] [0]
0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0
[1] [1]
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
[2] [2]
0 0 1 0 0 0 1 0 0 0 0 0 0 0 0 0
[3] [3]
0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0
[4] [4]
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
[5] [5]
0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0
[6] [6]
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
[7] [7]
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
OSRdyTbl[8] OSEventTbl[8]
 a) Quelle tâche occupe le CPU actuellement?

La tâche de priorité 3

b) La tâche trouvée en a) tente de s’approprier un sémaphore déjà possédé

par la tâche de priorité 21. Que se passera-t’il point de vue
ordonnancement?

7 6 5 4 3 2 1 0 7 6 5 4 3 2 1 0
[0] [0]
0 1
[1] [1]

[2] [2]

[3] [3]

[4] [4]

[5] [5]

[6] [6]

[7] [7]

OSRdyTbl[8] OSEventTbl[8]

c) Quelle tâche occupera le CPU?

La tâche de priorité 17

d) Au fil des millisecondes qui s’écoulent, la tâche trouvée en c) termine

son exécution et, par ailleurs, la tâche 21 rend le sémaphore. Que se
passera-t’il point de vue ordonnancement?

7 6 5 4 3 2 1 0 7 6 5 4 3 2 1 0

[0] [0]
1 0
[1] [1]

[2] [2]
0
[3] [3]

[4] [4]

[5] [5]

[6] [6]

[7] [7]

OSRdyTbl[8] OSEventTbl[8]
e) Quelle tâche occupera le CPU?

La tâche de priorité 3

f) À quel phénomène venons-nous d’assister?

Inversion de priorité
QUESTION #3

Le code suivant implante une pile partagée. Les fonctions push() et pop() peuvent être
appelées simultanément par plusieurs threads. La fonction push() bloque jusqu’à ce qu’un
espace soit libre dans la pile. De son côté, la fonction pop() bloque jusqu’à temps qu’une
donnée soit disponible sur la pile. Finalement, les threads doivent s’exclure entre eux.
Utilisez les mécanismes de synchronisation µCOS-II pour implanter ce comportement

int stackPointer;
int stack [ Size ];
OS_EVENT *full, *empty; 1
OS_EVENT *mutex;

void push (int a)

{
OSSemPend (empty);
2
OSMutexPend(mutex);

stack[ stackPointer ] = a;
stackPointer++;

OSMutexPost(mutex);
3
OSSemPost(full);
}

int pop()
{
OSSemPend(full); 4
OSMutexPend(mutex);

stackPointer--;
int tmp = stack[ stackPointer ];

OSMutexPost(mutex); 5
OSSemPost(empty);

return tmp;
}

main()
{
empty = OSSemCreate(Size);
full = OSSemCreate(0); 6

mutex = OSMutexCreate(4) ;
}
QUESTION #4 Ordonnancement

Soit l’ensemble de tâches à ordonnancer suivant :

Tâche Période (T) Temps % d’utilisation Priorité (P)

d’exécution (C) (U)
T1 4 2 50 ?
T2 10 1 10 ?
T3 5 2 40 ?
Ensemble de tâches d’un système

1) En vous basant sur le RMA (Rate Monotonic priority Assignment), déterminez

les priorités des tâches T1, T2 et T3.

T1 Æ 3 T2 Æ 1 T3 Æ 2

2) (1 pt) Que peut-on conclure à partir des résultats du test de Liu and Layland ?

On ne peut rien conclure.

3) (2 pt) Représentez graphiquement l’ordonnancement réalisé avec les priorités

trouvées en a) et montrez que l’ordonnancement est possible (ou non).

T3

T2
deadline manqué
T1

4) (2 pt) Existe-t’il une (une autre) configuration qui rend possible

l’ordonnancement des trois tâches? Si oui, donnez les priorités qui
permettraient cet ordonnancement. Sinon, comment peut-on procéder pour
rendre l’ordonnancement possible ?

Il n’existe pas de configuration de priorités qui rend l’ordonnancement

possible. Il faudrait songer à utiliser des priorités dynamiques pour régler le
problème.