Discussion :

[LeXo]

Bonjour
Pour emettre et écouter en meme temps sur le serveur

j'ai trouvé 3 choix

les threads
Duplication de process :les fork unix
le multiplexage d'E/S asynchrone

sur quel criteres, je choisis l'une ou l'autre ?

d'avance merci
je regarde le site de Beej'

[koala01]

Salut,

je suis désolé de faire une "réponse de normand", mais... tout dépend entièrement de ce que tu souhaites mettre en place.

J'ai presque la conviction que la préférence d'une des solutions par rapport aux autres deviendra manifeste en cours d'analyse et de conception.

Il n'est d'ailleurs pas impossible que tu choisisse une méthode pour une partie de l'application et une autre pour une autre partie, simplement, parce qu'elle te semblera être la meilleure pour le cas que tu veux gérer

[Feriaman]

Je suis moi-même désolé de ne pas t'être d'une grande aide, dans la mesure où je ne sais pas à quoi tu fais référence lorsque tu parles de "multiplexage d'entrées sorties asynchrones".

Concernant le choix entre Fork et thread, ça beaucoup de comment tes threads/fork vont devoir communiquer entre eux.

Les threads appartiennent au même programme, et notament partagent une certaine zone mémoire. Les fork vivent chacun leur vie de leur coté, (ce qui ne les empèche pas de communiquer).

Dans le cas d'un serveur de dessin coopératif, où plusieurs clients se connectent au même serveur pour dessiner en même temps sur le même tableau, j'imagine que tu utiliseras plutot des thread.

Dans le cas d'un serveur de génération de courbes, ou plusieurs clients se connectent au même serveur pour lui filer des listes de points et recevoir en échange des courbes de données, j'imagine que tu utiliseras plutot des forks.

Bonne chance.


P.S : Jusqu'à présent, tous les serveurs que j'ai codé utilisaient des threads.

[LeXo]

bha merci
ces réponses qui n'en sont pas

m'éclairent quand meme un peu

merci

[koala01]

En fait, il est meme fort vraissemblable que tu préféreras pour la partie "serveur", un peu à l'instar de ce que fait Apache, par exemple (désolé, l'exemple m'est venu à l'esprit bien après mon premier post), lancer carrément un processus séparé pour chaque requete, de manière à ce que le "processus parent" puisse toujours rester à l'écoute du port par défaut.
[EDIT](Ce qui ne l'empeche d'ailleurs pas forcément de lancer plusieurs threads pour gérer une seule requete... je ne suis pas allé assez loin dans son fonctionnement pour être précis sur le sujet )[/EDIT]

D'un autre coté, il n'est pas inenvisageable que tu envisage l'utilisation de threads dans une certaine mesure, et, pourquoi pas, le lancement d'un nouveau processus dans certains cas (comme l'ouverture d'une deuxième fenetre du navigateur)

Enfin, selon les cas toujours, il faudra voir ce qui est le plus efficace au niveau de la transmission des données: multiplexage ou connexion (et transmission) synchrone/asynchrone du client au serveur... Mais cà, cela dépendra de la charge que peut supporter la partie serveur et du temps que tu considère comme admissible entre l'envoi d'une requete et l'obtention du résultat

Finalement, tu vois que ma réponse de normand était un bon résumé du problème, non

[LeXo]

en fait, hier soir j'étais parti sur l'idée d'utiliser des threads pour gèrer la communication.

alors je vais regarder ce qui se fait

mon contexte : systeme embarqué avec un noyau linux

[LeXo]

depuis hier soir, je suis sur ce problème

j'ai un serveur
une classe gestionnaire de Client qui manipule un tableau(vector) de client type Client

mais dans mon accept je ne vois pas quel objet je vais lui passer

Code :

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

1
2
3
4
5
6
7
8
 
if((csock=accept(sock, (struct sockaddr *)&csockInf,&csinLen ))== -1){
    perror("Error :: accept failure : ");
    break;
}else{
...
gClient.addClient(csock,csockInf);
...

[LeXo]

depuis hier soir, je suis sur ce problème

j'ai un serveur
une classe gestionnaire de Client qui manipule un tableau(vector) de client type Client

mais dans mon accept je ne vois pas quel objet je vais lui passer

Code :

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

1
2
3
4
5
6
7
8
 
if((csock=accept(sock, (struct sockaddr *)&csockInf,&csinLen ))== -1){
    perror("Error :: accept failure : ");
    break;
}else{
...
gClient.addClient(csock,csockInf);
...

//Creation Thread
pthread_t unThread;
if((_idThread = pthread_create(&unThread,NULL,threadClient,??))== -1){
perror("Error :: pthread_create failed");
break;
}
...

void * threadClient(void * p){

}

[hegros]

si tu n'as pas de paramètre à passer tu mets NULL.

De façon minimale tu devrais passer en paramètre la socket retournée par accept car ton thread est un thread client par lequel tu vas chercher à dialoguer avec le client à travers cette socket.

[LeXo]

Bon alors,

resultat comme je ne voyais pas tres bien quoi envoyé

j'ai envoyé une struct mais ça passe pas tres bien

Code :

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

1
2
3
4
5
6
	struct client_struct{
		Serveur* serv;
		int sock;
		struct sockaddr_in sockInf;
	};
	client_struct clientSock;

bon mais ça coince quand je vais chercher le pointeur de serveur dans la structure

d'avance merci pour les conseils

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
		std::cout<<"Server is ready..."<<std::endl;
		while(1){
			//Envoi
 
			//Connexion d'un Client
			if((csock=accept(sock, (struct sockaddr *)&csockInf,&csinLen ))== -1){
				perror("Error :: accept failure : ");
				break;
			}else{
 
				//Creation Thread
				clientSock.serv=this;
				clientSock.sock= csock;
				clientSock.sockInf=csockInf;
				pthread_t unThread;
				if((_idThread = pthread_create(&unThread,NULL,threadClient,&clientSock))== -1){
					perror("Error :: create thread failure ");
					break;
				}
				//Envoi message a tous les connectes qu'un nouveau client est connecte
				sendMsgToAll();	
			}
		}
	}
	//Ajouter un Client au serveur
	void Serveur :: addClientToServer(struct client_struct cs){
 
		gClient.addClient(cs.sock,cs.sockInf);
		std::cout<<"Got connection "<<gClient.getNbClient()<<" with : "<<std::endl;
		std::cout<<inet_ntoa(cs.sockInf.sin_addr)<<" : "<<ntohs(cs.sockInf.sin_port)<<std::endl;
 
		//Deconnection :: error
		if((recu=recv(csock,buf,MAX_LINE,0))== -1){
			perror("Error :: Client disconnected ");
		}else{
			std::cout<<"Reception message : "<<buf<<std::endl;
		}
	}
	//Envoie Msg a tous les clients du serveur
	void * threadClient(void * p){
		struct client_struct *cs = (struct client_struct*) p;
		//Serveur *s= cs->serv;
		//s->addClienToServer(cs);
}