time.get_clock_info(name)

Holt Informationen über die angegebene Uhr. Unterstützte Uhrnamen

• "clock": time.clock()
• "monotonic": time.monotonic()
• "perf_counter": time.perf_counter()
• "process_time": time.process_time()
• "time": time.time()

Gibt ein time.clock_info-Objekt zurück, das die folgenden Attribute hat

• implementation (str): Name der zugrunde liegenden Betriebssystemfunktion. Beispiele: "QueryPerformanceCounter()", "clock_gettime(CLOCK_REALTIME)".
• monotonic (bool): True, wenn die Uhr nicht zurücklaufen kann.
• adjustable (bool): True, wenn die Uhr automatisch (z. B. von einem NTP-Daemon) oder manuell vom Systemadministrator geändert werden kann, False andernfalls
• resolution (float): Auflösung in Sekunden der Uhr.

time.monotonic()

Monotone Uhr, d. h. sie kann nicht zurücklaufen. Sie wird von Systemzeitaktualisierungen nicht beeinflusst. Der Bezugspunkt des zurückgegebenen Wertes ist undefiniert, so dass nur die Differenz zwischen den Ergebnissen aufeinanderfolgender Aufrufe gültig ist und eine Anzahl von Sekunden darstellt.

Unter Windows-Versionen vor Vista erkennt time.monotonic() Überläufe des GetTickCount()-Integers (32 Bit, Überlauf nach 49,7 Tagen). Es erhöht eine interne Epoche (Referenzzeit) um 2³², jedes Mal, wenn ein Überlauf erkannt wird. Die Epoche wird im prozesslokalen Zustand gespeichert, daher kann der Wert von time.monotonic() in zwei Python-Prozessen, die länger als 49 Tage laufen, unterschiedlich sein. Bei neueren Windows-Versionen und auf anderen Betriebssystemen ist time.monotonic() systemweit.

Verfügbarkeit: Windows, Mac OS X, Linux, FreeBSD, OpenBSD, Solaris. Nicht verfügbar auf GNU/Hurd.

Pseudocode [2]

if os.name == 'nt':
    # GetTickCount64() requires Windows Vista, Server 2008 or later
    if hasattr(_time, 'GetTickCount64'):
        def monotonic():
            return _time.GetTickCount64() * 1e-3
    else:
        def monotonic():
            ticks = _time.GetTickCount()
            if ticks < monotonic.last:
                # Integer overflow detected
                monotonic.delta += 2**32
            monotonic.last = ticks
            return (ticks + monotonic.delta) * 1e-3
        monotonic.last = 0
        monotonic.delta = 0

elif sys.platform == 'darwin':
    def monotonic():
        if monotonic.factor is None:
            factor = _time.mach_timebase_info()
            monotonic.factor = timebase[0] / timebase[1] * 1e-9
        return _time.mach_absolute_time() * monotonic.factor
    monotonic.factor = None

elif hasattr(time, "clock_gettime") and hasattr(time, "CLOCK_HIGHRES"):
    def monotonic():
        return time.clock_gettime(time.CLOCK_HIGHRES)

elif hasattr(time, "clock_gettime") and hasattr(time, "CLOCK_MONOTONIC"):
    def monotonic():
        return time.clock_gettime(time.CLOCK_MONOTONIC)

Unter Windows wird QueryPerformanceCounter() nicht verwendet, obwohl es eine bessere Auflösung als GetTickCount() hat. Es ist unzuverlässig und hat zu viele Probleme.

time.perf_counter()

Performance-Zähler mit der höchstmöglichen Auflösung zur Messung kurzer Dauern. Er schließt die während des Schlafens verstrichene Zeit ein und ist systemweit. Der Bezugspunkt des zurückgegebenen Wertes ist undefiniert, sodass nur die Differenz zwischen den Ergebnissen aufeinanderfolgender Aufrufe gültig ist und eine Anzahl von Sekunden darstellt.

Er ist auf allen Plattformen verfügbar.

Pseudocode

if os.name == 'nt':
    def _win_perf_counter():
        if _win_perf_counter.frequency is None:
            _win_perf_counter.frequency = _time.QueryPerformanceFrequency()
        return _time.QueryPerformanceCounter() / _win_perf_counter.frequency
    _win_perf_counter.frequency = None

