Discussion :

[ApprentiIngenieur]

Bonjour,

Comme l'indique mon pseudo je suis actuellement apprentis.

Dans le cadre de mon alternance professionnel je dois développer un environnement de travail purement virtuel ( c’est à dire, sur un pc avec VisualStudio) en langage C , à partir d'un code source C d'un système embarqué.
De ce fait je suis amené à "bouchonner" et/ou simuler tout un tas de fonctions qui dépendent du hard, dans le but de faire fonctionner le code source sur pc.

Je dois notamment simuler un composant physique externe, par l'intermédiaire d'un timer dans un thread qui fonctionnerait en parallèle du main (ou programme principal) .

J'aurai donc besoin d'un timer avec un pas en mirco-secondes, ou au pire en milli-secondes .

Voici donc ma question : Quelles sont les ressources disponibles pour créer un timer en langage C d'un pas de 1 micro-secondes, sur un pc sous windows avec visual studio ?

J'ai bien sur pensé à la fonction Sleep(Xms), mais d'après mes collègues, trop imprécise en dessous de 20 ms.

Je vous remercie par avance, et m'excuse pour la gène occasionné, mais si je vous sollicite, c'est que je suis tout nouveau dans le monde de la programmation professionnelle.

Merci !

Cordialement,

[ternel]

la micro seconde n'est pas accessible.

Ton timer ne sera pas plus précis que le scheduler de l'OS, qui est souvent calés sur des millisecondes.
Tu peux éventuellement avoir une mesure du temps plus précise, mais pas un contrôle.

[gangsoleil]

J'ai bien sur pensé à la fonction Sleep(Xms), mais d'après mes collègues, trop imprécise en dessous de 20 ms.

C'est probablement parce que le quantum de temps de ton processeur est de 20ms... Je pense que tu ne te rends pas bien compte de ce que tu demandes en fait, mais tu peux essayer de regarder du côté du temps-réel s'il y a des fonctionalités qui pourraient t'aider -- attention, ce n'est pas parce qu'on parle de temps réel que tu auras accès à des microsecondes.

[Invité]

Tu peux regarder du côté de la fonction nanosleep().

D'après mes souvenirs, on peut accéder grâce au temps réel à un pas de 1ms.
Sous linux, il est possible de modifier le noyaux pour allez jusqu'au 1µs. Mais je serai bien incapable de te dire ce qui est à modifier, je ne l'ai jamais réalisé encore.

[ternel]

nanosleep permet de le faire en théorie, mais le temps d'attente réel peut être plus grand.
La promesse est que le système fera du mieux qu'il peut pour attendre le temps suggéré, pas moins.

Tu peux aussi ne pas faire de sleep, et directement utiliser une mesure de "maintenant", mais avec la même imprécision.

Cela signifie que tu vas pouvoir lisser ton action, en fonction des derniers passages.
C'est le genre de chose qui se fait dans les jeux vidéos (soit toujours, soit avec l'option "limiter le FPS")

[ApprentiIngenieur]

Re,

Merci pour vos réponses! finalement en me baladant sur internet et en discutant avec des collègues je me suis bien rendu compte qu'un timer d'un pas de 1 microseconde n'est pas réalisable (sur windows en tout cas. "Sur linux il y aurait plus de possibilités")

Effectivement je ne me rendais pas bien compte de ce que je demandais. Du coup j'ai revu mes objectifs à la baisse ce qui n'est très grave au final car mon but est de créer un environnement de développement.

J'ai donc donc fais des tests avec la fonction SleepEx et j'arrive au mieux à un timer de 15 ms avec un delta de 1 ms, je vais devoir me contenter de ça ^^

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include <windows.h>
#include <time.h>
#include <stdio.h>
 
void main(void)
{
 
long i = 6000000L;
clock_t start, finish;
long double duration; 
 
while(1)
   {
   			start = clock();
			SleepEx(20, FALSE);
			finish = clock();
			duration = (long double)(finish - start) / CLOCKS_PER_SEC;
			printf( "%Lf seconds\n", duration );
   }
}

voila de ce qui est pour mon code de test, qui est bien sur soumis aussi à la précision de la fonction "clock".
En tout cas pour cet exemple(avec SleepEx(20, FALSE);) je trouve comme résultats :

15 ms
16 ms
31 ms
15 ms
16 ms
31 ms
....
...

bizarre le 31 ms
Par contre pour SleepEx(15, FALSE); je vais trouver

15 ms
16 ms
15 ms
16 ms

c'est un peu mieux mais ça reste un peu aléatoires bizarre comme résultats ^^

gangsoleil, tu veux dire quoi par "fonctionnalités du côté du temps-réel " ?

archMqx, j'ai regardé pour nanosleep et au passage usleep sur internet, mais je n'ai rien trouvé de vraiment convaincant. J'ai fais quelques tests mais à chaque fois les variables n'étaient pas reconnu du fait de la bibliothèque non lue sur windows ( peut être ? c'est ce que j'ai compris)

Merci!

[gangsoleil]

tu veux dire quoi par "fonctionnalités du côté du temps-réel " ?

Il y a certains OS qui supportent des modes pseudo-temps réel, c'est à dire un mode dans lequel tu peux émuler des fonctionalités temps-réel. Bien sur, tu ne pourras jamais trouver de temps-réel dur sans passer par du hardware, mais ça permet déjà pas mal de choses.

Quant au pas de 1 micro-seconde sous Linux, ne rève pas, ce n'est pas atteignable non plus.

[Médinoc]

À ma connaissance, le quantum de temps de Windows est de 1/64e de seconde, soit environ 15.6ms. La seule mesure de temps sous Windows qui soit vraiment plus précise est QueryPerformanceCounter().

[ApprentiIngenieur]

Ce qui pourrait expliquer pourquoi je trouve du 15~16ms en intervalle de temps minimum quand je fais un SleepEx(15, FALSE); et encore en-dessous ( SleepEx(10, FALSE).

En tout cas merci et Je vais essayer avec QueryPerformanceCounter() pour des mesures de temps précises plus précises.

[Obsidian]

Ce qui pourrait expliquer pourquoi je trouve du 15~16ms en intervalle de temps minimum quand je fais un SleepEx(15, FALSE); et encore en-dessous ( SleepEx(10, FALSE).
En tout cas merci et Je vais essayer avec QueryPerformanceCounter() pour des mesures de temps précises plus précises.

Si c'est pour faire des mesures, tu peux adopter l'approche inverse : lire une horloge. Soit l'horloge système, soit utiliser RDTSC ou RDTSCP pour lire directement le compteur de cycles du micro-processeur qui, lui, est très régulier. En revanche, ça va dépendre notoirement de beaucoup de choses : la cadence du micro-processeur elle-même, les effets dus au pipelining, à la parallélisation sur les différents cœurs et, enfin et surtout, au frequency scaling si tu fonctionne sur une machine prévue pour gérer cela (fort probable sur une machine de bureau pas trop vieille).