INF2610 : Noyau d’un système d’exploitation Corrige Examen final Hiver 2008

Cours INF2610

Corrigé Examen final

Hiver 2008

Question 1 (3 pts) : Généralités

Solution:
1. Un code réentrant est un code qui ne produit pas de résultats erronés
lorsqu’il est exécuté par plusieurs processus (en pseudo-parallèle). Il existe
plusieurs méthodes qui permettent de transformer un code non réentrant en
code réentrant :
• protéger les sections critiques avec des sémaphores
• désactiver les interruptions
• désactiver l’ordonnanceur
• utiliser uniquement des variables locales, etc.

2. Priorité donnée aux lecteurs: lorsqu’un rédacteur tente d’accéder à la

base, il est mis en attente si un ou plusieurs lecteurs sont en train de lire de
la base. Lorsqu’un rédacteur a terminé d’utiliser la base, il avertir en premier
les éventuels lecteurs en attente.
Priorité donnée aux rédacteurs: lorsqu’un lecteur tente d’accéder à la
base, il est mis en attente si un rédacteur est en train d’écrire dans la base.
Lorsqu’un lecteur a terminé d’utiliser la base, il avertir en premier les
éventuels rédacteurs en attente.

Question 2 (4 pts) : Moniteurs et interblocage

Solution :
1.
Moniteur Sémaphore
{
int value = 0; // compteur du sémaphore
condition c; // sémaphore disponible

void Incrémenter()
{
value++;
c.signal();
}
void Décrémenter()
{
while (value == 0)
c.wait();
value--;
}
Page 1 sur 4
INF2610 : Noyau d’un système d’exploitation Corrige Examen final Hiver 2008
}

2. On ne peut pas avoir d’interblocages, parce qu’il existe la préemption

(réquisition) des ressources.

Question 3 (4 pts) : Ordonnancement de processus

Solution :
1.
P3 P2 P2 P3 P1 P2 P3 P2 P1 P3 P2 P2 P3 P1 P1
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

2.
A1 A2 A2 A2
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

Le processus A1 respecte son échéance (il se termine à 10), tandis que le

processus A2 ne respecte pas son échéance (il se termine à 19, tandis que son
échéance est 17).

Question 4 (4.5 pts) : µC/OS-II

Solution :
1.
/*1*/
// Créer la queue de message
msgQ = OSQCreate((MSG_R *)&QMsgTbl[0], NUM_MSG);

// Initialiser les champs de la structure msgR

msgR.routine = (VOIDFUNCPTR) printf;
strcpy (msgR.arg , “Hello!\n”);

// Créer la tâche Task1

OSTaskCreate(Task1, (void *)&msgR, &Task1Stk[1023], TASK1_PRIO);

// Créer la tâche Task2

OSTaskCreate(Task2, (void *)0, &Task2Stk[1023], TASK2_PRIO);

/*2*/
// Récupérer le message reçu en paramètre
msgR.routine = (VOIDFUNCPTR) pdata->routine;
msgR.arg = pdata->arg;

/*3*/
// Déposer le message msgR dans la queue

Page 2 sur 4
INF2610 : Noyau d’un système d’exploitation Corrige Examen final Hiver 2008
OSQPost(msgQ, (void*) &msgR);

/*4*/
// Retirer un message de la queue, sans timeout
msgR = (MSG *) OSQPend(msgQ, 0, &err);

// Vérifier si l’opération de lecture a réussi

if (err == OS_NO_ERR)
printf(« Un message a été réceptionné!\n »);
else
printf(« Erreur de réception!\n »);

2. Code à ajouter:

#define TASKTIMER_PRIO 17 // Priorité de TaskTimer

...
#define PERIOD 300 // Période de Task1 en ticks d’horloge
...
OSEVENT *SemStart;
OSEVENT *SemStop;

void main(void)
{
...
SemStart = OSSemCreate(0);
SemStop = OSSemCreate(0);
...
}

void Task1(void* p)
{
...
for( ; ; )
{
OSSemPost(SemStart);
...
OSSemPend(SemStop,0,&err);
}
}

void TaskTimer(void* p)
{
for( ; ; )
{
OSSemPend(SemStart,0,&err);
OSTimeDly(PERIOD);
OSSemPost(SemStop);

Page 3 sur 4
INF2610 : Noyau d’un système d’exploitation Corrige Examen final Hiver 2008
}
}

Question 5 (4.5 pts) : Ordonnancement temps réel

Solution :

1. N : signifie une unité de temps où la tâche n’est pas exécutée par le processeur

T4 : À partir de l’instant 7 : ENNNAENNC

T3 : À partir de l’instant 2 : CCNNNNNNNNNACNE
T2 : À partir de l’instant 5 : EENEE
T1 : À partir de l’instant 0 : AANNANNNNNANNNNNNE

Sur le diagramme on voit 3 inversions des priorités :

1. pour T3, entre les instants 4 et 11 (durée 7)
2. pour T4, entre les instants 8 et 11 (durée 3)
3. pour T4, entre les instants 13 et 15 (durée 2)

2.
T4 : À partir de l’instant 7 : EAENC
T3 : À partir de l’instant 2 : CCNNANNNCNE
T2 : À partir de l’instant 13 : EEEE
T1 : À partir de l’instant 0 : AANNAANNNNNNNNNNNE

3.
T4 : À partir de l’instant 8 : EAEC
T3 : À partir de l’instant 4 : CCACNNNNE
T2 : À partir de l’instant 13 : EEEE
T1 : À partir de l’instant 0 : AAAANNNNNNNNNNNNNE

4.
a. B3 = 7, B4 = 5
b. B3 = 2, B4 = 1
c. B3 = 0, B4 = 0

Les protocoles PIP et ICPP réduisent les temps de blocage des tâches (la réduction
est plus grande avec ICPP qu’avec PIP).

Page 4 sur 4