Une classe simple en c++ pour mesurer le temps d'execution d'une portion de code sur une machine non dediee aux tests (windo

Télécharger le projet
Commenter

Description

On a parfois besoin de mesurer le temps d'exécution CPU d'une portion de code (lors de l'optimisation de l'efficacité d'une procédure par exemple), et pas toujours les moyens de consacrer une machine exclusivement aux tests.
L'utilisation de procédures comme clock(), GetTime(), QueryPerformanceCounter() ou d'autres permet de calculer le temps "réel" qui s'est écoulé entre deux points du code. Lorsqu'on ne peut pas dédier une machine aux tests, l'inconvénient de ces méthodes est de prendre en compte le temps des autres applications qui tournent sur le système en concurrence avec celle testée. Ce cas de figure est par exemple rencontré sur une machine sur laquelle on ne possède pas les droits suffisants pour désactiver une défragmentation, une analyse antivirus... automatique. Le temps consommé par ces applications n'est alors pas décompté par les méthodes sus-citées, ce qui fausse totalement les mesures.
Cette classe fournit un moyen simple de mesurer le temps processeur du processus courant uniquement entre un point de l'exécution et un autre grâce à l'utilisation de la fonction le l'API de Windows GetProcessTimes. L'utilisation de cette procédure permet de ne pas avoir recours à une gestion avancée du multi-tâche pour contrôler la préemption de notre processus.
Elle dispose en outre d'une mémoire comparable à celle d'un chronomètre classique afin de pouvoir ajouter une mesure à d'autres.
Elle présente les avantages suivants :
- ne mesurer que le temps du processus (si d'autres applications sont en cours d'exécution sur le système, la mesure n'est pas faussée)
- très simple (à mon avis) d'utilisation

Source / Exemple : 


//---------------------------------------------------------------------------
// Classe Chronomètre : permet de mesurer le temps CPU du processus courant
// Le temps considéré est le UserTime du processus, soit le temps pendant
// lequel le système exécute du code appartenant au processus uniquement.
//---------------------------------------------------------------------------
#ifndef chronoH
#define chronoH
#include <windows.h>
//---------------------------------------------------------------------------
class Chrono
{
  // Handle du processus courant
  HANDLE ihP;
  // Temps CPU lors du déclenchement
  unsigned int startTime;

public :
  // mémoire du chrono
  unsigned int m;

  // Constructeur
  Chrono() {reset();}
  // mise à zéro de la mémoire
  void reset() {m=0;}
  // Lance le chronomètre
  void iGo()
    {
    FILETIME ilpCreationTime;
    FILETIME ilpExitTime;
    FILETIME ilpKernelTime;
    FILETIME ilpUserTime;
    SYSTEMTIME stUser;
    ihP=GetCurrentProcess();
    GetProcessTimes(ihP,&ilpCreationTime,&ilpExitTime,&ilpKernelTime,&ilpUserTime);
    FileTimeToSystemTime(&ilpUserTime,&stUser);
    startTime=(stUser.wMilliseconds +1000*(stUser.wSecond
	     +60*(stUser.wMinute+60*(stUser.wHour+24*(stUser.wDay-1)))));
  }
  // Renvoie le temps CPU du processus, en millisecondes, 
  // écoulé depuis le lancement du chrono
  unsigned int iStop()
    {
    FILETIME ilpCreationTime;
    FILETIME ilpExitTime;
    FILETIME ilpKernelTime;
    FILETIME ilpUserTime;
    SYSTEMTIME stUser;
    GetProcessTimes(ihP,&ilpCreationTime,&ilpExitTime,&ilpKernelTime,&ilpUserTime);
    FileTimeToSystemTime(&ilpUserTime,&stUser);
    return stUser.wMilliseconds +1000*(stUser.wSecond
	+60*(stUser.wMinute+60*(stUser.wHour+24*(stUser.wDay-1))))
	-startTime;
    }
  // Ajoute le temps CPU du processus, en millisecondes, 
  // écoulé depuis le lancement du chrono à la mémoire
  void iStopAndAdd()
    {
    m+=iStop();
    }
};
//---------------------------------------------------------------------------
#endif

Conclusion :


Pour utiliser la classe, il suffit de :
- ajouter l'include (#include "Chrono.h" après avoir copié le fichier dans le répertoire source)
- définir un objet Chrono (par exemple, tps) pour chaque temps que vous voulez mesurer
- déclencher le chronomètre juste avant la portion de code à chronométrer (tps.iGo())
- si vous voulez ajouter le temps à la mémoire, faire tps.iStopAndAdd(), le temps écoulé sera ajouté à tps.m
si vous voulez seulement récupérer les temps écoulé depuis le déclenchement, faire temps=tps.iStop()
Le zip contient un exemple d'utilisation (demo.cpp), peut-être plus clair que ces explications...
Télécharger le projet

Codes Sources

A voir également

S'inscrire maintenant

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.