Discussion :

[jiganos]

Bonjour à tous,

après une certain nombre de recherche je me trouve bien bloqué
j'essaye de mettre des thread dans mon programme de façon à accélérer certaine partie de mon programme tout en essayant d'utiliser au mieux les cœurs de ma machine.

Mon problème:
J'ai une structure StructAgent composer de deux éléments un identifiant et un pointeur sur la structure suivante

à partir de la j'ai une liste de structure pas compliqué.

mon problème est dans la suppression du premier élément de la liste.

j'appelle ma fonction avec

Code :

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

pthread_create (&supAgent_thread, NULL, sup_agent2, StructAgent);

jusque la tous marche 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
19
20
21
22
23
24
25
26
27
28
29
30
31
32
void *sup_agent2(void *Agent)
{
	unAgent *tmp2 = (unAgent*) Agent;
	unAgent *tmp = (unAgent*) (Agent);
 
	//nextlist
	tmp2 = (tmp2)->suivant;
	while(tmp2 != NULL)
	{
		if((tmp2)->energie <= 0) 
		{
			(*tmp).suivant = (*tmp2).suivant;
			free(tmp2);
			tmp2 = (tmp)->suivant;
		}
		else
		{
			tmp = (tmp)->suivant;
			tmp2 = (tmp2)->suivant;
		}
	}
 
	// firstlist
	unAgent *tmp3 = (unAgent*) (Agent);
	unAgent *tmp4 = (unAgent*) (&Agent);
	if( (tmp3)->energie <= 0)
	{
		tmp4 = (tmp3)->suivant;
		free(tmp3);
	}
	return NULL;
}

mon problème vient des dernière ligne du code soit

Code :

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

1
2
3
4
5
6
7
8
	// firstlist
	unAgent *tmp3 = (unAgent*) (Agent);
	unAgent *tmp4 = (unAgent*) (&Agent);
	if( (tmp3)->energie <= 0)
	{
		tmp4 = (tmp3)->suivant;
		free(tmp3);
	}

quand j'insère la structure suivante ((tmp3)->suivant) à la racine (mon pointeur de base Agent) j'ai une belle erreur de segmentation.

le problème doit être simple mais je tourne un peu en rond depuis un bon moment, je dois me tromper à un endroit.

J'ai fais le tour ses faqs mais en utilisant thread je n'ai plus de pointeur de pointeur.
La méthode ci-dessous plante aussi et la je me retrouve coincé

Code :

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

1
2
3
4
5
6
7
	// firstlist
	unAgent *tmp3 = (unAgent*) (Agent);
	if( (tmp3)->energie <= 0)
	{
		Agent = (tmp3)->suivant;
		free(tmp3);
	}

Merci de vos réponses

[Invité]

Bonsoir,

cette ligne pose problème : unAgent *tmp4 = (unAgent*) (&Agent);
Il semble que &Agent pointe sur une adresse qui ne t'a pas été alouée, d'où le segmentation fault.

[jiganos]

merci feydaykyn
j'ai constaté exactement le problème que tu cite car je fais une duplication de la source et je ne cible pas l adresse source

ma deuxième solution ou je modifie directement Agent ne passe pas non plus même erreur constaté

pour l'instant j'ai résolu le problème en passant par une structure globale et je modifie l'origine directement
mais je ne veux pas passer par une globale et je voudrai pouvoir directement modifier ma structure à partir des adresses

Habituellement je fais des pointeurs de pointeur qui me permettent de cibler directement l'adresse source mais utilisant thread je ne peu pas passer un pointeur de pointeur mais un simple pointeur.

je continu à regarder mais je ne vois toujours pas la solution.

[diogene]

Ce n'est pas parce qu'on peut transtyper void * en un pointeur quelconque que cela est justifié : on ne doit transtyper un void * qu'en une adresse du type correspondant exactement à l'objet pointé.

Code :

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

1
2
	unAgent *tmp3 = (unAgent*) (Agent);
	unAgent *tmp4 = (unAgent*) (&Agent);

Ces deux lignes sont incompatibles : Si Agent est effectivement un pointeur sur un unAgent, alors &Agent ne peut pas l'être (et réciproquement).

D'autre part, Agent est une variable locale et &Agent donne l'adresse de cette variable locale.

tmp4 est aussi une variable locale et

Code :

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

		tmp4 = (tmp3)->suivant;

ne fait que modifier cette variable locale.

Habituellement je fais des pointeurs de pointeur qui me permettent de cibler directement l'adresse source mais utilisant thread je ne peu pas passer un pointeur de pointeur mais un simple pointeur.

Mais un pointeur de pointeur n'est qu'un cas particulier d'un pointeur et il n'y a rien de spécifique à ce cas. Rien n'empêche de passer un pointeur de pointeur. Du genre :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
unAgent *StructAgent;
.....
pthread_create (&supAgent_thread, NULL, sup_agent2, &StructAgent);
 
void *sup_agent2(void *Agent)
{
	unAgent ** adlist = Agent;
	unAgent *tmp  = *adlist ;
	unAgent *tmp2 = *adlist 
....
        *adlist = ...

[jiganos]

merci pour la réponse mais tous ceci ne m'aide pas car quand je parle de pointeur de pointeur je parle de cibler l'adresse source et non dupliquer les pointeurs.

mon problème est l'adresse initiale que je n'arrive pas à cibler directement.

Code :

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

1
2
unAgent *tmp3 = (unAgent*) (Agent);
unAgent *tmp4 = (unAgent*) (&Agent);

ceci n'était qu'un simple exemple de ce que je tenté de faire pour cibler l'adresse source.

En ce qui concerne mon problème je ne voix pas comment le résoudre.

Code :

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

pthread_create (&supAgent_thread, NULL, sup_agent2, &StructAgent);

ceci ne fonctionne pas car dans le code source de de la bibliothèque pthread la quatrième partie est un pointeur simple et non un double pointeur, donc ceci générera une erreur d'incompatibilité de type.

[diogene]

ceci ne fonctionne pas car dans le code source de de la bibliothèque pthread la quatrième partie est un pointeur simple et non un double pointeur, donc ceci générera une erreur d'incompatibilité de type.

Un pointeur sur un pointeur n'a rien de particulier par rapport aux autres genres de pointeur.
Le prototype de pthread_create() est

Code :

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

int pthread_create(pthread_t * thread, pthread_attr_t * attr, void * (*start_routine)(void *), void * arg);

Le quatrième paramètre est donc un void * compatible avec un &StructAgent, même si &StructAgent est un unAgent **