Discussion :

[darkwall_37]

Bonjour,

Je voulais tester la librairie pthread alors j'ai écris un petit bout de code en m'inspirant des différents tutoriaux disponibles sur le net.
Il s'agit simplement d'afficher pendant une boucle for la vitesse d'itération par seconde du processeur.

Avec le code ci-dessous, je constate dans le gestionnaire des tâches que le RAM utilisée par le programme augmente au fur et à mesure du temps et se libère à la fin de la boucle à environ 60Mo de RAM pour une itération stable de 35000 itérations/s.

Si dans la fonction task ci dessous, je dé commente la ligne

Code :

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

//if ( s[3]==1 )

qui permet de n'afficher le résultat que tout les 10% de progression alors cette fois ci la RAM va arriver à saturation très rapidement de 0 à 8Go et la vitesse d'itération elle va décroître dans le temps au fur et à mesure que la RAM elle augmente.

Visiblement, il y a quelque chose dans le concept du thread que je n'ai pas compris.
Est-ce que quelqu'un est en mesure de m'expliquer ce que je ne fais pas correctement parce que là je sèche total ?

Merci d'avance pour votre aide.

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
static void *task (void *p_data)
{
   if (p_data != NULL)
   {
        double *s = p_data;
 
        //if ( s[3]==1 )
            printf("\n iteration/s = %.2f --- progress %.0f %%", s[4], 100*s[1]);
 
        pthread_exit(NULL);
        free(s);
   }
   return NULL;
}
 
int main(int argc, char *argv[], char* env[])
{
    system("title Library");
    system("mode con cols=150 lines=75");
 
    if (logger_on()==TRUE)
    {
        pthread_t t;
 
        double *p = allocate_1D_d(5);
        p[0] = GetTickCount();
        p[1]=0;
        p[2]=0.1;
 
        int i = 0;
        for ( i = 0 ; i<INT_MAX/1000 ; i++ )
        {
            p[1]=1000.*i/INT_MAX;
            p[4] = 1000.*i/(GetTickCount()-p[0]);
 
            if ( p[1] >= p[2] )
                p[2] += 0.1, p[3]=1;
 
            else p[3]=0;
            pthread_create (&t, NULL, task, (double*)p);
 
        }
        free(p);
        pthread_join (t, NULL);
}

[BufferBob]

salut,

je crois surtout que ce qui limite la consommation de mémoire ici, c'est la vitesse de création d'exécution des threads, et ce qui limite la vitesse d'exécution dans chaque thread, c'est l'affichage avec printf
moins de printf, plus de threads, plus de mémoire utilisée

[darkwall_37]

Merci pour ta réponse Bob et là ça devient obscur

Donc la quantité de création des threads est totalement indépendante du nombre d'itérations de la boucle for dans laquelle il est crée ?
Effectivement
-Si le printf est systématique alors la quantité de RAM augmente doucement jusqu'à 70M à 35000 i/s.
-Si le printf se produit tout les 10% des 100% à atteindre alors la RAM arrive à saturation à 8Go en 3-4s xD. D'ailleurs à l'affichage des 10 premiers % on voit que la vitesse d'itération est de 45000 au lieu de 35000 lorsque le printf est systématique. Et ensuite chaque 10% supplémentaire, la vitesse d'itérations chute totalement.

Ca m'attriste beaucoup parce que justement, je pensais que les threads allaient palier ce problème, à savoir disposer d'un affichage régulier de valeurs sans que cela ralentisse l’exécution du programme. Ce qui est le cas mais en contre partie d'une utilisation de la RAM outrageuse. Ce qui au final, la rend plus ou moins obsolète à mes yeux, à cet instant et sans plus de connaissance du sujet. Bien que j'imagine qu'il existe d'autres solutions ?!

Je me pose donc la question suivante, lors d'une copie de fichiers, il y a un thread alloué aux rafraîchissements des valeurs. Il doit donc y avoir un "mécanisme" pour limiter ce phénomène sans pour autant saturer la RAM. En revanche, on perd en performance automatiquement car plus il y a d'affichage à réaliser, plus l’exécution est ralentie. J'imagine donc qu'il doit y avoir un compromis acceptable pour que les deux coexistent.

As-tu connaissance d'une telle chose ou simplement je n'ai d'autre choix que de faire un printf systématique dans la fonction pour limiter la création de threads et donc la RAM utilisée ?

EDIT :

Si je place le pthread_join dans la boucle pour bien libérer les données locales transmises à la fonction task, l'itération est stable à 20000 i/s par contre j'ai toujours un problème de fuite mémoire. La ram utilisée par le programme augmente toujours dans le temps et là je ne comprends pas pourquoi.

Merci d'avance.

[BufferBob]

en fait c'était qu'une intuition, ce que tu dis m'oblige à regarder plus en détail ton code
du coup comme je vois à la fois du GetTickCount() et du pthread_create() je me demandais, tu fais tourner sous quoi, windows ? linux ?
aussi y'a un certain nombre de fonctions dont on ne peut que supposer de ce qu'elle font, un if pas fermé, donc si tu pouvais mettre un code minimal qu'on puisse compiler ce serait idéal ^^

[darkwall_37]

Oui c'est bien sous windows !
Oui effectivement, ça devrait compiler avec ce code minimal :

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
 
#include <windows.h>
#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
#include <time.h>
#include <math.h>
#include <pthread.h>
 
static void *task (void *p_data)
{
   if (p_data != NULL)
   {
        double *s = p_data;
 
 
            if ( s[1] >= s[2] )
                s[2] += 0.1, s[3]=1;
 
            else s[3]=0;
 
        if ( s[3]==1 )
            printf("\n iteration/s = %.2f --- progress %.0f %%", s[4], 100*s[1]);
 
        pthread_exit(NULL);
 
   }
   return NULL;
}
 
int main(int argc, char *argv[], char* env[])
{
        pthread_t t;
 
        double *p = (double*)malloc(5*sizeof(double));
        p[0] = GetTickCount();
        p[1]=0;
        p[2]=0.1;
 
        int i = 0;
        for ( i = 0 ; i<INT_MAX/1000 ; i++ )
        {
            p[1]=1000.*i/INT_MAX;
            p[4] = 1000.*i/(GetTickCount()-p[0]);
 
            pthread_create (&t, NULL, task, (double*)p);
            pthread_join (t, NULL);
        }
        free(p);
        return 0;
}

Merci d'avance !

[dalfab]

Bonjour,

La présence ou non d'un printf() change fortement les choses.
Les printf() sont un point de passage commun, ils sont protégé par un mutex voire un semaphore.
Les threads sans printf() ne font qu'enchaîner des appels système puis s'arrêtent quasi-immédiatement, libérant leur mémoire.
Les threads avec printf() tentent de prendre le mutex et se retrouvent bloqués en attente du printf() des autres threads
La mémoire consommées par un thread c'est essentiellement pour sa pile (1MO à ma connaissance sous Windows), donc tous ces MO s'empilent et ne sont libérés que bien plus tard (il faut des dizaines de µs...)