c++, usleep() est obsolète, des solutions de contournement pour Windows/MingW?

J'ai déjà trouvé une autre question que Windows/MingW ne fournit pas les nanosleep() et setitimer() les solutions de rechange à l'obsolètes usleep().
Mais mon but est de corriger tous les avertissements que cppcheck me donne, y compris la usleep() style de mises en garde.

Alors, est-il une solution de contournement à quelque sorte d'éviter usleep() sur Windows sans l'utilisation de cygwin ou de l'installation des charges de nouvelles dépendances et les bibliothèques? Merci.

De quoi êtes-vous à l'aide de usleep?
question connexe: stackoverflow.com/questions/85122/... (j'ai pensé à proposer à utiliser, sélectionnez comme alternative)
À l'aide de select est une excellente idée. Il n'est pas très efficace, mais encore une fois quand on est en attente, qui s'en soucie. D'autre part, il est aussi portable que vous pouvez obtenir. Il n'existe pas de grave plate-forme qui n'a pas de sélectionner.
seulement aveuglément à essayer de résoudre tous les avertissements émis par cppcheck, sans réflexion sur leur raison d'être, et ce que cela signifie pour votre projet, ne semble pas être la meilleure idée
Il n'y a rien d'obsolète sur usleep.

OriginalL'auteur blubberbernd | 2011-04-27

  1. -3

    usleep() travaille avec les microsecondes. Dans windows pour obtenir de la microseconde precesion vous devez utiliser QueryPerformanceCounter() winapi fonction. Ici vous pouvez trouver comment obtenir que precesion de l'utiliser.

    Alors que QueryPerformanceCounter peut donner à haute résolution des valeurs de l'horloge, il n'est pas un vrai temps de sommeil de l'API, il peut seulement vous permettre de vous occupé-attendre.

    OriginalL'auteur Mihran Hovsepyan

  2. 38

    J'ai utilisé ce code (à l'origine de ici):

    #include <windows.h>

void usleep(__int64 usec) 
{ 
    HANDLE timer; 
    LARGE_INTEGER ft; 

    ft.QuadPart = -(10*usec); //Convert to 100 nanosecond interval, negative value indicates relative time

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

    Noter que SetWaitableTimer() utilise "100 intervalles de nanosecondes ... les valeurs Positives indiquent que le temps absolu. ... Les valeurs négatives indiquent un temps relatif." et que "La réelle précision de la minuterie dépend de la capacité de votre matériel."

    Si vous avez un compilateur C++11, alors vous pouvez utiliser cette version portable:

    #include <chrono>
#include <thread>
...
std::this_thread::sleep_for(std::chrono::microseconds(usec));

    Bravo de Howard Hinnant qui a conçu l'incroyable <chrono> de la bibliothèque (et dont la réponse ci-dessous mérite plus d'amour.)

    Si vous n'avez pas de C++11, mais vous avez coup de pouce, alors vous pouvez faire cette à la place:

    #include <boost/thread/thread.hpp>
