Tiki en temps réel - page 19

Nouveau commentaire
 
Yuriy Zaytsev:

Sinon, pour ne pas craindre que Symbol() fasse perdre du temps, il faut laisser les deux gestionnaires se "nourrir" également.

Nous pouvons remplacer la fonction Symbole() par une variable prédéfinie _Symbole

 

Symbol() n'a rien à voir avec cela. L'heure dans le journal est correcte.

Le retard se situe dans la file d'attente des événements ou dans les fonctions SymbolInfo.

C'est de ça que je parle.


Donc, si vous avez besoin du verre, travaillez avec OnBook. Si ce n'est pas nécessaire, travaillez en OnTick (sans files d'attente ni appels inutiles).

Il reste à trouver le moyen le plus rapide d'obtenir l'historique des tics pour les deux méthodes.

Je pense que, si seulement le dernier tick est nécessaire, SymbolInfo est meilleur. Si nous avons besoin d'une histoire sans lacunes, alors seulement CopyTicks.

 
Andrey Khatimlianskii:

Symbol() n'a rien à voir avec cela. L'heure dans le journal est correcte.

Le retard se situe dans la file d'attente des événements ou dans les fonctions SymbolInfo.

C'est de ça que je parle.

Je suis d'accord que Symbol ne peut pas mâcher beaucoup, mais peut apporter une certaine contribution, et certainement pour la pureté du test prendre du tempsavant tout appel.

En ce qui concerne la file d'attente, je suis curieux de savoir dans quelle mesure OnBook peut être en retard sur le même OnTick dans des conditions idéales. C'est-à-dire lorsque seul ce symbole est souscrit, que le terminal n'est pas occupé par autre chose, etc. et ce qui en est la cause.

Jusqu'à présent, je ne peux pas admettre qu'il s'agit uniquement de la file d'attente, car si les gestionnaires ne font rien, alors la file d'attente de 5-6 OnBooks ne devrait pas consommer plus que l'opération de vérification du symbole.

Nous devrions supprimer tous les contrôles et voir ce qui se passeentre OnTick et OnBook pour le même tick.

void OnBookEvent(const string &symbol)
{
ul=GetMicrosecondCount();  
  Print(__FUNCTION__, "; Time: ", ul, " mcs");
}
void OnTick()
{
ul=GetMicrosecondCount();  
  Print(__FUNCTION__, "; Time: ", ul, " mcs");
}
//+--

ap : Il est devenu clair que le vorace Print ne permet pas de vérifier proprement, car la file d'attente sera longue à cause du Print)

Je dois mettre le temps sans le print dans le tableau ulong, et ensuite déjà une fois toutes les 5 minutes pour sortir tout à Prints, je le coderai plus tard.

 

Je voulais d'abord tester le code

//---
bool is_book;
enum ENUM_BOOK_OR_TICK
{
        USE_BOOK,       // Use OnBookEvent
        USE_TICK        // Use OnTick
};
input ENUM_BOOK_OR_TICK Mode = USE_BOOK;
input int   SecForPrint =  120;
ulong TimeArrayBook[65536];
ulong TimeArrayTick[65536];
ushort curBook,curTick;
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
{
   curBook=0;
   curTick=0; 
   ArrayInitialize(TimeArrayBook,INT_MAX);
   ArrayInitialize(TimeArrayTick,INT_MAX);
  if(Mode == USE_BOOK) is_book = MarketBookAdd(Symbol());
  if (EventSetTimer(SecForPrint)) 
  return(INIT_SUCCEEDED);
  else return (INIT_FAILED);
}
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
  if(Mode == USE_BOOK)
  {
    if(is_book == true) MarketBookRelease(Symbol());
  }  
}
//+------------------------------------------------------------------+
//| BookEvent function                                               |
//+------------------------------------------------------------------+
void OnBookEvent(const string &symbol)
{
  TimeArrayBook[curBook++]=GetMicrosecondCount();
}
void OnTick()
{
  TimeArrayTick[curTick++]=GetMicrosecondCount();
}
//+------------------------------------------------------------------+
void OnTimer()
  {  
   int total=MathMax(curBook,curTick);
   int i=0,k=0;
   while(i<total)
     {
      while(i<total && TimeArrayBook[i]<TimeArrayTick[k])
        {
          Print("Book ",TimeArrayBook[i++]);
        }    
      if(k<curTick-1)
        {
         Print("Tick ",TimeArrayTick[k++]);
        }       
        i++;
     }
     if (curTick>0)Print("Tick ",TimeArrayTick[curTick-1], " last");
     curBook=0;
     curTick=0;
  }
