Mein Ansatz. Der Kern ist der Motor. - Seite 123

Neuer Kommentar
 
Реter Konow:

...

ZS: Es ist jedoch möglich, dass der Prozessor durch das Neuzeichnen überlastet wird. Das heißt, das Zeichnen innerhalb eines Arrays von Pixeln. Mit anderen Worten, eine konstante Initialisierung des Arrays mit Werten, die mit hoher (16ms) Timer-Frequenz erfolgt.

Nein, das Neuzeichnen belastet den Prozessor in keiner Weise; es dauert ein paar Nano- oder höchstens Mikrosekunden, bis er einen Befehl an den Grafiktreiber sendet. Der Prozessor der Videokarte führt das Bild selbst aus, Pixel für Pixel, wobei es in der Regel Hunderte von ihnen gibt, die gleichzeitig mit dem Prozessor parallel arbeiten. Das heißt, der Prozessor gibt dem Grafiktreiber den Befehl: Zeige einen Kreis mit dem Mittelpunkt in den Bildschirmkoordinaten Xc, Yc und dem Radius R im CopyPut-Modus. Für den Prozessor ist dies lediglich ein Funktionsaufruf mit übergebenen Parametern. Sie geht nicht weiter als dies. Solche Anrufe macht es nicht öfter als, zum Beispiel, 2 mal pro Sekunde, sonst kann der Benutzer einfach nicht verstehen, was auf dem Bildschirm, kann es nicht so oft gezogen werden. Sie können sich vorstellen, dass eine Liste der offenen Geschäfte eine Stunde, einen Tag oder mehr dauern kann.

Und der Algorithmus (googeln Sie z. B. "Bresenham-Algorithmus") der Pixel-für-Pixel-Farbgebung wird von der Grafikkarte ausgeführt, und der Prozessor hält sich nicht damit auf. Außerdem wird es sehr schnell ausgeführt. Und... einmal pro Anruf. Eine Neuinitialisierung nach 16 ms ist nicht erforderlich, das Bild wird im Videospeicher konstant gehalten, bis auf Befehl des Prozessors eine neue Änderung vorgenommen wird. Und nicht nur das: Um die Reaktion auf den sichtbaren Bildschirm zu beschleunigen, wird der Videospeicher in zwei Instanzen gehalten, Änderungen werden auf der unsichtbaren vorgenommen, und dann wird sofort auf die Videoseite gewechselt.

Wenn Ihr Ansatz für die Bildschirmausgabe immer noch die "konstante Initialisierung des Arrays" von Pixeln hat, die Sie beschreiben, sollten Sie es loswerden, es ist nicht der Fall.

 
Реter Konow:

Klicken Sie zur Ansicht.

Mit den Daten in der Spalte Öffnungszeit auf dem Bild stimmt etwas nicht.

 
Vladimir:

Nein, das Neuzeichnen belastet den Prozessor in keiner Weise; es dauert höchstens ein paar Nano- oder Mikrosekunden, bis er einen Befehl an den Grafiktreiber sendet. Die Prozessoren der Videokarte führen das Bild selbst aus, Pixel für Pixel, wobei es in der Regel Hunderte von ihnen gibt, die gleichzeitig mit dem Prozessor arbeiten, also parallel. Das heißt, der Prozessor gibt dem Grafiktreiber den Befehl: Zeige einen Kreis mit dem Mittelpunkt in den Bildschirmkoordinaten Xc, Yc und dem Radius R im CopyPut-Modus. Für den Prozessor ist dies lediglich ein Funktionsaufruf mit übergebenen Parametern. Sie geht nicht weiter als dies. Solche Anrufe macht es nicht öfter als, zum Beispiel, 2 mal pro Sekunde, sonst kann der Benutzer einfach nicht verstehen, was auf dem Bildschirm, kann es nicht so oft gezogen werden. Sie können sich vorstellen, dass eine Liste der offenen Geschäfte eine Stunde, einen Tag oder mehr dauern kann.

