Eis o que você pode fazer com OpenCL diretamente no MetaTrader 5 sem DLLs - página 5

Novo comentário
 
Renat Fatkhullin:

Neste contexto, a AMD parece vantajosa não apenas devido aos cálculos matemáticos obviamente mais rápidos (as fazendas de mineração são geralmente construídas sobre a AMD), mas também por sua estratégia de padrões abertos (elas se abriram e estão promovendo muito para o público). A introdução do OpenCL 2.0 nos cartões AMD aproximou muito esta especificação das capacidades da CUDA e agora não vale a pena lançar as bases para a CUDA.

Essa é uma informação útil, enquanto há cerca de 7 anos eu brincava com a CUDA e achava que ela ainda governava o jogo.

Minha pergunta é: e quanto aos depuradores para OpenCL hoje em dia? Não estou me referindo ao terminal MT5, mas ao terminal MT5 em geral. Até agora, eu só vi um depurador da Intel como plugin do Visual Studio e um depurador autônomo (depricated) da mesma empresa. Mas parece que são os processadores e gráficos incorporados da Intel que se destinam a esta finalidade. Eu não entendo bem como depurar código paralelo - para mim, ainda é apenas uma caixa preta.

 

Você só pode trabalhar com a CUDA para si mesmo ou para áreas específicas onde você pode exigir a presença explícita de cartões Nvidia.

Sim, a CUDA costumava ter mais características. Entretanto, com o hardware da AMD saindo com OpenCL 2.0 e a nova versão do OpenCL 2.1, não faz sentido ficar sentado sob o bloqueio do fornecedor. Especialmente quando esse fornecedor também diminui a funcionalidade.

Em termos de cobertura máxima, há apenas uma opção - OpenCL, que também funciona bem em processadores normais. Ou seja, você não precisa exigir a presença incondicional da GPU ou escrever duas versões de código para a GPU e a CPU. Uma vez escrito, o código OpenCL funcionará em diferentes configurações.

A CUDA/OpenCL só pode ser depurada em depuradores especializados. Aqui não pode haver milagre.

 
Renat Fatkhullin:

no exemplo

if((cl_ctx=CLContextCreate())==INVALID_HANDLE)

Nas configurações com um dispositivo disponível para CPU, é exibido "OpenCL não encontrado".

Caso contrário.

if((cl_ctx=CLContextCreate(CL_USE_ANY))==INVALID_HANDLE)

obras

*O problema é a seleção padrão do dispositivo

 

Podemos ter tudo isso de uma forma agradável, sem todas as citações? É muito inconveniente para a percepção e a criação.

E para redes neurais devemos ter classes padrão, e é possível usar o opcl instantaneamente) como o wellslab

"#define HL1Count "             + (string)hl1NeuronCount + "                     \r\n"
          "#define HL2Count "             + (string)hl2NeuronCount + "                     \r\n"
          //------------------------------------------------------------------------------------
          "#define NeuronSensitivity  "   + (string)NeuronSensitivity_P + "                \r\n"
          //------------------------------------------------------------------------------------
          "#define sampleCount "          + (string)sampleCount + "                        \r\n"
          //------------------------------------------------------------------------------------
          "#define signalCount "          + (string)signalCount + "                        \r\n"
          //------------------------------------------------------------------------------------
          "#define StrArrSaSize "         + (string)(sizeof(ArrSample) / sizeof(float)) + "\r\n"
          "typedef struct{float C[StrArrSaSize];} ArrSa;                                   \r\n"
          //------------------------------------------------------------------------------------
          "#define StrArrWeSize "         + (string)(sizeof(ArrWe) / sizeof(float)) + "    \r\n"
          "typedef struct{float C[StrArrWeSize];} ArrWe;                                   \r\n"
          //------------------------------------------------------------------------------------
          "#define StrArrCrSize "         + (string)(sizeof(ArrCr) / sizeof(float)) + "    \r\n"
          "typedef struct{float C[StrArrCrSize];}ArrCr;                                    \r\n"
          //------------------------------------------------------------------------------------
          "#define Spread "               + (string)(Spread_P * Point()) + "               \r\n"
          //------------------------------------------------------------------------------------
          "#define Point "                + (string)Point() + "                            \r\n"
          "#define SL "                   + (string)(StopLoss_P * Point()) + "             \r\n"
          "#define TP "                   + (string)(TakeProfit_P * Point()) + "           \r\n"
          //------------------------------------------------------------------------------------
          "                                                                                \r\n"
          "__kernel void Work(__global ArrSa *Sample,                                      \r\n"
          "                   __global ArrWe *Weights,                                     \r\n"
          "                   __global ArrCr *Result)                                      \r\n"
          "{                                                                               \r\n"
          "  int thread       = get_global_id(0);                                          \r\n"
          "                                                                                \r\n"
          "  //------------------Переменные нейронной сети---------------------------------\r\n"
 
Maxim Dmitrievsky:

Podemos ter tudo isso de uma forma agradável, sem todas as citações? É constrangedor para a percepção e criação.

E para redes neurais devemos ter classes padrão, e é possível usar o opcl instantaneamente) como o wellslab

Bem, por que não? Olhe, não há uma única função específica que a MQL não conheça. Usei MQL para escrever e depurar esta função para OCL e depois endureci tudo. Você pode até fazer um conversor de código em OCL, mas não vejo nenhum ponto em particular em fazer isso por mim mesmo. Talvez a MQ o faça, mas duvido que o faça.
 
Renat Fatkhullin:

Esta é uma demonstração não só dos cálculos da GPU no código MQL5, mas também das capacidades gráficas do terminal:

O código-fonte completo como um roteiro está anexado. O erro no OpenCL 1.2 foi corrigido.

Eu também sei bordar. E em uma máquina de escrever... (c) Para que serve todo este terminal comercial?
 
Irá para a nuvem para os agentes?
 
GKS:
Irá para a nuvem para os agentes?
Não
 

Tudo ótimo, mas! Há um grande problema com OCL e em geral com todos os meios de paralelização - muito poucos algoritmos podem ser efetivamente paralelizados. Por que nos exemplos de computação paralela tão populares estão a simulação de ondas, bola caindo sobre uma pirâmide com sua destruição, ou seja, tudo que pode ser quebrado em pequenos pedaços e computado em seu próprio processador.

Para os foros/urso, é claro, estas são redes neurais, várias transformações de Fourier, wavelets, filtros, etc., todos perfeitamente paralelos. Mas existem algoritmos lineares que não podem ser paralelos de forma alguma. Como regra, é quando o resultado da próxima etapa do algoritmo é baseado no resultado da etapa anterior.

Escrevi isto para aqueles que estão pensando que eu vou comprar duas placas de vídeo legais e tudo vai funcionar bem no meu testador.

123456789101112...18
Novo comentário