//---

Mais je ne peux pas ouvrir le compte démo de l'ouvreur pour quelque chose. L'heure n'est probablement pas dans l'ordre, ou bien il y a un autre problème ?



Puis code à dopiliser pour comparer exactement à partir d'un tick d'événement.

 
Aleksey Mavrin:

Je voulais d'abord tester le code

Mais je ne peux pas ouvrir le compte démo de l'ouvreur pour quelque chose. L'heure n'est probablement pas dans l'ordre, ou bien il y a un autre problème ?



Puis code à dopiliser pour comparer exactement à partir d'un tick d'événement.

Vous devez l'ouvrir sur leur site web. Ils envoient ensuite un code au bureau de poste.

 
Andrey Khatimlianskii:


Je pense que si seulement le dernier tick est nécessaire, SymbolInfo est meilleur. Si vous avez besoin d'une histoire sans sauts, alors seulement CopyTicks.

Le fait est que le marché urgent (FORTS), même sur les instruments "très liquides", est très faible,

Cela signifie qu'au bon prix, vous pouvez acheter unnombre trèslimité de contrats, donc nous n'avons pas seulement besoin du prix,

Le volume des contrats à ce prix est très important.


Et SymbolInfo ne donne pas le volume de ce prix.

Pour cette raison, nous devons utiliserMarketBookGet() qui fournit à la fois le prix et le volume du livre entier.

Vous pouvez utiliserMarketBookGet() uniquement en combinaison avec MarketBookAdd, pour obtenir les changements de la coupe du marché.

dans OnBookEvent. Vous pouvez ajouter le marché (MarketBookAdd) et utiliserMarketBookGet() depuis OnTck(),

mais dans ce cas, nous manquons d'autres changements du marché(les ordres en attente ne sont pas au meilleur prix).

Il est vrai que le marché peut jouer avec cela et construire le glissement du marché à partir des ticks entrants, mais est-ce vraiment nécessaire?

Ajouté par

Et je ne suis pas d'accord pour dire que nous pouvons obtenir des ticks de l'historique lorsque OnTck() est déclenché.

En se souvenant de l'heure du dernier tic, lorsque OnTck() est déclenché, nous pouvons obtenir les ticks.

en temps réel, un nouveau tick(s) est entré - déclenché par OnTck() nous le lisons immédiatement, c'est-à-dire qu'il n'est pas dans l'historique.

 
Andrey Khatimlianskii:

Il reste à trouver le moyen le plus rapide d'obtenir l'historique des tics réels pour les deux méthodes.


Mon OnTick() est le même ou légèrement plus rapide que OnBook (mais OnBook a des délais énormes).

Je testais la vitesse des fonctions(microsecondes).

2020.02.04 13:09:13.101 Ticks_test (GOLD-3.20,M1)       SymbolInfoTick: time = 2 mcs 2020.02.04 13:09:10.720 Bid=1573.1 
2020.02.04 13:09:13.101 Ticks_test (GOLD-3.20,M1)       SymbolInfoDouble: time = 28 mcs ask = 1573.3
2020.02.04 13:09:13.101 Ticks_test (GOLD-3.20,M1)       SymbolInfoDouble: time = 33 mcs bid = 1573.1
2020.02.04 13:09:13.101 Ticks_test (GOLD-3.20,M1)       SymbolInfoDouble: time = 36 mcs last = 1573.4
2020.02.04 13:09:13.101 Ticks_test (GOLD-3.20,M1)       OnTick: time = 41 mcs 2020.02.04 13:09:10.720 Bid=1573.1 
2020.02.04 13:09:13.101 Ticks_test (GOLD-3.20,M1)       OnTick: time = 41 mcs 2020.02.04 13:09:00.328 Ask=1573.3 
OnTick - имеется ввиду CopyTicks из OnTick

La plus rapide estSymbolInfoTick, mais cette fonction ne met pas le volume dans le tick !

Voir pour l'aide.

tick

[out]  Ссылка на структуру типа MqlTick, в которую будут помещены текущие цены и время последнего обновления цен.

