Examen 3I010

L3 – Licence d’Informatique -Année 2019

2 heures - Aucun document autorisé - Barème donné à titre indicatif

1. SYN CHRON ISATION S PAR SEMAPHORES (6 POIN TS )

On veu t synchroniser u n calcu l réparti. Tous les processu s sont cycliqu es et
bouclent ind éfiniment.
N processu s d e calcu l (C 0, C 1, …, C N -1) appellent u ne fonction d e calcu l local
qu i retou rne u n entier.
Tou tes les valeu rs prod u ites sont accum u lées d ans u ne variable partagée part
(part som m e les valeu rs produ ites par les C i). Lorsqu e tou s les p rocessu s C i
ont ajou té leu r valeu r à part, u n processus X est réveillé.
Une fois réveillé X fait u n calcu l global su r part et réinitialise part à 0.
Les processu s C i ne peu vent continu er qu e lorsqu e le calcu l global est
term iné.

Le pseu d o-cod e d es processus est le su ivant

#define N 10
void C(int i) {
int c ;
while(1) {
…
c = calcul_local() ;
…
part +=c;
…
}
}
void X(){
while (1) {
…
calcul_global(part) ;
part = 0;
…
}
}

1.1. (3 points)
Com plétez les cod es d e fonctions C et X.
Spécifiez les sémaphores et/ ou variables partagées u tilisés ainsi qu e leur
initialisation.

Un com pteur partagé cpt initialize à 0

1/ 8
Un tableau d e sém aphores d e taille N , initialisé à 1 pour bloquer les Ci

Un sém aphore SX initialisé à 0 pour bloquer X

Deux sém aphores MUTEX1 et MUTEX2 initialisé à 1

void C(int i) {
int c ;
w hile(1) {
P(SC[i]);
c = calcul_local() ;
P(MUTEX1);
part +=c;
V(MUTEX1);
P(MUTEX2);
cpt++;
if (cpt==N )
V(SX);
V(MUTEX2);
}
}

void X(){
int i;
w hile (1) {
P(SX);
/ * Mutexs inutiles ici car X est forcém ent seul ici */
calcul_global(part) ;
part = 0;
cpt = 0;
for (i=0 ; i<N ; i++)
V(SC[i]) ;
}
}

1.2. (3 points)
On sou haite m od ifier la synchronisation pou r qu e X soit réveillé lorsqu e les K
prem iers (K<N ) calcu ls locau x ont été effectu és. Les valeurs prod u ites par ces
K calcu ls locau x sont accu m u lées dans la variable partagée part. Com me
précéd em m ent, tous les processu s C i doivent attend re qu e tou s aient fini leu r
calcu l local avant de continu er.
Mod ifiez vos program m es en conséquence.

Ajout d ’un sém aphore Attente initialisé à 0.

2/ 8
void C(int i) {
int c ;
w hile(1) {
P(SC[i]);
c = calcul_local() ;
P(MUTEX1);
cpt++ ;
if (cpt <= K) {
part +=c;
if (cpt == K)
V(SC);
}
else {
if (cpt == N ) {
for (c=0 ; c<N -1 ; c++)
V(SC[c]) ;
cpt = 0;
part = 0;
V(Attente);
}
}
V(MUTEX1);
}
}

void X(){
w hile (1) {
P(SX);
P(MUTEX1);
calcul_global(part) ;
V(MUTEX1);
P(Attente);
}
}

2. M EMOIRE (4,5 POIN TS )

On d ispose d 'une m achine sim plement paginée avec d es pages d e 1024
octets.

2.1. (0,5 point)

La tradu ction d es ad resses virtu elles en ad resses physiqu es est -elle réalisée
par le processeu r ou par le systèm e d ’exploitation ? Ju stifiez votre réponse.

Trad uction est faite par la MMU pou r d es raisons d ’efficacité

3/ 8
 2.2. (0,5 point)
La table d es pages d ’u n processu s est-elle stockée en RAM ? A quel m om ent
la table d es pages d’u n processus est créée ?

La table est stockée en RAM et est créée à la création d u processus (fork).

2.3. (0,5 point)

La TLB est-elle stockée en RAM ? Ju stifiez.

N on, c’est u ne m ém oire interne d e la MMU, u tilisée pou r éviter les accès
RAM lors d e la tradu ction.

Soit u n processu s P, d ont la table d es pages est la su ivante :

case Présence LEX Référence

0 0 101 0
1 200 1 101 0

2 0 110 0

3 0 110 0
(L : lecteur, E : écriture, X : eXécution)

On d ispose d ’u ne seu le case libre, la case 300.

2.4. (2 points)
Qu e se passe-t-il lorsqu e P fait :
a) u n accès en lecture à l’ad resse 2019 ?
b) u n accès en écritu re à l’ad resse 3000 ?
Vou s préciserez les actions faites par le m atériel et celles faites par le systèm e.
Vou s d onnerez l’adresse physiqu e correspond ant à l’accès .
a) MMU : accès page <1,995>, d roit OK, Présence OK, ad resse physique = 200*1024+995 =
205795
b) MMU : accès page <2,952> , IT d éfaut d e page , Systèm e : traite d éfaut d e la page 2,
alloue la case 300, ad resse physique = 300*1024+952 = 308152

2.5. (1 point)
Donnez le nou vel état d e la table d es pages d e P après ces 2 accès.

case Présence LEX R

0 0 101 0

1 200 1 101 1

2 300 1 110 1

4/ 8
 3 ° 110 0

