OPTIMISATION DES CALLBACKS C++ RÉSOLUS À LA COMPILATION.

---

Commentaire sur cette source (17)
Ajouter un commentaire et/ou une note

Voici une classe de base pour réaliser simplement des callbacks "statiques" en C++. J'entends par "statiques", des callbacks pouvant être résolus au moment de la compilation.

La configuration de l'objet et de la fonction membre appelés est réalisée par template. Ainsi la mise en oeuvre du callback n'induit aucune surcharge à l'execution (à condition d'utiliser un compilateur/optimiseur performant).

//////////////////////////////////////////////////////////////////////
// Functor callback :
//////////////////////////////////////////////////////////////////////

#include<exception>
using std::exception;

// Configuration :
// - du type d'objet appelé,
// - du type de la valeur de retour de la fonction membre appelée,
// - du type de l'argument de la fonction membre appelée,
// - du pointeur de fonction membre.

// Callback statique vers une fonction membre non const :
template<
typename t_class,
typename t_return,
typename t_argument,
t_return ( t_class::*fm )( t_argument )
>
struct t_callback
{
	t_callback( t_class& c ) : _callback_class( c )	{}
	inline t_return operator()( t_argument arg )
	{
		return (_callback_class.*fm)( arg );
	}
private:
	t_class& _callback_class;
};

// Callback statique vers une fonction membre const :
template<
typename t_class,
typename t_return,
typename t_argument,
t_return ( t_class::*fm )( t_argument ) const
>
struct t_callback_const
{
	t_callback_const( const t_class& c ) : _callback_class( c )	{}
	inline t_return operator()( t_argument arg ) const
	{
		return (_callback_class.*fm)( arg );
	}
private:
	const t_class& _callback_class;
};

// Callback "dynamique" vers une fonction membre non const :
template <
typename t_class,
typename t_return,
typename t_argument
>
struct t_callback_dyn
{
	// exception
	struct bad_instance : exception
	{
		const char* what() const throw() { return "bad instance"; }
	};
	// exception
	struct bad_method : exception 
	{ 
		const char* what() const throw() { return "bad method"; }
	};
	// type de fonction membre
    typedef t_return ( t_class::*t_method )( t_argument );
	// constructeur
	t_callback_dyn( t_class* class_instance = 0, t_method method = 0 ) :
	_class_instance( class_instance ),
	_method( method )
    {
		
    }
	void set( t_class* class_instance, t_method method )
	{
		_class_instance = class_instance;
		_method = method;
	}
    inline t_return operator()( t_argument parameter )
    {
		return ( _class_instance->*_method )( parameter );
    }
    inline t_return call( t_argument parameter )
    {
		if( _class_instance == 0 ) 
			throw bad_instance();
		if( _method == 0 )
			throw bad_method();
		return ( _class_instance->*_method )( parameter );
    }
    inline t_return call_wo_throw( t_argument parameter ) throw()
    {
		try
		{
			if( _class_instance != 0 && _method != 0 )
				return ( _class_instance->*_method )( parameter );
			else
				return t_return();
		}
		catch(...) { return t_return(); }
    }
private:
    t_class*  _class_instance;
    t_method  _method;

};

// Callback "dynamique" vers une fonction membre const :
template <
typename t_class,
typename t_return,
typename t_argument
>
struct t_callback_dyn_const
{
	// exception
	struct bad_instance : exception
	{
		const char* what() const throw() { return "bad instance"; }
	};
	// exception
	struct bad_method : exception 
	{ 
		const char* what() const throw() { return "bad method"; }
	};
	// type de fonction membre
    typedef t_return ( t_class::*t_method )( t_argument ) const;
	// constructeur
	t_callback_dyn_const( t_class* class_instance = 0, t_method method = 0 ) :
	_class_instance( class_instance ),
	_method( method )
    {
		
    }
	void set( t_class* class_instance, t_method method )
	{
		_class_instance = class_instance;
		_method = method;
	}
    inline t_return operator()( t_argument parameter ) const
    {
		return ( _class_instance->*_method )( parameter );
    }
    inline t_return call( t_argument parameter ) const
    {
		if( _class_instance == 0 ) 
			throw bad_instance();
		if( _method == 0 )
			throw bad_method();
		return ( _class_instance->*_method )( parameter );
    }
    inline t_return call_wo_throw( t_argument parameter ) const throw()
    {
		try
		{
			if( _class_instance != 0 && _method != 0 )
				return ( _class_instance->*_method )( parameter );
			else
				return t_return();
		}
		catch(...) { return t_return(); }
    }
private:
    t_class*  _class_instance;
    t_method  _method;

};


