Präzise Gewinde Schlaf benötigt. Max 1ms Fehler

Sich aus der Frage, tags ich nehme an, du bist auf windows.
Werfen Sie einen Blick auf Multimedia-Timer, Sie werben für die Präzision unter 1ms.
Eine weitere Optionen ist die Verwendung Spin Locks aber das wird im Grunde halten Sie ein cpu-Kern bei maximaler Auslastung.

InformationsquelleAutor Marius

Ich war auf der Suche für leichte cross-Plattform-Standby-Funktion, die geeignet ist für Echtzeit-Anwendungen (also hohe Auflösung/hohe Präzision mit Zuverlässigkeit). Hier sind meine Ergebnisse:

Scheduling Grundlagen

Aufzugeben CPU und dann immer wieder ist teuer. Nach dieser Artikel, scheduler Latenz irgendwo zwischen 10-30ms auf Linux. Also, wenn Sie brauchen, um zu schlafen weniger als 10ms mit hoher Präzision, dann müssen Sie verwenden spezielle OS-spezifische APIs. Die üblichen C++11 std::this_thread::sleep_for ist nicht mit hoher Auflösung schlafen. Zum Beispiel auf meiner Maschine, quick-tests zeigt, dass es oft schläft mindestens 3ms, wenn ich bitten es zu schlafen für nur 1ms.

Linux

Beliebteste Lösung zu sein scheint, nanosleep () - API. Allerdings, wenn Sie wollen < 2ms Schlaf mit hoher Auflösung, als Sie brauchen, verwenden Sie auch sched_setscheduler Aufruf zum festlegen der thread - /Prozess-für real-time scheduling. Wenn Sie nicht als nanosleep() verhält sich genau wie veraltet usleep hatte die Auflösung von ~10ms. Eine andere Möglichkeit ist die Verwendung Alarme.

Windows

Lösung ist hier die Verwendung von multimedia-mal, wie andere vorgeschlagen haben. Wenn Sie möchten, zu emulieren die Linux nanosleep() auf Windows, unten ist, wie (original ref). Wieder, beachten Sie, dass Sie brauchen nicht zu tun CreateWaitableTimer() und immer wenn der Aufruf sleep() im loop.

#include <windows.h>    /* WinAPI */

/* Windows sleep in 100ns units */
BOOLEAN nanosleep(LONGLONG ns){
    /* Declarations */
    HANDLE timer;   /* Timer handle */
    LARGE_INTEGER li;   /* Time defintion */
    /* Create timer */
    if(!(timer = CreateWaitableTimer(NULL, TRUE, NULL)))
        return FALSE;
    /* Set timer properties */
    li.QuadPart = -ns;
    if(!SetWaitableTimer(timer, &li, 0, NULL, NULL, FALSE)){
        CloseHandle(timer);
        return FALSE;
    }
    /* Start & wait for timer */
    WaitForSingleObject(timer, INFINITE);
    /* Clean resources */
    CloseHandle(timer);
    /* Slept without problems */
    return TRUE;
}

Cross-Plattform-Code

Hier ist die time_util.cc implementiert Schlaf für Linux -, Windows-und Apple-Plattformen. Jedoch feststellen, dass es nicht real-time-Modus mit sched_setscheduler wie ich oben erwähnte, also, wenn Sie verwenden möchten, für <2ms, dann ist das etwas, das Sie tun müssen, zusätzlich. Eine andere Verbesserung, die Sie machen können, ist zu vermeiden, fordern CreateWaitableTimer für die Windows-version über und über wieder, wenn Sie anrufen, schlafen in einigen Schleife. Für wie dies zu tun, siehe Beispiel hier.

#include "time_util.h"

#ifdef _WIN32
#  define WIN32_LEAN_AND_MEAN
#  include <windows.h>

#else
#  include <time.h>
#  include <errno.h>

#  ifdef __APPLE__
#    include <mach/clock.h>
#    include <mach/mach.h>
#  endif
#endif //_WIN32

/**********************************=> unix ************************************/
#ifndef _WIN32
void SleepInMs(uint32 ms) {
    struct timespec ts;
    ts.tv_sec = ms / 1000;
    ts.tv_nsec = ms % 1000 * 1000000;

    while (nanosleep(&ts, &ts) == -1 && errno == EINTR);
}

