CSC 4103 – Programmation système

Dans le fichier exo1.c, ajoutez une structure nommée pokemon_type. Cette structure donne le nombre de pokemons d'un type donné, et contient un pointeur vers le nœud suivant de la liste. En détail, la structure pokemon_type contient :

• un pointeur vers l'élément suivant nommé next,
• un tableau de MAXLEN caractères nommée type donnant un type (MAXLEN est déjà défini dans pokemon.h),
• et un entier nommé n donnant le nombre de pokemon du type stocké par le nœud.

Ajoutez aussi une variable globale nommée pokemon_types pointant vers le premier nœud de la liste chaînée des types de pokemons. Initialement, ce pointeur doit être initialisé à NULL puisque, initialement, il n'y a aucun type de pokemon enregistré.

Écrivez une fonction void add(const char* type, int n) qui crée un nœud (type, n) et l'insère en tête de la liste chaînée. Cette fonction ne doit créer le nœud que si le paramètre type n'est pas une chaîne vide (c'est-à-dire une chaîne avec zéro caractères).

À cette question, on ne vous demande pas de vérifier si il existe déjà un nœud du type donné en paramètre dans la liste.

Copiez-collez le code suivant au début de votre fonction main pour tester votre code :

Écrivez une fonction void print(FILE* f) écrivant dans le flux f le nombre de pokemon de chaque type. Le formatage de cet affichage deviendra important vers la fin de l'exercice : il faut afficher, sur une ligne, le type suivi d'un espace, suivi du nombre de pokemons. Ajoutez aussi un appel à print(stdout) pour afficher l'état de la liste sur le terminal à la fin de la fonction main. Si votre code est correct, vois devriez avoir cet affichage :

On souhaite maintenant éviter d'avoir plusieurs fois le même type dans la liste. La première fois qu'un type est ajouté, il faut donc créer un nœud, mais les fois suivantes, il faut réutiliser le nœud préalablement créé. Sur notre exemple, à la fin, on souhaite donc qu'il n'y ait qu'un unique nœud Féérique qui compte 7 pokemons de ce type. Modifiez votre code en conséquence.

Ajoutez une fonction void cleanup() permettant de libérer tous les nœuds de la liste chaînée et de réinitialiser pokemon_types à NULL. Ajoutez un appel à cleanup() à la fin de la fonction main.

La liste des pokemons se trouve dans le fichier pokedex.dat (défini par la macro POKEDEX dans pokemon.h). Ce fichier contient un tableau de structures pokemon (voir aussi fichier pokemon.h).

Au début de la fonction main, commencez par calculer le nombre de pokemons se trouvant dans le fichier pokedex.dat avant de fermer le fichier. Stockez ce nombre dans une variable locale total. Si vous trouvez que total vaut 719, c'est que vous avez réussi la question.

Ajoutez une fonction void process(int first, int n) à exo2.c. Cette fonction ouvre le fichier pokedex.dat et parcourt n entrées à partir de first. Pour chaque entrée, la fonction doit mettre à jour la structure pokemon_types (voir exercice 1) en fonction des types du pokemon lu. Il faut savoir qu'un pokemon a un ou deux types (champs type[0] et type[1] de la structure pokemon), et qu'un même pokemon peut donc compter deux fois.

Dans la fonction main, utilisez process(0, total) puis affichez le nombre total de pokemons de chaque type. Si vous trouvez 18 types différents de pokemons, et si, parmi ceux-ci, vous trouvez 117 pokemons de type Water, vous avez réussi la question, félicitations.

On souhaite que le nombre de processus fils utilisé pour la parallélisation soit un paramètre du programme. Au début de la fonction main, avant le code que vous avez écrit pour les exercices précédents, stockez, dans une variable nb_children de type entier, le paramètre donné au programme. En l'absence de paramètre, votre programme doit afficher une erreur et quitter.

Après avoir calculé le nombre d'entrées de pokedex.dat mais avant l'appel à process, créez nb_children processus fils à l'aide d'une boucle. Chaque processus fils doit, pour le moment, s'endormir 1 seconde (fonction sleep) avant d'afficher [PID] child quitting et de quitter.

Modifiez votre programme de façon à ce que le père exécute la fonction process en parallèle des ses enfants, mais ne quitte que après la terminaison des nb_children enfants. Pour vous assurez que le comportement de votre programme est correct, ajoutez un affichage de [PID] quitting juste avant que la fonction main retourne. Si vous voyez systématiquement les affichages de [PID] children quitting avant l'affichage de [PID] quitting, c'est que votre synchronisation est correcte.

Pour chaque fils, stockez dans une variable first l'indice à partir duquel le fils doit traiter le fichier pokedex.dat, et dans une variable n le nombre d'entrées que le fils doit traiter. Affichez aussi ces bornes avec le PID du fils.

À cette étape, le code de votre programme devrait être à peu près celui-ci :

• Pour un fils :
  • calcul first et n (ajouté à cette question),
  • affiche [PID] process n entries from first (ajouté à cette question),
  • dort 1 seconde (question 3.b)
  • affiche [PID] child quitting (question 3.b),
  • quitte (question 3.b).
• Pour le père :
  • extrait nb_children à partir de l'argument donné au programme (question 3.a),
  • calcul total (question 2.a)
  • crée les nb_children processus enfants (question 3.b),
  • calcul et affiche du nombre de pokemons de chaque type (question 2.b),
  • attend la terminaison des enfants (question 3.c),
  • affiche [PID] quitting (question 2.b),
  • quitte.

Commencez par supprimer le process(0, total) du père. Ensuite, dans un fils, juste après avoir affiché [PID] process n entries from first, appelez process de façon adéquate pour traiter les entrées assignées au fils. Ensuite, il va falloir communiquer le résultat du traitement au père. Pour cela, nous utilisons un fichier result. Pour communiquer son résultat, un fils doit simplement utiliser la fonction print que vous avez mise en œuvre à question 1.c de façon à ajouter ses résultats au fichier result.

Dans le père, utilisez le fichier result afin de calculer et afficher le nombre total de pokemons de chaque type.

Dans cette question, on vous propose d'optimiser légèrement la synchronisation entre le père et ses fils. Techniquement, on vous demande d'utiliser un sémaphore pour que le père puisse commencer à traiter le fichier result dès que les fils ont écrit le résultat de leur traitement dans le fichier result. Commencez par ajouter sleep 1 juste avant la terminaison du fils. Ensuite, faîtes en sorte que le père puisse lire un fichier result correct sans avoir besoin d'attendre cette seconde artificiellement ajoutée.