mutexes et bizzarerie

serveur multi thread

2 septembre 2007 à 23:22:24

Bonjour,

Je concois un serveur multi thread pour mon mmo mais il m'arrive que j'ai des problemes avec mes mutexes.
Est ce que les mutexes mette en pause l'execution tant que le mutex n'est pas debloqquer ou passe t-il a la phase suivante (apres le unlock).

De plus la chose etrange dans mon code est que quand j'enleve cout << "lu" << endl;
ou autre chose dans le cout, le serveur ne marche pas !

Voila le code de test :

Il me semble que l'execution se poursuit.

#include "collision.h"
#include "serveur.h"
#include "ILogger.h"
#include <iostream>
#include <windows.h>
#include <list>
#include <functional>
#include "include/pthread.h"
typedef struct PL{
char PX[12],PY[12],PZ[12],RY[12],action[5];
int id;
};
using namespace std;
pthread_mutex_t job_queue_mutex = PTHREAD_MUTEX_INITIALIZER;
int id = 0;
PL mystruct[5000];
void player::game(MySQL Msql)
{
int myID = id;
char buffer[1024], old[1024];
pthread_mutex_lock (&job_queue_mutex);
id++;
pthread_mutex_unlock (&job_queue_mutex);
while(1)
{
pthread_mutex_lock (&job_queue_mutex);
strcpy(buffer,TCP_RECV(sock));
strcpy(mystruct[myID].action, buffer);
strcpy(old, buffer);
if(TCP_SEND(sock,".") == 0){break;}
strcpy(buffer,TCP_RECV(sock));
strcpy(mystruct[myID].PX, buffer);
if(strcmp(buffer, old) == 0){
pthread_mutex_unlock (&job_queue_mutex);
break;
}
if(TCP_SEND(sock,".") == 0){break;}
strcpy(buffer,TCP_RECV(sock));
strcpy(mystruct[myID].PY, buffer);
if(TCP_SEND(sock,".") == 0){break;}
strcpy(buffer,TCP_RECV(sock));
strcpy(mystruct[myID].PZ, buffer);
if(TCP_SEND(sock,".") == 0){break;}
strcpy(buffer,TCP_RECV(sock));
strcpy(mystruct[myID].RY, buffer);
pthread_mutex_unlock (&job_queue_mutex);
int ier = 0;
pthread_mutex_lock (&job_queue_mutex);
while(ier < id)
{
if(ier != myID)
{
TCP_SEND(sock,"LISTP");
TCP_RECV(sock);
TCP_SEND(sock,mystruct[ier].PX);
TCP_RECV(sock);
TCP_SEND(sock,mystruct[ier].PY);
TCP_RECV(sock);
TCP_SEND(sock,mystruct[ier].PZ);
TCP_RECV(sock);
TCP_SEND(sock,mystruct[ier].RY);
TCP_RECV(sock);
TCP_SEND(sock,mystruct[ier].action);
TCP_RECV(sock);
}
ier++;
//si j'enleve ca le serveur de reagit pas aux intercation.
cout << "lu" << endl;
}
pthread_mutex_unlock (&job_queue_mutex);
TCP_SEND(sock,"LISTD");
}
pthread_mutex_lock (&job_queue_mutex);
Msql.execute("UPDATE account SET X='%s', Y='%s', Z='%s', Rot='%s',action='%s' WHERE nickname='%s'",PX,PY,PZ,RY,action,nick);
Msql.execute("UPDATE account SET online='0' WHERE nickname='%s'", nick);
id--;
pthread_mutex_unlock (&job_queue_mutex);
return;
}

minirop

2 septembre 2007 à 23:41:08

Citation : tenmaCA

Est ce que les mutexes mette en pause l'execution tant que le mutex n'est pas debloqquer ou passe t-il a la phase suivante (apres le unlock).

si je dis pas de bêtise, il reste bloqué tant que le mutex demandé n'est pas libéré (ce qui est logique).

tenmaCA

2 septembre 2007 à 23:57:30

merci mais je ne comprend toujours pas pourquoi si je retire le cout le serveur ne fonctionne pas...
J'ai trouver une solution qui est un peu bourin mais qui marche.
Vu que je n'arrivais pas avec mes condition j'ai mit un Sleep(2) a la fin de ma boucle principale grace a cela j'ai pue enlever le cout.

Je crois que le cout faisais perdre du temps a l'execution et que l'autre thread arrive a prendre le mutex avec le temps de wait. Car en mettant Sleep(1); ca marche pas et tout les valeurs aux dessus de 1 me permette de fonctionne corectement. De plus ce systeme me donne la possibilite de synchroniser le tout.

atoboldom

3 septembre 2007 à 2:41:29

Qui te dis que sur une machine moins puissante il te faudrat pas plus de 2ms ?

tenmaCA

3 septembre 2007 à 3:50:39

Il y aura pas de machine moin puissante. Seulement plus puissant. C'est une toute petite machine qui tourne un vieu AMD 1.4ghz,128mo de ram.

atoboldom

3 septembre 2007 à 16:22:30

Mouais bon je trouve pas sa très propre, mais tu fait comme tu veut :-°

tenmaCA

3 septembre 2007 à 16:42:33

JE pense de toute facon que je mette plus de Sleep ou non ca ne changera rien car la progression des autres thread sera en avance donc forcement qu'ils passeront en premier.

MatteX

4 septembre 2007 à 16:08:23

Met un Sleep dans tout tes threads petit méchant :p... Non mais quand même laisse la chance à d'autres d'utiliser le processeur un peu!

Bon je ne sais pas si c'est possible avec ta classe (moi j'ai codé mon propre Mutex) tu peux facilement faire une vérification avec de vérouillé du genre :

1. Vérifie si le mutex est vérouillé
Si non :
2. vérouille le mutex
3. Traitement
4. dévérouille le mutex
...

Cette technique est valable lorsque tu vérouille la donnée partagée et non pas le thread.

Recherche Google : pthread_mutex_lock
"pthread_mutex_lock verrouille le mutex. Si le mutex est déverrouillé, il devient verrouillé et est possédé par le thread appelant; et pthread_mutex_lock rend la main immédiatement. Si le mutex est déjà verrouillé par un autre thread, pthread_mutex_lock suspend le thread appellant jusqu'à ce que le mutex soit déverrouillé."

tenmaCA

4 septembre 2007 à 18:04:04

Non mais je met un sleep pour justement laisser les autres obtenir la priorite.
Sinon mes mutex lock et unlock on pas l'air de bien marcher.
Le Sleep ordonne l'ordre de passage...