//////////////////////////////////////////////////////////////////////
// Mise en oeuvre et exemples
//////////////////////////////////////////////////////////////////////

// Variables de mesure des performances
const unsigned int nb_tests = 200;
const unsigned int nb_iterations = 200000000;

#include<vector>
#include<sstream>
#include<iostream>
#include<algorithm>
#include<functional>
#include<numeric>
#include<ctime>
using namespace std;

// Pour l'exemple, les fonctions membres appellées ont le prototype :
// "int f( const int& )" ou "int f( const int& ) const"

// Objet appelé n°1 pour l'exemple.
struct A
{
	A( const int& n ) : _coef( n ) {}
	int fa( const int& n ) { return _coef + n; }
private:
	int _coef;
};

// Objet appelé n°2 pour l'exemple.
struct B
{
	B( const int& n ) : _coef( n ) {}
	int fb( const int& n ) { return _coef + n; }
private:
	int _coef;
};

// Objet appelé n°3 pour l'exemple.
struct C
{
	C( const int& n ) : _coef( n ) {}
	int fc( const int& n ) const { return _coef + n; }
private:
	int _coef;
};

// Objet appelant sans callback (appel codé en dur) pour l'exemple.
struct W
{
	W( A& a ) : _a( a ) {}
	void event() { _a.fa( 888 ); }
private:
	A& _a;	
};

//////////////////////////////////////////////////////////////////////
//
// Si ce n'est pas A::fa mais B::fb qu'il faut appeler,
// la classe W doit être recoder en conséquence.
//
// Pour mettre en oeuvre un callback statique, il faut preciser au
// moment de la compilation (par template), le type de l'objet appelé
// et passer le pointeur vers la fonction membre appelée.
// A la construction de la classe intégrant un callback, il faut
// passer par référence une instance de l'objet appelé.
// A l'utilisation, le callback se manipule comme la fonction membre
// appelée (operateur ()).
//
//////////////////////////////////////////////////////////////////////

// Objet appelant avec callback "statique" (fonction membre non const)
template< typename t_class, int ( t_class::*fm )( const int& ) >
struct X
{
	X( t_class& c ) : callback( c ) {} 
	void event() { callback( 888 ); }
private:
	t_callback< t_class, int, const int&, fm > callback;
};

// Objet appelant avec callback "statique" (fonction membre const)
template< typename t_class, int ( t_class::*fm )( const int& ) const >
struct Y
{
	Y( t_class& c ) : callback( c ) {} 
	void event() { callback( 888 ); }
private:
	t_callback_const< t_class, int, const int&, fm > callback; // callback
};

// Objet appelant avec callback "dynamique" (fonction membre non const) 
// sans test class/methode
template< typename t_class >
struct Z
{
	typedef int ( t_class::*fm )( const int& );
	Z( t_class& c, fm f ) : callback( &c, f ) {} 
	void event() { callback( 888 ); }
private:
	t_callback_dyn< t_class, int, const int& > callback;
};

// Objet appelant avec callback "dynamique" (fonction membre non const)
// avec test class/methode
template< typename t_class >
struct Zt
{
	typedef int ( t_class::*fm )( const int& );
	Zt( t_class& c, fm f ) : callback( &c, f ) {} 
	void event() { callback.call( 888 ); }
private:
	t_callback_dyn< t_class, int, const int& > callback;
};

// Objet appelant avec callback "dynamique" (fonction membre const) 
// sans test class/methode
template< typename t_class >
struct Zc
{
	typedef int ( t_class::*fm )( const int& ) const;
	Zc( t_class& c, fm f ) : callback( &c, f ) {} 
	void event() { callback( 888 ); }
private:
	t_callback_dyn_const< t_class, int, const int& > callback;
};