C'est-à-dire seulement le temps et le prix, mais pas le volume :(

 

Pour les instruments négociés en bourse (notamment les FORTS), ce n'est pas seulement le prix qui compte,

mais aussi le volume des contrats à ce prix !

 

J'ai essayé de prendre le verre par OnTick() - d'énormes retards clairement visibles "à l'œil" !

//+------------------------------------------------------------------+
//|                                                   Ticks_test.mq5 |
//|                                      Copyright 2019 prostotrader |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2019 prostotrader"
#property link      "https://www.mql5.com"
#property version   "1.00"
//---
bool is_book;
MqlBookInfo BookInfo[];
int book_cnt;
struct MARKET_DATA
{
  double ask;
  long   ask_vol;
  double bid;
  long   bid_vol;
  double prev_ask;
  long   prev_ask_vol;
  double next_bid;
  long   next_bid_vol; 
};
MARKET_DATA m_data;
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
{
  is_book = MarketBookAdd(Symbol());
  if(is_book == false)
  {
    Alert("No add book!");
    return(INIT_FAILED);
  }
  return(INIT_SUCCEEDED);
}
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
  if(is_book == true) MarketBookRelease(Symbol());
}
//+------------------------------------------------------------------+
//| Expert OnTick function                                           |
//+------------------------------------------------------------------+
bool GetBook(const string a_symb, int &cnt)
{
  cnt = 0;
  if(MarketBookGet(a_symb, BookInfo) == true)//getBook )
  {
    m_data.ask = 0;
    m_data.ask_vol = 0;
    m_data.prev_ask = 0;
    m_data.prev_ask_vol = 0;
    m_data.bid = 0;
    m_data.bid_vol = 0;
    m_data.next_bid = 0;
    m_data.next_bid_vol = 0;
    cnt = ArraySize(BookInfo);
    if(cnt > 0)
    {
      for(int i = 0; i < cnt; i++)
      {
        if(BookInfo[i].type == BOOK_TYPE_BUY) //Стакан агрегирован, т.е от наибольшего Sell к наименьшему Buy
        {
          if((i + 1) <= (cnt- 1))
          {
            m_data.ask = BookInfo[i-1].price;
            m_data.ask_vol = BookInfo[i-1].volume;
            m_data.prev_ask = BookInfo[i-2].price;
            m_data.prev_ask_vol = BookInfo[i-2].volume;
            m_data.bid = BookInfo[i].price;
            m_data.bid_vol = BookInfo[i].volume;
            m_data.next_bid = BookInfo[i+1].price;
            m_data.next_bid_vol = BookInfo[i+1].volume;
            break;
          } else break;
        }
      }
      return(true);
    }
  }
  return(false);
}  
//+------------------------------------------------------------------+
//| Expert OnTick function                                           |
//+------------------------------------------------------------------+
void OnTick()
{
  if(GetBook(Symbol(), book_cnt) == true)
  {
    if(book_cnt >= 4)
    {
      Print("Prev Sell: ask = ", m_data.prev_ask, " volume = ",m_data.prev_ask_vol); 
      Print("Sell: ask = ", m_data.ask, " volume = ",m_data.ask_vol);
      Print("Buy: bid = ", m_data.bid, " volume = ",m_data.bid_vol);
      Print("Next Buy: bid = ", m_data.next_bid, " volume = ",m_data.next_bid_vol);
    }  
  }
}
//+------------------------------------------------------------------+
 

Tu as tout gâché.

J'ai écrit plus tôt que les transactions et le niveau 2 sont des abonnements de données différents, donc des gestionnaires d'événements différents.
C'estpourquoi les transactions doivent être appelées à partir de OnTick, et les gangs de volume à partir de OnBook.
Vous essayez d'appeler des transactions à partir d'événements OnBook et des gangs à partir d'événements OnTick. Je pense qu'OnBook sera plus rapide pour les échanges.
Ce ne sera pas plus rapide, je pense que c'est une illusion de comparer deux gestionnaires d'événements, chacun dédié à son propre flux de données.
Je comprends que ce ne sont que des expériences, mais si vous ne comprenez pas la logique selon laquelle il y a deux flux de données (les transactions et le niveau 2), vous allez confondre sans cesse ces gestionnaires OnTick et OnBook.

1...121314151617181920212223242526
Nouveau commentaire
Raison: