Esto es lo que puedes hacer con OpenCL directamente en MetaTrader 5 sin ninguna DLL - página 5

Nuevo comentario
 
Renat Fatkhullin:

En este contexto, AMD parece ventajosa no sólo por la evidente rapidez de los cálculos matemáticos (las granjas de minería suelen estar construidas sobre AMD), sino también por su estrategia de estándares abiertos (se han abierto y están promocionando mucho al público). La introducción de OpenCL 2.0 en las tarjetas de AMD ha acercado mucho esta especificación a las capacidades de CUDA y ahora no tiene sentido preparar el terreno para CUDA.

Esa es una información útil, mientras que hace unos 7 años estaba jugando con CUDA y pensaba que todavía domina el juego.

Mi pregunta es: ¿qué pasa con los depuradores de OpenCL hoy en día? No me refiero al terminal MT5 sino al terminal MT5 en general. Hasta ahora, sólo he visto un depurador de Intel como un plugin de Visual Studio y un depurador independiente (deprimido) de la misma empresa. Pero parece que son los procesadores y los gráficos integrados de Intel los que están destinados a este fin. No entiendo bien cómo depurar el código paralelo en absoluto - para mí es sólo una caja negra todavía.

 

Sólo se puede trabajar con CUDA para uno mismo o para áreas específicas donde se puede exigir la presencia explícita de las tarjetas Nvidia.

Sí, CUDA solía tener más funciones. Sin embargo, con el hardware de AMD que va a salir con OpenCL 2.0 y la nueva versión de OpenCL 2.1, no tiene sentido quedarse encerrado en el proveedor. Especialmente cuando ese vendedor también rebaja la funcionalidad.

En términos de máxima cobertura, sólo hay una opción: OpenCL, que también funciona bien en procesadores normales. Es decir, no hay que exigir la presencia incondicional de la GPU ni escribir dos versiones de código para la GPU y la CPU. Una vez escrito, el código OpenCL funcionará en diferentes configuraciones.

CUDA/OpenCL sólo puede depurarse en depuradores especializados. Aquí no puede haber ningún milagro.

 
Renat Fatkhullin:

en el ejemplo

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

En las configuraciones con un dispositivo con CPU disponible, se muestra "OpenCL no encontrado".

Por lo demás.

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

funciona

*El problema es la selección de dispositivos por defecto

 

¿Podemos tener todo esto en una forma agradable, sin todas las comillas? Es incómodo para la percepción y la creación.

Y para las redes neuronales deberíamos tener clases estándar, y es posible usar opcl instantáneamente) como 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 tener todo esto en una forma agradable, sin todas las comillas? Es incómodo para la percepción y la creación.

Y para las redes neuronales deberíamos tener clases estándar, y es posible usar opcl instantly) como wellslab

¿Por qué no? Mira, no hay una sola función específica que MQL no conozca. Utilicé MQL para escribir y depurar esta función para la OCL y luego lo endurecí todo. Incluso se puede hacer un convertidor de código en OCL, pero no veo ningún sentido en hacerlo para mí. Tal vez MQ lo haga, pero lo dudo.
 
Renat Fatkhullin:

Esta es una demostración no sólo de los cálculos de la GPU en el código MQL5, sino también de las capacidades gráficas del terminal:

Se adjunta el código fuente completo en forma de script. Se ha corregido el error en OpenCL 1.2.

También sé bordar. Y en una máquina de escribir... (c) ¿Para qué sirve toda esta terminal de comercio?
 
¿ Se va a ir a la nube para los agentes ?
 
GKS:
¿ Se va a ir a la nube para los agentes ?
No
 

Hay un gran problema con la OCL y, en general, con todos los medios de paralelización: muy pocos algoritmos se pueden paralelizar de forma efectiva. Por qué en los ejemplos de computación paralela tan populares son la simulación de las olas, la bola que cae en una pirámide con su destrucción, es decir, todo lo que se puede dividir en trozos pequeños y calcular en su propio procesador.

En el caso de Fora/Oso, por supuesto, se trata de redes neuronales, diversas transformadas de Fourier, ondículas, filtros, etc., todos ellos perfectamente paralelos. Pero hay algoritmos lineales que no pueden ser paralelos en absoluto. Por regla general, es cuando el resultado del siguiente paso del algoritmo se basa en el resultado del paso anterior.

He escrito esto para los que están pensando que voy a comprar dos tarjetas de vídeo geniales y todo funcionará bien en mi probador.

123456789101112...18
Nuevo comentario