// Objet appelant avec callback "dynamique" (fonction membre const) 
// sans test class/methode
template< typename t_class >
struct Ztc
{
	typedef int ( t_class::*fm )( const int& ) const;
	Ztc( t_class& c, fm f ) : callback( &c, f ) {} 
	void event() { callback.call( 888 ); }
private:
	t_callback_dyn_const< t_class, int, const int& > callback;
};


int main()
{
	// Varaibles de mesure des performances
	vector<clock_t> duree_ss_callback;
	vector<clock_t> duree_av_callback_sta;
	vector<clock_t> duree_av_callback_stac;
	vector<clock_t> duree_av_callback_dyn;
	vector<clock_t> duree_av_callback_dynt;
	vector<clock_t> duree_av_callback_dync;
	vector<clock_t> duree_av_callback_dyntc;
	
	// Objets appelés :
	A a( 12 );
	//B b( 12 );
	C c( 12 );

	// Boucle de test
	for( int repetition = nb_tests; repetition != 0; repetition-- )
	{
	
		// Test de performance avec un objet appelant sans callback :
		{
			W w( a );
			clock_t debut = clock();
			for( unsigned int iteration = nb_iterations; iteration !=0; iteration-- )
				w.event();
			duree_ss_callback.push_back( clock() - debut );
		}	
		// ... pas possible d'appeler une autre fonction membre de A, ou un autre objet sans recoder...
	
		// Test de performance avec un objet appelant avec callback statique (non const):
		{
			X<A, &A::fa> xa( a ); // Objet configuré pour appeler A::fa
			clock_t debut = clock();
			for( unsigned int iteration = nb_iterations; iteration !=0; iteration-- )
				xa.event();
			duree_av_callback_sta.push_back( clock() - debut );
		}	
	
		// Test de performance avec un objet appelant avec callback statique (non const):
		{
			Y<C, &C::fc> yc( c ); // Objet configuré pour appeler C::fc (methode const)
			clock_t debut = clock();
			for( unsigned int iteration = nb_iterations; iteration !=0; iteration-- )
				yc.event();
			duree_av_callback_stac.push_back( clock() - debut );
		}	
	
		// Test de performance avec un objet appelant avec callback dynamique (non const) (ss test class/methode):
		{
			Z<A> za( a, &A::fa ); // Objet configuré pour appeler A::fa
			clock_t debut = clock();
			for( unsigned int iteration = nb_iterations; iteration !=0; iteration-- )
				za.event();
			duree_av_callback_dyn.push_back( clock() - debut );
		}	

		// Test de performance avec un objet appelant avec callback dynamique (non const) (av test class/methode):
		{
			Zt<A> zta( a, &A::fa ); // Objet configuré pour appeler A::fa
			clock_t debut = clock();
			for( unsigned int iteration = nb_iterations; iteration !=0; iteration-- )
				zta.event();
			duree_av_callback_dynt.push_back( clock() - debut );
		}	

		// Test de performance avec un objet appelant avec callback dynamique (const) (ss test class/methode):
		{
			Zc<C> zc( c, &C::fc ); // Objet configuré pour appeler A::fa
			clock_t debut = clock();
			for( unsigned int iteration = nb_iterations; iteration !=0; iteration-- )
				zc.event();
			duree_av_callback_dync.push_back( clock() - debut );
		}	

		// Test de performance avec un objet appelant avec callback dynamique (const) (ac test class/methode):
		{
			Ztc<C> ztc( c, &C::fc ); // Objet configuré pour appeler A::fa
			clock_t debut = clock();
			for( unsigned int iteration = nb_iterations; iteration !=0; iteration-- )
				ztc.event();
			duree_av_callback_dyntc.push_back( clock() - debut );
		}	
	}
	
	// affichage des performances
	cout << "Temps d'execution sans callback                                : " << accumulate( duree_ss_callback.begin(), duree_ss_callback.end(), 0 ) << "ms" << endl;
	cout << "Temps d'execution avec callback statique (non const)           : " << accumulate( duree_av_callback_sta.begin(), duree_av_callback_sta.end(), 0 ) << "ms" << endl;
	cout << "Temps d'execution avec callback statique (const)               : " << accumulate( duree_av_callback_stac.begin(), duree_av_callback_stac.end(), 0 ) << "ms" << endl;
	cout << "Temps d'execution avec callback dynamique (non const)(ss test) : " << accumulate( duree_av_callback_dyn.begin(), duree_av_callback_dyn.end(), 0 ) << "ms" << endl;
	cout << "Temps d'execution avec callback dynamique (non const)(av test) : " << accumulate( duree_av_callback_dynt.begin(), duree_av_callback_dynt.end(), 0 ) << "ms" << endl;
	cout << "Temps d'execution avec callback dynamique (const)(ss test)     : " << accumulate( duree_av_callback_dync.begin(), duree_av_callback_dync.end(), 0 ) << "ms" << endl;
	cout << "Temps d'execution avec callback dynamique (const)(av test)     : " << accumulate( duree_av_callback_dyntc.begin(), duree_av_callback_dyntc.end(), 0 ) << "ms" << endl;
}

