Mein Ansatz. Der Kern ist der Motor. - Seite 123
Sie verpassen Handelsmöglichkeiten:
- Freie Handelsapplikationen
- Über 8.000 Signale zum Kopieren
- Wirtschaftsnachrichten für die Lage an den Finanzmärkte
Registrierung
Einloggen
Sie stimmen der Website-Richtlinie und den Nutzungsbedingungen zu.
Wenn Sie kein Benutzerkonto haben, registrieren Sie sich
...
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.
Klicken Sie zur Ansicht.
Mit den Daten in der Spalte Öffnungszeit auf dem Bild stimmt etwas nicht.
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.
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
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.
Hier ist ein Test-Berater. Sie müssen die Zeilen kommentieren und die CPU-Auslastung im Task-Manager überprüfen.
Hier ist sein Code:
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.
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.
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?
Ja, ich habe TimeToStr(OrderOpenPrice(),TIME_MINUTES|TIME_SECONDS) verwendet;
Ich weiß nicht, warum.
Denn anstelle von OrderOpenPrice setzen Sie OrderOpenTime()