Und der Algorithmus (googeln Sie z. B. "Bresenham-Algorithmus") der Pixel-für-Pixel-Farbgebung wird von der Grafikkarte ausgeführt, und der Prozessor hält sich nicht damit auf. Außerdem wird sie sehr schnell ausgeführt. Und... einmal pro Anruf. Eine Neuinitialisierung nach 16 ms ist nicht erforderlich, das Bild wird im Videospeicher konstant gehalten, bis auf Befehl des Prozessors eine neue Änderung vorgenommen wird. Und nicht nur das: Um die Reaktion auf den sichtbaren Bildschirm zu beschleunigen, wird der Videospeicher in zwei Instanzen gehalten, wobei Änderungen auf der unsichtbaren Seite vorgenommen werden und dann sofort auf die Videoseite umgeschaltet wird.

Wenn Ihr Ansatz für die Bildschirmausgabe immer noch die von Ihnen beschriebene "permanente Array-Initialisierung" von Pixeln vorsieht, sollten Sie sie loswerden, das ist nicht der Fall.

Was für ein Chaos...
Es ist ein Mischmasch aus bruchstückhaftem Wissen...

Letztendlich funktioniert das aber nicht so.

 
Vladimir:

Nein, das Neuzeichnen belastet den Prozessor in keiner Weise; es dauert höchstens ein paar Nano- oder Mikrosekunden, bis er einen Befehl an den Grafiktreiber sendet. Die Prozessoren der Videokarte führen das Bild selbst aus, Pixel für Pixel, wobei es in der Regel Hunderte von ihnen gibt, die gleichzeitig mit dem Prozessor arbeiten, also parallel. Das heißt, der Prozessor gibt dem Grafiktreiber den Befehl: Zeige einen Kreis mit dem Mittelpunkt in den Bildschirmkoordinaten Xc, Yc und dem Radius R im CopyPut-Modus. Für den Prozessor ist dies lediglich ein Funktionsaufruf mit übergebenen Parametern. Sie geht nicht weiter als dies. Solche Anrufe macht es nicht öfter als, zum Beispiel, 2 mal pro Sekunde, sonst kann der Benutzer einfach nicht verstehen, was auf dem Bildschirm, kann es nicht so oft gezogen werden. Sie können sich vorstellen, dass eine Liste der offenen Geschäfte eine Stunde, einen Tag oder mehr dauern kann.

Und der Algorithmus (googeln Sie z. B. "Bresenham-Algorithmus") der Pixel-für-Pixel-Farbgebung wird von der Grafikkarte ausgeführt, und der Prozessor hält sich nicht damit auf. Außerdem wird sie sehr schnell ausgeführt. Und... einmal pro Anruf. Eine Neuinitialisierung nach 16 ms ist nicht erforderlich, das Bild wird im Videospeicher konstant gehalten, bis auf Befehl des Prozessors eine neue Änderung vorgenommen wird. Und nicht nur das: Um die Reaktion des sichtbaren Bildschirms zu beschleunigen, wird auch der Videospeicher doppelt gehalten, Änderungen werden auf dem unsichtbaren Speicher vorgenommen, und dann wird sofort auf die Videoseite umgeschaltet.

Wenn Ihr Ansatz für die Ausgabe immer noch die "konstante Initialisierung des Arrays" von Pixeln hat - müssen Sie es loswerden.

Das ist eine interessante Theorie, auch wenn sie nicht ganz mit den Ergebnissen meiner Experimente übereinstimmt, die ich jetzt weiter unten veröffentlichen werde.

Wie der Test zeigt, ist es die Initialisierung des Pixelarrays, die die CPU am meisten belastet.

Prüfen Sie den unten stehenden Test EA.

 

Ich muss zugeben, dass ich von den Ergebnissen des Tests etwas überrascht war.

Wir sprechen also von konstanten Funktionsaufrufen mit einer Frequenz von 16 ms.

Es hat sich herausgestellt, dass die Initialisierung des Pixelarrays beim Zeichnen den Prozessor am meisten belastet.

Aber das Seltsamste war, dass der wiederholte Funktionsaufruf

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

würde den Prozessor um 10 bis 15 % belasten.

