TThread et multiprocesseur

**noahsaga** · 25/03/2011, 09h13

Salut à tous,

A chaque jour son petit sujet...

Je travail sur la création de thread afin de faire du "parallèle". Voici le petit thread de chronométrage que j'ai "créé" :

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
#ifndef chronometreH
#define chronometreH
//---------------------------------------------------------------------------
#include <Classes.hpp>
//---------------------------------------------------------------------------
class ThChrono : public TThread
{
private:
protected:
        void __fastcall Execute();
        void __fastcall AffMessage();
 
public:
        __fastcall ThChrono(bool CreateSuspended);
 
        LARGE_INTEGER  start;      //!< The start time of the chronometer
        LARGE_INTEGER  tic;
        LARGE_INTEGER  FQPF;
 
        bool           HRPCAvail;  //!< Is there an available HRPC
 
        AnsiString millit;
        double result;
};
//---------------------------------------------------------------------------
#endif

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
#include <vcl.h>
#pragma hdrstop
 
#include "chronometre.h"
#include "page_essai.h"
#pragma package(smart_init)
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
 
__fastcall ThChrono::ThChrono(bool CreateSuspended)
        : TThread(CreateSuspended)
{
}
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
void __fastcall ThChrono::Execute()
{
 
        HRPCAvail=QueryPerformanceCounter(&start); //memo du temps de start
        if (!HRPCAvail)   //si le compteur n'était pas disponible
        {
          start.LowPart = ::GetTickCount();   //basse resolution
          start.HighPart = 0;
        }
 
        while (!Terminated)
        {
           if (HRPCAvail) //si le compteur haute resolution était dispo
           {
             QueryPerformanceCounter(&tic); //recup du temps
 
             QueryPerformanceFrequency(&FQPF); //recup de la frequence
 
             //resultat en msec
             result=static_cast<double>(tic.QuadPart - start.QuadPart) * 1000
              /static_cast<double>(FQPF.QuadPart);
           }
           else //si le compteur n'était pas disponible
           {
             tic.LowPart = ::GetTickCount();
             tic.HighPart = 0;
 
             result = 0;
             //resultat
             result=tic.LowPart - start.LowPart;
 
           }
           millit = AnsiString(result);
           Synchronize(AffMessage);
        }
}
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
void __fastcall ThChrono::AffMessage()
{
       ecran_essai->Label1->Caption = millit;
}

Je met créé entre guillemet car j'ai énormément pompé sur le code trouvé dans ce poste

Ma question est de savoir s'il existe un moyen de s'assurer ou de forcer l'utilisation des différents cœurs du PC? Un coeur pour le process principal et un autre pour les threads.

Même si mon process n'est composé que de tâches durant plusieurs centième de seconde, que ce chrono est "riche" pour mon utilisation, je préfère assuré le process.

**nirgal76** · 25/03/2011, 09h22

Tu as la fonction SetThreadAffinityMask qui permet de définir les coeurs que pourras utiliser ton thread

http://msdn.microsoft.com/en-us/libr...=vs.85%29.aspx

DWORD_PTR WINAPI SetThreadAffinityMask(
__in HANDLE hThread,
__in DWORD_PTR dwThreadAffinityMask
);

hThread : premier paramètre, l'ID de ton thread
dwThreadAffinityMask : le masque d'utilisation des cores. 1 bit par coeur. bit de poids faible pour le core n°1.
exemple :
pour n'utiliser que le core n°1, tu mets 0x1
pour n'utiliser que le core n°2, tu mets 0x2
pour n'utiliser que les core n°1 et 2, tu mets 0x3
pour n'utiliser que le core n°3, tu mets 0x4
pour n'utiliser que les core n°1 et 3, tu mets 0x5
pour n'utiliser que les core n°2 et 3, tu mets 0x6
pour n'utiliser que les core n°1, 2 et 3, tu mets 0x7
...
Attention, tu dois donner un pointer sur un dword contenant le masque, pas le dword lui même

DWORD mask=0x3;
SetThreadAffinityMask(threadID, &mask);

**noahsaga** · 25/03/2011, 10h39

Super merci Nirgal76. Ça parait assez simple à utiliser.

