Errori, bug, domande - pagina 2878

Nuovo commento
 
Igor Makanu:

quale variante di conversione funzionerà più velocemente durante l'ottimizzazione

Questo sarà chiamato solo una volta per ogni passaggio. Pertanto, non fa alcuna differenza.

 
fxsaber:

Questo sarà chiamato solo una volta per l'intero passaggio. Quindi non fa differenza.

quindi sì... Ma ho intenzione di eseguirlo per un paio di giorni per l'ottimizzazione, voglio misurare le prestazioni in qualche modo ..... anche se sospetto che la variante 1 sarà più efficiente, non ci saranno 100500 volte di copia in array

 
Igor Makanu:

Sì... Ma ho intenzione di far funzionare il computer per un paio di giorni per ottimizzarlo, voglio misurare le prestazioni in qualche modo ..... anche se sospetto che l'opzione 1 sarà più efficiente, non ci saranno 100500 volte di copia in array

Quindi la variante 2 è molto probabilmente più veloce, ma come hai sottolineato sopra, non importa.
 
TheXpert:
L'unione non è copiare su array, è un'interpretazione diversa dello stesso spazio di memoria. quindi la seconda opzione è probabilmente più veloce, ma come notato sopra, non importa.
L'Unione non è così veloce come sembra. Purtroppo.
Io scommetto sul primo.
 
Igor Makanu:

Sì... Ma ho intenzione di far funzionare il computer per un paio di giorni per ottimizzarlo, voglio misurare le prestazioni in qualche modo ..... anche se sospetto che l'opzione 1 sarà più efficiente, non ci saranno 100500 volte di copia in array

c'è un vecchio modo di misurare la velocità

nello stile di

per (int i=0; i< 1000000; i++) {il nostro codice1}....
per (int i=0; i< 1000000; i++) {il nostro codice2}....

 
Nikolai Semko:
L'Unione non è così veloce come sembra. Ho scommesso sul primo.

Scommetto anche sulla prima! Gli operatori binari sono molte volte più veloci dell'operatore if, anche se la seconda non ce l'ha.

 

controllato:

#define    SpeedTest(count_x10,msg,EX)        {ulong mss=GetMicrosecondCount(); ulong count=(ulong)pow(10,count_x10);for(ulong _i=0;_i<count&&!_StopFlag;_i++){EX;} \
                                              printf("%s: loops=%llu ms=%llu",msg,count,GetMicrosecondCount()-mss);}
//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
{
   ulong sum = 0;
   SpeedTest(10, "tst 1 : ",
   {
      ushort in01A = (ushort)rand();
      ushort in01B = (ushort)rand();
      ushort in02A = (ushort)rand();
      ushort in02B = (ushort)rand();
      ushort in03A = (ushort)rand();
      ushort in03B = (ushort)rand();
      ushort in04A = (ushort)rand();
      ushort in04B = (ushort)rand();
      ushort in05A = (ushort)rand();
      ushort in05B = (ushort)rand();
      uint param[5];
      param[0] = (uint)in01A << (sizeof(ushort) * 8) | in01B;
      param[1] = (uint)in02A << (sizeof(ushort) * 8) | in02B;
      param[2] = (uint)in03A << (sizeof(ushort) * 8) | in03B;
      param[3] = (uint)in04A << (sizeof(ushort) * 8) | in04B;
      param[4] = (uint)in05A << (sizeof(ushort) * 8) | in05B;
      for(int i = 0; i < 5; i++) sum += param[i];
   });
//--   
   sum = 0;
   union ushortTouint
   {
      uint param[5];
      ushort in[10];
   }U;
   SpeedTest(10, "tst 2 : ",
   {
      ushort in00 = (ushort)rand();
      ushort in01 = (ushort)rand();
      ushort in02 = (ushort)rand();
      ushort in03 = (ushort)rand();
      ushort in04 = (ushort)rand();
      ushort in05 = (ushort)rand();
      ushort in06 = (ushort)rand();
      ushort in07 = (ushort)rand();
      ushort in08 = (ushort)rand();
      ushort in09 = (ushort)rand();
      ushortTouint u;
      u.in[0] = in00;
      u.in[1] = in01;
      u.in[2] = in02;
      u.in[3] = in03;
      u.in[4] = in04;
      u.in[5] = in05;
      u.in[6] = in06;
      u.in[7] = in07;
      u.in[8] = in08;
      u.in[9] = in09;
      for(int i = 0; i < 5; i++) sum += u.param[i];
   });

}

