Discussion :

[micaz]

Bonjour,

j'ai un programme principal qui crée deux fils, puis execute calcul_1 et calcul_2. Je veux faire en sorte que les 3 processus aient fini leur calcul_1 avant que l'un d'eux ne commence le calcul_2.
En gros je veux faire une barrière de synchronisation avec les signaux SIGUSR.

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
 
#include <signal.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
 
int main(int argc, char **argv){
	int i = 0;
	pid_t pid_fils[2];
	struct sigaction act;
 
	while ((i<2) && (pid_fils[i] = fork()) != 0))
		i++;
 
	calcul_1();
	calcul_2();
 
	printf("fin processus %d \n", i);
 
	return EXIT_SUCCESS;
}

[souviron34]

et la question est ?

[micaz]

La question est comment mettre en place une barrière de synchro à l'aide de SIGUSR1/SIGUSR2.

[lemmel]

utiliser SIGUSR1/SIGUSR2 pour ca me paraît compliqué, surtout si en fait ton exemple n'est qu'un code pour vérifier ce qui est possible et qu'en conséquence tu augmente le nombre de processus, etc.
Voici une liste d'IPC : http://en.wikipedia.org/wiki/Interprocess_communication.

Si tes processus ne sont pas sensés migrer, travaille sur de la mémoire partagée (ce qui te permettra également de faire circuler les résultats des calculs entre process) ; auquel cas voici des liens :
http://www.opengroup.org/onlinepubs/.../shm_open.html

(pour le C++ et portable : http://www.boost.org/doc/libs/1_36_0...erprocess.html)

[lemmel]

au cas où la réponse n'aurait pas été comprise, il faut ensuite utiliser des mutex (ou semaphores) pour synchroniser ces processus.

[souviron34]

utiliser SIGUSR1/SIGUSR2 pour ca me paraît compliqué,

au cas où la réponse n'aurait pas été comprise, il faut ensuite utiliser des mutex (ou semaphores) pour synchroniser ces processus.

Autant je suis d'accord avec la mémoire partagée sur une seule machine autnt une solution "simple" me semble effectivement plus basée sur les signaux que les mutex + le reste de ce que tu dis

La question est comment mettre en place une barrière de synchro à l'aide de SIGUSR1/SIGUSR2.

Simplement en mettant une callback sur la réception de SIGUSR1 et faire appeler calcul2 après la mise d'un drapeau dans cette callback..

[lemmel]

une solution "simple" me semble effectivement plus basée sur les signaux

Le hic c'est que son problème n'a pas été présenté de manière détaillé, et je suppose que cette histoire de signaux ne sera que le début de ses problèmes ; dans le cas des signaux il veut que tous les processus attendent que tous soient arrivés au même point (juste avant le calcul_2). À coup de signaux, une solution serait :

- les fils une fois arrivé au calcul_2 (mais avant de le faire) envoit un SIGUSR à leur père
- le père comptabilise les signaux reçus
- une fois le nombre de signaux reçus étant égales au nombre de fils, il envoit un SIGUSR à tous ses fils

très sincèrement le mutex/semaphore est fait pour ce type de synchro, et surtout permet beaucoup plus de souplesse (si les processus doivent être synchro sur le calcul_2, c'est très probablement qu'il va y avoir une mise en commun des résultats précédents[1]) ; peut-être est-ce du à l'habitude, mais les mutex/sémaphore me paraissent être plus simple dans ce cas et plus adaptés.


[1] alors il risque d'y avoir une bidouille, dans le genre enregistrement des résultats dans un fichier, et relecture par les fils, etc