Domande su OOP in MQL5 - pagina 71

Nuovo commento
 
Igor Makanu:

se si scrivono tali classi:

a giudicare dalla tua ricerca, la classe B sarà più lenta da eseguire se usi frequentemente campi struttura nei calcoli?

Quindi, stavamo discutendo il tempo di attraversare un array di oggetti)))

Secondo il tuo esempio sarà lo stesso in plus, ma in mql c'è una sfumatura, ci sono due campi impliciti, che vanno per primi, quindi, il campo dati sarà accessibile ad un offset, cioè, saranno eseguiti dei calcoli aggiuntivi durante la dereferenziazione.

 
Vladimir Simakov:

Quindi, stavamo discutendo il tempo di attraversare l'array di oggetti))

Secondo il tuo esempio sarà lo stesso in plus, ma in mql c'è una sfumatura, ci sono due campi impliciti, che vanno per primi, quindi, il campo dati sarà avvicinato da shift, cioè da calcoli aggiuntivi durante la dereferenziazione.

Grazie, questo è utile!

 
Vladimir Simakov:

Quindi, stavamo discutendo il tempo di attraversare l'array di oggetti))

Secondo il tuo esempio sarà lo stesso in plus, ma in mql c'è una sfumatura: ci sono due campi impliciti che vanno per primi, quindi il campo dati sarà accessibile con un offset, cioè verranno eseguiti dei calcoli di dereferenziazione aggiuntivi.

Entrambe le classi sono simili. L'accesso è per offset in entrambi i casi, solo che non è relativo all'inizio della struttura, ma all'inizio della classe. In altre parole, la struttura stessa è senza peso. Solo le classi creano un overhead.
 
Vladimir Simakov:

Quindi, nessun misticismo - le leggi della fisica in azione.

Non si adatta alle "leggi della fisica".

#include <fxsaber\Benchmark.mqh> // https://c.mql5.com/3/321/Benchmark.mqh

long f1( const int Size, const long Amount = 5 e9 )
{
  long Sum = 0;
  
  for (long i = 0; i < Amount; i++)
  {
    Sum += Size * i;
    
    Sum |= 1;
  }
    
  return(Sum);
}

long f2( const int Size, const long Amount = 5 e9 )
{
  long Sum = 0;
  
  for (long i = 0; i < Amount; i++)
  {
    Sum += Size * (Amount - i);
    
    Sum |= 1;
  }
    
  return(Sum);
}

void OnStart()
{
  Print(_B(f1(2), 1));
  Print(_B(f1(200), 1));
  
  Print(_B(f2(2), 1));
  Print(_B(f2(200), 1));
}


        Alert: Time[Test6.mq5 267: f1(2)] = 3252 ms.
        6553255921290448385
        Alert: Time[Test6.mq5 268: f1(200)] = 4602 ms.
        -8757194524499019775
        Alert: Time[Test6.mq5 270: f2(2)] = 3061 ms.
        6553255931290448385
        Alert: Time[Test6.mq5 271: f2(200)] = 3112 ms.
        -8757193524499019775


Questo è un risultato paradossale. I calcoli più complessi vengono eseguiti 1,5 volte più velocemente e non dipendono dalle dimensioni.

 
Vladimir Simakov:

Quindi, stavamo discutendo il tempo di attraversamento dell'array di oggetti)))

Secondo il tuo esempio sarà lo stesso in plus, ma c'è una sottigliezza in mql: ci sono due campi impliciti che vanno per primi, quindi il campo dati sarà accessibile ad un offset, cioè verranno eseguiti ulteriori calcoli di dereferenziazione.

Grazie a Vladimir per lo studio dell'assemblatore.
E come suggerisce Alexey, l'overhead è creato dalle classi.
Da questo possiamo concludere che se si può fare a meno delle classi, è meglio scrivere codice in stile procedurale.
Cioè, se il compito non richiede velocità, potete avvolgerlo in una classe, ma se avete a che fare con i tic, per esempio, è meglio usarlo direttamente senza wrapper.
In linea di principio, questo è l'approccio che ho seguito, e spesso trovando un esempio di una classe, smonto i suoi metodi in approccio procedurale.

 
Roman:

