MQL5 · Avancé
Profiler et optimiser son code MQL5 : le profileur de MetaEditor et GetMicrosecondCount
Trouver ce qui ralentit réellement un EA ou un indicateur : profilage sur données réelles ou historiques, lecture de Total CPU et Self CPU, mesures avec GetMicrosecondCount, et les optimisations qui comptent dans un robot de trading.
Pour savoir où un programme MQL5 passe son temps, utilisez le profileur intégré à MetaEditor : ouvrez le fichier source, puis lancez « Démarrer le profilage sur données réelles » ou « sur données historiques » depuis le menu Débogage. MetaEditor compile une version instrumentée, l’exécute, et affiche dans l’onglet Profileur de la boîte à outils le temps passé dans chaque fonction et chaque ligne, avec les colonnes Total CPU et Self CPU. Pour une mesure ciblée, encadrez un bloc de code par deux appels à GetMicrosecondCount(). Optimisez ensuite uniquement ce que la mesure désigne : dans un EA, les gains viennent presque toujours d’un calcul répété inutilement à chaque tick.
Cette page appartient à la rubrique MQL5 avancé. Le profileur est l’un des outils de MetaEditor présentés dans Bien utiliser MetaEditor ; ici, nous l’utilisons dans le but précis d’accélérer un robot.
Pourquoi la performance compte dans un EA
Un EA lent ne perd pas seulement des millisecondes. En réel, un OnTick qui dure trop longtemps fait manquer des ticks : le terminal ne rappelle pas le gestionnaire tant que le précédent n’est pas terminé. Un indicateur lent pénalise tous les graphiques du même symbole, qui partagent son fil d’exécution. Et en optimisation, chaque milliseconde est multipliée par le nombre de ticks et le nombre de passes : diviser par deux le temps d’un EA, c’est diviser par deux la durée d’une optimisation génétique, ou tester deux fois plus de combinaisons dans le même temps.
Comment fonctionne le profileur de MetaEditor
Le profileur repose sur l’échantillonnage : il interrompt le programme environ 10 000 fois par seconde et note où il se trouve, pile d’appels comprise. Cette méthode est légère et ne modifie pas le code analysé. Deux modes sont proposés :
- Sur données réelles : le programme tourne sur un graphique alimenté en direct. C’est le reflet exact de la production, mais il faut attendre les ticks, et le marché doit être ouvert.
- Sur données historiques : le programme tourne dans le Strategy Tester, toujours en mode non visuel. Pas besoin d’attendre les ticks, et l’on peut profiler le week-end. C’est le mode le plus pratique pour un EA ou pour un indicateur qui ne calcule qu’à l’arrivée de nouveaux ticks.
Par défaut, le profilage se fait sur EURUSD H1 ; le symbole, la période et les réglages du testeur se modifient dans les options de MetaEditor, onglet Débogage. Pour arrêter, la documentation recommande de retirer le programme du graphique plutôt que d’utiliser la commande d’arrêt, afin d’obtenir des résultats plus précis. Pendant le profilage sur données réelles, sollicitez toutes les fonctions du programme (boutons, conditions d’entrée), sinon elles n’apparaîtront pas.
Lire le rapport : Total CPU et Self CPU
Les résultats s’affichent dans l’onglet Profileur et sont surlignés dans le code, d’autant plus vivement que la ligne est coûteuse. Deux colonnes structurent la lecture :
| Colonne | Signification | Usage |
|---|---|---|
| Total CPU | fréquence de présence de la fonction dans la pile d’appels, sous-fonctions comprises | repérer les grandes branches coûteuses |
| Self CPU | fréquence des interruptions survenues directement dans la fonction | désigner le goulet d’étranglement réel |
La méthode est simple : triez par Self CPU, ouvrez la fonction en tête, puis basculez sur l’affichage par lignes pour voir quelle instruction coûte. Les résultats s’exportent en Excel, HTML ou CSV, pratique pour comparer avant et après une optimisation.
Deux réglages influencent la précision. L’inlining fusionne les petites fonctions dans leurs appelants : le désactiver rend le rapport par fonctions plus exact. Désactiver l’optimisation du compilateur ajoute du détail mais ralentit le programme de plusieurs fois et peut déplacer les goulets apparents ; à n’utiliser qu’en connaissance de cause.
Mesurer soi-même avec GetMicrosecondCount
Pour comparer deux versions d’une fonction ou surveiller la durée de OnTick en production, un chronomètre manuel suffit. GetMicrosecondCount() renvoie le nombre de microsecondes écoulées depuis le lancement du programme ; la différence entre deux appels donne la durée du bloc. La mémoire utilisée par le programme se lit avec MQLInfoInteger(MQL_MEMORY_USED). Le script suivant compare deux manières de lire une moyenne mobile : créer le handle à chaque appel, ou une seule fois.
//+------------------------------------------------------------------+
//| BenchHandles.mq5 : mesurer le coût d'un mauvais usage des handles|
//+------------------------------------------------------------------+
#property script_show_inputs
input int InpLoops=200; // nombre de lectures simulées
//--- version lente : un handle créé et libéré à chaque lecture
double ReadSlow()
{
int h=iMA(_Symbol,PERIOD_CURRENT,50,0,MODE_SMA,PRICE_CLOSE);
double buf[];
double v=0.0;
if(h!=INVALID_HANDLE)
{
if(CopyBuffer(h,0,1,1,buf)==1) v=buf[0];
IndicatorRelease(h);
}
return(v);
}
//--- version rapide : handle créé une fois, copie d'une seule valeur
int g_ma=INVALID_HANDLE;
double ReadFast()
{
double buf[];
return(CopyBuffer(g_ma,0,1,1,buf)==1 ? buf[0] : 0.0);
}
void OnStart()
{
g_ma=iMA(_Symbol,PERIOD_CURRENT,50,0,MODE_SMA,PRICE_CLOSE);
if(g_ma==INVALID_HANDLE) { Print("iMA a échoué"); return; }
double dummy[];
CopyBuffer(g_ma,0,1,1,dummy); // premier appel : laisse l'indicateur se calculer
ulong t0=GetMicrosecondCount();
double s1=0.0;
for(int i=0;i<InpLoops;i++) s1+=ReadSlow();
ulong t1=GetMicrosecondCount();
double s2=0.0;
for(int i=0;i<InpLoops;i++) s2+=ReadFast();
ulong t2=GetMicrosecondCount();
PrintFormat("Handle recréé : %I64u µs au total, %.1f µs par lecture",t1-t0,(double)(t1-t0)/InpLoops);
PrintFormat("Handle unique : %I64u µs au total, %.1f µs par lecture",t2-t1,(double)(t2-t1)/InpLoops);
PrintFormat("Mémoire utilisée par le script : %d Mo",MQLInfoInteger(MQL_MEMORY_USED));
if(s1!=s2) Print("Attention : résultats différents (données pas encore prêtes ?)");
IndicatorRelease(g_ma);
}
Les chiffres exacts dépendent de votre machine et de l’historique chargé ; c’est l’écart entre les deux versions qui est instructif. Notez la comparaison des résultats en fin de script : une optimisation qui change le résultat n’en est pas une. Pour la bonne gestion des handles, consultez Handles d’indicateurs et CopyBuffer.
Les optimisations qui comptent vraiment
Dans un robot de trading, les mêmes causes reviennent presque toujours en tête du profileur :
- Calculer à chaque tick ce qui ne change qu’à chaque bougie. Un signal sur bougie clôturée ne doit être évalué qu’une fois par barre. La détection d’une nouvelle bougie élimine souvent l.essentiel des calculs.
- Créer des handles d’indicateurs dans
OnTick. Créez-les dansOnInit, libérez-les dansOnDeinit. - Copier trop de données. Copier 1 000 valeurs pour en lire deux est un gaspillage : demandez seulement les barres utiles.
- Parcourir l’historique complet à chaque tick.
HistorySelectsur des années de transactions est coûteux ; limitez la période ou mettez les résultats en cache. - Écrire sur disque ou dans le journal en permanence.
Printà chaque tick ralentit le backtest et noie l’information. - Redimensionner un tableau élément par élément.
ArrayResizeaccepte un troisième paramètre de réserve qui évite des réallocations répétées. - Boucles imbriquées sur des séries longues. Une moyenne glissante peut se mettre à jour par différence au lieu d’être recalculée entièrement ; les matrices et vecteurs offrent aussi des calculs vectorisés.
Pièges fréquents
- Optimiser sans mesurer : l’intuition se trompe souvent sur l’emplacement du goulet. Mesurez d’abord.
- Profiler un scénario incomplet : une fonction jamais appelée pendant la session n’apparaît pas dans le rapport.
- Comparer des mesures non comparables : même symbole, même période, même historique, sinon les écarts ne veulent rien dire.
- Sacrifier la lisibilité pour un gain négligeable : quelques microsecondes sur une fonction appelée une fois par bougie ne justifient pas un code obscur.
Questions fréquentes
Comment lancer le profileur de MetaEditor ?
Ouvrez le fichier source MQ5, puis choisissez dans le menu Débogage « Démarrer le profilage sur données réelles » ou « sur données historiques ». MetaEditor compile automatiquement une version de profilage et affiche les résultats dans l’onglet Profileur.
Quelle différence entre Total CPU et Self CPU ?
Total CPU mesure la présence d’une fonction dans la pile d’appels, en comptant tout ce qu’elle appelle. Self CPU ne compte que le temps passé directement dans la fonction : c’est l’indicateur principal pour trouver le vrai goulet d’étranglement.
Peut-on profiler un indicateur ?
Oui. Le profilage sur données historiques est même recommandé pour les indicateurs qui ne calculent qu’à l’arrivée de nouveaux ticks : le testeur fournit les ticks sans attendre le marché.
Comment mesurer la durée de OnTick en production ?
Appelez GetMicrosecondCount() au début et à la fin de OnTick, conservez le maximum et la moyenne, et affichez-les périodiquement plutôt qu’à chaque tick pour ne pas fausser la mesure par les écritures dans le journal.
- Programmation orientée objet : classes
- Héritage et polymorphisme
- La bibliothèque standard
- Matrices et vecteurs
- Modèles ONNX dans MQL5
- Le module Python MetaTrader5
- Lire et écrire des fichiers CSV
- Bases de données SQLite
- WebRequest et API externes
- Importer des DLL
- Le calendrier économique en MQL5
- Versionner son code (MQL5 Algo Forge)
- Publier un produit sur le Market MQL5
