Nouveau : la formation trading algorithmique MQL5, MQL4 et ProRealTimeDécouvrir →

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.

Mis à jour le 23 octobre 2026Lecture : 9 minPar Alix, OptiBot 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 :

ColonneSignificationUsage
Total CPUfréquence de présence de la fonction dans la pile d’appels, sous-fonctions comprisesrepérer les grandes branches coûteuses
Self CPUfréquence des interruptions survenues directement dans la fonctiondé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 :

  1. 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.
  2. Créer des handles d’indicateurs dans OnTick. Créez-les dans OnInit, libérez-les dans OnDeinit.
  3. Copier trop de données. Copier 1 000 valeurs pour en lire deux est un gaspillage : demandez seulement les barres utiles.
  4. Parcourir l’historique complet à chaque tick. HistorySelect sur des années de transactions est coûteux ; limitez la période ou mettez les résultats en cache.
  5. Écrire sur disque ou dans le journal en permanence. Print à chaque tick ralentit le backtest et noie l’information.
  6. Redimensionner un tableau élément par élément. ArrayResize accepte un troisième paramètre de réserve qui évite des réallocations répétées.
  7. 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.

A

Alix · fondateur d’OptiBot Trading

Développeur MQL5 et ProBuilder, spécialiste du backtest et de l’optimisation de stratégies automatiques. Chaque contenu est vérifié sur la documentation officielle (MQL5.com, manuels ProRealTime) et testé avant publication. Notre méthode éditoriale.