Discussion :

[ffb.boy.30]

Bonjour,
J'ai créé un thread dans lequel je fais des calculs lié au temps comme un PID.
Je cherche une idée qui me permettrait de faire des boucles d'environ 1ms, j'ai essayé thread.sleep(1) mais c'est un désastre.
J'ai essayé cette solution aussi

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
            UInt16 i = 0;
 
 
            DateTime _Start = DateTime.Now;
            DateTime _New = DateTime.Now;
            do
            {
                while ((DateTime.Now - _New)< TimeSpan.FromMilliseconds(1))  ;
                _New = DateTime.Now;
                i++;
                //Thread.Sleep(1);
            } while (i < 5000);
 
            TimeSpan _Span = DateTime.Now.Subtract(_Start);
            Console.WriteLine("dt {0}", _Span);

​Mais ma boucle de 5000 tours à pris 7.6 seconde.

Je pensais à la solution d'intégrer un coefficient Delta T à chaque boucle au lieu d'une simple incrémentation. Mais il faut que je me rapproche de la ms pour ne pas trop dériver.

Si quelqu'un a une idée je suis preneur.

[ffb.boy.30]

Je m'auto réponds

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
Stopwatch _St = new Stopwatch();
            _St.Start();
            DateTime _Start = DateTime.Now;
            do
            {
                while (_St.ElapsedMilliseconds < 1)
                {
 
                }
                _St.Restart();
                i++;
                //Thread.Sleep(1);
            } while (i < 5000);
 
            TimeSpan _Span = DateTime.Now.Subtract(_Start);
            Console.WriteLine("dt {0}", _Span.TotalMilliseconds);

et mes 5000 boucles durent 5003,8292ms

[François DORIN]

Bonjour,

Une attente active comme ça, en général, ce n'est pas vraiment la solution. Cela va consommer énormément de temps CPU pour rien.

J'avais écris un article à ce sujet, qui montre notamment comment réaliser des tâches périodiques : https://fdorin.developpez.com/tutori...eadpool/part4/


Toutefois, ici on est dans un cas particulier : la période est de 1ms. Les API .Net sont très bien adaptées pour réaliser des tâches périodiques dont la période est supérieure à la ms.

Pour les périodes inférieurs, il faudrait que je regarde pour voir si les choses ont changé, mais l'API ne permet pas de mettre en attente. Il faut donc dans ce cas là, utiliser une attente active, par exemple, comme tu l'as fait avec StopWatch.

Donc pour résumer, en fonction de la durée de la période :
- > 1ms : suivre les préconisations de mon tutoriel, basées sur des Thread.Sleep, Task.Delay, etc.
- < 1ms : attente active avec Stopwatch

Attention toutefois : sur des périodes aussi basse, on atteint ce que l'on appel des systèmes temps-réel. .Net n'a pas été conçu pour ça et cela peut générer quelques surprises (=non respect des périodes, par exemple si le ramasse-miettes se déclenche ou simplement préemption par d'autres tâches/processus). Il faut donc vérifier la tolérance au non respect des contraintes temporels. Et cela dépend du système contrôlé (certains n'accepteront aucune déviance, tandis que d'autres toléreront 19 déviances sur 20 !)