Grazie Vladimir per lo studio di montaggio.
E come suggerisce Alexey, l'overhead crea delle classi.
Da questo possiamo concludere che se possiamo fare a meno delle classi, è meglio scrivere codice in stile procedurale.
Cioè, se il compito non richiede velocità, potete avvolgerlo in una classe, ma se avete a che fare con i tic, per esempio, è meglio scrivere direttamente senza wrapper.
In linea di principio, questo è l'approccio che ho seguito e spesso quando trovo un esempio di una classe, smonto i suoi metodi usando l'approccio procedurale.

C'è un troll sul forum...
Non capivo perché alcuni utenti chiedessero la funzione di ignorare, ah come manca ora...

 

Forum sul trading, sistemi di trading automatico e test di strategia

Domande OOP in MQL5

fxsaber, 2020.05.30 14:06

Non ho idea di cosa farci. Ho fatto strutture semplici.

        50000000
        50000000
        Alert: Time[Test6.mq5 280: Func(Array1)] = 312 ms.
        1333106752
        Alert: Time[Test6.mq5 281: Func(Array3)] = 1348 ms.
        1333106752
        : sizeof(STRUCT1) = 20
        : sizeof(STRUCT3) = 84

Non sono sicuro del perché l'accesso al primo campo di una struttura semplice dipenda dalla sua dimensione.

State usando 50M elementi in un array.
Per le strutture di dimensione 20 e 84 byte questo è 0,93GB e 3,91GB di dati, rispettivamente.
E nel quadro del vostro calcolo, presumibilmente, tutta questa memoria passa attraverso la cache del processore.
E una spiegazione molto logica per questi risultati sarebbe che 0,93 GB di dati verrebbero scaricati dalla memoria nella cache della CPU quattro volte più velocemente dei 3,91 GB di dati.

E i risultati del test C++?
Perché ho visto codice assembler, ma nessun risultato di test, o ho guardato male?
 
Sergey Dzyublik:

C'è un troll sul forum...
Non capivo perché alcuni utenti chiedessero la funzione di ignorare, ah come manca ora...

Dovresti badare a te stesso, non agli altri.
Non tu e non per te era la risposta.
Ignorare in silenzio ))

 
Sergey Dzyublik:
State usando 50M elementi in un array.
Per strutture di 20 e 84 byte, sono rispettivamente 0,93GB e 3,91GB di dati.
E come parte del vostro calcolo, presumibilmente tutta questa memoria passa attraverso la cache del processore.
E una spiegazione molto logica per questi risultati sarebbe che 0,93 GB di dati verrebbero scaricati dalla memoria nella cache della CPU quattro volte più velocemente dei 3,91 GB di dati.

E i risultati del test C++?
Perché ho visto codice assembler, ma nessun risultato di test, o ho guardato male?
Funziona allo stesso modo. È solo un po' più veloce, ma il rapporto è lo stesso, quindi è hardware.
 
Roman:

Grazie Vladimir per lo studio di montaggio.
E come suggerisce Alexey, l'overhead crea delle classi.
Da questo possiamo concludere che se possiamo fare a meno delle classi, è meglio scrivere codice in stile procedurale.
Cioè, se il compito non richiede velocità, potete avvolgerlo in una classe, ma se avete a che fare con i tic, per esempio, è meglio usarlo direttamente senza wrapper.
In linea di principio, questo è l'approccio che prendo, e spesso trovando un esempio di una classe, smonto i suoi metodi in stile procedurale.

Puoi usare una struttura invece di una classe, vanno bene.

1...646566676869707172737475767778...96
Nuovo commento
Motivazione: