Discussion :

[Tinkh]

Bonjour à tous,

Un petit post pour un souci sur lequel je sèche complètement. Je dois simuler une application qui tourne à la base sur deux processeurs distincts. Cette simulation doit être faite en utilisant les threads : thread A pour le processeur 1, thread B pour le processeur 2. Il faut savoir que ces deux threads vont faire quasiment la même chose, l'un étant la sauvegarde de l'autre en cas de problème.
Mon souci vient du fait qu'une des variables globales du threadA a le même nom qu'une du thread B, mais pas le même type (donc pas la même taille) et vu que la zone mémoire des threads est commune, j'ai des soucis de compilation. J'aurais voulu savoir comment contourner ce problème de la façon la plus propre possible, et en évitant de renommer ces deux variables sur l'ensemble de mon code.

En gros, dans mon thread A, j'ai un "typeA toto;" et dans mon thread B, j'ai un "typeB toto;" et bien entendu je ne veux pas que cette variable soit partagée entre ces deux threads.

[royal380]

C'est bien pour ça qu'on préconise de ne jamais utiliser de variable globale

Pourquoi tu ne définis pas directement tes variables dans tes threads?

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
void * threadA (void * toto) //thread envoie
{
 
    ......
 
    return 0;
}
 
void * threadB (void * toto) //thread envoie
{
 
    ......
 
    return 0;
}

Ainsi toto et toto n'ont rien à voir car définit en local.

[LittleWhite]

Bonjour,

En théorie, un programme a deux threads ne consiste que en 1 programme. Donc 1 code source.
Après, pour une raison d'organisation, on va faire en sorte d'avoir le code du threadA dans un fichier A.c et le code du threadB dans le fichier B.c
Du coup, on en revient au simple problème de C, qui est: peut être avoir deux variables ayant le même nom.
La réponse est Oui, mais c'est assez dangereux.
Notamment, si on définit la variable a globale au fichier A.c et la variable globale au fichier B.c ça peut encore passé, mais y a beaucoup de cas ou le recouvrement posera des problèmes.

Après le partage est encore un autre problème, mais ce n'est pas le votre, pour le moment

(et je me suis fait grillé par royal380)

[royal380]

(et je me suis fait grillé par royal380)

ton éxplication est quand même plus teCHnique

EDIT:
Si je comprend bien :

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
void * envoie(void * p_data) //thread envoie
{
    paramClient * toto = (paramClient*) p_data; 
    send(toto->socks,(char *)toto->PosClient,sizeof(toto->PosClient),0);
 
    return 0;
}
 
void * recevoir(void * p_data)  //thread de réception
{
    paramClient * toto = (paramClient*) p_data; 
 
 
    recv(toto->socks,(char *)toto->PosServBalle,sizeof(toto->PosServBalle),0);
 
 
    return 0;
}

envoie et recevoir sont un seul programme ?
Ou alors je comprend pas bien

Je croyais que c'était 2 programmes bien distinct aux quels le processeur alloué du temps chacun leur tours.

[LittleWhite]

EDIT:
Si je comprend bien :

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
void * envoie(void * p_data) //thread envoie
{
    paramClient * toto = (paramClient*) p_data; 
    send(toto->socks,(char *)toto->PosClient,sizeof(toto->PosClient),0);
 
    return 0;
}
 
void * recevoir(void * p_data)  //thread de réception
{
    paramClient * toto = (paramClient*) p_data; 
 
 
    recv(toto->socks,(char *)toto->PosServBalle,sizeof(toto->PosServBalle),0);
 
 
    return 0;
}

envoie et recevoir sont un seul programme ?
Ou alors je comprend pas bien

Je croyais que c'était 2 programmes bien distinct aux quels le processeur alloué du temps chacun leur tours.

Hum ...

Tout d'abord, votre exemple de code fonctionne, car la visibilité de la variable 'paramClient' est limité au bloc (l'espace entre les accolades). Donc dans ce cas là, il n'y a aucun conflit. (Cela compile)
Maintenant, pour revenir sur ce que j'ai dit. En fait, un programme qui contient des threads, et un programme unique (un seul executable, donc un seul code source). Tout programme démarre un thread (le thread principale, comme on aime bien l'appeler). Mais il peut toujours demarrer un second thread, qui partagera la mémoire, si je me rappelle bien, et qui partagera aussi le temps d'execution que la système laisse au programme). (Je confonds peut être avec les fork ... qui sont un peu différent sur le partage).

[Tinkh]

En fait, je ne maitrise pas le contenu du code. Ce dernier est un système avionique complexe qui tourne de base sur deux processeurs distincts et que je dois simuler pour le faire tourner sur une machine mono-processeur, en utilisant donc les threads. Je subis donc un peu les idées pas forcément adapter que je dois mettre en place.
Entre temps, j'ai vu qu'il existait la possibilité d'allouer une zone mémoire propre à chaque thread (la TSD ou TLS, voir http://fr.wikipedia.org/wiki/Thread_Local_Storage). Je tente d'utiliser ce mécanisme mais c'est pas très clair pour le moment. En effet, j'ai mes deux variables "typeA toto" et "typeB toto" que je dois déclarer explicitement pour pouvoir les utiliser en "extern" et je ne sais pas encore si l'utilisation de la TSD le permet (avec les fonction pthread_key_create, pthread_set/getspecific ...).
Une petite question en passant : j'ai du mal à trouver de la doc sur l'utilisation du préfixe "__thread", est ce que quelqu'un sait quand on peut l'utiliser ?
Merci d'avance

[Médinoc]

__thread (et le TLS en général), c'est pour une variable du même type partout qui est indépendante pour chaque thread.
C'est ce qui est utilisé pour des fonctions comme strtok() et strerror() à la place des variables globales.

Mais pour des variables de type différent et signification différente qui squattent le même nom, ça n'ira pas. C'est précisément pourquoi on recommande de limiter la portée des variables globales à un seul fichier source (mot-clé static).

Si le code que tu ne maitrises pas est déjà compilé, il n'y a pas vraiment de solution. Sinon, tu peux séparer tes fichiers source un peu mieux et mettre un #define toto totoA / #define toto totoB dans les en-têtes ou en ligne de commande (généralement /Dtoto=totoA, mais ça doit dépendre du compilo).