Avaliação de núcleos de CPU para otimização - página 6

Novo comentário
 
Aqui estão algumas informações de uma fonte sobre a natureza das instruções

Instruções que a E5-2670 não possui:
BMI (Bit Manipulation Instructions) são conjuntos de instruções usados em processadores Intel e AMD para acelerar as operações de manipulação de bits. As IMC não são instruções SIMD e funcionam somente com registros universais de processadores.
As operações de manipulação de bits são mais freqüentemente utilizadas por aplicações projetadas para controle de dispositivos de baixo nível, detecção e correção de erros, otimização, compressão e criptografia. O uso do IMC por programas acelera significativamente estas operações (às vezes por um fator de vários); no entanto, o código do programa torna-se mais difícil de ser escrito pelos programadores.
Os conjuntos de instruções BMI em processadores Intel e AMD diferem significativamente.
Os processadores Intel usam BMI1 e BMI2 (além do BMI1).
Os processadores AMD usam instruções ABM (Advanced Bit Manipulation) que fazem parte do pacote SSE4a (estas instruções também são usadas pela Intel, mas são implementadas como parte do SSE4.2 e do BMI1). Além disso, os processadores AMD utilizam o conjunto de instruções TBM (Trailing Bit Manipulation), que é uma extensão do IMC1.

F16C é um conjunto de instruções usado em processadores x86 para acelerar as conversões entre números binários de meia-precisão (16 bits) e números binários padrão de ponto flutuante de precisão única (32 bits).
O F16C é usado tanto em processadores AMD quanto Intel, ampliando drasticamente suas capacidades para lidar com dados multimídia, bem como com outros tipos de dados.
F16C (16-bit Floating-Point conversion) - é um conjunto de instruções usado em processadores x86 para acelerar as conversões entre números binários de meia precisão (16 bits) e números binários padrão de ponto flutuante de precisão única (32 bits). É essencialmente uma extensão das instruções SSE básicas de 128 bits.
O uso de diferentes números de precisão na engenharia informática é um compromisso entre a precisão e a gama de valores representados, necessários para alcançar um desempenho de alta velocidade e uma ampla gama de tarefas a serem realizadas.
O F16C foi usado pela primeira vez nos processadores AMD em 2009, embora tenha sido desenvolvido muito antes e era conhecido como CVT16. A CVT16 foi originalmente planejada como parte do pacote SSE5, nunca lançado, que deveria incluir instruções XOP e BMI4.
Atualmente, o conjunto de instruções F16C é usado tanto em processadores AMD quanto Intel, ampliando significativamente suas capacidades em termos de manuseio de dados multimídia, bem como outros tipos de dados.

FMA
Um conjunto de instruções do processador acelerando a multiplicação do ponto flutuante e as operações de adição. FMA é um acrônimo para Fused Multiply-Add, que significa multiplicação e adição de uma única volta.
As operações Multiply-Add são muito comuns e desempenham um papel importante na tecnologia da computação. Especialmente quando se trata de processamento digital de sinais analógicos (codificação binária de vídeo e áudio e outras operações similares). Por causa disso, o suporte às instruções FMA foi incorporado não apenas nas CPUs, mas também nas GPUs de muitas das placas gráficas atuais.

Instruções que todos, exceto a i7-8700, não têm:
TSX (Transactional Synchronization eXtensions) é um conjunto de instruções de processadores multi-core desenvolvido pela Intel que melhora a eficiência dos núcleos que se comunicam entre si quando compartilham os mesmos dados e, em última análise, aumenta o desempenho geral do computador.

MPX (Memory Protection Extensions) - Uma tecnologia que proporciona maior proteção contra vírus e outras ameaças usando mecanismos de buffer overflow.
O processador pode examinar os limites do buffer de pilha e pilha antes de acessar a memória para garantir que as aplicações que acessam a memória acessem somente a área de memória alocada a elas. Isto torna muito mais difícil para um hacker ou programa malware "substituir" seu código para a CPU via memória.

SGX (Software Guard Extensions) - um conjunto de instruções desenvolvido pela Intel e utilizado em seus processadores, começando com a arquitetura Skylake.
O SGX permite que seções protegidas de código e dados (chamados "enclaves") forneçam um alto nível de proteção para programas em execução contra aplicações maliciosas e ataques de hackers.


BMI2 (complementar ao BMI1).

