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

[Реter Konow]

Hablando de intuición. Quiero darles un ejemplo interesante. Mi post, impreso en este hilo https://www.mql5.com/ru/forum/95632/page12hace más de dos años:

Реter Konow:

1. El concepto de motor gráfico.

2. Concepto de núcleo gráfico.

3. etapas de creación del estudio visual para la plataforma MT.

4. Descripción del mecanismo de creación de la interfaz EA.

Elmotor gráfico es un programa diseñado como indicador. Este programa está diseñado únicamente para la gestión de la interfaz de usuario. Ejecuta un conjunto de funciones básicas:

• Carga del núcleo de la interfaz gráfica desde un archivo.
• Guardar los ajustes personalizados de la interfaz.
• Implementación del control unificado y coordinado de todos los procesos en la interfaz. Implementa la "mecánica" de la interfaz, que incluye: abrir y cerrar ventanas, cambiar el tamaño de las ventanas, moverlas, fusionarlas, escalarlas, reproducir scripts, cambiar los estados de los objetos, enlazar objetos, controlar los valores de los parámetros de los controles según sus tipos y propiedades, crear y destruir variables globales.

El motor gráfico se añade a un gráfico como cualquier otro indicador . Incluye el siguiente conjunto de ventanas:

• Una barra de tareas, en cuya parte derecha se añadirán varios iconos para llamar a las ventanas deservicio del propio motor.
• Un navegador de archivos que se utilizará para seleccionar el archivo de arranque deuna lista de archivos con interfaces situados en una carpeta especial.
  
• Ventanas de ajustes opcionales, que no juegan un papel crucial en esta etapa.

Esto, en principio, es el fin del concepto de motor gráfico. Lo importante es que sin ella el funcionamiento de la interfaz es imposible.

Un motor gráfico es un bloque de información que contiene datos de todos los objetos y ventanas de una interfaz, que se registra en una matriz y se guarda en un archivo.

Este bloque es una representación digital de la interfaz gráfica. El motor gráfico lo carga a petición del usuario. El propio motor gráfico tiene su propio núcleo gráfico interno que garantiza el funcionamiento de sus propias ventanas, y dentro de este núcleo se proporciona espacio libre para la integración de la interfaz de usuario (en forma digital) en él. La integración se realiza en el proceso de carga del núcleo gráfico desde un archivo.

3. La creación de un estudio visual en la plataforma MT, según tengo entendido, se divide en dos etapas:

• En la primera etapa, se creará una versión basada en archivos del constructor de interfaces. En él, el usuario trabajará con plantillas de tablas. En las tablas, el usuario escribirá los tipos y nombres de los elementos de la interfaz y establecerá las propiedades de sus parámetros. La creación será extremadamente fácil para el usuario, no tendrá que preocuparse por el posicionamiento correcto de sus elementos en las ventanas (el motor calculará todo automáticamente) y será suficiente con disponer los elementos en el orden requerido.
• En la segunda fase, se creará un entorno visual que implementa el mismo método de construcción de interfaces que el constructor de archivos, sólo que será más fácil y cómodo de usar. También añadirá la posibilidad de cambiar la apariencia de los controles. En general, el usuario tendrá más opciones gráficas.

4. Me gustaría esbozar el mecanismo del proceso de creación de interfaces y levantar ligeramente el velo sobre su tecnología. Explica de dónde viene la facilidad de crear una interfaz a través de un archivo.

Este es el caso: el motor tiene una función especial que crea un núcleo gráfico completo basado en un único archivo con una cantidad mínima de información de carga. La información de arranque en este archivo se explica por sí misma y es legible para las personas. Es fácil de escribir y editar. Por ejemplo, es necesario escribir "_CREATE_NEW_WINDOW" para crear una ventana, y "_CHECKBOX" y el nombre de la casilla de verificación, (el motor reconoce automáticamente el nombre del elemento, como nombre del propio elemento y como nombre de su parámetro).

