La « livraison » de votre travail en fin de TP noté se fera par remontée sous Moodle (rubrique « TP noté de 3 heures ») du fichier d'extension tgz constitué de la manière suivante :

Pour l'instant, run_app crée un tube nommé, puis appelle la fonction run_application qui positionne LD_PRELOAD et lance l'application dans le processus courant.

Modifiez la fonction main du programme run_app.c pour créer un processus fils. Une fois créé, le processus fils appelle run_application(argc-1, &argv[1]). Le processus père appelle la fonction process_requests, puis attend que le processus fils termine avant de lui-même se terminer.

Dans run_app.c, implémentez la fonction process_requests. Cette fonction doit:

• Ouvrir le tube nommé PIPE_NAME (défini dans liblock.h) en lecture seule.
• Dans une boucle infinie, lire un struct lock_event depuis le tube
• Si le champ function de l'événement lu est supérieur ou égal à NB_FUNCTIONS, fermer le tube nommé et sortir de la fonction.
• Sinon, appeler la fonction process_event.

Modifiez maintenant liblock.c pour que les événements générés dans record_event soient écrits dans le tube nommé. Pour cela:

• Lors du chargement de la bibliothèque, ouvrez le fichier PIPE_NAME en écriture.
• A la fin de la fonction record_event, écrivez le struct lock_event généré dans le tube
• Dans le destructeur de la bibliothèque, appelez record_event(function_entry, NB_FUNCTIONS, NULL), puis fermez le tube.

Dans le fichier run_app.c, la fonction get_thread recherche dans le tableau threads l'entrée dont le champs tid correspond à celui de event.

Modifiez la fonction get_thread pour que, lorsqu'aucune entrée n'est trouvée, la fonction agrandisse le tableau threads, initialise le nouveau struct thread_info, et retourne son adresse.

Commencez par créer un répertoire exercice3 dans le répertoire racine du contrôle (celui dans lequel se trouve déjà exercice2). Dans ce répertoire, écrivez un programme stack.c qui :

• Prend deux paramètres de type entier que nous appellerons n et t. n indique le nombre de données que doit produire un producteur. t donne le nombre de threads de type producteurs et le nombre de threads de type consommateur (au total, il faut donc créer 2*t threads). On vous rappelle que la fonction atoi permet de convertir une chaîne de caractères en entier.
• Lance t threads exécutant la fonction void* prod(void* arg) et tthreads exécutant la fonction void* cons(void* arg).
• Attend que les t producteurs et les t consommateurs termine.

À cette étape, les fonctions prod et cons doivent être laissées vides.

On va représenter la pile des messages échangés entre les producteurs et les consommateurs avec une liste chaînée. Pour cela, il faut définir une structure struct node contenant un pointeur vers le nœud suivant appelé next et une valeur entière appelée data (il s'agit de la donnée produite). Il faut aussi déclarer une variable de type struct node appelée stack et initialisée à NULL.

Modifiez votre programme de façon à ce que l'argument arg reçu par la fonction void* prod(void* arg) soit le nombre d'éléments à produire (paramètre n du programme). Un producteur doit déposer en tête de stack n nouveaux nœuds. La valeur data de chaque nœud peut être quelconque.

Pensez que plusieurs threads peuvent essayer de déposer en concurrence des éléments dans la pile. Pour vérifier que votre code est correct, vous le lancerez avec comme paramètre n=10000 et t=5.

De façon similaire, un consommateur doit retirer n éléments, et cet argument doit être transmis à la fonction cons. Un consommateur retire un élément en commençant par la tête de la liste. Il n'y a donc pas besoin de parcourir la liste chaînée, il suffit de retirer le premier élément.

Attention, lorsque vous retirez un élément, la pile peut être vide. Dans ce cas, il ne faut pas décrementer le nombre d'éléments restant à dépiler.

À la fin de la fonction main, après avoir attendu la terminaison des threads, vérifiez que stack vaut NULL. Si votre programme est correct, ça devrait être le cas.

Lorsque la pile est vide, un consommateur tourne en boucle en attendant qu'une donnée soit déposée dans la pile. Ce fonctionnement est inefficace puisqu'un consommateur utilise le CPU pour rien. Pour cette raison, modifiez votre programme de façon à ce qu'un consommateur s'endorme sur une variable condition lorsque la pile est vide.

Comme le code demandé à cette question est plus complexe, il vous est conseillé de copier le fichier stack.c en stack-cond.c et de réaliser cet exercice dans le fichier stack-cond.c.

Ajoutez le champ int prio à la structure struct proc, et ajoutez l'appel système int set_priority(int pid, int priority). Cet appel système vérifie que le processus PID existe (c'est à dire que son état n'est pas UNUSED). Ensuite, l'appel système change la priorité du processus dont le PID est pid et affiche le message "Process <pid> now runs with priority <priority>".

Le but à cette question est d'élire les processus possédant la même priorité en FIFO, en commençant d'abord par élire les processus ayant la plus haute priorité. Pendant un cycle, tous les processus doivent être élu une fois. Pour cela, vous devez modifier la fonction elect(struct proc* old) de façon à mettre en œuvre cet algorithme. En détails :

• Si old est différent de 0, il faut élire le processus prêt qui suit old dans la table des processus et ayant la même priorité. Si un tel processus n'existe pas (old est le dernier du tableau), il faut choisir un processus qui a la priorité suivante (la priorité la plus grande strictement inférieur à celle de old). Si plusieurs processus ont cette priorité, il faut choisir celui que se trouve en premier dans le tableau.
• Si old est égal à 0 ou, dans le cas où old est différent de 0, aucun processus n'a été trouvé avec la procédure décrite précédemment (aucun processus de plus petite priorité que old n'a été trouvé), il faut choisir le processus ayant la plus haute priorité. Si deux processus ont la priorité maximale, il faut choisir celui qui se trouve en premier dans le tableau.