[POSIX threads] Petite question -- relative aux pointeurs void*

**hurukan** · 11/04/2022, 08h11

Salutations !!

Pour m'amuser -- et aussi parce que j'avais besoin de lancer plusieurs threads "en même temps" (sujet d'une autre discussion... plus tard ^^) pour effectuer diverses tâches en parallèle -- j'ai commencé à écrire
quelque chose pour "synchroniser" l'exécution, ici d'un thread avec la fonction main().

A priori je pense avoir quelque chose de fonctionnel, il doit y avoir deux ou trois bugs latents et j'aurais probablement à revenir sur mon approche plusieurs fois, je fais un peu cela au "feeling".
A terme j'aimerais "trigger" un groupe de threads pour qu'ils attendent d'être lancés puis commencent leur exécution "en synchro".

Je pense avoir lu quelque part que c'était possible avec les POSIX threads, mais je n'ai pas approfondi, j'ai du temps et je trouve intéressant de programmer ce genre de trucs ^^

Mon fichier "header"

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
#ifndef SYNCEDTHREAD_H
#define SYNCEDTHREAD_H
 
// ****************************************************************************
// SECTION : fichiers d'inclusions
// ****************************************************************************
 
#include <pthread.h>
#include <semaphore.h>
 
// **************************************************************************** 
// Définitions des constantes symboliques
// **************************************************************************** 
 
// **************************************************************************** 
// Définition(s) des structures, types et énumérations
// **************************************************************************** 
 
typedef struct s_SyncedThread
{
	pthread_t	internalID;
	sem_t		*SEM_TriggerOn;
	sem_t		*SEM_Exiting;
 
	char		*pInternalName;
	bool		bRunning;
	bool		bExiting;
 
	void		(*pFunction)(void*);
 
}t_SyncedThread;
 
// **************************************************************************** 
// Définition(s) des variables statiques/externes
// **************************************************************************** 
 
extern pthread_mutex_t	MTX_Internal;
extern void							*Internal_params;
 
// **************************************************************************** 
// Définition(s) des fonctions
// **************************************************************************** 
 
 
#endif /* SYNCEDTHREAD_H */

Mon fichier source

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
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
// **************************************************************************** 
// Fichiers de définitions
// **************************************************************************** 

#include <stdio.h>
#include <stdlib.h>

#include <stdbool.h>      
#include <unistd.h>
#include <string.h>

#include <pthread.h>
#include <semaphore.h>

#include <sys/stat.h>
#include <fcntl.h>
#include <signal.h>


#include "syncedthread.h"

// **************************************************************************** 
// Déclaration des constantes symboliques
// **************************************************************************** 

// **************************************************************************** 
// Déclaration des variables globales, externes, ...
// **************************************************************************** 

pthread_mutex_t MTX_Internal=PTHREAD_MUTEX_INITIALIZER;
void						*Internal_params=NULL;

// ****************************************************************************
// SECTION : prototypes des fonctions en test pour CE code source
// ****************************************************************************

t_SyncedThread* InitSyncedThread(char*,void(*)(void*));
void						RemoveThread(t_SyncedThread*);
void						PrepareThread(t_SyncedThread*,void *params);
void						RunThread(t_SyncedThread*);
void						core(void*);				

void						mabellefonction(void*);

/*
 * FONCTION PRINCIPALE
 */
int main(int argc,char** argv)
{
	t_SyncedThread *monthread=InitSyncedThread("/monbeauthread",mabellefonction);
	if(monthread==NULL) 
	{
		perror("[thread creation fatal error] ");
		return(EXIT_FAILURE);
	}
		
	int value=10;
	PrepareThread(monthread,(void*)&value);			// Comment faire pour juste passer 10 comme paramètre ???? 
	int cptTimer=5;
	while(cptTimer>=0)
	{
		sleep(1);
		printf("%03d\t",cptTimer);
		fflush(stdout);
		cptTimer--;
	}
	printf("\n");
	RunThread(monthread);
	cptTimer=5;
	while(cptTimer>=0)
	{
		sleep(1);
		printf("%03d\t",cptTimer);
		fflush(stdout);
		cptTimer--;
	}
	printf("\n");
	RemoveThread(monthread);
	return(EXIT_SUCCESS);
}

// ****************************************************************************
// SECTION : implémentation des fonctions
// ****************************************************************************

t_SyncedThread* InitSyncedThread(char *pName,void (*pFunction)(void*))
{
	t_SyncedThread *tmp=calloc(1,sizeof(t_SyncedThread));
	
	if(pName==NULL) return NULL;
	if(pFunction==NULL) tmp->pFunction=NULL;
	
	int len=strlen(pName);
	tmp->pInternalName=calloc(len,sizeof(char));
	strcpy(tmp->pInternalName,pName);
	
	tmp->SEM_TriggerOn=sem_open(tmp->pInternalName,O_CREAT,S_IRWXU);
	if(tmp->SEM_TriggerOn==NULL) return NULL;
	
	sem_init(tmp->SEM_TriggerOn,1,0);
	
	tmp->SEM_Exiting=calloc(1,sizeof(sem_t));
	sem_init(tmp->SEM_Exiting,1,0);

	tmp->internalID=-1;
	tmp->bRunning=false;
	
	tmp->pFunction=pFunction;
	
	return tmp;
}

void RemoveThread(t_SyncedThread *thisthread)
{
	if(thisthread==NULL) return;
	sem_close(thisthread->SEM_TriggerOn);
	sem_unlink(thisthread->pInternalName);
	thisthread->bRunning=false;
	thisthread->internalID=-1;
	thisthread->pFunction=NULL;
	free(thisthread->pInternalName);
	free(thisthread->SEM_Exiting);
	thisthread->pInternalName=NULL;
}

void PrepareThread(t_SyncedThread *thisthread,void *params)
{
	Internal_params=params;
	pthread_create(&thisthread->internalID,NULL,(void*)core,(void*)thisthread);
}

void	RunThread(t_SyncedThread *thisThread)
{
	if(thisThread->SEM_TriggerOn==NULL) return;
	sem_post(thisThread->SEM_TriggerOn);
}

void	StopThread(t_SyncedThread *thisthread)
{
	if(thisthread->SEM_Exiting==NULL) return;
	sem_post(thisthread->SEM_Exiting);
}

void core(void *wrapped)
{
	t_SyncedThread *thisthread=(t_SyncedThread*)wrapped;
	
	if(thisthread->pFunction==NULL) return;
	sem_wait(thisthread->SEM_TriggerOn);
	thisthread->bRunning=true;
	pthread_mutex_lock(&MTX_Internal);
	thisthread->pFunction((void*)Internal_params);
	pthread_mutex_unlock(&MTX_Internal);
	thisthread->bExiting=true;
	sem_wait(thisthread->SEM_Exiting);
	thisthread->bExiting=false;
	thisthread->bRunning=false;
}

void mabellefonction(void *params)
{
	int *pMax=calloc(1,sizeof(int));
	memcpy(pMax,params,sizeof(int));
	while(*pMax>=0)
	{
		printf("coucou !!\n");
		(*pMax)--;
	}
}

Mon programme fonctionne, avec un seul thread... tout va bien.
Cependant... je voudrais pouvoir passer des valeurs comme paramètres sans devoir passer par une variable... (si je mets (void*)10 l'adresse de Internal_params sera 0xa du coup et je serais dans le vecteur d'interruptions ou une saloperie du genre :{ )
...je me demande si cela est possible avec les pointeurs génériques de (type void*)

J'ai une connaissance assez bonne des pointeurs mais là je suis un peu dubitatif... je ne pense pas que ce soit possible d'utiliser un littéral casté en (void*)... c'est obligatoirement une adresse qui se trouve à droite de la parenthèse fermante...

Nom : firsttry000.png
Affichages : 138
Taille : 8,8 Ko

Nom : firsttry000.png
Affichages : 138
Taille : 8,8 Ko

**WhiteCrow** · 11/04/2022, 10h07

Envoyé par hurukan

[...]
A priori je pense avoir quelque chose de fonctionnel, il doit y avoir deux ou trois bugs latents et j'aurais probablement à revenir sur mon approche plusieurs fois, je fais un peu cela au "feeling".
A terme j'aimerais "trigger" un groupe de threads pour qu'ils attendent d'être lancés puis commencent leur exécution "en synchro".

Je pense avoir lu quelque part que c'était possible avec les POSIX threads, mais je n'ai pas approfondi, j'ai du temps et je trouve intéressant de programmer ce genre de trucs ^^
[...]

Bonjour,
oui ce sont les thread pools avec des threads synchronisés.

Envoyé par hurukan

[...][
Cependant... je voudrais pouvoir passer des valeurs comme paramètres sans devoir passer par une variable... (si je mets (void*)10 l'adresse de Internal_params sera 0xa du coup et je serais dans le vecteur d'interruptions ou une saloperie du genre :{ )
...je me demande si cela est possible avec les pointeurs génériques de (type void*)

J'ai une connaissance assez bonne des pointeurs mais là je suis un peu dubitatif... je ne pense pas que ce soit possible d'utiliser un littéral casté en (void*)... c'est obligatoirement une adresse qui se trouve à droite de la parenthèse fermante...

Alors non ce n'est pas «obligatoirement une adresse qui se trouve à droite de la parenthèse fermante». Un pointeur est un scalaire. Ce n'est que lorsque tu le déréférences que sa valeur est interprétée comme une adresse, et que pour éviter un crash il faut que cette adresse soit valide (en gros).
Maintenant c'est pas hyperportable de prendre un int et de le caster vers un void* et inversement. Ce qui l'est plus est d'utiliser le type intptr_t que la norme définit comme un entier que l'on peut caster en pointeur et inversement sans qu'il y a iat de soucis.
Tu peux également passer une instance de structure littérale comme :

Code :

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

1
2
3
4
5
6
7
 
struct thread_param {
    int value;
};
 
....
    PrepareThread(monthread, &(struct thread_param) {.value=10,} );

**Bousk** · 11/04/2022, 14h46

Si tu veux débloquer plusieurs threads, tu devrais plutôt te tourner vers les condition variables.
https://pubs.opengroup.org/onlinepub...nd_signal.html

**hurukan** · 11/04/2022, 15h03

ah ! oui voilà !!

Les "condition variable" j'avais lu mais jamais réellement approfondi.
Je m'y mets...

**hurukan** · 16/04/2022, 01h59

Modifications du code source... toujours pas eu le temps de faire des tests avec des "grappes de threads".

Le principe de ces "expériences" consiste -- à terme -- à pouvoir lancer des processus qui devraient effectuer des opérations du style "reconnaissance de forme".
Ces "processus" sont des exécutables acceptant des paramètres dont je ne possède pas le code source.
Je pense en plus qu'ils ont été écrits en assembleur... faudrait que je vérifie.

Dans mes pérégrinations, lectures de toutes sortes, je suis tombé sur un appel de fonction prctl() qui permet de nommer un processus. Cependant elle n'a pas l'air POSIX donc j'en conclus que elle pourrait ne pas être "portable".
J'utiliserais plutôt pthread_setname_np() mais le "np" de fin de fonction m'indiquerais qu'elle ne soit pas portable non plus :{

En soi ce n'est pas bien grave de ne pas pouvoir nommer les threads mais je trouverais cela élégant d'attribuer un nom de groupe à une série de threads et d'assigner des condition variables non plus via les identifiants mais bien le nom d'un groupe donné.

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
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
#ifndef SYNCEDTHREAD_H
#define SYNCEDTHREAD_H
 
// ****************************************************************************
// SECTION : fichiers d'inclusions
// ****************************************************************************
 
#include <pthread.h>
#include <semaphore.h>
#include <time.h>
 
// **************************************************************************** 
// Définitions des constantes symboliques
// **************************************************************************** 
 
// **************************************************************************** 
// Définition(s) des structures, types et énumérations
// **************************************************************************** 
 
typedef struct s_SyncedThread
{
	pthread_t	internalID;
	sem_t		*SEM_TriggerOn;
	sem_t		*SEM_Exiting;
 
	char		*pInternalName;
	bool		bRunning;
	bool		bExiting;
 
	void		(*pFunction)(void*);
 
}t_SyncedThread;
 
typedef struct s_STDatas
{
	int					data_int;
 
	short				data_short;
	float				data_float;
 
	long				data_long;
	long long		data_llong;
 
	double			data_double;
	long double	data_ldouble;
 
	unsigned short	data_ushort;
	unsigned long		data_ulong;
	unsigned int		data_uint;
}t_STDatas;
 
 
 
// **************************************************************************** 
// Définition(s) des variables statiques/externes
// **************************************************************************** 
 
extern pthread_mutex_t	MTX_Internal;
extern void							*Internal_params;
 
extern	struct timespec delais;
 
// **************************************************************************** 
// Définition(s) des fonctions
// **************************************************************************** 
 
 
#endif /* SYNCEDTHREAD_H */

syncedthread.h

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
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
 
// **************************************************************************** 
// Fichiers de définitions
// **************************************************************************** 
 
#include <stdio.h>
#include <stdlib.h>
 
#include <stdbool.h>      
#include <unistd.h>
#include <string.h>
 
#include <pthread.h>
#include <semaphore.h>
 
#include <sys/stat.h>
#include <fcntl.h>
#include <signal.h>
 
#include "syncedthread.h"
 
// **************************************************************************** 
// Déclaration des constantes symboliques
// **************************************************************************** 
 
// **************************************************************************** 
// Déclaration des variables globales, externes, ...
// **************************************************************************** 
 
pthread_mutex_t MTX_Internal=PTHREAD_MUTEX_INITIALIZER;
void						*Internal_params=NULL;
struct timespec	delais={0L,125000000L};
 
// ****************************************************************************
// SECTION : prototypes des fonctions en test pour CE code source
// ****************************************************************************
 
t_SyncedThread* InitSyncedThread(char*,void(*)(void*));
void						RemoveThread(t_SyncedThread*);
void						PrepareThread(t_SyncedThread*,void *params);
void						RunThread(t_SyncedThread*);
void						TerminateThread(t_SyncedThread*);
void						core(void*);				
 
void						mabellefonction(void*);
 
/*
 * FONCTION PRINCIPALE
 */
int main(int argc,char** argv)
{
	t_SyncedThread *monthread=InitSyncedThread("/sem_syncthread",mabellefonction);
	if(monthread==NULL) 
	{
		perror("[thread creation fatal error] ");
		return(EXIT_FAILURE);
	}
 
	t_STDatas datas;
	datas.data_int=10;
 
	PrepareThread(monthread,(void*)&datas);			
	int cptTimer=5;
	while(cptTimer>=0)
	{
		sleep(1);
		printf("%03d\t",cptTimer);
		fflush(stdout);
		cptTimer--;
 
	}
	printf("\n");
 
	printf("1. thread running %s\n",monthread->bRunning?"true":"false");
	RunThread(monthread);
	nanosleep(&delais,NULL);
	printf("2. thread running %s\n",monthread->bRunning?"true":"false");
	fflush(stdout);
	cptTimer=5;
	while(cptTimer>=0)
	{
		sleep(1);
		printf("%03d\t",cptTimer);
		fflush(stdout);
		cptTimer--;
 
	}
	printf("\n");
	printf("3. thread exiting %s\n",monthread->bExiting?"true":"false");
	printf("4. thread running %s\n",monthread->bRunning?"true":"false");
	TerminateThread(monthread);
	nanosleep(&delais,NULL);
	printf("5. thread exiting %s\n",monthread->bExiting?"true":"false");
	printf("6. thread running %s\n",monthread->bRunning?"true":"false");
 
	RemoveThread(monthread);
	return(EXIT_SUCCESS);
}
 
// ****************************************************************************
// SECTION : implémentation des fonctions
// ****************************************************************************
 
t_SyncedThread* InitSyncedThread(char *pName,void (*pFunction)(void*))
{
	t_SyncedThread *tmp=calloc(1,sizeof(t_SyncedThread));
 
	if(pName==NULL) return NULL;
 
	int len=strlen(pName);
	tmp->pInternalName=calloc(len,sizeof(char));
	strcpy(tmp->pInternalName,pName);
 
	tmp->SEM_TriggerOn=sem_open(tmp->pInternalName,O_CREAT,S_IRWXU);
	if(tmp->SEM_TriggerOn==NULL) return NULL;
 
	sem_init(tmp->SEM_TriggerOn,1,0);
 
	tmp->SEM_Exiting=calloc(1,sizeof(sem_t));
	sem_init(tmp->SEM_Exiting,1,0);
 
	tmp->internalID=-1;
	tmp->bRunning=false;
 
	tmp->pFunction=pFunction;
 
	return tmp;
}
 
void RemoveThread(t_SyncedThread *thisthread)
{
	if(thisthread==NULL) return;
	sem_close(thisthread->SEM_TriggerOn);
	sem_close(thisthread->SEM_Exiting);
	sem_unlink(thisthread->pInternalName);
	thisthread->bRunning=false;
	thisthread->internalID=-1;
	thisthread->pFunction=NULL;
	free(thisthread->pInternalName);
	free(thisthread->SEM_Exiting);
	thisthread->pInternalName=NULL;
}
 
void PrepareThread(t_SyncedThread *thisthread,void *params)
{
	Internal_params=params;
	pthread_create(&thisthread->internalID,NULL,(void*)core,(void*)thisthread);
}
 
void	RunThread(t_SyncedThread *thisThread)
{
	if(thisThread->SEM_TriggerOn==NULL) return;
	sem_post(thisThread->SEM_TriggerOn);
}
 
void core(void *wrapped)
{
	pthread_mutex_lock(&MTX_Internal);
 
	t_SyncedThread *thisthread=(t_SyncedThread*)wrapped;
 
	if(thisthread->pFunction==NULL) 
        {
            pthread_mutex_unlock(&MTX_Internal);
            return;
        }
	sem_wait(thisthread->SEM_TriggerOn);
	thisthread->bRunning=true;
 
	thisthread->pFunction((void*)Internal_params);
 
	thisthread->bExiting=true;
	sem_wait(thisthread->SEM_Exiting);
	thisthread->bExiting=false;
	thisthread->bRunning=false;
 
	pthread_mutex_unlock(&MTX_Internal);
}
 
void TerminateThread(t_SyncedThread *thisthread)
{
	sem_post(thisthread->SEM_Exiting);
}
 
void mabellefonction(void *params)
{
	t_STDatas *tmp=(t_STDatas*)params;
 
	while(tmp->data_int>=0)
	{
		printf("coucou !!\n");
		tmp->data_int--;
	}
}

syncedthread.c

[POSIX threads] Petite question -- relative aux pointeurs void*

POSIX C

Discussions similaires

Partager

Partager