Discussion :

[hidewak]

Bonjour,

Encore et toujours j'ai besoin de votre aide !

Je dois réaliser un petit programme représentant le dîner des philosophes (http://fr.wikipedia.org/wiki/D%C3%AEner_des_philosophes) mais impossible de passer outre un segfault venant de la fonction pthread_join(). J'ai pas mal cherché sur le net (mais l'anglais et moi c'est pas encore ça) sans réellement comprendre ce qui pouvait produire ce segfault. Peut-être une histoire de thread pas encore créés (mais après certains test je ne pense pas) ou encore de la valeur du deuxième argument de pthread_join() qui doit être déclaré pour ne pas lui passer NULL mais malgrès cela rien à faire...

Ma structure (liste doublement chainée circulaire ) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
typedef struct s_philo
{
  int rank;
  int nb_eat;
  t_etat etat;
  pthread_t th_philo;
  struct s_philo 	*next;
  struct s_philo	*prev;
  int baguette[2];
  int lock;
} t_philo;

Segment Fault spotted line 9 !
Petite précision : Je segfault lorsque je tente de join le dernier thread.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
int run(t_philo **list)
{
  t_philo *nav;
  void *end;
 
  nav = *list;
  while (nav)
  {
    if (pthread_join(nav->th_philo, &end) != 0)
      printf("Can't join !\n");
    nav = nav->next;
  }
  return (1);
}
 
int	main()
{
  t_philo *list;
  t_philo *nav;
  t_philo *philo;
 
  int     i;
 
  i = 0;
  list = NULL;
  while (i < 8)
  {
    philo = init_philo(i);
    add_in_list(&list, &philo);
    i++;
  }
// D'après mes tests ma liste est correctement remplie, mis à part
// pthread_t th_philo, eux c'est start_threads qui s'en charge  
  start_threads(&list);
  run(&list);  
  return (0);
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
int start_threads(t_philo **list)
{
	t_philo *nav;
 
	nav = *list;
	while (nav->next != *list)
	{
		if (pthread_create(&(nav->th_philo), NULL, &engine, &nav) != 0)
			printf("Cannot create thread n°%i!\n", nav->rank);
		nav = nav->next;
	}
	return (1);
}

Merci d'avance pour votre aide.

[Neckara]

Bonjour,

Généralement, on ne met pas de parenthèses pour les return.

Sinon, es-tu sûr que next est bien mis à NULL pour le dernier t_philo ?

Sinon, tu peux très bien faire : pthread_join(nav->th_philo, NULL) sans problèmes.

[hidewak]

Bonjour,

Tout d'abord merci pour votre réponse (si tôt un dimanche matin) !

pour les parenthèses sur le return norme d'epitech oblige ! (c'est comme ça sinon des points en moins )

Je viens de me rendre compte de la raison du segfault (qui ma fois est tout à fait logique, la fatigue...)
Lorsque j'arrive au dernier élément de ma liste je repars sur le premier (liste circulaire) mais le thread n'existe plus ! Du coup segfault, logique.

Ce que je n'arrive pas à comprendre c'est que mes threads philosophes doivent suivre le comportement qui est défini dans engine() (la fonction que je passe en paramètre lorsque je crée mes threads) et ce infiniment (donc techniquement dans une boucle infini) or si je fais cela j'arrive sur mon pthread_join(philosophe #0, ...) mais comme mon philosophe tourne dans une boucle infini le join ne pourra pas joindre le philosophe suivant et restera sur le premier à attendre (sans fin) qu'il ce finisse ... c'est un peu déroutant là ...
Je dois pourtant arriver à un moment ou à un autre à joindre tout mes threads/philosophes...

Si quelqu'un a réussi à comprendre ce que je viens d'expliquer (je ne suis pas sur d'avoir compris moi même ) et que quelque chose lui parait incohérent pourrait il me l'expliquer ?

Je vous remercie d'avance pour votre aide !

[Obsidian]

Hello,

pour les parenthèses sur le return norme d'epitech oblige ! (c'est comme ça sinon des points en moins )

Je connaissais déjà les « normes » de codage d'Epita et Epitech de réputation, mais qu'on vous oblige à aller coller des parenthèses là où devrait justement vous apprendre à ne pas en mettre, ça devient dérangeant. Certes, ça n'empêchera jamais votre programme de compiler mais vous allez vous faire conspuer exactement comme l'auront fait vos professeurs mais dans l'autre sens, lorsque vous allez arriver sur le marché. Ce sera encore plus difficile de se déshabituer.

Après il faudra expliquer qu'en principe, on n'en met pas à sizeof non plus (quand on mesure la taille d'un type, c'est au nom du type qu'elles s'appliquent, comme un cast). Là, ça risque de devenir compliqué. :-)

Ce que je n'arrive pas à comprendre c'est que mes threads philosophes doivent suivre le comportement qui est défini dans engine() (la fonction que je passe en paramètre lorsque je crée mes threads) et ce infiniment (donc techniquement dans une boucle infini) or si je fais cela j'arrive sur mon pthread_join(philosophe #0, ...) mais comme mon philosophe tourne dans une boucle infini le join ne pourra pas joindre le philosophe suivant et restera sur le premier à attendre (sans fin) qu'il ce finisse ... c'est un peu déroutant là ...
Je dois pourtant arriver à un moment ou à un autre à joindre tout mes threads/philosophes...

Probablement un deadlock puisque ce problème y est particulièrement sujet.
Peut-on voir la fonction engine() ?

Si quelqu'un a réussi à comprendre ce que je viens d'expliquer (je ne suis pas sur d'avoir compris moi même ) et que quelque chose lui parait incohérent pourrait il me l'expliquer ?

Qu'appelles-tu « joindre un philosophe » ? Bien que l'une des caractéristiques du problème initial soit qu'il ait exactement le même nombre de fourchettes que de philosophes, celles-ci en sont complètement indépendantes. Il s'agit d'un problème d'accès à des ressources partagées, avec la contrainte qu'un philosophe ne peut accaparer que les fourchettes qui sont à côté de lui.

Donc, comme dans de nombreux cas, la solution de ton problème n'est probablement pas technique mais dans la façon dont tu modélises ton programme au départ.

[hidewak]

Donc, comme dans de nombreux cas, la solution de ton problème n'est probablement pas technique mais dans la façon dont tu modélises ton programme au départ.

Exactement, le problème venait du fait que je n'avais pas à utiliser un pthread_join() dans mon cas étant donné que le engine() (comportement des philosophes) bouclé lui même infini, il m'aurait été utile dans le cas ou mes philosophes s’arrête à un moment.

Après il faudra expliquer qu'en principe, on n'en met pas à sizeof non plus (quand on mesure la taille d'un type, c'est au nom du type qu'elles s'appliquent, comme un cast). Là, ça risque de devenir compliqué. :-)

Je n'ai pas bien compris là ou tu voulais en venir ?