Mi enfoque. El núcleo es el motor. - página 123

Nuevo comentario
 
Реter Konow:

...

ZS. Es posible, sin embargo, que el procesador se esté sobrecargando al redibujar. Es decir, dibujar dentro de una matriz de píxeles. En otras palabras, la inicialización constante de la matriz con valores, que se produce a alta (16ms) frecuencia del temporizador.

No, el redibujado no carga el procesador de ninguna manera; tarda unos nano o, como mucho, microsegundos en enviar una orden al controlador de gráficos. El procesador de la tarjeta de vídeo realiza el pintado por sí mismo, píxel a píxel, mientras que suele haber cientos de ellos y trabajan simultáneamente con el procesador en paralelo. Es decir, el procesador emite la orden al controlador gráfico: mostrar un círculo con el centro en las coordenadas de pantalla Xc, Yc y radio R en modo CopyPut. Para el procesador esto es sólo una llamada a una función con parámetros pasados. No va más allá de esto. Tales llamadas que hace no más a menudo que, por ejemplo, 2 veces por segundo, de lo contrario el usuario simplemente no puede entender nada en la pantalla, no se puede tirar tan a menudo. Para una lista de operaciones abiertas, puede imaginarse que puede tardar una hora o un día o más.

Y el algoritmo (busca en Google "Algoritmo Bresenham", por ejemplo) de coloreado píxel a píxel lo ejecuta la tarjeta gráfica, y el procesador no se entretiene en ello. También se ejecuta muy rápidamente. Y... una vez por llamada. No es necesaria la reinicialización a los 16ms, la imagen de la pantalla se almacena permanentemente en la memoria de vídeo hasta un nuevo cambio a la orden del procesador. No sólo eso, la memoria de vídeo también se mantiene por duplicado para acelerar la respuesta de la pantalla visible, los cambios se realizan en la invisible, y luego se cambia la página de vídeo inmediatamente.

Si su enfoque de la salida de la pantalla todavía tiene la " inicialización constante de la matriz" de píxeles que usted describe - usted debe deshacerse de él, no es el caso.

 
Реter Konow:

Haga clic para ver.

Hay un problema con los datos de la columna de la hora de apertura en la imagen.

 
Vladimir:

No, el redibujado no carga el procesador de ninguna manera; tarda como mucho unos nano o microsegundos en enviar una orden al controlador de gráficos. Los procesadores de la tarjeta de vídeo realizan el pintado propiamente dicho, píxel a píxel, y suelen ser cientos y trabajan simultáneamente con el procesador, en paralelo. Es decir, el procesador emite la orden al controlador gráfico: mostrar un círculo con el centro en las coordenadas de pantalla Xc, Yc y radio R en modo CopyPut. Para el procesador esto es sólo una llamada a una función con parámetros pasados. No va más allá de esto. Tales llamadas que hace no más a menudo que, por ejemplo, 2 veces por segundo, de lo contrario el usuario simplemente no puede entender nada en la pantalla, no se puede tirar tan a menudo. Para una lista de operaciones abiertas, puede imaginarse que puede tardar una hora o un día o más.

Y el algoritmo (busca en Google "Algoritmo Bresenham", por ejemplo) de coloreado píxel a píxel lo ejecuta la tarjeta gráfica, y el procesador no se entretiene en ello. También se ejecuta muy rápidamente. Y... una vez por llamada. No es necesario reiniciar a los 16ms, la imagen de la pantalla se mantiene constante en la memoria de vídeo hasta que se realiza un nuevo cambio a la orden del procesador. No sólo eso, para acelerar la respuesta de la pantalla visible, la memoria de vídeo también se mantiene en dos instancias, los cambios se hacen en la invisible, después de lo cual la página de vídeo se cambia inmediatamente.

Si su enfoque de la salida de la pantalla todavía tiene la " inicialización permanente de la matriz" de píxeles que usted describe - usted debe deshacerse de él, no es el caso.

Qué lío...
Es una mezcla de conocimientos fragmentarios...

Al final, no es así como funciona.

 
Vladimir:

No, el redibujado no carga el procesador de ninguna manera; tarda como mucho unos nano o microsegundos en enviar una orden al controlador de gráficos. Los procesadores de la tarjeta de vídeo realizan el pintado propiamente dicho, píxel a píxel, y suelen ser cientos y trabajan simultáneamente con el procesador, en paralelo. Es decir, el procesador emite la orden al controlador gráfico: mostrar un círculo con el centro en las coordenadas de pantalla Xc, Yc y radio R en modo CopyPut. Para el procesador esto es sólo una llamada a una función con parámetros pasados. No va más allá de esto. Tales llamadas que hace no más a menudo que, por ejemplo, 2 veces por segundo, de lo contrario el usuario simplemente no puede entender nada en la pantalla, no se puede tirar tan a menudo. Para una lista de operaciones abiertas, puede imaginarse que puede tardar una hora o un día o más.

