Erros, bugs, perguntas - página 2878

Novo comentário
 
Igor Makanu:

qual variante de conversão funcionará mais rapidamente durante a optimização

Isto só será chamado uma vez por passe. Por conseguinte, não faz qualquer diferença.

 
fxsaber:

Isto só será chamado uma vez para toda a passagem. Portanto, não faz qualquer diferença.

por isso, sim... Mas vou executá-lo durante alguns dias para optimização, quero medir o desempenho de alguma forma ..... embora suspeite que a variante 1 será mais eficiente, não haverá 100500 vezes de cópia em matrizes

 
Igor Makanu:

sim... Mas vou executar o computador durante alguns dias para o optimizar, quero medir o desempenho de alguma forma ..... embora suspeite que a opção 1 será mais eficiente, não haverá 100500 vezes de cópia para as matrizes

Portanto, a variante 2 é muito provavelmente mais rápida, mas, como já assinalou, não importa.
 
TheXpert:
união não é copiar para matrizes, é uma interpretação diferente do mesmo espaço de memória. por isso a 2ª opção é provavelmente mais rápida, mas como já foi referido acima, não importa.
A União não é tão rápida como parece. Infelizmente.
Estou a apostar no primeiro.
 
Igor Makanu:

sim... Mas vou executar o computador durante alguns dias para o optimizar, quero medir o desempenho de alguma forma ..... embora suspeite que a opção 1 será mais eficiente, não haverá 100500 vezes de cópia para as matrizes

há uma maneira antiga de medir a velocidade

no estilo de

para (int i=0; i< 1000000; i++) {nosso código1}
para (int i=0; i< 1000000; i++) {nosso código2}....

 
Nikolai Semko:
A união não é tão rápida como parece. Aposto no primeiro.

Aposto também no primeiro! Os operadores binários são várias vezes mais rápidos do que o se operador, embora o segundo não o tenha.

 

verificado:

#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

a diferença não é significativa, é altamente provável que se mudarmos os testes na ordem oposta, os resultados sejam o oposto

não crítico

 
Igor Makanu:

não uma diferença significativa, é altamente provável que, se trocar os testes, os resultados sejam o oposto

É altamente provável que o compilador tenha gerado o mesmo código para ambos os casos. Neste caso, basta escolher o que mais lhe agrada subjectivamente

 
Igor Makanu:

verificado:

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

a diferença não é significativa, é altamente provável que se mudarmos os testes na ordem oposta, os resultados sejam o oposto

não crítico

O script aqui demonstra que o tempo de criação do número aleatório pode ser desigual e depende do tamanho das variáveis criadas))))

E o código de que precisamos neste número de repetições leva-me 0 ms.

Ainda sem resposta.

ou o optimizador de código está a cortar algo desnecessário
 
Alexandr Andreev:

Parece haver um guião que demonstra que o momento da geração de números aleatórios pode ser desigual

nenhum rand() é uma função normal, funciona sempre da mesma forma

Mas ao testar a velocidade, se a inicializar com constantes, os testes "aceleram" na execução - a optimização do código em MQL durante o tempo de execução é boa

em geral, foi verificado muitas vezes

Alexandr Andreev:

e muito depende do tamanho das variáveis criadas))))

claro, a atribuição de memória é demorada, verifiquei-a, estou a testar tanto objectos criados dinamicamente ( novo ponteiro ) como apenas objectos de âmbito local, o teste estica-se 100500 vezes por novo + apagar

toda a questão foi, porque no testador no âmbito global a memória é atribuída às variáveis uma vez e não a cada passagem - mas preciso de arrays uint, por isso testei com este guião, não como o escrevi da primeira vez

Alexandr Andreev:

E o código de que precisamos neste número de repetições leva-me 0 ms

ainda sem resposta

Ou o optimizador de códigos está a cortar algo desnecessário.

usou o meu guião? - ou não esperou até ao fim do teste e interrompeu ou transbordou ulong - o primeiro parâmetro macro é 10^ contagem



Andrei Trukhanovich:

é altamente provável que o compilador tenha gerado o mesmo código para ambos os casos. neste caso, basta escolher aquele que mais lhe agrada subjectivamente.

sim, talvez sim

era isso que eu estava a pedir - li muitas vezes que os processadores modernos podem executar mais do que uma operação elementar por relógio optimizando o pipeline de instruções .... muito blá, blá, blá, blá... e a questão é que as instruções aritméticas são executadas pelo processador num número imprevisível de ciclos de relógio

Quanto às operações de ramificação e alocação de memória, são muito mal optimizadas pelo processador, por isso não procure a optimização na simplificação da aritmética, tente escrever código linear máximo com ramificações mínimas, e as variáveis são melhor declaradas e atribuídas valores imediatamente antes dos cálculos, o que permite uma pipeline de instruções e uma previsão de amostragem em cache para optimizar este código


Isto é, os valores de amostragem dos elementos da matriz (endereçamento) muito provavelmente não serão cruciais para a velocidade - pensei que haveria uma vantagem de mudança versus união, afinal não há qualquer diferença

1...287128722873287428752876287728782879288028812882288328842885...3184
Novo comentário