3  Rémanence de pthread_join

La spécification POSIX de la fonction pthread_join() d’attente de terminaison d’un thread précise que la valeur ne peut être récupérée qu’une unique fois par un unique thread. Nous proposons ici de rendre cette valeur rémanente : elle pourra être accédée de multiples fois, par autant de threads que désiré.

Le principe est de mémoriser la valeur de type void * retournée par le thread au sein d’une structure et de faire des accès à cette structure pour accéder à cette valeur. De plus, un accès à cette structure alors que le thread n’a pas encore terminé devra être bloquant en attendant la terminaison.

Un type sera défini pour une telle structure :

struct join_s ; 

Une telle structure sera mémorisée pour chacun des threads dont on désire garder la valeur de retour rémanente. Deux fonctions d’allocation et de recherche de telles structures sont fournies (vous n’avez pas à les écrire). La fonction

struct join_s *new_join(pthread_t tid);

retourne un pointeur sur une nouvelle structure ; elle sera associée à la terminaison du thread tid.

La fonction

struct join_s *get_join_by_tid(pthread_t tid);

retourne pour sa part une référence sur la structure struct join_s associée au thread tid.

Notre objectif est de fournir trois fonctions équivalentes aux fonctions POSIX pthread_create(), pthread_exit(), et pthread_join(). L’utilisation de nos fonctions de remplacement permet des accès rémanents à la valeur retournée par un thread.

• La fonction

  int jn_create(
          pthread_t *tid,
          const pthread_attr_t *attr,
          void *(*threadfunction)(void*),
          void *arg);
  

  sera appelée pour la création d’un thread. En plus de réaliser la création du thread par pthread_create(), elle se devra d’initialiser une structure struct join_s pour le thread.
• La fonction

  void jn_exit(void *value_ptr);
  

  sera utilisée pour terminer un thread. Avant d’appeler pthread_exit(), cette fonction devra
  • mettre à jour la structure struct join_s qui lui est associée ;
  • débloquer d’éventuels threads en attente de sa terminaison.
• La fonction

  int jn_join(
          pthread_t tid,
          void **value_ptr);
  

  sera utilisée en remplacement de pthread_join() par un thread voulant accéder à la valeur retournée par le thread tid. Cette fonction devra
  • si le thread a terminé, retourner la valeur mémorisée dans la structure struct join_s ;
  • sinon, si le thread n’a pas terminé, se mettre en attente de cette terminaison.
• Lors de la terminaison par jn_exit(), il est donc nécessaire de réveiller les éventuels threads en attente de cette terminaison.

Une structure struct join_s se compose d’un indicateur de terminaison du thread, de la valeur de type void * retournée par le thread, d’un mécanisme permettant aux threads en attente de la terminaison du thread de se bloquer. Ces différentes valeurs peuvent être potentiellement accédées simultanément par plusieurs threads. On ajoutera donc un mécanisme assurant l’exclusion mutuel des accès.