3. REMPLACEMEN T D E PAGES (4,5 POIN TS )

On d ispose d 'u ne m achine sim plem ent paginée. Soit d eu x processu s P1 et P2
n’exécu tant pas le m êm e cod e.
P1 fait les accès su ivant à ses pages :
0 1 2 2 1 0 1 2 0
P2 fait les accès su ivant à ses pages :
1 2 3 3 4 1 2 1 4
On d ispose en tou t d e 6 cases libres pou r exécu ter P1 et P2.
P1 et P2 s’exécu tent en temps partagé su ivant l’algorithm e d u tou rniqu et
sim ple avec une commutation toutes les 3 références (on consid ère
qu’initialem ent P1 est élu ). On considère d ans la su ite qu ’aucune page n’est
initialement chargée en mémoire.
On fait u ne stratégie d e rem placement d e page d e type FIFO appliqué
localem ent à chaque processus : le systèm e allou e 3 cases à P1 (les cases 10, 20
et 30) et trois cases à P2 (les cases 40, 50 et 60). Le remplacem ent d e page
d ’u n processus ne se fait qu ’au sein d es pages d u processus : par exem ple si
P1 a besoin d ’u ne nou velle page alors qu ’il a d éjà u tilisé ses 3 cases, on
choisira parm i les pages d e P1 la plus anciennem ent chargée.

3.1. (3 points)
a) Qu els sont les d éfau ts d e page engend rés par cette séqu ence ? Faites un
tableau pou r ind iqu er à qu els m om ents ces d éfau ts ont lieu et la case u tilisée
lors d e chacu n d e ces d éfau ts.
b) Quel est le nombre total d e d éfau ts d e pages ?

P1 P2 P1 P2 P1 P2
0 1 2 1 2 3 2 1 0 3 4 1 1 2 0 2 1 4
0 10
P1 1 20
2 30
1 40 X 50
2 50 X 60
P2
3 60 X
4 40
Défau ts D D D D D D D D D

9 d éfauts
5/ 8
 3.2. (1,5 points)
Donnez l’état d es tables d es pages à la fin d e ses séquences. Pou r chaque
page, vous ind iqu erez : la case éventuelle, les bits d e présence.
TP d e P1
<page,case,P >
<0,10,1>
<1,20,1>
<2,30,1>

TP d e P2
<page,case,P >
<1,50,1>
<2,60,1>
<3,-,0>
<4,40,1>

4. FICHIERS (5 POIN TS )

On consid ère la gestion d e la FAT vu e en TME d ont le form at est le su ivant :

Le pointeu r short * pt _FAT pointe vers le d ébu t d e la FAT et le pointeu r st ruct

ent _dir* pt _DIR pointe vers le d ébu t d u répertoire. La taille d es blocs
(secteu rs) est d e 128 octets. Chaqu e entrée d u répertoire possèd e les cham ps
su ivants :

6/ 8
  del_flag : 0 ind iqu e qu e l’entrée est libre ; 1 ind iqu e qu e l’entrée est
occu pée.
 name : nom d u fichier
 first_bloc, last bloc: prem ier et d ernier bloc d u fichier.
 size : taille d u fichier.
Les entrées 11 à 127 d e la table pt_FAT contiennent 0.
4.1. (1 point)
- Qu els sont les blocs com posant les fichiers « fichier1 » et « fichier2 » ?
- Qu els sont les blocs libres ?

fichier1 : 5 4 7
fichier2 : 6 10 8

Libres : 2, 3, 9, 11 à 127

On veu t écrire u ne fonction int fusion_file(char *f1, char *f2)

qu i fu sionne les blocs d es fichiers f1 et f2. Après l’appel à la fonction , le
fichier f1 sera composé d es blocs d e f1 et f2 d e façon alternative ; le fichier f2
est lu i d étru it. La fonction retou rne 0 si la fusion s’est faite correctem ent et -1
sinon. Pou r sim plifier, on su ppose qu e f1 et f2 ont le même nombre de blocs
et qu e la taille d es fichiers est u n mu ltiple d e 128.
Par exem ple, si avant l’appel, f1 est com posé d es blocs 23, 15 et 17 et f2 des
blocs 30, 40 et 35, après l’appel f1 sera com posé, d ans cet ord re, d es blocs 23,
30, 15, 40, 17 et 35.

4.2. (4 points)
Donnez le programm e C d e la fonction fu sion_file.
int fusion_file(char *f1, char *f2){
int i,auxb1,auxb2,b1,b2;
struct ent_d ir * pt = pt_DIR, *pt1, *pt2;

pt1= pt2 = N ULL;

for (i=0; i< N B_DIR; i++) {
if ((pt->d el_flag) && (!strcm p (pt->nam e, f1)))
pt1 = pt;
else
if ((pt->d el_flag) && (!strcm p (pt->nam e, f2)))
pt2 = pt;
pt++;
}

if (!pt1 | | !pt2) {
return -1;
}
7/ 8
 b1 = pt1->first_bloc;
b2 = pt2->first_bloc;

w hile (b1 != -1 && b2 != -1) {

auxb1 = pt_FAT[b1];
auxb2 = pt_FAT[b2];
pt_FAT[b1] = b2;
p t_FAT[b2] = auxb1;
b2 = auxb2;
b1 = auxb1;
}
pt1->size += pt2->size;
p 1-> last_bloc = p2->last_bloc;
pt2->d el_flag = 0;
return 0 ;
}

8/ 8