2020.10.15 21:48:01.401 SpeedTst (EURUSD,H1) tst 1 : : : loops=10000000000 ms=10864370

2020.10.15 21:48:12.264 SpeedTst (EURUSD,H1) tst 2 : : : loops=10000000000 ms=10862287

la differenza non è significativa, è altamente probabile che se cambiamo i test nell'ordine opposto, i risultati saranno opposti

non critico

 
Igor Makanu:

non è una differenza significativa, è altamente probabile che se si scambiano i test, i risultati saranno opposti

È molto probabile che il compilatore abbia generato lo stesso codice per entrambi i casi. In questo caso, basta scegliere quello che soggettivamente ti piace di più

 
Igor Makanu:

controllato:

2020.10.15 21:48:01.401 SpeedTst (EURUSD,H1) tst 1 : : : loops=10000000000 ms=10864370

2020.10.15 21:48:12.264 SpeedTst (EURUSD,H1) tst 2 : : : loops=10000000000 ms=10862287

la differenza non è significativa, è altamente probabile che se cambiamo i test nell'ordine opposto, i risultati saranno opposti

non critico

Lo script qui dimostra che il tempo di creazione dei numeri casuali può essere non uniforme e dipende dal volume delle variabili create))

E il codice che ci serve in questo numero di ripetizioni mi prende 0 ms.

Ancora nessuna risposta.

o l'ottimizzatore di codice sta tagliando qualcosa di inutile
 
Alexandr Andreev:

Sembra esserci uno script che dimostra che la tempistica della generazione di numeri casuali può essere disuguale

no rand() è una funzione normale, funziona sempre allo stesso modo

Ma quando si testa la velocità, se lo si inizializza con delle costanti, i test "accelereranno" durante l'esecuzione - l'ottimizzazione del codice in MQL durante l'esecuzione è buona

in generale, è stato controllato molte volte

Alexandr Andreev:

e molto dipende dalla dimensione delle variabili create)))

naturalmente, l'allocazione della memoria richiede tempo, l'ho controllato, sto testando sia oggetti creati dinamicamente ( nuovo puntatore ) che solo oggetti in ambito locale, il test si estende 100500 volte per nuovo + cancellazione

l'intera domanda era, perché nel tester in ambito globale la memoria è allocata alle variabili una volta e non ad ogni passaggio - ma ho bisogno di array uint, così ho testato con questo script, non come l'ho scritto la prima volta

Alexandr Andreev:

E il codice di cui abbiamo bisogno in questo numero di ripetizioni mi prende 0 ms

ancora nessuna risposta

O l'ottimizzatore di codice sta tagliando qualcosa di inutile.

hai usato il mio script? - o non hai aspettato la fine del test e hai interrotto o hai fatto un overflow di ulong - il primo parametro della macro è 10^ count



Andrei Trukhanovich:

è molto probabile che il compilatore abbia generato lo stesso codice per entrambi i casi. in questo caso, basta scegliere quello che soggettivamente ti piace di più.

sì, forse sì

È quello che stavo chiedendo - ho letto molte volte che i processori moderni possono eseguire più di un'operazione elementare per clock ottimizzando la pipeline di istruzioni .... un sacco di bla-bla-bla... e il punto è che le istruzioni aritmetiche sono eseguite dal processore in un numero imprevedibile di cicli di clock

Per quanto riguarda la ramificazione e le operazioni di allocazione della memoria, sono ottimizzate molto male dal processore, quindi non cercate l'ottimizzazione nella semplificazione dell'aritmetica, cercate di scrivere codice massimamente lineare con la minima ramificazione, e le variabili sono meglio dichiarate e assegnate ai valori subito prima dei calcoli, ciò permette alla pipeline delle istruzioni e alla predizione del campionamento della cache di ottimizzare questo codice


Cioè il campionamento dei valori degli elementi nell'array (indirizzamento) molto probabilmente non sarà cruciale per la velocità - ho pensato che ci sarebbe stato un vantaggio di spostamento rispetto all'unione, si scopre che non c'è alcuna differenza

1...287128722873287428752876287728782879288028812882288328842885...3184
Nuovo commento