void SleepInUs(uint32 us) {
    struct timespec ts;
    ts.tv_sec = us / 1000000;
    ts.tv_nsec = us % 1000000 * 1000;

    while (nanosleep(&ts, &ts) == -1 && errno == EINTR);
}

#ifndef __APPLE__
uint64 NowInUs() {
    struct timespec now;
    clock_gettime(CLOCK_MONOTONIC, &now);
    return static_cast<uint64>(now.tv_sec) * 1000000 + now.tv_nsec / 1000;
}

#else //mac
uint64 NowInUs() {
    clock_serv_t cs;
    mach_timespec_t ts;

    host_get_clock_service(mach_host_self(), SYSTEM_CLOCK, &cs);
    clock_get_time(cs, &ts);
    mach_port_deallocate(mach_task_self(), cs);

    return static_cast<uint64>(ts.tv_sec) * 1000000 + ts.tv_nsec / 1000;
}
#endif //__APPLE__
#endif //_WIN32
/************************************ unix <=**********************************/

/**********************************=> win *************************************/
#ifdef _WIN32
void SleepInMs(uint32 ms) {
    ::Sleep(ms);
}

void SleepInUs(uint32 us) {
    ::LARGE_INTEGER ft;
    ft.QuadPart = -static_cast<int64>(us * 10);  //'-' using relative time

    ::HANDLE timer = ::CreateWaitableTimer(NULL, TRUE, NULL);
    ::SetWaitableTimer(timer, &ft, 0, NULL, NULL, 0);
    ::WaitForSingleObject(timer, INFINITE);
    ::CloseHandle(timer);
}

static inline uint64 GetPerfFrequency() {
    ::LARGE_INTEGER freq;
    ::QueryPerformanceFrequency(&freq);
    return freq.QuadPart;
}

static inline uint64 PerfFrequency() {
    static uint64 xFreq = GetPerfFrequency();
    return xFreq;
}

static inline uint64 PerfCounter() {
    ::LARGE_INTEGER counter;
    ::QueryPerformanceCounter(&counter);
    return counter.QuadPart;
}

uint64 NowInUs() {
    return static_cast<uint64>(
        static_cast<double>(PerfCounter()) * 1000000 / PerfFrequency());
}
#endif //_WIN32

Andere noch komplette cross-Plattform-code kann finden Sie hier.

Eine Andere Schnelle Lösung

Wie Sie vielleicht bemerkt haben, obige code ist nicht mehr sehr leicht. Es muss der Windows-header unter anderem Dinge, die vielleicht nicht sehr wünschenswert, wenn Sie die Entwicklung header-only-Bibliotheken. Wenn Sie brauchen, schlafen weniger als 2ms und Sie sind nicht sehr scharf auf mit OS-code, dann kann man nur folgende einfache Lösung, die ist cross-Plattform und arbeitet sehr gut auf meine Prüfungen. Denken Sie nur daran, dass Sie jetzt nicht mit stark optimierten OS-code, die vielleicht viel besser auf Energie sparen und verwalten von CPU-Ressourcen.

typedef std::chrono::high_resolution_clock clock;
template <typename T>
using duration = std::chrono::duration<T>;

static void sleep_for(double dt)
{
    static constexpr duration<double> MinSleepDuration(0);
    clock::time_point start = clock::now();
    while (duration<double>(clock::now() - start).count() < dt) {
        std::this_thread::sleep_for(MinSleepDuration);
    }
}

Fragen

• Wie man thread schlafen weniger als einer Millisekunde auf Windows
• Cross-Plattform-Sleep-Funktion für C++
• Gibt es eine alternative sleep-Funktion in C, die Millisekunden?

InformationsquelleAutor Shital Shah

Diese Funktionen:

• CreateWaitableTimer
• SetWaitableTimer
• WaitForSingleObject

lassen, die Sie erstellen, eine wartemöglichkeit timer mit einer 100-Nanosekunden-Auflösung, warten Sie, und der aufrufende thread ausführen einer bestimmten Funktion bei trigger-Zeit.

Hier ist ein Beispiel für den Einsatz von Sprach-timer.

Beachten Sie, dass die WaitForSingleObject hat ein timeout, gemessen in Millisekunden, das könnte vielleicht funktionieren wie ein plumper Ersatz für die Wartezeit, aber ich würde nicht darauf Vertrauen. Sehen dies SO Frage für details.

InformationsquelleAutor didierc