def perf_counter():
    if perf_counter.use_performance_counter:
        try:
            return _win_perf_counter()
        except OSError:
            # QueryPerformanceFrequency() fails if the installed
            # hardware does not support a high-resolution performance
            # counter
            perf_counter.use_performance_counter = False
    if perf_counter.use_monotonic:
        # The monotonic clock is preferred over the system time
        try:
            return time.monotonic()
        except OSError:
            perf_counter.use_monotonic = False
    return time.time()
perf_counter.use_performance_counter = (os.name == 'nt')
perf_counter.use_monotonic = hasattr(time, 'monotonic')

time.process_time()

Summe der System- und Benutzer-CPU-Zeit des aktuellen Prozesses. Sie schließt die während des Schlafens verstrichene Zeit nicht ein. Sie ist per Definition prozessweit. Der Bezugspunkt des zurückgegebenen Wertes ist undefiniert, sodass nur die Differenz zwischen den Ergebnissen aufeinanderfolgender Aufrufe gültig ist.

Er ist auf allen Plattformen verfügbar.

Pseudocode [2]

if os.name == 'nt':
    def process_time():
        handle = _time.GetCurrentProcess()
        process_times = _time.GetProcessTimes(handle)
        return (process_times['UserTime'] + process_times['KernelTime']) * 1e-7
else:
    try:
        import resource
    except ImportError:
        has_resource = False
    else:
        has_resource = True

    def process_time():
        if process_time.clock_id is not None:
            try:
                return time.clock_gettime(process_time.clock_id)
            except OSError:
                process_time.clock_id = None
        if process_time.use_getrusage:
            try:
                usage = resource.getrusage(resource.RUSAGE_SELF)
                return usage[0] + usage[1]
            except OSError:
                process_time.use_getrusage = False
        if process_time.use_times:
            try:
                times = _time.times()
                cpu_time = times.tms_utime + times.tms_stime
                return cpu_time / process_time.ticks_per_seconds
            except OSError:
                process_time.use_getrusage = False
        return _time.clock()
    if (hasattr(time, 'clock_gettime')
        and hasattr(time, 'CLOCK_PROF')):
        process_time.clock_id = time.CLOCK_PROF
    elif (hasattr(time, 'clock_gettime')
          and hasattr(time, 'CLOCK_PROCESS_CPUTIME_ID')):
        process_time.clock_id = time.CLOCK_PROCESS_CPUTIME_ID
    else:
        process_time.clock_id = None
    process_time.use_getrusage = has_resource
    process_time.use_times = hasattr(_time, 'times')
    if process_time.use_times:
        # sysconf("SC_CLK_TCK"), or the HZ constant, or 60
        process_time.ticks_per_seconds = _times.ticks_per_seconds

time.time()

Die Systemzeit, die normalerweise die bürgerliche Zeit ist. Sie ist per Definition systemweit. Sie kann manuell vom Systemadministrator oder automatisch von einem NTP-Daemon eingestellt werden.

Sie ist auf allen Plattformen verfügbar und kann nicht fehlschlagen.

Pseudocode [2]

if os.name == "nt":
    def time():
        return _time.GetSystemTimeAsFileTime()
else:
    def time():
        if hasattr(time, "clock_gettime"):
            try:
                return time.clock_gettime(time.CLOCK_REALTIME)
            except OSError:
                # CLOCK_REALTIME is not supported (unlikely)
                pass
        if hasattr(_time, "gettimeofday"):
            try:
                return _time.gettimeofday()
            except OSError:
                # gettimeofday() should not fail
                pass
        if hasattr(_time, "ftime"):
            return _time.ftime()
        else:
            return _time.time()

time.sleep()

Setzt die Ausführung für die angegebene Anzahl von Sekunden aus. Die tatsächliche Aussetzungszeit kann kürzer sein als die angeforderte, da jedes aufgefangene Signal time.sleep() nach der Ausführung der Routine zum Abfangen dieses Signals beendet. Außerdem kann die Aussetzungszeit aufgrund der Planung anderer Aktivitäten im System beliebig länger als angefordert sein.

Pseudocode [2]

try:
    import select
except ImportError:
    has_select = False
else:
    has_select = hasattr(select, "select")

if has_select:
    def sleep(seconds):
        return select.select([], [], [], seconds)

elif hasattr(_time, "delay"):
    def sleep(seconds):
        milliseconds = int(seconds * 1000)
        _time.delay(milliseconds)