Auch die Anrufe

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

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

den Prozessor um die gleichen 10-15 % zu belasten.

Gleichzeitig können alle drei Funktionen gleichzeitig aufgerufen werden

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

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

Verursacht keine Stapelung von Lasten. Die Belastung beträgt immer noch 10-15 %.

Wenn Sie jedoch zu diesen Aufrufen eine konstante Array-Reinitialisierungsschleife von einer Million Zellen hinzufügen

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

dann steigt die CPU-Last auf 50 %.

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

Die Funktion selbst

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

belastet den Prozessor nicht.

Die Funktion

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

wird je nach Größe des Arr[]-Arrays zwischen 0 und 5% geladen.

 

Hier ist ein Test-Berater. Sie müssen die Zeilen kommentieren und die CPU-Auslastung im Task-Manager überprüfen.

Dateien:
Test_1.mq4  11 kb
 

Hier ist sein Code:

//+------------------------------------------------------------------+
//|                                                       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:

Mit den Daten in der Spalte Öffnungszeit in der Abbildung stimmt etwas nicht.

Ja, ich habe TimeToStr(OrderOpenPrice(),TIME_MINUTES|TIME_SECONDS) verwendet;

Ich weiß nicht, warum das so ist.

 
Реter Konow:

Ich muss zugeben, dass ich von den Ergebnissen des Tests etwas überrascht war.

Wir sprechen also von konstanten Funktionsaufrufen mit einer Frequenz von 16 ms.

Es stellt sich heraus, dass die Initialisierung des Pixelarrays beim Zeichnen den Prozessor am meisten belastet.

Aber das Seltsamste war, dass der wiederholte Funktionsaufruf

würde den Prozessor um 10 bis 15 % belasten.

Auch die Anrufe

den Prozessor um die gleichen 10-15 % zu belasten.

Gleichzeitig können alle drei Funktionen gleichzeitig aufgerufen werden

Verursacht keine Stapelung von Lasten. Die Belastung beträgt immer noch 10-15 %.

Wenn Sie jedoch zu diesen Aufrufen eine konstante Array-Reinitialisierungsschleife von einer Million Zellen hinzufügen

dann steigt die CPU-Last auf 50 %.

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

Die Funktion selbst

belastet den Prozessor nicht.

Die Funktion

lädt von 0 bis 5 %, je nach Größe des Arr[]-Arrays.

Retrog Konow:

Ich muss zugeben, dass ich von den Ergebnissen des Tests etwas überrascht war.

Es handelt sich also um konstante Funktionsaufrufe mit 16 msec.

Es hat sich herausgestellt, dass die Initialisierung eines Pixelarrays beim Zeichnen den Prozessor am meisten belastet.

Aber das Seltsamste war, dass der wiederholte Funktionsaufruf

würde den Prozessor um 10 bis 15 % belasten.

Auch die Anrufe

den Prozessor um die gleichen 10-15 % zu belasten.

Gleichzeitig können alle drei Funktionen gleichzeitig aufgerufen werden

Verursacht keine Stapelung von Lasten. Die Belastung beträgt immer noch 10-15 %.

Wenn Sie jedoch zu diesen Aufrufen eine konstante Array-Reinitialisierungsschleife von einer Million Zellen hinzufügen

dann steigt die CPU-Last auf 50 %.

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

Die Funktion selbst

belastet den Prozessor nicht.

Die Funktion

wird je nach Größe des Arr[]-Arrays zwischen 0 und 5% geladen.


Peter, ich habe das starke Gefühl, dass du nichts von dem hörst, was man dir seit Hunderten von Seiten erzählt hat.
Lesen Sie das Thema noch einmal - es gibt Antworten auf die Frage "Warum?

 
Реter Konow:

Ja, ich habe TimeToStr(OrderOpenPrice(),TIME_MINUTES|TIME_SECONDS) verwendet;

Ich weiß nicht, warum.

Denn anstelle von OrderOpenPrice setzen Sie OrderOpenTime()

1...116117118119120121122123124125126127128129130...184
Neuer Kommentar
Grund der Beschwerde: