Salut à tous ,
 
Je suis en train de développer en C++ sous VS2005 et j'aurais besoin d'un timer ayant une précision de l'ordre de la milliseconde.
Je sais que sous Windows, il est difficile de descendre en dessous des 10 ms.  Cependant je me demandais s'il n'existait pas une sorte de driver Timer tournant au niveau kernel à qui je pourrais filer un pointeur vers la fonction que je désir effectuer périodiquement.
 
Si vous aviez l'une ou l'autre idée, piste, suggestion, ce serait vraiment génial!
 
A+,
 
BigBulle

QueryPerformanceCounter je pense

Merci beaucoup! J'vais aller regarder ça.

Voici une class que j'ai développé pour que les animation opengl ou directx puisse touner a la même vitesse sur toutes les machines (technique utilisé dans tous les jeux) utilisant QueryPerformanceCounter
 
 
fichier .h
//---------------------------------------------------------------------------
#ifndef Clock_H
#define Clock_H
 
class Clock
{
private:
    bool PerfTime;
    LONGLONG Frq,Time0,Time1;
    float OneTick,dt;
public:
    Clock();
    ~Clock();
    void Initialise();
    float GetTime();
};
//---------------------------------------------------------------------------
#endif
 
fichier .cpp
 
#include "Clock.h"
 
Clock::Clock()
{
}
 
Clock::~Clock()
{
}
 
void Clock::Initialise()
{
    PerfTime=QueryPerformanceFrequency((LARGE_INTEGER*) &Frq);
    if (PerfTime)
    {
        //on peut lire le temps à l'aide du compteur de performance
        //alors on le fait
        QueryPerformanceCounter((LARGE_INTEGER*) &Time0);
        OneTick=1.0f/Frq;
    }
    else
    {
        //on peut pas lire le compteur de perf. Bon on utilise aut chose
        Time0=timeGetTime();
        OneTick=0.001f;
    }
}
 
float Clock::GetTime()
{
    if (PerfTime)
        QueryPerformanceCounter((LARGE_INTEGER*) &Time1);
    else
        Time1=timeGetTime();
 
    dt=(Time1-Time0)*OneTick;
    Time0=Time1;
    return dt;
}
 
//-------------------------------------------------------------
 
 
dt te renvoi le temps entre l'appel a la fonction initialise et la fonction gettime.
 
Voila, j'espère que cela t'aidera.

Merci pour ta réponse !
 
J'ai enfin terminé une permière ébauche de mon programme et fait quelque test. J'ai utilisé le timer multimedia de windows.
 
Ce timer est très précis (<1 ms). Cependant, dans certains cas (rafraichissment d'écran, etc...) je perds la main pendant plus de 500 ms.
J'imagine que c'est du au squeduler de windows...(j'connais pas trop les entrrailles de windows).
 
Pour mon application, j'ai besoin d'exécuter une fonction une fois toutes les 100 ms, même si c'est parfois 105 parfois 95 ms.
 
Existerais-t-il une espèce de driver timer tournant au niveau kernel à qui je pourrais filer un pointeur vers ma fonction à exécuter tous les 100 ms?
(Un peu dans le genre des drivers ASIO)
 
Merci beaucoup d'avance!

 
En fait je l'ai utilisé, et c'est plus du 4ms de précision.