elif os.name == "nt":
    def sleep(seconds):
        milliseconds = int(seconds * 1000)
        win32api.ResetEvent(hInterruptEvent);
        win32api.WaitForSingleObject(sleep.sigint_event, milliseconds)

    sleep.sigint_event = win32api.CreateEvent(NULL, TRUE, FALSE, FALSE)
    # SetEvent(sleep.sigint_event) will be called by the signal handler of SIGINT

elif os.name == "os2":
    def sleep(seconds):
        milliseconds = int(seconds * 1000)
        DosSleep(milliseconds)

else:
    def sleep(seconds):
        seconds = int(seconds)
        _time.sleep(seconds)

time.clock()

Unter Unix gibt die aktuelle Prozessorzeit als Gleitkommazahl in Sekunden zurück. Sie ist per Definition prozessweit. Die Auflösung und die genaue Bedeutung von „Prozessorzeit“ hängen von der C-Funktion mit demselben Namen ab, aber in jedem Fall ist dies die Funktion, die für das Benchmarking von Python oder die Zeitmessung von Algorithmen verwendet werden sollte.

Unter Windows gibt diese Funktion die Wandzeit in Sekunden zurück, die seit dem ersten Aufruf dieser Funktion verstrichen ist, als Gleitkommazahl, basierend auf der Win32-Funktion QueryPerformanceCounter(). Die Auflösung ist typischerweise besser als eine Mikrosekunde. Sie ist systemweit.

Pseudocode [2]

if os.name == 'nt':
    def clock():
        try:
            return _win_perf_counter()
        except OSError:
            # QueryPerformanceFrequency() fails if the installed
            # hardware does not support a high-resolution performance
            # counter
            pass
        return _time.clock()
else:
    clock = _time.clock

Eine Funktion mit einem Flag: time.monotonic(fallback=True)

• time.monotonic(fallback=True) fällt auf die Systemzeit zurück, wenn keine monotone Uhr verfügbar ist oder wenn die monotone Uhr fehlschlägt.
• time.monotonic(fallback=False) löst OSError aus, wenn die monotone Uhr fehlschlägt, und NotImplementedError, wenn das System keine monotone Uhr bereitstellt

Ein Keyword-Argument, das als Konstante im Aufrufer übergeben wird, ist normalerweise eine schlechte API.

Das Auslösen von NotImplementedError für eine Funktion ist in Python ungewöhnlich und sollte vermieden werden.

Eine time.monotonic()-Funktion, kein Flag

time.monotonic() gibt (time: float, is_monotonic: bool) zurück.

Eine Alternative ist die Verwendung eines Funktionsattributs: time.monotonic.is_monotonic. Der Attributwert wäre None vor dem ersten Aufruf von time.monotonic().

mach_absolute_time

Mac OS X bietet eine monotone Uhr: mach_absolute_time(). Sie basiert auf der absoluten verstrichenen Zeit seit dem Systemstart. Sie wird nicht angepasst und kann nicht eingestellt werden.

mach_timebase_info() gibt einen Bruch zur Umrechnung des Zählerwerts in Nanosekunden zurück. Siehe auch das Technical Q&A QA1398.

mach_absolute_time() stoppt während eines Ruhezustands auf einer PowerPC-CPU, aber nicht auf einer Intel-CPU: Different behaviour of mach_absolute_time() on i386/ppc.

CLOCK_MONOTONIC, CLOCK_MONOTONIC_RAW, CLOCK_BOOTTIME

CLOCK_MONOTONIC und CLOCK_MONOTONIC_RAW stellen eine monotone Zeit seit einem nicht spezifizierten Ausgangspunkt dar. Sie können nicht gesetzt werden. Die Auflösung kann mit clock_getres() gelesen werden.

Dokumentation: siehe die Handbuchseite Ihres Betriebssystems. Beispiele

• FreeBSD clock_gettime() Handbuchseite
• Linux clock_gettime() Handbuchseite

CLOCK_MONOTONIC ist mindestens auf den folgenden Betriebssystemen verfügbar

• DragonFly BSD, FreeBSD >= 5.0, OpenBSD, NetBSD
• Linux
• Solaris

Die folgenden Betriebssysteme unterstützen CLOCK_MONOTONIC nicht

• GNU/Hurd (siehe offene Probleme/ clock_gettime)
• Mac OS X
• Windows

Unter Linux kann NTP die Rate von CLOCK_MONOTONIC anpassen (slewed), aber sie kann nicht rückwärts springen.