Y el algoritmo (busca en Google "Algoritmo Bresenham", por ejemplo) de coloreado píxel a píxel lo ejecuta la tarjeta gráfica, y el procesador no se entretiene en ello. También se ejecuta muy rápidamente. Y... una vez por llamada. No es necesario reiniciar a los 16ms, la imagen de la pantalla se mantiene constante en la memoria de vídeo hasta que se realiza un nuevo cambio a la orden del procesador. Y no sólo eso, para acelerar la respuesta de la pantalla visible, la memoria de vídeo también se mantiene por duplicado, los cambios se realizan en la invisible y luego se cambia inmediatamente a la página de vídeo.

Si su enfoque de la salida todavía tiene la " inicialización constante de la matriz" de píxeles - usted necesita para deshacerse de él.

Tienes una teoría interesante, aunque no encaja del todo con los resultados de mis experimentos, que publicaré a continuación.

Como muestra la prueba, es la inicialización de la matriz de píxeles lo que más carga la CPU.

Comprueba la prueba EA que aparece a continuación.

 

Tengo que admitir que me sorprendieron un poco los resultados de la prueba.

Por lo tanto, estamos hablando de llamadas constantes a funciones con una frecuencia de 16 ms.

Resulta que es la inicialización de la matriz de píxeles durante el dibujo lo que más carga al procesador.

Pero lo más extraño fue que la repetida llamada a la función

ObjectSetInteger(0,"MT object",OBJPROP_SELECTED,1);

cargaría el procesador entre un 10 y un 15%.

Además, las llamadas

   ObjectSetString(0,"MT object",OBJPROP_BMPFILE,"::MT object");  

   ObjectSetString(0,"MT object",OBJPROP_TEXT,"QWERTY");

cargar el procesador en el mismo 10-15%.

Al mismo tiempo, las llamadas simultáneas de las tres funciones

ObjectSetInteger(0,"MT object",OBJPROP_SELECTED,1);
   
ObjectSetString(0,"MT object",OBJPROP_BMPFILE,"::MT object");  

ObjectSetString(0,"MT object",OBJPROP_TEXT,"QWERTY");

No provoca el apilamiento de la carga. La carga sigue siendo del 10-15%.

Sin embargo, si a estas llamadas se les añade un bucle constante de reinicialización de arrays de un millón de celdas

for(int a1 = 0; a1 < 1000000; a1++)Arr[a1] = MathRand();

entonces la carga de la CPU sube al 50%.

//-----------------------------------------------------------------------------------------------------------------------------------------------------

La función en sí misma

ResourceCreate("::MT object",Arr,1000000,1,0,0,0,COLOR_FORMAT_XRGB_NOALPHA);

no carga el procesador.

La función

ResourceReadImage("::MT object",Arr,w,h);

cargará de 0 a 5% dependiendo del tamaño de la matriz Arr[].

 

Aquí hay un asesor de prueba. Tienes que comentar las líneas y comprobar la carga de la CPU en el administrador de tareas.

Archivos adjuntos:
Test_1.mq4  11 kb
 

Aquí está su código:

//+------------------------------------------------------------------+
//|                                                       Test_1.mq4 |
//|                                                      Peter Konow |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Peter Konow"
#property link      "https://www.mql5.com"
#property version   "1.00"
#property strict
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
uint Arr[1000000];
//+------------------------------------------------------------------+
int OnInit()
  {
//--- create timer
   EventSetMillisecondTimer(16); 
   //----------------------------------------------------
   //Создаем МТ-объект.
   //----------------------------------------------------
   ObjectCreate(0,"MT object",OBJ_BITMAP_LABEL,0,0,0);
   //----------------------------------------------------
   //Соединяем с файлом.
   //----------------------------------------------------   
   ObjectSetString(0,"MT object",OBJPROP_BMPFILE,"::MT object");
   //----------------------------------------------------
   //Создаем ресурс.
   //----------------------------------------------------
   ResourceCreate("::MT object",Arr,1000000,1,0,0,0,COLOR_FORMAT_XRGB_NOALPHA);   
   //----------------------------------------------------  
//---
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
//--- destroy timer
   EventKillTimer();
   
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//---
   
  }
