CYCLE INGENIEUR EN INFORMATIQUE – 1ère ANNÉE -

EXAMEN ÉCRIT – SESSION PRINCIPALE (GR. INGTA-1-I)

Module Systèmes d’Exploitation Date 24/12/2022

Enseignant M. Mohamed Chiheb BEN CHAÂBANE Durée 02 heures
Documents Non Autorisés (Calculatrice autorisée) Nbre Pages 07 pages

Partie A : QUIZ (06 pts)

NB : Une question peut avoir une ou plusieurs réponses exactes

1. La partition SWAP dans les OS Linux est :
a. configurable
b. installée par défaut avec l’OS Linux
c. pour être efficace sa taille doit être 1.5 la RAM ou plus
d. pour être efficace sa taille doit être 1.25 la RAM

2. Parmi lesquels des Systèmes d’Exploitation sont des OS Linux :

a. Unix, Debian, CentOS, Ubuntu
b. Linux, Fedora Server, CentOS, OS/390
c. FreeBSD, Debian, CentOS, Ubuntu
d. RedHat, Debian, CentOS, Ubuntu

3. Pour un système de fichiers NTFS, la taille maximale d’un fichier est :

a. 100 Go
b. 2 Go
c. 16 To
d. 512 Mo

4. Une ressource est :

a. est toute entité matérielle/logicielle nécessaire pour le travail d’un Thread
b. est toute entité matérielle/logicielle nécessaire pour le travail d’un Processus
c. est toute entité logicielle nécessaire pour le travail d’un Thread
d. est toute entité matérielle nécessaire pour le travail d’un Processus

5. Quel(s) avantage(s) du NTFS par rapport au système de fichiers FAT32 ? :

a. NTFS supporte les algorithmes de compression, FAT32 ne les supporte pas
b. NTFS supporte les algorithmes d’hachage, FAT32 ne les supporte pas
c. NTFS offre une capacité de stockage de fichiers plus importante
d. NTFS offre une taille de stockage par fichier plus grande
e. Toutes les réponses mentionnées ci-dessus sont correctes

Page 1 sur 7
6. Parmi lesquels sont considérés des algorithmes de remplacement de mémoire :
a. FIFO
b. Worst Fit
c. Best Fit
d. Least Recently Used
e. Lastly Used

7. Parmi lesquels sont considérés des Paradigmes de programmation :

a. SOA
b. MicroServices
c. Orientée Objet
d. SRA

8. Quel est le nombre maximal de partitions primaires dans un OS :

a. 2
b. 4
c. 16
d. 128

9. Le DMA :
a. est un protocole d’E/S
b. est un accès direct à la Mémoire
c. est un dialogue entre la RAM et le périphérique d’E/S sans passer par la CPU

10. Quelle est la mémoire la plus rapide en temps d’accès ?

a. La mémoire cache
b. La mémoire vive
c. La mémoire morte (ROM)
d. La mémoire virtuelle

11. Quel est le niveau le plus rapide en temps d’accès au niveau de la mémoire cache ?
a. Niveau L1
b. Niveau L2
c. Niveau L3
d. Niveau L4

12. L’état zombie d’un processus :

a. désigne un état où un processus ne peut plus évoluer avec des ressources libérées
b. désigne un état où un processus ne peut plus évoluer avec des ressources non libérées
c. désigne un état où un processus peut évoluer avec des ressources libérées
d. désigne un état où un processus peut évoluer lentement avec des ressources libérées

Page 2 sur 7
Partie B : EXERCICES (14 pts)
Exercice 1 : (Gestion d’Ordonnancement des Processus) (07 pts)
Soit un Système monoprocesseur qui ordonnance l’exécution des processus suivants :

Temps Temps
Processus
d'Arrivée CPU
A 0 2
B 2 5
C 4 4
D 5 3
E 7 2

a. Supposons qu’on travaille en mode monoprocesseur, donnez les diagrammes de Gantt des
algorithmes suivants : FIFO, SJF, SRTF et le Tourniquet (Quantum = 2ms) montrant
l’allocation de ces processus et l’évolution de leurs états. (Tracer un diagramme pour
chaque algorithme)
(NB : Veuillez utiliser 2 stylos de couleurs différentes afin de distinguer les états des
processus).
b. Calculer le temps moyen d’attente, le temps moyen de séjour et le temps de réponse moyen
pour les algorithmes SJF, SRTF et le Tourniquet. Interpréter le résultat.

Exercice 2 : (Gestion des Sémaphores : Le Dîner des Philosophes) (07 pts)

Considérons cinq philosophes, installés autour d'une table circulaire, et qui passent leur temps à penser
et à manger. (Voir figure1)