#include <boost/date_time/posix_time/posix_time.hpp>
...
boost::this_thread::sleep(boost::posix_time::microseconds(usec));
    Et si vous avez le C++14, vous pouvez utiliser le ms défini par l'utilisateur littérale, comme dans std::this_thread::sleep_for(100ms);. Cela ne fonctionne que sur des valeurs constantes (évidemment), et nécessite un using directive. Voir cette réponse pour plus de détails.
    GCC mise en œuvre de std::this_thread::sleep_for utilisera ::nanosleep lors de la prise en charge, mais ::Sleep sur Windows avec milliseconde. Ne sais pas à propos de VS un.

    OriginalL'auteur Adi Shavit

  3. 8

    L'ordre de la milliseconde régime de la Sleep() fonction est bien expliqué et bien compris. Il ne fait rien d'imprévisible. Parfois, la fonction est blâmé pour effectuer imprévisible, c'est à dire retourner avant le délai a expiré. Je dois dire que c'est faux. Une enquête approfondie permettra de confirmer que son comportement est absolument prévisible. Le seul problème est
    il y a beaucoup à lire à ce sujet et la plupart des il est kiddish. Il est souvent dit que
    windows-il pas un système d'exploitation temps réel. Mais ces commentaires ne contribuent pas quoi que ce soit, d'ailleurs telle
    les commentaires sont utilisés pour masquer le manque de connaissances. Il me rend sorte de colère, qui n'est même pas
    microsoft avis le présent et offre une meilleure documentation.

    Cependant, sans exagérer cette petite réponse: Le sleep() la fonction est précis, lorsqu'il est utilisé de manière adéquate, et que si l'on connaît les caractéristiques. Une attention particulière doit être accordée à dormir(0). C'est un très puissant outil, particulièrement lorsqu'il est utilisé conjointement avec le processus de la classe de priorité, la priorité de thread, multimédia réglages de la minuterie, le processeur et le masque d'affinité.

    Donc généralement un vrai sommeil peut être effectuée facilement et en sécurité vers le bas pour les systèmes d'interruption de la période. Quand il s'agit de dort plus courte que la période d'interruption de la filature est nécessaire.
    Une résolution plus élevée source de temps doit être utilisé dans oder pour spin pour de courtes périodes dans le temps.
    La source la plus commune pour ce qui est du compteur de performance. QueryPerformanceCounter(*arg) offre une incrémentation *arg. QueryPerformanceFrequency(*arg) offre la fréquence à laquelle le compteur de performance à la fois. C'est généralement dans l'MHz régime et varie selon le matériel sous-jacent. Une fréquence dans la gamme MHz offre une résolution. De cette façon, quelque chose de haute résolution peut être utilisée pour attendre un laps de temps d'expirer. Cependant, la précision de cette doit être examiné avec soin: Le système retourne le compteur de performance de fréquence est constante. C'est une erreur! Puisque la fréquence est généré être un périphérique physique, il y a toujours un décalage et il est également pas un
    constante. Il a dérive thermique. Des systèmes plus modernes ont moins de dérive. Mais si la dérive thermique est juste 1ppm, l'erreur sera 1/s. Le décalage peut facilement être plusieurs 100. Un décalage de 100 à 1MHz correspond à 100us/s.

    Si un thread est d'attendre tout du temps à haute résolution, il doit établir un thread de service. Deux fils doivent partager un événement nommé. Le thread de service doit dormir jusqu'à 1 interruption de la période avant la mise en sommeil de retard, et puis tourner sur le compteur de performance pour le reste de la microseconde. Lorsque le thread de service atteint la fin des temps, il a créé l'événement nommé et se termine. Le thread de réveil, parce qu'il a été en attente pour l'événement nommé par le biais d'une fonction d'attente.

    Résumé:

    • Sommeil est bien compris, mais mal documentée.
    • Un thread de service peuvent imiter dort à haute résolution.
    • Un tel service thread coulb être esablished comme un système de services à l'échelle.
    • Exactitude du compteur de performance est à examiner attentivement. Un étalonnage est nécessaire.

    Des informations plus détaillées peuvent être trouvées à l' Windows Timestamp Projet

    Pas tout à fait! La résolution n'est pas nécessairement l'inverse de la fréquence signalée Sur l'un de mes cartons, FPQ() retourne la valeur nominale fréquence d'horloge du PROCESSEUR, mais QPC() retourne toujours un multiple de 10. Je suppose que cela est dû à la mise en œuvre d'un "invariant du CST" un.k.un. constant_tsc.
    Ai-je suggérer de ne pas faire confiance à la suite de la FQD? Oui je l'ai fait, parce que son résultat ne montre jamais la vérité, il ne montre jamais la fréquence physique. Il doit être considéré comme une estimation de constant. Les rapports de la fréquence d'horloge du PROCESSEUR à 1 hz unités est un peu stupide. Même des unités de 10 sont ridicules parce que la fréquence réelle s'écarte par plusieurs ppm. 1ppm est égal à 2000Hz sur un processeur à 2 ghz matériel. Donc plus réaliste de granularité pour la sortie de la FQD devrait/pourrait être 1ppm de la fréquence. BTW: Ce serait donner aux gens aussi le soupçon que la sortie de FQD n'est qu'une estimation.
    J'ai été spécifiquement répondre "à Une fréquence dans la gamme MHz offre une résolution" et je pense que vous avez mal interprété moi: Mes résultats suggèrent que la QPC() compte les étapes de la de 10 sur un de mes boîtes, donnant un résolution de l'ordre de 1/(240 MHz); pas de 1/(2.4 GHz). Dérive de l'horloge/inclinaison est une autre boîte de pandore...
    Ainsi, 1/240MHz est ~ 4ns. C'est beaucoup mieux que la microseconde de résolution. Et: bien sûr, la résolution est également déterminée par la quantification/granularité (présumée dans tous les ci-dessus).
    a juste porté à mon attention: constant TSC serait de retour FPQ() avec CPU freq./1024. La fréquence du PROCESSEUR. il n'existe pas de matériel, il est gernerated par un multiplicateur de fréquence (1024).

    OriginalL'auteur Arno

  4. 8

    Nouvelle réponse pour une vieille question:

    Justification de la réponse: Outils /OSs ont été mis à jour tel qu'il y est un meilleur choix aujourd'hui qu'il y a lorsque la question a été initialement demandé.

    Le C++11 <chrono> et <thread> std-têtes ont été dans le VS jeu d'outils depuis plusieurs années maintenant. L'utilisation de ces en-têtes de ce qui est le mieux codé en C++11:

    std::this_thread::sleep_for(std::chrono::microseconds(123));

    Je suis en utilisant microsecondes seulement comme un exemple de la durée. Vous pouvez utiliser quelle que soit la durée qui se passe pour être pratique:

    std::this_thread::sleep_for(std::chrono::minutes(2));

    Avec C++14 et certains à l'aide de directives, ce qui peut être écrit un peu plus compacte:

    using namespace std::literals;