CLOCK_MONOTONIC_RAW ist spezifisch für Linux. Es ist ähnlich wie CLOCK_MONOTONIC, bietet aber Zugriff auf eine rohe, hardwarebasierte Zeit, die keinen NTP-Anpassungen unterliegt. CLOCK_MONOTONIC_RAW erfordert Linux 2.6.28 oder neuer.

Linux 2.6.39 und glibc 2.14 führen eine neue Uhr ein: CLOCK_BOOTTIME. CLOCK_BOOTTIME ist identisch mit CLOCK_MONOTONIC, mit der Ausnahme, dass sie auch die Zeit einschließt, die im Ruhezustand verbracht wurde. Lesen Sie auch Waking systems from suspend (März 2011).

CLOCK_MONOTONIC stoppt, während der Computer im Ruhezustand ist.

Linux bietet seit Linux 2.6.32 auch CLOCK_MONOTONIC_COARSE. Es ist ähnlich wie CLOCK_MONOTONIC, weniger präzise, aber schneller.

clock_gettime() schlägt fehl, wenn das System die angegebene Uhr nicht unterstützt, auch wenn die Standard-C-Bibliothek sie unterstützt. Zum Beispiel erfordert CLOCK_MONOTONIC_RAW eine Kernelversion 2.6.28 oder neuer.

Windows: QueryPerformanceCounter

Hochauflösender Performance-Zähler. Er ist monoton. Die Frequenz des Zählers kann mit QueryPerformanceFrequency() gelesen werden. Die Auflösung ist 1 / QueryPerformanceFrequency().

Er hat eine viel höhere Auflösung, aber eine geringere Langzeitpräzision als die Uhren von GetTickCount() und timeGetTime(). Zum Beispiel wird er im Vergleich zu den Uhren mit geringer Präzision abweichen.

Dokumentation

• MSDN: QueryPerformanceCounter() Dokumentation
• MSDN: QueryPerformanceFrequency() Dokumentation

Hardware-Uhren, die von QueryPerformanceCounter verwendet werden

• Windows XP: RDTSC-Instruktion von Intel-Prozessoren, die Taktfrequenz ist die Frequenz des Prozessors (zwischen 200 MHz und 3 GHz, heutzutage meist größer als 1 GHz).
• Windows 2000: ACPI-Stromverwaltungs-Timer, Frequenz = 3.549.545 Hz. Er kann über das Flag "/usepmtimer" in boot.ini erzwungen werden.

QueryPerformanceFrequency() sollte nur einmal aufgerufen werden: die Frequenz ändert sich nicht, während das System läuft. Er schlägt fehl, wenn die installierte Hardware keinen hochauflösenden Performance-Zähler unterstützt.

QueryPerformanceCounter() kann nicht angepasst werden: SetSystemTimeAdjustment() passt nur die Systemzeit an.

Fehler

