Concours d’accés a I’école doctorale STIC 13 octobre 2008 Option Ingénierie des Systémes Informatiques Epreuve de systémes d’exploitation Durée 1h 30mn Exercicet : ( 1 point) On désire transférer un secteur de 512 octets d'un disque (sans mémoire ou buffer cache) vers la mémoire centrale (on ignore la position du secteur par rapport au début de la piste). Remargue : Arrondir le résultat par excés. #) En utilisant les entrées/sorties asynchrones avec interruption, combien de rotations du disque sont nécessaires pour transférer ce secteur ? ») Combien de rotations sont nécessaires pour transférer ce secteur en Mode DMA (ou ADM) ? Exercice2 : ( 1 point) Lors du démarrage d'un ordinateur 4 base de processeur INTEL, les actions suivantes peuvent étre effectuées pour tester la configuration matérielle ct charger le systéme: 1) Changer et exécuter le secteur de démarrage (ou secteur boot) de la partition active. 2) Rechercher la partition active dans la table des Partitions, 3) Tester la configuration matérielle, 4) Exécuter Ie BIOS, 5) Charger et exécuter le MBR (Master Boot Record), ©) Charger le systéme d’exploitation, Donner la séquence d’opérations qui permet de charger un systéme d’exploitation: Solutions Proposées: . AiK5, 1, 3, 4,2, 65 . B:¥4, 3, 1, 8,6, . NO: 43,5216 . D3, 4, 2,1, 6; . Ex4, 1, 3, 6 . F: 4,3,5,2, 6; Exercice3 : ( 6 points) On considére un systime disposant de 32Mo de mémoire physique, avec la partie résidente du systéme sur &Mo Les processus “arrivent" dans le systéme dans lordre suivant :Processus Arrivée Taille ‘Temps processeur PO 10 10 Mo 6ms PL 10.42 6 Mo 4ms P2 1043 | 12Mo 3ms P3 1045 3 Mo 2ms P4 10 +6 1Mo ‘4ms P5 1047 4Mo. ‘Sms ‘Un processus dont la demande de mémoire n’est pas satisfaite cst mis en attente. Remarque : Un processus n'est « réellement créé » que s'il dispose de toute la mémoire nécessaire & son exécution, ‘Les processus sont exécutés sur une machine monoprocesseur et l’ordonnancement des processus est réalisé avec Palgorithme SIF (Shortest Job First). Remarques : 1) A chaque libération de la mémoire, on commence d’abord par Vallocation de la mémoire att Processus en attente, ensuite on alloue le processeur @ un processus de la file « prét ». 2) Le temps d’allocation est négligeable. 1) Mémoire avec des partitions de taille fixes : ‘* 5 partitions de tailles respectives : $Mo (systéme), 12Mo, 6Mo, 4Mo et 2Mo; * L’allocateur de la mémoire utilise une file de processus par partition, 8) Donner lidentificateur (N°) du processus actif ou élu au temps t0-+10. N° processus (0...5); f 0. Pa. b) Donner le temps d’attente du processus actif au temps t0-+10. Gs dens © Donner l'identificateur(N°) du demier processus exécuté par le processeur ° 5 4) Donner le temps d’attente du demier processus exécuté par le processeur. 29 ..5 2) Mémoire a1 ions de tailles variables © Taille de la mémoire centrale est égale 4 32Mo dont 8Mo pour le systéme; ‘* Lalgorithme de gestion mémoire : Buddy system; * Toute la mémoire (les 32 Mo) est gérée avec l’algorithme Buddy system; * Les requétes (demandes de mémoire) sont satisfaites selon Vordre d’arrivée des processus. 2) Donner l'identificateur (N°) du processus actif ou éu au temps t0+10. N° processus (0.5); #04 'b) Donner le temps d’attente du processus actif au temps t0+10. Lw5 ©) Dans ce systéme, la plus petite unité que on peut allouer a un processus est de 1Ko (ou taille de la plus petite partition); Donner le nombre de partitions de tailles différentes que I’on peut créer dans ce systéme (y compris la partition initiale de 32 Mo). © Exerciced : (2 points) Soit la chaine de références @ = 6,3,9,1,5,3,4,1,5,9,6,4,3,5,6,4, On dispose de 4 processus dont les exécutions générent la méme chaine de références @ et de 16 cases mémoire (pages réetles) initiatement vides. Dans ce systéme la mémoire est allouée de maniére équitable entre les différentles différents processus et utilise le remplacement local. Donner le nombre de défauts de page généré avec chacun des algorithmes suivants: a) LRU © b) Hortoge. Exercice 5 : (2 points) Considérons une machine utilisant le systéme Unix SystemV. La taille d’un bloc est de 1024 octets et la taille d'une entrée d'un bloc d'index et de 4 octets. a) Quelle est la taille maximale des données (en k octets) pour un fichier dont la représentation nécessite exactement 200 blocs d'index d'allocation de niveau d’indirection 3 7 b) On désire copier ce fichier sur un systéme Windows utilisant un systéme de fichiers FAT 32 ayant des clusters de 4Ko, combien d’entrées de la FAT sont nécessaires pour représenter ce fichier. Exercice 6: (2 points) 1) On dispose d’un programme PE (exécutable), le propriétaire peut effectuer toutes les opérations sur ce programme; Par contre, pour le reste des utilisateurs I'exécution est la seule opération permise. Donner, en octal, la protection de ce fichier. 2) Ce programme modifie un fichier de données FD qui n'est autorisé qu’en lecture pour tout utilisateur autre que le propriétaire. On désire autoriser les utilisateurs a modifier le fichier FD en utilisant sculement le programme PE. Donner en octal la protection du fichier FD et la nouvelle protection du programme PE. ‘Exereice7: Communication par buffer dynamique 4 Taide des sémaphores @ points). ‘On veut réaliser une communication entre un producteur P et un consommateur C, mais a aide d'un buffer dynamique constitué d’une liste de blocs chainés alloués la demande. A chaque production P alloue dynamiquement un bloc, y dépose 1’ élément produit et le chaine au précédent. A chaque retrait d’un élément C libare Ie bloc correspondant et consomme I’élément retiré. La fonction Allouer(bloc) bloque le processus appelant tant que l'espace mémoire demandé n'est pas disponible puis renvoie un pointeur sur bloc dés que Vallocation devient possible. La fonction Liberer(ptr) libére le bloc pointé par ptr Les algorithmes du producteur et du consommateur seront : ‘Type bloc : record ; BUF srecord ; Info :element ; Tete, Queue :“bloc init NIL ; Pir :Mbloe ; end ; End; ‘Téte pointe le prochain bloc a retirer, Queue pointe le demiier bloc déposé. Procedure P; Procedure C ; Var Nextp : element ; ‘Var Nexte : element ; Begin Begin Repeat Repeat Produire(Nextp) ; Retirer(BUF,Nextc); Déposer(BUF, Nextp) ; Consommer(Nextc) ; until false ; until false ; End Producteur ; End Consommateur ; 3Questions: On demiande de programmer par sémaphores les procédures de dépot et retrait d'un élément: Solutions proposées : Solution A. ‘Var Mutex :semaphore init 1 ; Procedure Deposer(BUF, element) ; Var p:“bloc ; Begin P :=Allouer(bloc) ; p*bloc.Info :=element ; p*bloc.ptr :=NIL ; P(Mutex) ; If(BUF.Téte= BUF.Queue=NIL) then BUF.Téte =p; Var Nvide :semaphore init 1 ; Nplein : semaphore init 0 : Procedure Deposer(BUF,element) ; Var p :“bloc ; Begin p:=Allouer(bloc) ; p*bloc.Info :=element ; p*bloc. ptr IL 5 P(Nvide) I{(BUF. Téte= BUF. Queue=NIL) then BUF.Téte Else BUF.Queue*bloc. ptr =p ; maphore init 5 ; semaphore init 0: Procedure Deposer(BUF,element) ; Var p :“bloc ; Begin =Allouer(bloc) ; p**bloc.Info :=element ; pA bloc. ptr :=NIL ; Procedure Retirer(BUF, element) ; Var f :“bloc ; Begin f:=BUF. Téte ; element :=BUF. Téte*bloc. Info ; P(Mutex) ; If(BUF. Téte= BUF.Queue) then BUF.Queue :=NIL ; BUF. Téte := BUF. Téte“bloc. ptr ; Liberer(f) ; V(Mutex) ; End Retirer ; Procedure Retirer(BUF element) ; Var £:Abloc ; Begin PNplein) ; f=BUF-Téte ; element :=BUF.Téte*bloc.Info ; If(BUF. Téte= BUF.Queue) then BUF.Queue :=NIL ; BUF. Téte := BUF.Téte”bloc.ptr ; VaNvide) ; Liberer(f) 5 End Retirer ; Procedure Retirer(BUF,element) ; Var f:bloc ;P(Nvide) ; ‘I(BUF. Téte= BUF.Queue=NIL) then BUF.Téte :=p; Else BUF.Queue*bloc. ptr :=p ; BUF.Queue :=p ; ‘V@Nplein) ; End Deposer ; i Var Mutex :semaphore init 1; Nplein : semaphore init 0 ; Procedure Deposer(BUF,element) ; Var p :“bloc ; Begin p:=Allouer(bloc) ; p*bloc.Info :=element ; p*bloc.ptr :=NIL ; P(Mutex) ; If(BUF.Téte= BUF.Queue=NIL) then BUF. Téte :=p ; Else BUF.Queue*bloc.ptr : BUF.Queue :=p ; V(Mutex) ; V@Nplein) ; End Deposer ; Solution E: Var Mutex :semaphore init 1 ; Nplein : semaphore init 0 ; Nvide :semaphore init 1; Procedure Deposer(BUF, element) ; Var p bloc ; Begin P*bloc.Info :=element ; p*bloc. ptr :=NIL ; If(BUF. Téte= BUF. Queue) then BUF. Queue :=NIL ; BUF. Téte := BUF. Téte“bloc.ptr ; VoNvide) ; Liberer(f) ; End Retirer ; Procedure Retirer(BUF, element) ; Var f:“bloc ; Begin PNplein) ; BUF. Téte ; element :=BUF.Téte*bloc.Info ; P(Mutex) ; If(BUF. Téte= BUF. Queue) then BUF.Queue :=NIL ; BUF. Téte := BUF. Téte“bloc.ptr ; ‘V(Mutex) ; Liberer(f) ; End Retirer ; Procedure Retirer(BUF,element) ; Var f “bloc ; Pplein) 5 BUF. Téte ; element :=BUF.Téte*bloc.Info ; P(Nvide) ; If(BUF.Téte= BUF. Queue) then BUF.Queue :=NIL ; If(BUF.Téte= BUF.Queue=NIL) then BUF. Téte := BUF. Téte“bloc.ptr ; BUF.Téte =p; V@Nvide) ; Else BUF.Queue“bloc. ptr =p ; Liberer(f) ; BUF.Queue :=p ; ‘V(Mutex) ; ‘VeNplein) ; End Retirer ; ‘V(Mutex) ; End Deposer ; —_Exercice8 : Modéle Producteur/Consommateur en Distribué. (3 points) (On désire réaliser une application du modéle producteur/consommateur sur un buffer BUF de N cases dans un environnement distribué faiblement couplé (pas de mémoire commune ni d’horloge commune, les machines sont interconnectées par un réseau de communication). On dispose de 2 producteurs Prodi) et Prod(3-i) et de 2 consommateurs Cons(i) et Cons(3-i) avec i= 1 ou 2. Donner Ia condition de dépot pour l'algorithme de Prodti) et la condition de retralt pour Valgorithme de Cons(i) dans ua environnement distribué en utilisant les compteurs Pautorisation de laction du processus i (Aut(action(j)) et de terminaison de l'action du processus i Term(action(i))) avec leurs copies respectives, les primitives de communication réseau : _Send(processus,message) : envoi d’un message a un processus nommé _Receive(processus,message) : reception d’un message d’un processus nommé _ Receive_Any(identité processus emetteur , message) reception d'un message venant de tout processus avec reception de son identité. ‘On supposera chaque processus sur une machine distincte ; L'accds au buffer se fera par les procédures : _Déposer(i, BUF, clement) permettant au producteur i de déposer I’élément courant dans BUF. _Retirer(,BUF clement) permettant au consommateur i de retirer I’élément courant de BUF. Ces procédures sont appelables par la technique du RPC (Remote Procedure Call ou Appel de Procédure & distance) destiné au serveur du buffer. Le serveur du buffer garantit exclusion mutuelle entre les dépots simultanés et les retraits simultanés. Chaque processus P aura 2 parties; la partie Action(P) effectuant L'action utile et la partie Réception(P) recevant les messages de synchronisation venant des processus extemnes. Dh Producteur. Var Aut(Déposer(i)) : compteur init 0; Term(Déposer(i)) : compteur init 0; Copie(Aut(Déposer(3-i))) : compteur init 0; Copie(Term(Déposer(3-1))) : compteur init 0; Copie(Aut(Retirer())):compteur init 0; Copie(Aut(Retirer(3-i))):compteur init 0; Copie(Term(Retirer()))):compteur init 0; | Copie(Term(Retirer(3-1))):compteur init 0; Nextp: element; Debut Action(Prod()) Produire(Nextp); Repeat until _condition_depot ; Aut(Déposer(i)) + + ; Send(Cons(j), ‘dépét courant autorisé’) ; Send(Cons(3-i), ‘dépét courant autorisé’) ; Send(Prod(3-i), ‘dépat courant autorisé’) ; Déposer(i, BUF Nextp); Term@époser()) + +; Send(Cons(i), ‘dépdt courant terminé’) ; Send(Cons(3-i), ‘dépét courant terminé’) ; Send(Prod(3-4), ‘dépdt courant terminé’) ; Until FinP ;Fin Action(Prod(@); ‘Début Réception(Prod(i)) Receive_Any({dentité processus emetteur , message); Case (identité processus emetteur) of “Prod(3-i)’ : Case (message) of “dép6t courant autorisé’ : Copie(Aut(Déposer(3-))) + +; ‘dépét courant terminé’ : Copie(Term(Déposer(3-i))) + + ; end case; ‘Cons(iy’ : Case (message) of ‘retrait courant autorisé’ : Copie(Aut(Retirer(i))) + + ; ‘retrait courant terminé’ : Copie(Term(Retirer())) + +; end case; ‘Cons(3-i’ : Case (message) of ‘retrait courant autorisé’ : Copie(Aut(Retirer(3-i))) + + ; ‘retrait courant terminé’ : Cople(Term(Retirer(3-1))) + +; end case; end case; Fin Réceptionrod(i) ; A: { (N -Term(Déposer() + Copie(Term(Retirer()) + Copie(Term(Retirer(3-i)) ) > 0} B: { (N_ -Term@époser()) - Copie(Term(Déposer-)) + Copie(Term(Retirer()) + Copie(Term(Retirer(3-i)) ) >0 } C: { W -Aut(DEposer()) ~ Copie(Aut@époser(3-i))) + Copie(Term(Retirer(i)) + Copie(Term(Retirer@-)) 270} D: { (Aut@époser(i)) — Copie(Term(Déposer(3-i)) + Copie(Lerm(Retirer()) + Copie(Term(Retirer(3-i))) 0 } Bz { ( Term@époser()) + Copie(Term((Déposer(3-i) - Aut(Retirer()) - Copie(Aut(Retirer(3-0) ) >0 } C: { (AutDéposer()) — Cople(Aut(Déposer(S-i)) + Cople(Term(Retirer()) + Copie(Term(Retirer(3-1) ) 30} D: { (Aut(@époser() — Copie(Term(Déposer(3-1))}+ Copie(Term(Retirer())) - Cople(Term(Retirer(3-1))) <0}