Wait und Wait-Until, seltsame Effekte, ich verstehs einfach nicht...

Hi,

in meinem Projekt, einem Spiel, in dem mit einem Luftkissenboot ein sich zufällig platzierendes Objekt (eine flatternde Flagge) gegen die Zeit eingesammelt werden muss, laufen 4 Whileschleigen parallel.

1. 30ms Verzögerung, "Hauptschleife" Steuerung, Bewegung des Fahrzeuges usw.
2. 40ms Verzögerung, flattern der Flagge
3. 70ms Verzögerung, Aktualisierung der Messanzeiger (Tacho usw.)
4. 1000ms Verzögerung, Countdown der Spielzeit

...nur damit ungefähr gesagt ist, worum es geht. Falls es zur Sache tun sollte, hier mal ein Screenshot:

   


Performancetechnisch komm ich an die Grenze -ist aber gut spielbar. -WENN ich in allen 4 Schleifen das Metronom zur Verzögerung verwende. Mit der Armbanduhr ruckelt und flimmert es.


Bisher habe ich angenommen, dass die Armbanduhr die KOMPLETTE Zeit wartet, das Metronom hingegen die Zeit MINUS die Zeit, die für den in der Schleife ausgeführten Code benötigt wurde. Würde ja auch Sinn machen von den Begriffen "Wait" und "Wait until".

Das scheint aber nicht zu stimmen, nach allem was ich so lese. Das dürfte eigentlich garnicht sein... -Entweder er hat den Code gepackt in der Zeit und gut oder eben nicht und es ruckelt. Ich verstehs nicht.

Meine Fragen an euch sind also:


1. Weshalb habe ich mit dem Metronom eine bessere Performance?

2. Was ist der genaue Unterschied der beiden Möglichkeiten? -Alles was ich darüber zu lesen finde, hat nichts mit meiner Situation zu tun...


Spätestens zur Präsentation muss ich das irgendwie begründen, dass ich das Metronom verwende, weil in der Vorlesung immer nur vom Armbanduhr die Rede war. Könntet ihr mir da bitte weiterhelfen?


Danke!!

Guten Morgen,

die Bezeichnung "Wait until" gibt dir einen Hinweis auf deine FRage. Dein Code wird abgearbeitet und dann auf das nächste Vielfache des ms-Wertes gewartet.
Gehen wir davon aus das dein code 20ms Zeit benötigt. Dem Metronom hast du 80ms aus Wert vorgegeben. Es wird versucht diese 80ms zu halten. Sprich 20ms code + 60 ms wait = 80 ms.

Bei der "Armanduhr" wird der anegebene Wert gewartet. Deine Iteration wäre also 20ms code + 80ms wait = 100ms

Schaue dir mal den codeschnipsel an den ich angehängt habe. Tausche einfach mal die beiden timer aus, dann erklärt es sich von selbst.

Grüße, Ralf

Hallo catbull,

ein paar Egänzungen zu RMR's Antwort:

Zitat:Gehen wir davon aus das dein code 20ms Zeit benötigt. Dem Metronom hast du 80ms aus Wert vorgegeben. Es wird versucht diese 80ms zu halten. Sprich 20ms code + 60 ms wait = 80 ms.

Wenn dein Code jetzt aber länger als die angegebene Wartezeit benötigt, wird wieder bis zum nächsten Vielfachen der Wartezeit gewartet:

Code:

90ms (Code) + 70ms (wait until multiple) = 160ms (next multiple)

Diese ganzen Rechnungen gelten aber nur, wenn das WaitUntil nach deinem Code aufgerufen wird. Wenn es parallel läuft, passiert folgendes:

Code:

MAX(90ms code, 80ms wait) = 90ms

Und beim nächsten Durchlauf kann dann wieder irgendwas anderes dein Timing stören…

Zitat:Bei der "Armanduhr" wird der anegebene Wert gewartet. Deine Iteration wäre also 20ms code + 80ms wait = 100ms

Diese Aussage gilt nur, wenn das Wait nach dem Code aufgerufen wird.
Im Normalfall läuft es aber parallel zum Code, sodass sich die Rechnung

Code:

MAX(20ms code, 80ms wait) = 80ms

ergibt…

Zu deinem Bild:
- Musst du den Code wirklich auf 4 Schleifen verteilen? Ich würde hier evtl. auf ein Producer-Consumer-Schema umstellen, bei dem der Producer im 10ms-Takt läuft und einfach Befehle für einen/mehrere Consumer im korrekten Takt verteilt.
- Sind deine FGV-Aufrufe wirklich so schnell, wie du vermutest? Kann es sein, dass die FGV(s) evtl. irgendwelche (langsamen) Operationen ausführen, die dein Schleifentiming beeinflussen können?

Es gibt auch noch einen kleinen Unterschied. Angenommen, die Wartezeit läuft parallel zum Code (wie auf deinen Bildern), und angenommen, der Code ist immer kürzer als die Wartezeit. Die Wartezeit sei 70ms. Dann ist bei der "Armbanduhr" die Wartezeit immer 70ms, beim Metronom zwar auch, nur nicht beim ersten Schleifendurchlauf. Da ist die Wartezeit irgendetwas Zufälliges wischen 0 und 70ms.
Wenn man zwei parallele Schlifen mit gleicher Wartezeit hat, dann laufen sie mit "Wait until" synchron zueinander, beim normalen Wait sind sie in der Phasenlage irgendwie zufällig zueinander versetzt. (Es gibt aber bessere Methoden, um Schleifen miteinander zu synchronisieren)