Contrôle périodique du cours INF3600
Contrôle périodique du cours INF3600
Systèmes d’exploitation · exam
Voir tous les documents en systèmes d'exploitation et cloudTous les examens en systèmes d'exploitation et cloud
Fiche de révisionCorrigé
Rédigée à partir de ce document, puis vérifiée avant publication.
Ce contrôle périodique du cours INF3600 porte sur les systèmes d’exploitation. Il évalue les compétences en création de processus UNIX, ordonnancement des processus avec l'algorithme du tourniquet sur un système multiprocesseur, ainsi qu'en synchronisation de processus à l'aide de sémaphores dans un contexte de tampons partagés.
Cette question aborde les avantages et inconvénients de la création de processus par duplication sous UNIX, les caractéristiques des processus légers (threads), ainsi qu'un programme d'illustration en C/C++.
Avantage : La duplication facilite la création de processus exécutant le même programme, car le processus fils hérite de l’état du père.
Inconvénient : Elle complique la création de processus exécutant des programmes différents, car il faut ensuite remplacer l’image mémoire du fils (avec exec).
Le programme crée quatre processus fils, chacun appelant la fonction Recherche sur une partie différente du fichier. Chaque fils retourne 0 en cas de succès (mot trouvé) et 1 sinon. Le père attend les fils et, dès qu’un fils réussit, il tue les autres.
int main ()
{
int pid[4], status, x;
for (int i=0; i<4; i++)
{
// création du (i+1)ième fils
if ((pid[i] = fork()) == 0)
{
if (Recherche("COURS", "INF3600", i+1))
exit(0);
else
exit(1);
}
}
while ((x = wait(&status)) > 0)
{
if (status >> 8 == 0) // succès d’un fils
{
for (int i=0; i<4; i++)
if (pid[i] != x)
kill(pid[i], SIGKILL);
exit(0);
}
}
exit(1);
}
Réponse finale : Le programme ci-dessus réalise la création des quatre fils, la recherche parallèle, la récupération des résultats via wait, et la terminaison des fils restants dès qu’un succès est détecté.
Cette étude analyse un système multiprocesseur composé de deux CPU et d'une unité d'E/S, fonctionnant selon l'algorithme du tourniquet avec un quantum de 3 unités de temps.
Description des besoins en ressources des processus A, B et C :
| Processus | Instant d’arrivée | Temps d’exécution |
|---|---|---|
| A | 0 | 4 unités CPU, 2 unités E/S, 2 unités CPU |
| B | 2 | 3 unités CPU, 4 unités E/S, 2 unités CPU |
| C | 3.5 | 5 unités CPU |
Règles de priorité pour la gestion des événements simultanés :
Planification sur les processeurs et l'unité d'E/S :
Le temps de virement (TV) correspond à la durée écoulée entre l'arrivée du processus et sa fin d'exécution :
Le temps moyen de virement (TVM) est obtenu par la formule :
TVM = (8 + 10 + 5.5) / 3 = 23.5 / 3 ≈ 7.83
Note : La valeur arrondie à 7.8 dans l'énoncé source correspond aux calculs de l'évaluation.
Réponse finale : Le temps moyen de virement est environ 7.83 unités de temps.
Cette section traite de la synchronisation de trois processus P0, P1 et P2 communicant via deux tampons partagés T0 et T1 de taille N. P0 traite des messages puis les place dans T0, P1 transfère de T0 à T1, et P2 lit T1 pour envoyer les messages.
Afin d'assurer l’exclusion mutuelle et d'éviter les interblocages lors des accès aux tampons, la solution repose sur :
Semaphore
mutex1 = 1, mutex0 = 1, Vide0 = N, Vide1 = N, Plein0 = 0, Plein1 = 0;
P0
Message m, mc;
int ip = 0;
Répéter
{
m = lire(); // Lecture d’un message clavier
mc = Encrypter(m); // Traitement (encryption)
P(Vide0); // Attente tampon T0 non plein
P(mutex0); // Exclusion mutuelle sur T0
T0[ip] = mc; // Dépôt dans T0
V(mutex0); // Libération mutex0
ip = (ip + 1) mod N; // Avancement de l’indice circulaire
V(Plein0); // Signal tampon T0 non vide
}
P1
int icp = 0;
Répéter
{
P(Plein0); // Attente tampon T0 non vide
P(Vide1); // Attente tampon T1 non plein
P(mutex0); // Exclusion mutuelle sur T0
P(mutex1); // Exclusion mutuelle sur T1
T1[icp] = T0[icp]; // Transfert de T0 vers T1
V(mutex1); // Libération mutex1
V(mutex0); // Libération mutex0
icp = (icp + 1) mod N; // Avancement de l’indice circulaire
V(Plein1); // Signal tampon T1 non vide
V(Vide0); // Signal tampon T0 non plein
}
P2
Message mc;
int ic = 0;
Répéter
{
P(Plein1); // Attente tampon T1 non vide
P(mutex1); // Exclusion mutuelle sur T1
mc = T1[ic]; // Lecture du message dans T1
V(mutex1); // Libération mutex1
ic = (ic + 1) mod N; // Avancement de l’indice circulaire
V(Vide1); // Signal tampon T1 non plein
Envoyer(mc); // Envoi du message
}
Réponse finale : Les pseudocodes ci-dessus mettent en œuvre la gestion synchronisée des tampons partagés en évitant les conditions de course et les risques d'interblocage.