Limitation :
- Ne compile pas sous VC6 (testé avec MinGW, Cygwin et Visual.Net-7.1).

Observation :
- Excellent niveau de performance avec Visual.Net-7.1 pour les callbacks statiques (inlining poussé),
- Optimisation peu convaincante avec GCC/win32 (Cygwin et MinGW).

A faire :
- Améliorer la génération et la propagation des exceptions dans toutes les classes callback.

Toutes remarques sont les bienvenues ! ;-)

26 décembre 2004 22:37:09 :

Mise en forme.

26 décembre 2004 23:03:07 :

Modification du titre.

27 décembre 2004 21:20:55 :

Ajout d'une seconde classe callback capable d'appeler une fonction membre const.

27 décembre 2004 21:21:47 :

Mise en forme.

27 décembre 2004 21:23:14 :

Mise en forme (oui, je persiste!)

27 décembre 2004 23:15:11 :

Correction de t_callback_const.

28 décembre 2004 13:58:03 :

Code (mesure des performances) & Screenshot (resultat avec compilateur .Net 2003 - VC7).

29 décembre 2004 12:39:24 :

Ajout d'une classe callback dynamique adaptée aux fonctions membres const. Ajout d'une fonction membre dans la classe callback dynamique sans test de validité du callback. Ajout de plusieurs mesures de performances (callback dynamique av/ss const, av/ss test validité). Amélioration du mécanisme d'exception de la classe callback dynamique. Mise à jour du screenchot des resultats du test (VC7.1 / -O2). Mise en forme.

29 décembre 2004 12:46:07 :

Correction d'erreur.

30 décembre 2004 23:47:56 :

Ajout d'une fonction membre dans les classes callback dynamiques en throw().

31 décembre 2004 09:09:05 :

Correction d'erreur.

• CLASSE INTERPRETEUR DE COMMANDES
• CODE DE CESAR (CHIFFRE/DÉCHIFFRE) EN C.
• MINXL (MINIMALIST XML LIBRARY) : GÉNÉRATEUR/ANALYSEUR/TRAITEMENT DE FLUX/FICHIERS XML EN C++
• [WIN32 & LINUX] THREADS C++
• SERVEUR HTTP 1.1 SIMPLE V2.XX (WINDOWS & GNU/LINUX COMPATIBLE)

• TRONQUER LES ZERO INUTILES D'UN NOMBRE A L'AFFICHAGE
• UTILISATION DES TOUCHES TAB, ENTREE ET ECHAP DANS UNE FENÊTRE WIN32.
• CALCULER NOMBRE DE MERSENNE AVEC BIBLIOTHÈQUE DE GESTION DE GRANDS NOMBRES
• RECHERCHER LE CHEMIN OPTIMALE DANS UN GRAPHE ( ALGORITHME DE DIJKSTRA )
• LIBRAIRIE POUR ÉVITER LES FUITES MEMOIRES