Discussion :

[Stillbogus]

Bonjour,

J'aurais besoin d'un petit coup de main sur la liste chain�e suivante, en fait je d�bute avec les pthreads, et je gal�re en particulier avec les fonctions pthread_cond_wait et pthread_cond_signal, je ne comprends pas bien ou les placer dans la fonction push pour r�duire la charge cpu. A votre bon coeur.

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
 
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
 
struct list {
    int i;
    struct list *next;
};
 
struct list *init(void) {
    struct list *p = malloc(sizeof(struct list));
    p->i = 0;
    p->next = NULL;
    return p;
}
 
static struct list *stack = NULL;
pthread_mutex_t zone = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t condition = PTHREAD_COND_INITIALIZER;
 
static void print(struct list *p) {
    printf("%d %p\n", p->i, p->next);
}
 
void *push(struct list *p) {
    int i = 0;
    pthread_mutex_init(&zone, NULL);
    pthread_mutex_lock(&zone);
	pthread_cond_init(&condition, NULL);
    while(i++ < 1000000) {
        stack = p;
        stack->i += 1;
        stack->next = init();
        print(stack);
/*   	pthread_cond_signal(&condition);  */      
/*  	pthread_cond_wait(&condition, &zone);  */
    } 
    pthread_mutex_unlock(&zone);
}
 
int main(void) {
    struct list *p = init();
    pthread_t td;
pthread_create(&td, NULL, (void *) push, (void *) p);
    pthread_join(td, NULL);
    return 0;
}

[M�dinoc]

Il me para�t tr�s bizarre, l'appel � pthread_mutex_init() dans la fonction push()...

Aussi, elle ne fait pas UN empilement, mais un million d'empilements bizarres (normalement, avec une pile simplement cha�n�e, on ins�re au d�but de la liste, pas � la fin).

En gros, en th�orie tu devrais avoir un truc comme ceci, avec le verrou gard� le moins de temps possible:

Code C :

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
struct list {
	int i;
	struct list *next;
};
struct syncStack {
	struct list *pTop;
	pthread_mutex_t myLock;
};
 
void push(struct syncStack *pStack, int newValue)
{
	struct list *newLink = init();
	newLink->i = newValue;
 
	pthread_mutex_lock(&pStack->myLock);
	newLink->i = pStack->pTop;
	pStack->pTop = newLink;
	pthread_mutex_unlock(&pStack->myLock);
}
int pop(struct syncStack *pStack)
{
	struct list *pDel = NULL;
	int ret;
 
	pthread_mutex_lock(&pStack->myLock);
	pDel = pStack->pTop;
	pStack->pTop = pDel->next;
	pthread_mutex_unlock(&pStack->myLock);
 
	ret = pDel->i;
	free(pDel);
	return ret;
}
 
void* pushMillion(void*pv)
{
	struct syncStack *pStack = pv;
	int i;
	for(int i=0 ; i<1000000 ; i++)
		push(pStack, i);
}

Ensuite, le reste est brod� autour (threads acc�dant � la pile, s�maphore sur nombre d'�lements de la pile, etc.)

[Stillbogus]

Re, merci votre aide, j'ai eu le temps de regarder un peu plus en d�tail votre code, mais votre impl�mentation ne prends pas en compte les deux fonctions suivantes: pthread_cond_signal(&condition) et pthread_cond_wait(&condition, &zone). J'ai compil� votre code et le miens et grosso modo les performances sont semblables, en utilisant les les pthreads_cond_* il est normalement possible de diminuer drastiquement la conso cpu, en synchronisant les threads...

[M�dinoc]

Sauf que pour l'instant, vous n'avez m�me pas post� ce que chaque thread est cens� faire...

[Stillbogus]

Sauf que pour l'instant, vous n'avez m�me pas post� ce que chaque thread est cens� faire...

Si si, la fonction push est suppos�e employer les fonctions, pthread_cond_signal(&condition) et pthread_cond_wait(&condition, &zone), jettez un oeil sur: http://franckh.developpez.com/tutori...pthreads/#LX-D et vous verrez la cons�quence en terme de conso cpu....

[M�dinoc]

En gros, si j'ai bien compris il faut rajouter une variable pour la taille de la pile, et probablement une condition qu'on attend quand la taille atteint z�ro, et qu'on signale quand on rempile quelque chose.