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.