• Der Wert des Performance-Zählers kann aufgrund eines Hardwarefehlers unerwartet vorwärtssprungen. Siehe KB274323.
• Auf VirtualBox inkrementiert QueryPerformanceCounter() den oberen Teil nicht jedes Mal, wenn der untere Teil überläuft. Siehe Monotonic timers (2009).
• VirtualBox hatte einen Fehler in seinem HPET-virtualisierten Gerät: QueryPerformanceCounter() sprang um ca. 42 Sekunden vorwärts (Issue #8707).
• Windows XP hatte einen Fehler (siehe KB896256): auf einem Mehrprozessorcomputer gab QueryPerformanceCounter() für jeden Prozessor einen anderen Wert zurück. Der Fehler wurde in Windows XP SP2 behoben.
• Probleme mit Prozessoren mit variabler Frequenz: Die Frequenz wird je nach Arbeitslast geändert, um den Speicherverbrauch zu reduzieren.
• Chromium verwendet QueryPerformanceCounter() nicht auf Athlon X2 CPUs (Modell 15), da "QueryPerformanceCounter unzuverlässig ist" (siehe base/time_win.cc im Chromium-Quellcode)

Windows: GetTickCount(), GetTickCount64()

GetTickCount() und GetTickCount64() sind monoton, können nicht fehlschlagen und werden nicht von SetSystemTimeAdjustment() angepasst. MSDN-Dokumentation: GetTickCount(), GetTickCount64(). Die Auflösung kann mit GetSystemTimeAdjustment() gelesen werden.

Die von GetTickCount() oder GetTickCount64() abgerufene verstrichene Zeit schließt die Zeit ein, die das System im Ruhezustand oder Ruhezustand verbringt.

GetTickCount64() wurde zu Windows Vista und Windows Server 2008 hinzugefügt.

Es ist möglich, die Präzision mit der undokumentierten Funktion NtSetTimerResolution() zu verbessern. Es gibt Anwendungen, die diese undokumentierte Funktion verwenden, Beispiel: Timer Resolution.

WaitForSingleObject() verwendet denselben Timer wie GetTickCount() mit derselben Präzision.

Windows: timeGetTime

Die Funktion timeGetTime() ruft die Systemzeit in Millisekunden ab. Die Systemzeit ist die seit dem Start von Windows verstrichene Zeit. Lesen Sie die timeGetTime() Dokumentation.

Der Rückgabetyp von timeGetTime() ist eine 32-Bit-Ganzzahl ohne Vorzeichen. Wie GetTickCount() rollt timeGetTime() nach 2^32 Millisekunden (49,7 Tage) über.

Die von timeGetTime() abgerufene verstrichene Zeit schließt die Zeit ein, die das System im Ruhezustand verbringt.

Die Standardpräzision der Funktion timeGetTime() kann fünf Millisekunden oder mehr betragen, je nach Computer.

timeBeginPeriod() kann verwendet werden, um die Präzision von timeGetTime() auf bis zu 1 Millisekunde zu erhöhen, dies wirkt sich jedoch negativ auf den Stromverbrauch aus. Das Aufrufen von timeBeginPeriod() beeinflusst auch die Granularität einiger anderer Zeitaufrufe, wie z. B. CreateWaitableTimer(), WaitForSingleObject() und Sleep().

Solaris: CLOCK_HIGHRES

Das Solaris-Betriebssystem verfügt über eine CLOCK_HIGHRES-Uhr, die versucht, eine optimale Hardwarequelle zu verwenden, und möglicherweise eine Auflösung nahe der Nanosekunde liefert. CLOCK_HIGHRES ist die nicht einstellbare, hochauflösende Uhr. Für mit einem clockid_t-Wert von CLOCK_HIGHRES erstellte Timer versucht das System, eine optimale Hardwarequelle zu verwenden.

Die Auflösung von CLOCK_HIGHRES kann mit clock_getres() gelesen werden.

Solaris: gethrtime

Die Funktion gethrtime() gibt die aktuelle hochauflösende Echtzeit zurück. Die Zeit wird in Nanosekunden seit einer beliebigen Zeit in der Vergangenheit ausgedrückt; sie steht in keiner Korrelation zur Tageszeit und unterliegt daher keiner Zurücksetzung oder Abweichung durch adjtime() oder settimeofday(). Die HiRes-Uhr ist ideal für Leistungsmessungsaufgaben geeignet, bei denen eine kostengünstige, genaue Intervallzeitmessung erforderlich ist.

Die Linearität von gethrtime() wird über einen Suspend-Resume-Zyklus nicht beibehalten (Bug 4272663).

Lesen Sie die Handbuchseite gethrtime() von Solaris 11.

Auf Solaris ist gethrtime() dasselbe wie clock_gettime(CLOCK_MONOTONIC).

Windows: GetSystemTimeAsFileTime

Die Systemzeit kann mit GetSystemTimeAsFileTime(), ftime() und time() gelesen werden. Die Auflösung der Systemzeit kann mit GetSystemTimeAdjustment() gelesen werden.

Lesen Sie die GetSystemTimeAsFileTime() Dokumentation.

Die Systemzeit kann mit SetSystemTime() gesetzt werden.

Systemzeit unter UNIX

gettimeofday(), ftime(), time() und clock_gettime(CLOCK_REALTIME) geben die Systemzeit zurück. Die Auflösung von CLOCK_REALTIME kann mit clock_getres() gelesen werden.

Die Systemzeit kann mit settimeofday() oder clock_settime(CLOCK_REALTIME) gesetzt werden.

Linux bietet seit Linux 2.6.32 auch CLOCK_REALTIME_COARSE. Es ist ähnlich wie CLOCK_REALTIME, weniger präzise, aber schneller.

Alexander Shishkin schlug eine API für Linux vor, um benachrichtigt zu werden, wenn die Systemzeit geändert wird: timerfd: add TFD_NOTIFY_CLOCK_SET to watch for clock changes (4. Version der API, März 2011). Die API wurde noch nicht akzeptiert, aber CLOCK_BOOTTIME bietet eine ähnliche Funktion.

Funktionen

• Windows: GetProcessTimes(). Die Auflösung kann mit GetSystemTimeAdjustment() gelesen werden.
• clock_gettime(CLOCK_PROCESS_CPUTIME_ID): Hochauflösende Pro-Prozess-Uhr der CPU. Die Auflösung kann mit clock_getres() gelesen werden.
• clock(). Die Auflösung ist 1 / CLOCKS_PER_SEC.
  • Windows: Die seit Beginn des Prozesses verstrichene Wanduhrzeit (verstrichene Zeit in Sekunden mal CLOCKS_PER_SEC). Beinhaltet die während des Ruhezustands verstrichene Zeit. Kann fehlschlagen.
  • UNIX: Gibt eine Annäherung an die vom Programm verwendete Prozessorzeit zurück.
• getrusage(RUSAGE_SELF) gibt eine Struktur der Ressourcennutzung des aktuellen Prozesses zurück. ru_utime ist Benutzer-CPU-Zeit und ru_stime ist System-CPU-Zeit.
• times(): Struktur der Prozesszeiten. Die Auflösung ist 1 / ticks_per_seconds, wobei ticks_per_seconds sysconf(_SC_CLK_TCK) oder die Konstante HZ ist.

Der Python-Quellcode enthält eine portable Bibliothek, um die Prozesszeit (CPU-Zeit) zu erhalten (Tools/pybench/systimes.py).

Siehe auch die QueryProcessCycleTime() Funktion (Summe der Taktzyklen aller Threads) und clock_getcpuclockid().

Funktionen

• Windows: GetThreadTimes(). Die Auflösung kann mit GetSystemTimeAdjustment() gelesen werden.
• clock_gettime(CLOCK_THREAD_CPUTIME_ID): Threadspezifische CPU-Zeit-Uhr. Sie verwendet eine Anzahl von CPU-Zyklen, nicht eine Anzahl von Sekunden. Die Auflösung kann mit clock_getres() gelesen werden.

Siehe auch die QueryThreadCycleTime() Funktion (Taktzyklus für den angegebenen Thread) und pthread_getcpuclockid().

Funktionen

• sleep(Sekunden)
• usleep(Mikrosekunden)
• nanosleep(Nanosekunden, verbleibend): Linux-Manpage von nanosleep()
• delay(Millisekunden)

clock_nanosleep

clock_nanosleep(clock_id, flags, nanoseconds, remaining): Linux-Manpage von clock_nanosleep().

Wenn flags TIMER_ABSTIME ist, wird die Anfrage als absolute Zeit interpretiert, gemessen von der Uhr clock_id. Wenn die Anfrage kleiner oder gleich dem aktuellen Wert der Uhr ist, gibt clock_nanosleep() sofort zurück, ohne den aufrufenden Thread zu suspendieren.

POSIX.1 besagt, dass das Ändern des Wertes der CLOCK_REALTIME-Uhr über clock_settime(2) keine Auswirkungen auf einen Thread hat, der auf einer relativen clock_nanosleep() blockiert ist.

select()

select(nfds, readfds, writefds, exceptfs, timeout).

Seit Linux 2.6.28 verwendet select() hochauflösende Timer zur Behandlung des Timeouts. Ein Prozess hat ein "slack"-Attribut zur Konfiguration der Präzision des Timeouts, das Standard-Slack beträgt 50 Mikrosekunden. Vor Linux 2.6.28 wurden Timeouts für select() vom Hauptzeitgebersystem mit einer Auflösung im Jiffy-Level behandelt. Lesen Sie auch High- (aber nicht zu hoch-) resolution timeouts und Timer slack.

Andere Funktionen

• poll(), epoll()
• sigtimedwait(). POSIX: "Wenn die Monotonic Clock Option unterstützt wird, soll die CLOCK_MONOTONIC Uhr verwendet werden, um das Zeitintervall zu messen, das durch das Timeout-Argument angegeben ist."
• pthread_cond_timedwait(), pthread_condattr_setclock(). "Der Standardwert des Uhrenattributs bezieht sich auf die Systemzeit."
• sem_timedwait(): "Wenn die Timers Option unterstützt wird, basiert das Timeout auf der CLOCK_REALTIME Uhr. Wenn die Timers Option nicht unterstützt wird, basiert das Timeout auf der Systemzeit, wie sie von der time()-Funktion zurückgegeben wird. Die Präzision des Timeouts ist die Präzision der Uhr, auf der es basiert."
• WaitForSingleObject(): verwendet denselben Timer wie GetTickCount() mit derselben Präzision.