Petites précisions :

Ta fonction s'utilise dans la definition du thread ou dans le code qui lance le thread ?

sur le ThreadID. Si je lance mon thread comme cela :

Code :

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

1
2
3
4
5
6
7
 
void __fastcall Tecran_essai::startClick(TObject *Sender)
{
 
        chrono = new ThChrono(false);
 
}

Quel est le threadID (handle) ?

//+++++++++++++++++++++++++++++++++++++++

Pour la suite c'est plus un problème d'utilisation du thread que je rencontre. Mon premier code fonctionne mais j'aimerai que le label récupérant le temps chrono ne soit pas écrit en dur dans le thread. J'aimerai donc pouvoir spécifié à la création du thread où il doit écrite la donnée lors de la synchronisation. Voici donc le code que j'ai fait :

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
#ifndef chronometreH
#define chronometreH
//---------------------------------------------------------------------------
#include <Classes.hpp>
//---------------------------------------------------------------------------
class ThChrono : public TThread
{
private:
protected:
        void __fastcall Execute();
        void __fastcall AffMessage();
 
public:
        __fastcall ThChrono(bool CreateSuspended,AnsiString *data);
        AnsiString *Thdata;
 
        LARGE_INTEGER  start;      //!< The start time of the chronometer
        LARGE_INTEGER  tic;
        LARGE_INTEGER  FQPF;
 
        bool           HRPCAvail;  //!< Is there an available HRPC
 
        AnsiString millit;
        double result;
};
//---------------------------------------------------------------------------
#endif

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
__fastcall ThChrono::ThChrono(bool CreateSuspended,AnsiString *data)
        : TThread(CreateSuspended)
{
        Thdata = data;
}
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
void __fastcall ThChrono::Execute()
{
 
        HRPCAvail=QueryPerformanceCounter(&start); //memo du temps de start
        if (!HRPCAvail)   //si le compteur n'était pas disponible
        {
          start.LowPart = ::GetTickCount();   //basse resolution
          start.HighPart = 0;
        }
 
        while (!Terminated)
        {
           if (HRPCAvail) //si le compteur haute resolution était dispo
           {
             QueryPerformanceCounter(&tic); //recup du temps
 
             QueryPerformanceFrequency(&FQPF); //recup de la frequence
 
             //resultat en msec
             result=static_cast<double>(tic.QuadPart - start.QuadPart) * 1000
              /static_cast<double>(FQPF.QuadPart);
           }
           else //si le compteur n'était pas disponible
           {
             tic.LowPart = ::GetTickCount();
             tic.HighPart = 0;
 
             result = 0;
             //resultat
             result=tic.LowPart - start.LowPart;
 
           }
           millit = AnsiString(result);
           Synchronize(AffMessage);
        }
}
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
void __fastcall ThChrono::AffMessage()
{
       *Thdata = millit;
}

Avec l'appel du thread :

Code :

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

1
2
3
4
5
 
void __fastcall Tecran_essai::startClick(TObject *Sender)
{
        chrono = new ThChrono(false,&(Label1->Caption));
}

Ça compile bien mais j'ai un bel access violation à l'exécution et c'est visiblement lors de l'exécution de la fonction du thread AffMessage().
Une idée sur le pourquoi du comment?

**noahsaga** · 30/03/2011, 23h20

Un petit up car j'ai toujours mon problème.

**nazgul66** · 31/03/2011, 08h17

Bonjour, tu passe quoi en paramètre à ton Thread ?

**ShaiLeTroll** · 31/03/2011, 11h52

C'est surprenant que cela compile !
tu ne peux pas passer une propriété (Caption) en paramètre var (* ou &), cela contournerait les accesseurs défini par __property !
En Delphi, ça ne compilerait pas du tout ! le C++ se laisse berner !

le plus propre serait de définir un Evènement dans lequel tu fournis le nouveau libellé, lancer par Synchronize évidemment !

Quel est le threadID (handle) ?

tu as une propriété Handle et ThreadID sur l'objet TThread, c'est cela que tu parles ?

TThread et multiprocesseur

C++Builder

Vue hybride

Discussions similaires

Partager

Partager