Esta función se llama "G_CORE_BUILDER()" y construye el núcleo gráfico tomando datos de dos fuentes principales: un archivo de arranque creado por el usuario y la matriz "CONTENT[]" que contiene todos los grupos de objetos estándar incluidos en las plataformas de ventanas y controles. "CONTENT[]" también contiene estados y scripts de objetos. Todo en una sola matriz. En general, el material de origen de "CONTENT[]" + el archivo de carga creado por el usuario es utilizado por "G_CORE_BUILDER()" para construir el núcleo gráfico con el que trabaja el motor.

[Реter Konow]

Es sorprendente lo mucho que NO han cambiado los términos y conceptos en dos años de duro trabajo. Y las funciones y los arrays y las palabras clave son como dice aquí. Todo se ha implementado de acuerdo con este escenario. Y esta tecnología funciona y evoluciona, a pesar deque hace dos años no tenía NINGUNA experiencia en el desarrollo de un lenguaje de marcas.

No llegué a un callejón sin salida, no cambié el concepto, no cambié la dirección. Seguí creando el motor, el núcleo y el lenguaje de marcado exactamente como pretendía en un principio. Y la práctica confirma que el camino que elegí fue el correcto.

Si esto no es una intuición profética, ¿qué es?

[Реter Konow]

Estimados opositores.

Aquí está el código de la secuencia de comandos que:

1. Mide el tiempo de transferencia de una cadena a una matriz Char, para pasar la cadena a otro programa a través de un recurso y el tiempo de recuperación de una cadena de una matriz Char para la posterior división y recuperación de información.
2. Mide el tiempo para escribir la cadena en la descripción del objeto MT y el tiempo para recuperar la cadena de la descripción del objeto MT, para la posterior división y recuperación de la información.

//+------------------------------------------------------------------+
//|                        CharArrayToString и StringToCharArray.mq4 |
//|                                                      Peter Konow |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Peter Konow"
#property link      "https://www.mql5.com"
#property version   "1.00"
//--------------------------------------------

//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
  {
//---
   string qwerty = "qierfhqoerifhqoiwerufhqoiwerfhwioefhqowasdkfj";   
   uchar Arr[];
   //---------------------------------
   //Создаем объект связи.
   //---------------------------------
   ObjectCreate(0,"button_1",OBJ_BUTTON,0,0,0);   
   //---------------------------------
   ulong t1 = GetMicrosecondCount();
   //---------------------------------
   //Переводим строку в тип Char
   //---------------------------------
   StringToCharArray(qwerty,Arr,0,WHOLE_ARRAY);
   //---------------------------------
   ulong t2 = GetMicrosecondCount();
   //---------------------------------
   //Переводим массив Char обратно в строку:
   //---------------------------------
   string str_1 = CharArrayToString(Arr,0,WHOLE_ARRAY);
   //---------------------------------
   ulong t3 = GetMicrosecondCount();
   //---------------------------------
   //Записываем строку в описании МТ-объекта.
   //---------------------------------
   ObjectSetString(0,"button_1",OBJPROP_TEXT,"qierfhqoerifhqoiwerufhqoiwerfhwioefhqowasdkfj");
   ulong t4 = GetMicrosecondCount();
   //---------------------------------
   //Cчитываем строку из описания МТ-объекта.
   //---------------------------------
   string str_2 = ObjectGetString(0,"button_1",OBJPROP_TEXT);
   ulong t5 = GetMicrosecondCount();
   //---------------------------------   
   //Замеряем время исполнения.
   //----------------------------------------------
   Print("Time of execution StringToCharArray:   ",t2-t1);
   Print("Time of execution CharArrayToString:   ",t3-t2," строка от CharArrayToString:  ",str_1);
   //----------------------------------------------
   Print("Time of execution ObjectSetString:     ",t4-t3);
   Print("Time of execution ObjectGetString:     ",t5-t4," строка от ObjectGetString:  ",str_2);
   //----------------------------------------------
  }
//+------------------------------------------------------------------+

Resultado:

2018.12.18 16:44:20.042 CharArrayToString и StringToCharArray GBPUSD,M5: Time of execution StringToCharArray:   47
2018.12.18 16:44:20.042 CharArrayToString и StringToCharArray GBPUSD,M5: Time of execution CharArrayToString:   35 строка от CharArrayToString:  qierfhqoerifhqoiwerufhqoiwerfhwioefhqowasdkfj

2018.12.18 16:44:20.042 CharArrayToString и StringToCharArray GBPUSD,M5: Time of execution ObjectSetString:     3
2018.12.18 16:44:20.042 CharArrayToString и StringToCharArray GBPUSD,M5: Time of execution ObjectGetString:     3 строка от ObjectGetString:  qierfhqoerifhqoiwerufhqoiwerfhwioefhqowasdkfj

[Реter Konow]

Mi solución es más de 10 veces más rápida.

Añade a tu solución, el tiempo para guardar el recurso y el tiempo para obtener el recurso en el array usando ResourceReadImage();

En mi solución, no se requiere ni lo primero ni lo segundo.

[Vasiliy Sokolov]

Реter Konow:
Mi solución es más de 10 veces más rápida.

Peter, si trabajas con cuerdas, perderás rendimiento en cualquier caso. Por eso sorprende que persigas un rendimiento mítico, aunque originalmente hayas elegido una solución inadecuada para ello: pasar los mensajes a través de una cadena y luego parsear ese mensaje.

[Реter Konow]

Vasiliy Sokolov:

Peter, si trabajas con cuerdas, perderás rendimiento en cualquier caso. Así que es sorprendente escuchar que persigues un rendimiento mítico, a pesar de que originalmente elegiste una solución inadecuada para ello: pasar mensajes a través de una cadena y luego analizar ese mensaje.

Vasily, ¿de qué otra forma se pueden transferir datos de todo tipo entre programas?

OnChartEvent() es parcialmente adecuado.

1. No funciona en el probador.
2. Con un gran número de llamadas, la cola de eventos se atasca.

[Vasiliy Sokolov]

Y, por cierto, las mediciones inferiores a 20 milisegundos no son, estrictamente hablando, válidas en absoluto, al menos en los sistemas multihilo preventivos. Pero incluso si aceptas tu resultado (en general lo admito), sigue sin decirte nada, porque lo que importa son los costes del ciclo completo. Y lo que has medido es sólo una parte.

[Реter Konow]

Vasiliy Sokolov:
Y por cierto, medir menos de 20 milisegundos, estrictamente hablando no es válido en absoluto, al menos en sistemas con multithreading preventivo. Pero aunque aceptes tu resultado (en general lo admito), sigue sin decirte nada, porque lo que importa son los costes del ciclo completo. Y lo que has medido es sólo una parte.

Necesito una forma universal y la más rápida. Para trabajar en el probador y evitar la cola de eventos OnChartEvent();

La prueba muestra que es 10 veces más lenta la transferencia a través de los recursos. (sin medir el tiempo para guardar el recurso y obtener los datos del mismomediante ResourceReadImage()) .

Mi solución es la mejor opción en las condiciones iniciales.

[Реter Konow]

Vasiliy Sokolov:
...Pero aunque aceptes tu resultado (en general lo admito), sigue sin decirte nada, porque lo que importa son los costes del círculo completo. Y lo que has medido es sólo una parte.

Es cierto, pero si se extrapola a más líneas y marchas, mi opción sigue ganando.

[Vasiliy Sokolov]

Реter Konow:

Vasiliy, ¿de qué otra forma se pueden transferir datos de todo tipo entre programas?

Mapeo directo de estructuras a través de la unión a la matriz de bytes, compartida para el acceso global. No sé si esto es técnicamente factible, pero si es así, la velocidad será cósmica, porque no tendrás que copiar nada en absoluto.