Como MPX e SGX são sobre proteção, eu me atreveria a adivinhar que o compilador usa ativamente as instruções/tecnologias BMI2 e há um efeito do TSX, o que é menos provável.

 
Alexey, parece-me que seria mais eficiente aprender a escrever código para o OpenCL e comprar um bom cartão para isso.
O OpenCL em uma placa será a priori muito mais eficiente do que vários processadores.
E esqueça este inconveniente de comparar processadores.
Mas sim, você tem que descobrir como escrever código para o OpenCL.
Não posso realmente dizer o quanto é informativo - tenho tentado lê-lo por conta própria.
 
Roman:
Alexey, acho que seria mais eficiente aprender a escrever o código OpenCL e obter um bom cartão para isso.
O OpenCL em uma placa será a priori muito mais eficiente do que vários processadores.
E esqueça este inconveniente de comparar processadores.
Mas sim, você tem que descobrir como escrever código para o OpenCL.
Não posso realmente dizer o quanto é informativo - tenho tentado lê-lo por conta própria.

Não é tão fácil escrever em OpenCL, estudei um pouco a teoria, é mais fácil fazer um agente com tecnologia OpenCL, não como agora, mais fácil em termos de consumidores.

E então, o OpenCL nem sempre é eficiente, então eu estava comparando no software da placa Yandex(CatBoost) 1060 e do processador FX-8350 - descobri que o processador é duas vezes mais rápido, e se essa tendência é economicamente mais lucrativa para comprar um processador poderoso do que cinco 1080i, do qual certamente haverá um efeito, mas caro ... em geral, não é claro e não é uma solução para todos.

E então, eu acho que no compilador você pode simplesmente desativar o suporte para as tecnologias mais recentes e para os veteranos tudo funcionará mais rápido, a opção de desativar.
 
Aleksey Vyazmikin:

Não é tão fácil escrever em OpenCL, estudei um pouco a teoria, é mais fácil fazer um agente com tecnologia OpenCL, não como agora, mais fácil em termos de consumidores.

E então, o OpenCL nem sempre é eficiente, então eu estava comparando no software da placa Yandex (CatBoost) 1060 e do processador FX-8350 - descobri que o processador é duas vezes mais rápido, e se essa tendência é economicamente mais lucrativa para comprar um processador potente do que cinco 1080i, do qual certamente haverá um efeito, mas caro ... em geral, não é claro e não é uma solução para todos.

Para cálculos matemáticos, os verdes não são particularmente adequados.
Os vermelhos são melhores para matemática, eles têm até mesmo um modo matemático como padrão, que pode ser configurado através do aplicativo oficial.
Tenho uma antiga referência Radeon 7970, ela ainda suporta a mineração. Isso não quer dizer que eu minere em um cartão, não é lucrativo, mas que puxa os cálculos.
Para cálculos matemáticos no cartão, você precisa olhar para o número de shaders, quanto mais deles, melhor, o resto dos fps, etc. não importa, mais importante os blocos de sombreamento.


 
Roman:

Para cálculos matemáticos, os verdes não são particularmente adequados.
Para as matemáticas, as vermelhas são melhores. Elas têm até um modo matemático como padrão, que pode ser configurado através do aplicativo oficial.
Tenho uma antiga referência Radeon 7970, ela ainda suporta a mineração. Isto não quer dizer que eu minto em um cartão, não é lucrativo, mas que ele puxa os cálculos.
Para cálculos matemáticos no cartão, você precisa olhar para o número de shaders, quanto mais deles, melhor, o resto dos fps, etc. não importa, mais importante os blocos de shader.


Tanto quanto sei, os vermelhos só sabem trabalhar com o dobro e os verdes não - eu sei disso. Mas, no aprendizado de máquinas (CatBoost) há uma afiação nas operações de comparação, que por idéia deve funcionar tão rápido quanto em vermelho e verde. E os vermelhos não são suportados pela CatBoost, infelizmente.

Em qualquer caso, eu mesmo não posso fazer isso, e os artistas não foram tão fáceis de encontrar por um preço e compreensão adequados.

 

Foi-me sugerido que o código poderia ser acelerado utilizando a enumeração do switch.