std::this_thread::sleep_for(2min);

    ou:

    std::this_thread::sleep_for(123us);

    Cela fonctionne bien sur VS-2013 (modulo la chrono-littéraux). Je ne suis pas sûr au sujet des versions antérieures de VS.

    OriginalL'auteur Howard Hinnant

  5. 4

    Cela dépend de ce que granularité dont vous avez besoin. Si vous parlez en millisecondes, puis Win32 fonction de Veille va faire le travail - voir http://msdn.microsoft.com/en-us/library/ms686298%28v=vs.85%29.aspx. Si vous parlez de la microseconde, alors il n'y a pas de moyen facile de le faire, et vous seriez chanceux pour obtenir ce genre de résolution du timer sur Windows (qui n'est pas un RTOS), ou sur Linux, venez pour que.

    OriginalL'auteur Neil Butterworth

  6. 4

    J'ai trouvé ce billet de blog à ce sujet. Il utilise QueryPerformanceCounter. La fonction posté le:

    #include <windows.h>

void uSleep(int waitTime) {
    __int64 time1 = 0, time2 = 0, freq = 0;

    QueryPerformanceCounter((LARGE_INTEGER *) &time1);
    QueryPerformanceFrequency((LARGE_INTEGER *)&freq);

    do {
        QueryPerformanceCounter((LARGE_INTEGER *) &time2);
    } while((time2-time1) < waitTime);
}

    J'espère que cela aide un peu.

    C'est une attente active. Il sera déchets de cycles CPU.
    Oui, il le fera. Autant que je sache, le processus de windows planificateur de ne pas fournir le sommeil procédure avec une précision. Vous pouvez créer un hybride fonction de veille, utilisez alors la valeur par défaut de fonction de Veille pour les millisecondes et l'utilisation occupé attente pour le dernier petit temps d'attente. Cela peut réduire les performances d'accès à moins de 5 ms de occupé attente sans pour autant sacrifier la précision.
    Le code actuel est ignorant la valeur de freq. Au lieu de cela, si waitTime est donné en microsecondes, le test final doit être time2-time1 < waitTime*freq/1000000 .

    OriginalL'auteur orlp