Discussion :

[roseau]

ps: post à partir du compte d'une collège, en attendant que le mien (Vikarius) soit activé.
-------------------------------------------------------------------------

Bonjour,

Dans le cadre d'un projet en langage c, je peine dans mon choix d'architecture depuis quelques jours déjà...

L'idée:
- un serveur accorde à ses clients la possibilité de communiquer ensemble
- (côté serveur) un tableau de données unique matérialise la communication entre les "fork"
- (côté serveur) le "père" envoi à chaque "fork" un pointeur vers le tableau cité ci-dessus
- (côté serveur) la première entrée du tableau "data[0]" autorise l'écriture pour un "fork" à la fois
(ex: lorsqu'un "fork" désire écrire dans le tableau, il doit attendre que cette entrée
lui donne le feu vert et le cas échéant, un feu rouge y est signalé aux autres "fork" le temps de l'écriture)

La démarche:
- un tableau est déclaré en en-tête du "main"
- le père envoi a ses fils un pointeur sur ce tableau via un "tube"
- les fils récupèrent ce pointeur et procèdent à des traitements sur ce tableau (désormais théoriquement partagé)

La situation:
- les "fork" héritent bien du tableau initial mais les traitements demeurent en leur sein

La problématique:
- obtenir un partage de ce tableau entre les "fork"
- trouver une âme charitable qui voudrait bien éclairer ma lanterne ^_^

L'outil:
- distribution linux Ubuntu (émulation sous xp)
- compilateur gcc

La source (la dernière en date):

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
38
39
40
41
42
43
44
45
46
47
48
49
50
51
...
 
char data[1000][2048];
 
int main() {
 
	...
 
	if(pipe(tube)==-1) {
		perror("failed");
	}
 
	...
 
	strcpy(data[0],"test");
 
	...
 
	switch (pid=fork()) {
		case -1: perror("failed");
		case 0: child();
		default: parent();
	}
 
}
 
void child() { // fils
	close(tube[1]);
	if (read(tube[0],&data,2048)<0) {
		write(newsock,"failed",256);
	}
	*pdata = &data;
	close(tube[0]);
	write(newsock,pdata,256); // renvoie "test1" au client
	read(newsock,data[0],256); // réceptionne une saisie du client (exemple "test2")
	write(newsock,data[0],256); // renvoie les données au client (exemple "test2")
 
 
	// après avoir lancé un client qui a renseigné ses données,
        //  "test1" s'affiche chez les nouveaux clients au lieu de par exemple "test2"...
}
 
void parent() { // père
	strcpy(data[0],"test1");
	close(tube[0]);
	write(tube[1];&data,2048);
	close(tube[1]);
 
}
 
...

Si je ne suis pas assez explicite, n'hésitez pas à me le faire remarquer

Merci pour votre attention,

VikariuS

[seiron]

tu devrais regarder les docs sur les IPCs (Communication Inter-Processus) et les shm (memoire partage) pour faire ton projet.

[roseau]

ps: post à partir du compte d'une collège, en attendant que le mien soit activé.
--------------------------------------------------------------------------------



Merci, mais dois-je en conclure que ma démarche ne fonctionnera jamais?
Car si elle peut fonctionner, cela m'intéresse plus que d'avoir recours à IPC & shm...

VikariuS

[Neuromancien2]

Bonjour,

Il faut utiliser un sémaphore et un segment de mémoire partagée. C'est assez complexe. Je te poste un exemple de code dès que possible.

[souviron34]

disons qu'avec ce choix d'architecture tu te bloques a fonctionner sur une seule machine.....

Ce que je choisrais, c'est de definir un message pour chaque fork/chaque mort, et que ce message soit dispatche par le pere, et que chaque fils mettent a jour sa liste en fonction des messages...

A chaque nouveau fork, le pere envoie au nouvel enfant la liste des enfants avant lui. A chaque nouvelle mort, le pere dispatch aux enfants restant la mort.

L'avantage est que les peres/fils ne sont pas lies a une seule machine : un fils peut etre sur une autre machine, et etre lui-meme le pere d'une nouvelle serie...

[VikariuS]

En fait, ce choix est volontairement destiné à fonctionner sur une seule machine. Donc, même si elle est très intéressante, l'architecture que tu me proposes complexifie ma problématique inutilement

Okai Neuromancien2, un exemple de squelette ne serait effectivement pas de refus étant donné cette approche assez délicate en soit

En attendant, je me documente sur le sujet

[VikariuS]

Concernant l'architecture initiale, celle-ci est bel et bien irréalisable compte tenu du principe de fonctionnement de linux (les données en mémoire d'un processus ne peuvent être partagées via des pointeurs).

Sinon, je planche toujours sur le sujet...