Figure 1 - Illustration du problème des philosophes

Page 3 sur 7
La table est mise avec cinq fourchettes qui sont disposés entre chacun des philosophes.
De temps en temps, un philosophe a faim et essaye de prendre les fourchettes qui sont
immédiatement à côté de lui (ceux qui sont entre lui et son voisin de gauche et de droite). Un
philosophe a besoin de deux fourchettes pour manger, et ne peut évidemment pas prendre un couvert
qui est dans la main d'un voisin.
Quand un philosophe affamé a ses deux fourchettes dans les mains en même temps, il mange sans les
libérer. Dans le cas contraire, il doit attendre que ceux-ci deviennent libres (voir figure2).

Figure 2 - Changements d'état des philosophes

Enfin, quand il finit de manger, il repose ses deux fourchettes et commence à penser à nouveau.
Précisons que les philosophes mangent et pensent durant des temps aléatoires différents, leur
changements d'état, se produisent donc de manière totalement asynchrone.
Le problème même du dîner des philosophes consiste donc à réguler les changements d'état de ces
derniers suivant la disponibilité des fourchettes, qui dépend bien entendu de l'état des voisins du
philosophe concerné.

Question 1 : Soit l’algorithme ci-dessous, d’après-vous quelles sont problèmes rencontrées suite à son
implémentation.

Void philosophe()
{
While(1)
{
Sleep();
Prendre_fourchette_droite();
Prendre_fourchette_gauche();
Manger();
Deposer_fourchette_droite();
Deposer_fourchette_gauche();
}
}

Page 4 sur 7
Question 2 :

Compléter le script par les types/fonctions correspondant(e)s à l’aide du Tableau Annexe ci-dessous
mentionné :

#define NB_PHILO 5

typedef enum{Pense, Mange, Attend} T_etat;

T_etat etatPhilo[NB_PHILO];

static sem_t fourchettes[NB_PHILO]; // sémaphore privé, sémaphore pour les ressources fourchettes
(1 par philosophe)
static sem_t SemaPublic; // pour l'affichage (il faut pas que ça change pendant qu'on affiche)

void changeEtaffiche ( int* id, T_etat nouvelEtat) // fonction affichant les états des différents
philosophes sur une ligne
{
int i;
……………(&SemaPublic); // Variable Sémaphore
etatPhilo[*id] = nouvelEtat;
for (i = 0; i<NB_PHILO; i++)
{
switch(etatPhilo[i]){
case Pense: printf(" P "); break;
case Mange: printf(" M "); break;
case Attend: printf(" A "); break;
}
}
sem_post(……………….);
}

void* philosophe ( void* arg )

{
int *id=(int *) arg;
int left = *id;
int right = (left + 1) % NB_PHILO;

// il attend
changeEtaffiche(id,Attend);
if(left<right) {
sem_wait(…………………);
…………..(&fourchettes[right]);
}
else {
sem_wait(&fourchettes[right]);
sem_wait(&fourchettes[left]);

Page 5 sur 7
 }

// il mange
changeEtaffiche(id,Mange);
//sleep(2);

// il pense (important: avant de relacher ses fourchette, parce que s'il le fait après, l'affichage
mettrait que 2 voisins mange en même temps)
changeEtaffiche(id,Pense);
………..….(&fourchettes[left]);
sem_post(&fourchettes[right]);

//sleep(2);

return (NULL);
}

int main ( int argc, char *argv[])

{
int i;
int id[NB_PHILO];
……………. thread[NB_PHILO]; // Déclaration des threads philosophes

srand(getpid());

………….(&SemaPublic,0,1); // Initialisation

for (i = 0; i < NB_PHILO; i++) {

id[i]=i;
etatPhilo[i] = Pense(); // au début TOUS les philosophes pensent
sem_init( &fourchettes[i], 0, 1);
}

for (i = 0; i < NB_PHILO; i++) {

…………(&thread[i], NULL, philosophe, (void*)&(id[i]) ); // Création Thread
}

for (i = 0; i < NB_PHILO; i++) {

pthread_join(thread[i], NULL); // Attente de Terminaison Mutuelle
}

for (i = 0; i < NB_PHILO; i++) {

……………(………….[i]); // Libération Sémaphore
}

sem_destroy(…………..);

return (EXIT_SUCCESS);
}

Question 3 : Quel mécanisme de synchronisation doit-on implémenter pour régulariser la section critique
afin de la protéger des conditions et manipulations non structurées ?

Page 6 sur 7
Tableau Annexe des fonctions de la Bibliothèque pthread.h selon le standard POSIX

/. Bon travail ./

Page 7 sur 7