Salut à tous!
 
 
je suis actuellement sur le fameux problèmes des philosophes. je programme sous linux, et j'ai un problème de variable.  
Mon problème se situe au nioveau du tableau d'entier state, de taille N  (N est fixé bien sûr!)
Je créé 5 processus, mais apparament, quand l'un d'eux modifie le tableau, les autres n'arrivent pas à voir le smodifications apportées, alors qu'il s'agit d'un tableau (pointeur) et déclaré en variables globales!
Si vous pouviez me filer un ptit coup de main... ce serait sympa.
Merci!

un processus ne partage pas ses variables globales avec les autres processus.
Ce sont les threads qui en sont capables (dans un meme processus bien sur).
Tu peux utiliser aussi la memoire partagée (shmget, shmat, ...), cela permet de partager des données entre plusieurs processus.

personnellement, je te conseille d'utilisé les thread, ils sont bien plus simple a programmé...  
 
et je confirme ce que ++fab a dit... deux processus distinct n'ont pas la même zone mémoire qui leur est alloué... donc pas la mm zone CS/DS/SS

oula, ok, mais j'ai pas du tout appris à utiliser ces deux fonctions....  elle se trouvent où? tu peux m'en dire un peu plus sur la façon dont je peux arranger mon code avec ces fonctions?

c'est pas de chance j'ai pas non plus appris à utiliser des threads... ça marche comment?

la mémoire partagée n'est pas qq de facile a faire... pour cel aje te conseille de faire des threads si ton programme 'nest pas trop gros...
 
sinon tu fais un man des deux fonctions et tu veras comment les utilisés...

le prog n'est pas gros, je vais utiliser les threads, enfin je vais essayer....
Merci

 
pour les threads, c'est pas compliqué, je vais essayé de te donné un pti exemple assez simple pour que tu comprennes...
 

euh en fait la mémoire pârtagée c'est avec les mutex !
j'ai appris à les utiliser, MDR

Merci pour l'exmple, mais je dois faire sans les threads, je dois forcément utiliser des fork

Bon, c'est clair, il faut que je dois créer un segment de mémoire partagée, et y mettre mon tableau de 5 entiers, pour que mes processus puissent y accéder. Vous pouvez me file un coup de main pour faire ça?

 
1) un premier processus crée un segment de mémoire partagée avec "shmget(clef, taille, option)". Cette fonction te renvoie un identifiant "id".
2) il te faut attacher ce segment avec "shmat(id)". Cette fonction te renvoie un "void*" pointant vers ta mémoire partagée que tu récupères dans un pointeur "pt" de type que tu veux
3) maintenant tu as à ta disposition un pointeur "pt" pointant vers une zone de "x" octets. Tu peux donc écrire dans cette zone où tu veux (à toi de ne pas aller là où il faut pas).

Et tout processus réalisant les opérations "1" et "2" pourra lui-aussi écrire au même endroit ou lire ce qu'il y a été mis (sauf que les autres processus qui veulent accéder à la zone n'auront pas besoin de spécifier la taille dans "shmget()" ).
 
Une fois tes opérations terminées, tu dois détacher ton pointeur "pt" de ta zone => shmdet(pt). Si t'as plus besoin de ta zone tu peux la supprimer => shmctl(id, IPC_RMID)
 
 
Maintenant je ne comprends pas trop pourquoi tes processus ont besoin de s'échanger des valeurs. Moi, quand j'ai écrit l'algo des philosophes, je n'ai utilisé que les sémaphores
1) je génère un tableau de P sémaphores, P étant le nombre de philosophes
2) je génère autant de processus que de philosophes. Chaque processus connait la taille du plat qu'il doit avaler et la taille de sa fourchette (définies au début du programme)
3) quand un philosophe veut manger, il prend en une seule opération
- son sémaphore
- le sémaphore de son voisin (de droite ou de gauche ça importe peu mais si tu décides la droite, tous prennent celui de droite)
Si l'opération est permise (2 sémaphores libres), le processus mange (sa quantité décroit) et garde son sémaphore qq secondes pour que tu puisses voir ton algo tourner. Si l'opération n'est pas permise ben tant pis, le philosophe attend.  
4) une fois qu'il a fini sa cuillère, le processus rend les deux sémaphores en une seule opération. Dès que son plat est vide, il se termine.
 
Avec cet algo, aucun processus n'a besoin d'envoyer des infos à un autre. Chaque processus mange quand il peut et tous coopèrent.

quand tu dis que les autres processus n'auront pas besoin de préciser la taille, je mets quoi dans le champ taille de la fonction shmget?

 
T'as le choix entre remettre exactement la même taille ou mettre la valeur neutre "0".