Costumava ser assim:

         if(Type_Poisk_Tree==Tree_Buy_Filter || Type_Poisk_Tree==Tree_Sell_Filter || Type_Poisk_Tree==Tree_Buy || Type_Poisk_Tree==Tree_Sell)
           {
            if(Test_P>=1000 && Test_P<5000)
              {
               if(Test_P<2500)
                 {
                  if(Test_P==1000)if(DonProc<5.5 && Levl_Down_DC<-7.5) CalcTest=CalcTest+1; //(0.4810127 0.3037975 0.2151899)
                  if(Test_P==1001)if(DonProc< 5.5 && Levl_Down_DC>=-7.5 && TimeH< 21.5 && TimeH>=16.5 && TimeH< 19.5 && Levl_Close_H1s1N< 2.5) CalcTest=CalcTest+1; //(0.4400657 0.4072250 0.1527094)
                  if(Test_P==1002)if(DonProc< 5.5 && Levl_Down_DC>=-7.5 && TimeH< 21.5 && TimeH>=16.5 && TimeH< 19.5 && Levl_Close_H1s1N>=2.5) CalcTest=CalcTest+1; //(0.3739837 0.5121951 0.1138211)
                  if(Test_P==1003)if(DonProc<5.5 && Levl_Down_DC>=-7.5 && TimeH<21.5 && TimeH>=16.5 && TimeH>=19.5) CalcTest=CalcTest+1; //(0.3390706 0.4647160 0.1962134)
                //Ещё 70к сравнений
                }

E agora é assim:

         if(Type_Poisk_Tree==Tree_Buy_Filter || Type_Poisk_Tree==Tree_Sell_Filter || Type_Poisk_Tree==Tree_Buy || Type_Poisk_Tree==Tree_Sell)
           {
                  switch(Test_P)
                    {
                     case 1000: if(DonProc<5.5 && Levl_Down_DC<-7.5) CalcTest=CalcTest+1; break; //(0.4810127 0.3037975 0.2151899)
                     case 1001: if(DonProc< 5.5 && Levl_Down_DC>=-7.5 && TimeH< 21.5 && TimeH>=16.5 && TimeH< 19.5 && Levl_Close_H1s1N< 2.5) CalcTest=CalcTest+1; break; //(0.4400657 0.4072250 0.1527094)
                     case 1002: if(DonProc< 5.5 && Levl_Down_DC>=-7.5 && TimeH< 21.5 && TimeH>=16.5 && TimeH< 19.5 && Levl_Close_H1s1N>=2.5) CalcTest=CalcTest+1; break; //(0.3739837 0.5121951 0.1138211)
                     case 1003: if(DonProc<5.5 && Levl_Down_DC>=-7.5 && TimeH<21.5 && TimeH>=16.5 && TimeH>=19.5) CalcTest=CalcTest+1; break; //(0.3390706 0.4647160 0.1962134)
                     //ещё 70к сравнений
                   }

De acordo com as primeiras estimativas, FX-8350 é 30% mais rápido, mas os processadores Phenom II são cerca de 3 vezes mais rápidos! Farei testes comparativos mais tarde, quando as máquinas estiverem livres de otimização.

Estou anexando a nova versão do Tree_Brut_TestPL Expert Advisor, e adicionei "_Fast" ao seu nome. Por favor, teste-o também, pois é muito interessante saber em quais arquiteturas o ganho será. Há uma esperança de que estas pesquisas ajudem a melhorar o compilador ME.

Arquivos anexados:
Tree_Brut_TestPL_F_Fast.zip  2399 kb
 

Recebi dados adicionais do membro do fórumFast528 (atualmente incapaz de postar no fórum)

Ryzen 2700 não overclocked, memória 3333

Árvore_Brut_TestPL 8 núcleos 16 fios

2019.08.13 10:24:14.813 Tester optimization finished, total passes 11
2019.08.13 10:24:14.824 Statistics optimization done in 1 minutes 56 seconds
2019.08.13 10:24:14.824 Statistics shortest pass 0:01:13.337, longest pass 0:01:20.403, average pass 0:01:15.853
2019.08.13 10:24:14.824 Statistics 8731 frames (3.43 Mb total, 412 bytes per frame) received
2019.08.13 10:24:14.824 Statistics local 11 tasks (100%), remote 0 tasks (0%), cloud 0 tasks (0%)
2019.08.13 10:24:14.864 Tester 11 new records saved to cache file 'tester\cache\Tree_Brut_TestPL.30.E415F787BBBCE67C438526613B41CB4F.opt'

Árvore_Brut_TestPL_F8 núcleos 16 fios

2019.08.13 10:24:14.824 Statistics 8731 frames (3.43 Mb total, 412 bytes per frame) received
2019.08.13 10:31:30.562 Tester optimization finished, total passes 11
2019.08.13 10:31:30.573 Statistics optimization done in 2 minutes 32 seconds
2019.08.13 10:31:30.573 Statistics shortest pass 0:02:12.689, longest pass 0:02:31.529, average pass 0:02:21.243
2019.08.13 10:31:30.573 Statistics 11000 frames (4.32 Mb total, 412 bytes per frame) received
2019.08.13 10:31:30.573 Statistics local 11 tasks (100%), remote 0 tasks (0%), cloud 0 tasks (0%)
2019.08.13 10:31:30.626 Tester 11 new records saved to cache file 'tester\cache\Tree_Brut_TestPL_F.30.E415F787BBBCE67C438526613B41CB4F.opt'

Este teste não está completo, pois precisamos de uma variante com 8 núcleos e 8 fios devido à ativação de 8 agentes e também 16 passes devem ser especificados na guia "Otimização" - de acordo com o número de fios (Início 0, Passo 1, Parada 15).

Ao executar o teste novamente, não se esqueça de limpar o cache, que está localizado em ... Testador

Acrescentarei os resultados intermediários à tabela por enquanto como 8 núcleos / 8 agentes.

 

Infelizmente eu não posso mais editar o primeiro post, então estou postando a classificação aqui

 

Aqui está o resultado da freqüência fx8320e de 4GHz, memória 1866 2 canais, posição 2.

Árvore_Brut_TestPL_F_F_Fast

4 agentes 8 passes

DF      0       13:27:26.728    Core 4  pass 6 returned result 1001000.00 in 0:00:28.342
HL      0       13:27:26.732    Core 1  pass 2 returned result 1001000.00 in 0:00:28.414
PE      0       13:27:26.844    Core 3  pass 4 returned result 1001000.00 in 0:00:28.476
PJ      0       13:27:26.936    Core 2  pass 0 returned result 1001000.00 in 0:00:28.619
QP      0       13:27:53.132    Core 4  pass 7 returned result 1001000.00 in 0:00:26.406
KI      0       13:27:53.219    Core 1  pass 3 returned result 1001000.00 in 0:00:26.489
MN      0       13:27:53.337    Core 3  pass 5 returned result 1001000.00 in 0:00:26.495
ND      0       13:27:53.571    Core 2  pass 1 returned result 1001000.00 in 0:00:26.637
OR      0       13:27:53.571    Tester  optimization finished, total passes 8
OF      0       13:27:53.582    Statistics      optimization done in 0 minutes 57 seconds
PI      0       13:27:53.582    Statistics      shortest pass 0:00:26.406, longest pass 0:00:28.619, average pass 0:00:27.484
NM      0       13:27:53.582    Statistics      8000 frames (3.14 Mb total, 412 bytes per frame) received
HL      0       13:27:53.582    Statistics      local 8 tasks (100%), remote 0 tasks (0%), cloud 0 tasks (0%)

8 agentes 8 passes

DI      0       13:30:59.789    Core 2  pass 1 returned result 1001000.00 in 0:00:33.072
KN      0       13:30:59.887    Core 1  pass 0 returned result 1001000.00 in 0:00:33.177
PD      0       13:31:00.132    Core 3  pass 2 returned result 1001000.00 in 0:00:33.422
PM      0       13:31:00.245    Core 4  pass 3 returned result 1001000.00 in 0:00:33.531
RR      0       13:31:00.590    Core 8  pass 7 returned result 1001000.00 in 0:00:32.922
IH      0       13:31:00.615    Core 5  pass 4 returned result 1001000.00 in 0:00:33.197
CQ      0       13:31:00.981    Core 6  pass 5 returned result 1001000.00 in 0:00:33.506
GF      0       13:31:01.111    Core 7  pass 6 returned result 1001000.00 in 0:00:33.614
CS      0       13:31:01.111    Tester  optimization finished, total passes 8
KG      0       13:31:01.122    Statistics      optimization done in 0 minutes 35 seconds
RN      0       13:31:01.122    Statistics      shortest pass 0:00:32.922, longest pass 0:00:33.614, average pass 0:00:33.305
NO      0       13:31:01.122    Statistics      8000 frames (3.14 Mb total, 412 bytes per frame) received
HJ      0       13:31:01.122    Statistics      local 8 tasks (100%), remote 0 tasks (0%), cloud 0 tasks (0%)

8 agentes quase 2x mais rápido

 
Maxim Romanov:

Aqui está o resultado da freqüência fx8320e de 4GHz, memória 1866 2 canais, posição 2.

Árvore_Brut_TestPL_F_F_Fast

4 agentes 8 passes

8 agentes 8 passes

8 agentes quase 2x mais rápido

Obrigado, mas acrescente Tree_Brut_TestPL_F e Tree_Brut_TestPL resultados para avaliação !

12345678910111213...22
Novo comentário