Vous êtes sur la page 1sur 4

Contrôle Continu Système d’Exploitation

Exercice1

typedef struct

int ∗ tab ;

size_t tab_size ;

size_t sub_tab_start ;

size_t sub_tab_end ;

int thread_r a n k ;

int ∗ global_sum ;

pthread mutex_t mut ; // Mutex

pthread_cond_t cond ; // Condi ti on

pthread_barrier_t barrier ; // B a r ri `e r e

} func_input ;

1)

int main ()

func_input pthread mutex_t mut ;

func_input pthread_cond_t cond ;

func_input pthread_barrier_t barrier ;

void *print_local_sum(void *arg)

int sum = 0;

int *tab = (int *)arg;

for (i = func_input->sub_tab_start; i < func_input->sub_tab_end; ++i) {

sum += func_input->tab[i];

return 0 ;

2)
pthread_mutex_t mut;

int global_sum = 0;

void *compute_global_sum(void *arg)

{ int *tab = (int *)arg;

for (i = sub_tab_start; i < sub_tab_end; ++i)

pthread_mutex_lock(&mut);

global_sum += tab[i];

pthread_mutex_unlock(&mut);

3)

void *print_global_sum(void *arg)

EXERCICE 4

1)

Même si l'espace de swap peut aider les ordinateurs disposant d'une quantité de RAM limitée, il ne
faut pas le considérer comme un outil remplaçant la RAM. L'espace de swap est situé sur les disques
durs ayant un temps d'accès plus lent que la mémoire physique. Si on n’a pas assez de mémoire et
pas d'espace de swap, cela entraînera souvent l'échec de l'allocation de mémoire pour les demandes
nécessitant plus de pages de mémoire.

2)

Un bit associé à chaque page est positionné à 1 à chaque fois qu'une page est utilisée par un
processus. Avant de retirer une page de la mémoire, on va essayer de lui donner une deuxième
chance. On utilise un algorithme FIFO plus la deuxième chance:
Si le bit d'utilisation est à 0, la page est swappée hors mémoire (elle n'a pas été utilisée depuis la
dernière demande de page).
Si le bit est à 1, il est positionné a zéro et l'on cherche une autre victime. Ainsi cette page ne sera
swappée hors mémoire que si toutes les autres pages ont été utilisées, et utilisent aussi leur
deuxième chance.

On peut voir ceci comme une queue circulaire, où l'on avance sur les pages qui ont le bit à 1 (en le
positionnant à zéro) jusqu'à ce que l'on trouve une page avec le bit d'utilisation à zéro.
3)
Un défaut de page est en quelque sorte une opération qui se produit sur un ordinateur doté de
RAM , permettant a une partie du disque dur d’augmenter la mémoire physique de l’ordinateur et
non pas et non pas de dire qu’une page est accédé en un minimum de temps.

4)

L’algorithme d’ordonnancement de page apportant les meilleures performances n’est l’algorithme


de Belady mais plutôt l’algorithme de l’Horloge.

5)

Plus la taille d’une page est grand et plus les performances sont moins meilleurs , ainsi la mémoire
doit être plus utilisé et donc elle est moins optimisé.

EXERCICE 5

• pthread create() -> • fork()

• printf() ->• write()

• malloc() -> • mmap()

• fprintf() -> • write()

• fopen() -> • open()

EXERCICE 2

1) Le temps d’execution de A est 10, de B est 4, de C est 7 et celui de D est 3


2) Le processus B
3) Le processus 1 
4) L’algorithme d’ordonnance est celui de round-robin (circulaire)
5)  
6) CCCACACACADACADCBADCBABABAA

EXERCICE 3

1. D’apres les annexes , 1seek est une fonction qui place la tête de lecture/écriture a un endroit
précis avec des directives , ici a la ligne 23 , grâce à la directive SEEK_CUR , la tête de lecture
ou écriture est avancé a -2 octets avec pour descripteur arg2.

1. Le read de la ligne 20 retourne 0 si et seulement si le fichier est vide ou dans un cas de EOF
ou si le count vaut 0 or ici le count vaut 1 , donc read lit ici 1 octet , donc elle lit obligatoirement un
octet et retournera pas 0.
1. Cette boucle marche jusqu’à que read arrive a 0 et la on return soit false soit true , pour que
cette boucle continue , il suffit ‘avoir beaucoup plus de caractères dans arg1 et donc plus de lecture
de octets et donc une boucle qui dure plus longtemps.

Une contrainte d'intégrité est une clause permettant de contraindre la modification de tables,
faite par l'intermédiaire de requêtes d'utilisateurs, afin que les données saisies dans la base soient
conformes aux données attendues. Ces contraintes doivent être exprimées dès la création de la table
grâce aux mots clés suivants :

 CONSTRAINT
 DEFAULT
 NOT NULL
 UNIQUE
 CHECK

Ainsi, un patient doit obligatoirement avoir un nom, prénom, un mail et numéro de téléphone (pour
recevoir une notification dans le cas ou il une modification dans la prise de rendez-vous. De même il
doit avoir un numéro de sécurité sociale.

Le médecin de même que le patient doit avoir un nom, prénom, mail, numéro de téléphone, mais en
plus il doit avoir une adresse et un identifiant qui sont NOT NULL.

Les identifiants sont UNIQUE pour chaque entité.

Un rendez-vous ne peut-être pris par le patient sans qu’il n’y ait une plage horaire de disponible.
C’est-à-dire qu’un patient peut prendre un rendez-vous le nombre de fois qu’il veut du moment que
le médecin a une plage de disponible. Cependant, un deuxième rendez-vous ne peut-être pris si le
premier n’a pas été confirmé au préalable. Les rendez-vous se prennent pendant les horaires très
précis entre 8h et 20h. UN rendez-vous ne se fait qu’après avoir sélectionné un jour, et une heure
bien précise.

La consultation se fait uniquement en ligne et pour en avoir une un patient doit avoir soit son compte
déjà crée (il a déjà utilisé la plateforme) soit il doit le créer.

Seuls les patients ayant déjà été consultés par un tel médecin peuvent noter ledit médecin. La
notation (l’avis) se fait qu’une seule fois après la consultation.

Vous aimerez peut-être aussi