bonjour, j'ai une question sur les sémaphore, et je n'arrive pas à trouver la réponse sur le net....

quelles sont les différentes manières de partager un sémaphore non nommé ?

merci pour une réponse, ou des liens appropriés

et question additionnelle (ou complémentaire plutôt) : peut-on protéger une ressource partagée entre processus à l'aide de sémaphore non nommée ?

merci.

Qu'est ce qu'un sémaphore non nommé ? quelle api utilise-tu ? quels appels pour créer tes sémaphores ?

par sempahore non nomme, je pense il parle de semaphore qui ne sont pas dans le systeme de fichiers et cree par sem_init en posix.

Ils sont partages entre les processus au moment de l'appel a fork. Il faut donc avoir le controle sur un processus parent.

effectivement, je pensais que c'était une notion "générique" que sémaphore non nommé.
Mais godrik a vu juste.

Alors dans ce cas, le code suivant me permet-t-il de gérer le partage de ressources correctement (avec mes sémaphores). Parceque je n'en ai pas l'impression, mais si tu pouvais me dire la méthode à utiliser je pense que cela m'aiderait

1. define CHECK(sts,msg) if ((sts) == -1) {perror(msg); exit(-1); }

sem_t sem;

void main() {

int pid1,pid2;

char *string1 = "blabla";
char *string2 = "iopiop";

CHECK ((sem_init(&sem, 1, 1) == -1) , "Probleme avec sem_init");

void* affiche(void *p) {
//var
sem_wait(&sem);
//code blabla
sem_post(&sem);
}

pid1 = fork();
CHECK(pid1, "fork - probleme creation processus 1")
pid2 = fork();
CHECK(pid2, "fork - probleme creation processus 2")

if (pid1 == 0) {
affiche(string2);
exit(0);
}
if (pid2 == 0) {
affiche(string1);
exit(0);
}

printf("\n\n");
return ;
}

arsenicbottle, j'ai regarde rapidement ton probleme et j'ai le meme constat que toi. Les semaphores ont l'air de marcher bizarrement, il ya qqch que je n'ai pas comprsi dans leur fonctionement. Malheuresement, je n'ai pas des masses de temps pour fouiller en ce moment.

Pour bien voir le probleme, j'avais changer la fonction affiche() pour afficher un message en entre et sortie de semaphore et une pause de plusieurs secondes.

J'ai demande l'avis d'un amis prof de systeme, il m'a repondu ca:

Mon nouveau mantra préféré, piqué à Cyrille :
C ne fait rien, POSIX non plus

"sem_init(&sem, 1, 1) qui devrait les mettre dans un segment de memoire
partage."

Sem_init ne fait rien, c'est le programmeur qui doit choisir une adresse
pour sem_t qui est dans un segment de mémoire partagée (héritable au fork)

il va falloir faire des choses avant le fork du genre
int fd = shm_open("/un_nom_qui_va_bien", ...+ options)
void *debut_segment = mmap(0, taille, ..., fd, 0);

avec les options bonnes pour avoir la lecture et l'écriture partagée.

A bientôt,

follow up sur la question. J'avais ecrit:

selon le man :
int sem_init(sem_t *sem, int pshared, unsigned int value);

The pshared argument indicates whether this semaphore is to be shared between the threads of a
process, or between processes.

If pshared has the value 0, then the semaphore is shared between the threads of a process, and
should be located at some address that is visible to all threads (e.g., a global variable, or a
variable allocated dynamically on the heap).

If pshared is non-zero, then the semaphore is shared between processes, and should be located
in a region of shared memory (see shm_open(3), mmap(2), and shmget(2)). (Since a child created
by fork(2) inherits its parent’s memory mappings, it can also access the semaphore.) Any pro‐
cess that can access the shared memory region can operate on the semaphore using sem_post(3),
sem_wait(3), etc.

Du coup, je ne comprends pas a quoi sert le parametre pshared... Si tu
met le semaphore dans un segment de memoire partage et que tu ne met
pas pshared a 1, alors ca ne marchera pas non plus ?

Et il me repond:

Je ne vois pas non plus l'usage de cette option. En particulier je ne
m'avancerait pas sur le fait que cela ne marchera pas si tu prends un
segment partagé sans mettre l'option pshared a 1.

Néanmoins, il y a quand même une différence si les processus partagent ou
pas le même espace d'adressage lors des commutations de processus. Je ne
vois pas vraiment le problème. Il faudrait tester en "vrai" et/ou lire le
code de la libc/noyau pour répondre en détails.

Si tu as une réponse un jour, je veux bien la connaître.

Quand j'aurais du temps, je testerai ca.

merci bcp pour avoir pris le temps de chercher un peu en tout cas. J'avais laissé tombé depuis, mais je me repencherai dessus quand j'aurais un peu plus de temps devant moi

keep us posted.