Discussion :

[MonsieurAk]

bonjour,
Je cherche à réaliser des pauses dans un programme de l'ordre de la microseconde.
Sous certains OS, on peut trouver cela en standard (usleep, nanosleep)
Mais sous windows, j'ai beau cherché je ne trouve pas grand chose en standard:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
#define usleep(x) Sleep(x/1000) ... Ah non ca ne va pas marcher.

Il y a aussi le select (je viens de le voir dans un post antérieur), mais rien ne ganrantit que ca marche. (je n'ai pas testé...)

Bref, N'y a-t- il aucune méthode pour le faire ?

[Ditch]

sleep(0) ca ne fonctionne pas? Ca laisse juste le temps de donner la main

[MonsieurAk]

Salut,
j'ai lu (sur internet) une remarque sur l'utilisation de sleep(0) qui interrompt le thread en cours (au minimum je crois me souvenir que l'interruption est de 6µs et max 150µs mais je ne suis pas certain des valeurs, mais il est vrai que nous sommes de l'ordre de la µs)

Cependant, dans mon cas je désire spécifier le temps d'attente.
je veux pouvoir faire varier ce temps d'attente entre [1microseconde et 1 milliseconde]

La solution proposée n'est donc pas utilisable...

PS: J'ai essayé de faire fonctionner via un select mais c'est pas propre et devoir définir une socket etc. etc C'est pas top.
C'est tout de même surprenant que ce ne soit pas standard sous Windows (seulement la milliseconde !) Alors que sur d'autres OS, le standard est de l'ordre de la NANOsecondes !)

[hegros]

En même temps Windows (quel est ta version en fait ?) n'est pas un OS avec un noyau temps réel ce qui veut dire que tu ne peux pas spécifier une attente < a la milliseconde parce que le système ne sait pas le faire...

[MonsieurAk]

quel est ta version en fait ?

Windows XP

n'est pas un OS avec un noyau temps réel ce qui veut dire que tu ne peux pas spécifier une attente < a la milliseconde parce que le système ne sait pas le faire...

Remarque très constructive.
Mais alors je me pose la question suivante:
Sur linux (admettons une redHat), j'ai la possibilité de le faire (via usleep, nanosleep). son noyau n'est pourtant pas du temps réel ? (c'est une version standard que j'utilise (pas une version linux temps réel utilisé en embarqué par exemple)

Merci en tout cas de suivre ce sujet (pauvre en réponse et information)

[Grulim]

Dans des OS non temps réels, le fait que la fonction existe n'indique pas que le délai est respecté...
usleep(20) indique que la tache s'endort pour au moins 20 µs

[buzzkaido]

Disons plutot que si windows ne fourni pas de usleep, c'est surement car la precision n'est pas garantie.

Pour le sleep non plus, d'ailleurs, aucune garantie.

Mais si la precision moyenne est, mettons, de 20 microsecondes, c'est suffisant pour faire un sleep(milisecondes)

La precision moyenne du timer de windows doit etre trop grande pour se permettre de compter dessus lors d'un usleep...

Sous linux, la fonction est implementée, mais avec quelle precision ?

Ca depend surement de comment tu le configures et de la distribution que tu utilises...

---------

Sinon, il y a peut-etre une autre solution (qui permet d'augmenter artificiellement la precision du timer) :

Tu declenche un timer à une frequence elevée mais acceptable (genre toutes les 10 millisecondes) et à chaque appel tu faire un appel à getTimerSystem (ou une fonction du meme genre) qui te renvoit le temps systeme (generalement en microsecondes)

A chaque appel, tu fait la difference avec le temps systeme precedent, ca te donne le nombre de microsecondes qui se sont ecoulées...

Comme ça, meme si une action a enormement ralentit le systeme et que des appels n'ont eu lieu que toutes les 10secondes, tu gardes quand meme la precision....


Cette technique m'a permis d'avoir une bonne precision en Java : je souhaiter deplacer un dessin à l'ecran toutes les 15ms.

En declenchant un timer toutes les 15ms, l'animation était sacadée (un coup 15ms, un coup 20, un coup 10)

En comptant le temps ecoulé entre deux appels, j'ai pu interpoler mon mouvement en fonction de ça et j'ai obtenu une animation visiblement plus fluide et surtout le dessin mettait exactement 4 secondes pour aller d'un bout à l'autre de l'ecran, à la miliseconde pres !

Voila, si ca peut t'inspirer une solution, tant mieux !

[Grulim]

Tu peux peut être t'en sortir avec

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

QueryPerformanceCounter

et

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

QueryPerformanceFrequency

??

[buzzkaido]

Pour info, une microseconde, c'est vachement petit !

Derriere cette verité universelle, se cache une experience personnelle :

En projet de 3ème année d'école d'ing, j'ai réalisé une carte electronique de controleur d'injection pour une voiture.

En gros, il faut injecter le carburant au bon moment et pendant la bonne durée.

Si mes souvenirs sont bons, les temps étaient de l'ordre de quelques microsecondes (voiture speciale pour le marathon ecoshell)

Malgré un microcontoleur entierement dédié au timing et programmé en assembleur, les tests à l'oscilloscopes ont mis en evidence des décalages allant jusqu'a 10% sur les timing.

De plus, les relais ouvrant les vannes à carburant rajoutaient un peu de latence.

Là je parle bien de hardware electronique, sans OS, et executant une seule et unique tache...

La precision n'etait donc pas flambante, sauf si on avait utilisé des composants à 20.000 $ (mais largement suffisante)

-------------------
Morale de l'histoire :

Je sais pas pourquoi tu veux compter des microsecondes, mais j'espere que t'as une bonne raison, pasque avec du matos grand public, c'est pas gagné !

[MonsieurAk]

Je sais pas pourquoi tu veux compter des microsecondes, mais j'espere que t'as une bonne raison, pasque avec du matos grand public, c'est pas gagné !

En effet !


Merci pour vos réponses.

[buzzkaido]

Avec le QueryPerformanceCounter, tu peut savoir combien de temps s'est passé, avec une precision (d'apres la doc) de l'ordre de la nanoseconde...

En gros, je pense que ça compte le nombre de cycles d'horloge.

Du coup, tu peux faire un truc du genre :

timeFin = QueryPerformanceCounter + quelquesMilisecondes
while (QueryPerformanceCounter < timeFin) {};

Comme ça, tu fait une pause tres courte, d'au moins quelquesMilisecondes, mais rien ne t'assures qu'elle n'a pas duré plus longtemps...

[hegros]

Avec le QueryPerformanceCounter, tu peut savoir combien de temps s'est passé, avec une precision (d'apres la doc) de l'ordre de la nanoseconde...

En gros, je pense que ça compte le nombre de cycles d'horloge.

Du coup, tu peux faire un truc du genre :

timeFin = QueryPerformanceCounter + quelquesMilisecondes
while (QueryPerformanceCounter < timeFin) {};

Comme ça, tu fait une pause tres courte, d'au moins quelquesMilisecondes, mais rien ne t'assures qu'elle n'a pas duré plus longtemps...

Le code que tu mets ne permet pas de spécifier une attendre de l'ordre de la micro ou nanoseconde.

Tu récupéres et compare 2 temps c'est tout.

[buzzkaido]

Pardon, j'ai mal ecrit le code, mais c'eatit pour l'esprit du truc

timeFin = QueryPerformanceCounter + quelquesMilisecondes
time = QueryPerformanceCounter
while (time < timeFin)
{
time = QueryPerformanceCounter
};