//+------------------------------------------------------------------+
//| Timer function                                                   |
//+------------------------------------------------------------------+
void OnTimer()
  {
//---
   uint w = 0,h = 0;
   string name;
   //----------------------------------------------------
   //Читаем свойство bool.//Нагрузка процессора отсутствует.
   //----------------------------------------------------
   ObjectGetInteger(0,"MT object",OBJPROP_SELECTED);
   //----------------------------------------------------
   
   //----------------------------------------------------
   //Устанавливаем свойство bool.//Нагрузка процессора: 10% - 15%.
   //----------------------------------------------------
   ObjectSetInteger(0,"MT object",OBJPROP_SELECTED,1);
   //---------------------------------------------------- 
   
   //---------------------------------------------------- 
   //Перерисовываем изображение в массиве Arr[].
   //Нагрузка процессора зависит от размера массива. 
   //При 10000 ячеек, нагрузки нет, при 1000000 ячеек, - ~35%.
   //---------------------------------------------------- 
   for(int a1 = 0; a1 < 1000000; a1++)Arr[a1] = MathRand();
   //---------------------------------------------------- 
   
   //---------------------------------------------------- 
   //Пересоздаем ресурс.//Нагрузка процессора отсутствует
   //при любом размере массива.
   //----------------------------------------------------
   ResourceCreate("::MT object",Arr,1000000,1,0,0,0,COLOR_FORMAT_XRGB_NOALPHA);   
   //---------------------------------------------------- 
   
   //----------------------------------------------------
   //Читаем ресурс.
   //Нагрузка процессора зависит от размера массива. 
   //При 10000 ячеек, нагрузки нет, при 1000000 ячеек, 
   //Нагрузка "плавает" от 1 до 6%.   
   //----------------------------------------------------
   ResourceReadImage("::MT object",Arr,w,h);     
   //----------------------------------------------------
   
   //----------------------------------------------------
   //Пересоединяем с файлом.//Нагрузка процессора: 10% - 15%
   //----------------------------------------------------   
   ObjectSetString(0,"MT object",OBJPROP_BMPFILE,"::MT object");  
   //----------------------------------------------------
   
   //----------------------------------------------------
   //Устанавливаем описание объекта.//Нагрузка процессора: 10% - 15%
   //---------------------------------------------------- 
   ObjectSetString(0,"MT object",OBJPROP_TEXT,"QWERTY");   
   //----------------------------------------------------
   
   //----------------------------------------------------
   //Читаем описание объекта.//Нагрузка процессора отсутствует.
   //---------------------------------------------------- 
   name = ObjectGetString(0,"MT object",OBJPROP_TEXT);         
  }
//+------------------------------------------------------------------+
 
Andrey Barinov:

Hay un problema con los datos de la columna de la hora de apertura en la imagen.

Sí, he utilizado TimeToStr(OrderOpenPrice(),TIME_MINUTES|TIME_SECONDS);

No sé por qué es así.

 
Реter Konow:

Tengo que admitir que me sorprendieron un poco los resultados de la prueba.

Por lo tanto, estamos hablando de llamadas constantes a funciones con una frecuencia de 16 ms.

Resulta que es la inicialización de la matriz de píxeles durante el dibujo lo que más carga al procesador.

Pero lo más extraño fue que la repetida llamada a la función

cargaría el procesador entre un 10 y un 15%.

Además, las llamadas

cargar el procesador en el mismo 10-15%.

Al mismo tiempo, las llamadas simultáneas de las tres funciones

No provoca el apilamiento de la carga. La carga sigue siendo del 10-15%.

Sin embargo, si a estas llamadas se les añade un bucle constante de reinicialización de arrays de un millón de celdas

entonces la carga de la CPU sube al 50%.

//-----------------------------------------------------------------------------------------------------------------------------------------------------

La función en sí misma

no carga el procesador.

La función

carga de 0 a 5%, dependiendo del tamaño de la matriz Arr[].

Retrog Konow:

Debo admitir que me sorprendieron un poco los resultados de la prueba.

Por lo tanto, estamos hablando de llamadas de función constantes a 16 mseg.

Resulta que es la inicialización de una matriz de píxeles durante el dibujo lo que más carga al procesador.

Pero lo más extraño fue que la repetida llamada a la función

cargaría el procesador entre un 10 y un 15%.

Además, las llamadas

cargar el procesador en el mismo 10-15%.

Al mismo tiempo, las llamadas simultáneas de las tres funciones

No provoca el apilamiento de la carga. La carga sigue siendo del 10-15%.

Sin embargo, si a estas llamadas se les añade un bucle constante de reinicialización de arrays de un millón de celdas

entonces la carga de la CPU sube al 50%.

//-----------------------------------------------------------------------------------------------------------------------------------------------------

La función en sí misma

no carga el procesador.

La función

cargará de 0 a 5% dependiendo del tamaño de la matriz Arr[].


Peter, hay una sensación persistente de que no escuchas nada de lo que te han dicho durante cientos de páginas.
Vuelve a leer el hilo: hay respuestas a la pregunta "¿por qué?"

 
Реter Konow:

Sí, he utilizado TimeToStr(OrderOpenPrice(),TIME_MINUTES|TIME_SECONDS);

No sé por qué.

Porque en lugar de OrderOpenPrice poner OrderOpenTime()

1...116117118119120121122123124125126127128129130...184
Nuevo comentario
Razón de la queja: