Il mio approccio. Il nucleo è il motore. - pagina 85

[Реter Konow]

Parlando di intuizione. Voglio darvi un esempio interessante. Il mio post, stampato in questo thread https://www.mql5.com/ru/forum/95632/page12più di due anni fa:

Реter Konow:

1. Il concetto di motore grafico.

2. Concetto del nucleo grafico.

3. fasi di creazione dello studio visivo per la piattaforma MT.

4. Descrizione del meccanismo di creazione dell'interfaccia EA.

Ilmotore grafico è un programma progettato come un indicatore. Questo programma è progettato esclusivamente per la gestione dell'interfaccia utente. Esegue una serie di funzioni di base:

• Caricamento del nucleo dell'interfaccia grafica da un file.
• Salvare le impostazioni personalizzate dell'interfaccia.
• Attuazione del controllo unificato e coordinato di tutti i processi dell'interfaccia. Implementa la "meccanica" dell'interfaccia, tra cui: apertura e chiusura di finestre, ridimensionamento di finestre, spostamento di finestre, fusione di finestre, ridimensionamento, riproduzione di script, cambiamento di stato degli oggetti, binding di oggetti, controllo dei valori dei parametri dei controlli in base ai loro tipi e proprietà, creazione e distruzione di variabili globali.

Il motore grafico viene aggiunto a un grafico come qualsiasi altro indicatore . Include il seguente set di finestre:

• Una barra delle applicazioni, sul cui lato destro saranno aggiunte diverse icone per chiamare le finestre diservizio del motore stesso.
• Un navigatore di file che sarà utilizzato per selezionare il file di avvio dauna lista di file con interfacce situate in una cartella speciale.
  
• Finestre di impostazioni opzionali, che non giocano un ruolo cruciale in questa fase.

Questo, in linea di principio, è la fine del concetto di motore grafico. La cosa importante è che senza di essa il funzionamento dell'interfaccia è impossibile.

Un motore grafico è un blocco di informazioni che contiene i dati di tutti gli oggetti e le finestre di un'interfaccia, che viene registrato in un array e salvato in un file.

Questo blocco è una rappresentazione digitale dell'interfaccia grafica. Viene caricato dal motore grafico su richiesta dell'utente. Il motore grafico stesso ha un proprio kernel grafico interno che assicura il funzionamento delle proprie finestre, e all'interno di questo kernel viene fornito spazio libero per l'integrazione dell'interfaccia utente (in forma digitale) in esso. L'integrazione viene eseguita nel processo di caricamento del nucleo grafico da un file.

3. La creazione di uno studio visivo sulla piattaforma MT, da quanto ho capito, si divide in due fasi:

• Nella prima fase, sarà creata una versione su file del costruttore di interfacce. In esso, l'utente lavorerà con modelli di tabelle. Nelle tabelle, l'utente scriverà i tipi e i nomi degli elementi dell'interfaccia e imposterà le proprietà dei loro parametri. La creazione sarà estremamente facile per l'utente, non dovrà preoccuparsi del corretto posizionamento dei suoi elementi nelle finestre (il motore calcolerà tutto automaticamente) e sarà sufficiente disporre gli elementi nell'ordine richiesto.
• Nella seconda fase, sarà creato un ambiente visivo che implementa lo stesso metodo di costruzione dell'interfaccia del costruttore di file, solo che sarà più facile e comodo da usare. Aggiungerà anche la possibilità di cambiare l'aspetto dei controlli. In generale, l'utente avrà più opzioni grafiche.

4. Vorrei delineare il meccanismo del processo di creazione dell'interfaccia e sollevare leggermente il velo sulla sua tecnologia. Spiegare da dove viene la facilità di creare un'interfaccia tramite un file.

Questo è il caso: il motore ha una funzione speciale che crea un kernel grafico completo basato su un singolo file con una quantità minima di informazioni di caricamento. Le informazioni di avvio in questo file sono autoesplicative e leggibili dall'uomo. È facile da scrivere e modificare. Per esempio dovete scrivere "_CREATE_NEW_WINDOW" per creare una finestra, e "_CHECKBOX" e il nome della casella di controllo, (il motore riconosce automaticamente il nome dell'elemento, come nome dell'elemento stesso e come nome del suo parametro).

Questa funzione si chiama "G_CORE_BUILDER()" e costruisce il nucleo grafico prendendo dati da due fonti principali: un file di avvio creato dall'utente e l'array "CONTENT[]" che contiene tutti i gruppi standard di oggetti inclusi nelle piattaforme di finestre e controlli. "CONTENT[]" contiene anche stati e script di oggetti. Tutto in una sola matrice. In generale, il materiale di origine da "CONTENT[]" + il file loader creato dall'utente viene utilizzato da "G_CORE_BUILDER()" per costruire il nucleo grafico con cui lavora il motore.

[Реter Konow]

È incredibile quanto i termini e i concetti NON siano cambiati in due anni di duro lavoro. E le funzioni e gli array e le parole chiave sono come dice qui. Tutto è stato implementato secondo questo scenario. E questa tecnologia funziona e si evolve, nonostante ilfatto che due anni fa non avevo nessuna esperienza nello sviluppo di un linguaggio di markup.

Non ho raggiunto un vicolo cieco, non ho cambiato il concetto, non ho cambiato la direzione. Ho continuato a creare il motore, il nucleo e il linguaggio di markup esattamente come intendevo all'inizio. E la pratica conferma che la strada che ho scelto era quella giusta.

Se questa non è un'intuizione profetica, allora cosa lo è?

[Реter Konow]

Cari avversari.

Ecco il codice dello script che:

1. Misura il tempo di trasferimento di una stringa in un array Char, per passare la stringa a un altro programma tramite una risorsa e il tempo di recupero di una stringa da un array Char per la successiva suddivisione e il recupero di informazioni.
2. Misura il tempo per scrivere la stringa nella descrizione dell'oggetto MT e il tempo per recuperare la stringa dalla descrizione dell'oggetto MT, per la successiva suddivisione e il recupero delle informazioni.

//+------------------------------------------------------------------+
//|                        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);
   //----------------------------------------------
  }
//+------------------------------------------------------------------+

Risultato:

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]

La mia soluzione è più di 10 volte più veloce.

Aggiungete alla vostra soluzione, il tempo per salvare la risorsa e il tempo per ottenere la risorsa nell'array usando ResourceReadImage();

Nella mia soluzione, né la prima né la seconda sono necessarie.

[Vasiliy Sokolov]

Реter Konow:
La mia soluzione è più di 10 volte più veloce.

Peter, se lavori con le stringhe, perderai prestazioni in ogni caso. Quindi è sorprendente sentirti inseguire una prestazione mitica, anche se in origine hai scelto una soluzione inadeguata per questo: passare messaggi attraverso una stringa e poi analizzare quel messaggio.

[Реter Konow]

Vasiliy Sokolov:

Peter, se lavori con le stringhe, perderai prestazioni in ogni caso. Quindi è sorprendente sentirti inseguire prestazioni mitiche, anche se in origine hai scelto una soluzione inadeguata per questo: passare messaggi attraverso una stringa e poi analizzare quel messaggio.

Vasily, come si fa altrimenti a trasferire dati di tutti i tipi tra i programmi?

OnChartEvent() è parzialmente adatto.

1. Non funziona nel tester.
2. Con un gran numero di chiamate - la coda degli eventi si intasa.

[Vasiliy Sokolov]

E a proposito, misure inferiori a 20 millisecondi non sono, a rigore, affatto valide, almeno nei sistemi multithreading preemptive. Ma anche se accetti il tuo risultato (in generale lo ammetto), ancora non ti dice nulla, perché sono i costi a tutto tondo che contano. E quello che avete misurato è solo una parte di esso.

[Реter Konow]

Vasiliy Sokolov:
E a proposito, misurare meno di 20 millisecondi non è affatto valido, almeno nei sistemi con multithreading preemptive. Ma anche se accetti il tuo risultato (in generale lo ammetto), ancora non ti dice nulla, perché sono i costi a tutto tondo che contano. E quello che avete misurato è solo una parte di esso.

Abbiamo bisogno di un modo universale e il più veloce. Per lavorare nel tester e per bypassare la coda di eventi OnChartEvent();

Il test mostra che è 10 volte più lento da trasferire attraverso le risorse. (senza misurare il tempo per salvare la risorsa e ottenere dati da essausando ResourceReadImage()).

La mia soluzione è l'opzione migliore nelle condizioni iniziali.

[Реter Konow]

Vasiliy Sokolov:
...Ma anche se accetti il tuo risultato (in generale lo ammetto), ancora non ti dice nulla, perché sono i costi a tutto tondo che contano. E quello che avete misurato è solo una parte di esso.

Vero, ma se si estrapola a più linee e ingranaggi, la mia opzione vince ancora.

[Vasiliy Sokolov]

Реter Konow:

Vasiliy, come si fa altrimenti a trasferire dati di tutti i tipi tra programmi?

Mappatura diretta delle strutture tramite unione ad array di byte, condivisa per l'accesso globale. Non so se questo è tecnicamente fattibile, ma se è così, la velocità sarà cosmica, perché non dovrete copiare assolutamente nulla.