Synchronisierungs Timer

[anogayales]

Hallo liebe Python Gemeinde,

ich habe zwei Prozesse die bei mir Daten sammeln und rausschreiben. Nun möchte ich beide Streams synchronisieren. Dabei bin ich auf die time.time() Funktion gestoßen. Diese hat unter Windows leider eine geringe Auflösung. Die time.clock() Methode bietet mir aber nur die Walltime an, sprich ich sehe nur WANN die Prozesse gestartet wurden, aber untereinander hilft mir das nicht weiter.

Gibt es einen Weg trotzdem die Präzisions von time.clock() zu bekommen, aber basierend auf einen Referenzwert (z.B Unix Epoche)?

Code: Alles auswählen

process_start_time = time.time()
...
current_time = process_start_time + time.clock()

würde eigentlich klappen, oder gibt es eine elegantere Lösung?

Wenn sich ein Prozess schlafen legt, wird das ja nicht über time.clock() erfasst, oder?

Hier hat jemand was ähnliches probiert:
http://stackoverflow.com/questions/1573 ... 208#160208

Grüße,
anogayales

[BlackJack]

@anogayales: Ich verstehe jetzt nicht so ganz was Du eigentlich machen möchtest‽ ``current_time = process_start_time + time.clock()``, da könntest Du doch einfach ``current_time = time.time()`` schreiben.

Ansonsten würde ich von `datatime.datetime.now()` erwarten, dass eine aktuelle Zeit mit der höchsten Auflösung die möglich ist, geliefert wird.

[anogayales]

Das Problem ist, dass unter Windows die Auflösung von time.time() sehr beschränkt ist, bei mir etwa 1 ms. time.clock() hat hingegen auf Windows eine höhere Auflösung als time.time(), liefert aber nur die Walltime. Unter Unix ist time.time() präziser und da kann man, wie du bereits gesagt hast, einfach time.time() benutzen.

Datetime benutzt intern time.time() und das hat unter Windows die bekannten Präzisionsprobleme.

Grüße,
anogayales

[lunar]

@anogayales "time.time()" gibt Dir die Systemzeit. Diese Zeit hat faktisch keinen konstanten Takt und ist nicht streng monoton. Sie kann springen, bei Änderung der Zeitzone sogar um Stunden, und wird normalerweise fortwährend vom laufenden NTP-Dienst nachjustiert, um den Uhrenfehler, sprich die Abweichung zu Zeit und Takt der exakten NTP-Zeit, möglichst gering zu halten. Für längere Synchronisation ist diese Zeit mithin denkbar ungeeignet.

Du musst ein monotones und gleichförmiges Zeitmaß verwenden, also die monotone Systemzeit, oder gar den Performance Counter des Systems. Die Standardbibliothek bietet allerdings vor Version 3.3 keinen Zugriff auf diese Zeitquellen. Ab Python 3.3 kannst Du dann "time.monotonic()" oder "time.perf_counter()" verwenden.

Diese Zeiten haben allerdings unspezifizierte Startpunkte, mithin können die Werte zwischen verschiedenen Prozessen abweichen. Du musst also zu Beginn Referenzwerte messen und abgleichen, was wiederum Latenzprobleme mit sich bringt.

Je nach Deinem Problem ist es daher vielleicht einfacher, die Kindprozesse einfach über einen vom Vaterprozess ausgehenden Tick zu betreiben. So sind die Kindprozesse garantiert synchron, zumindest solange Du keine Echtzeitanforderungen hast. Oder alternativ die synchron zu erledigenden Berechnungen über eine Queue an einen einzigen Prozess zu übergeben.

Beschreibe doch Dein Problem mal detailliert, dann können wir Dir besser helfen.