Discussion :

[lvr]

Bonjour,

Je souhaite exécuter une opération à une cadence très précise et rapide. De l'ordre de 3ms. Quand je dis précis, je veux dire pas 3,1ms, pas 2,9, mais 3ms, car je dois m'aligner sur d'autre système.

La manière dont je bosse (voir le code ci-dessous), c'est qu'avant l'exécution de mon code, je mesure le temps avec System.nanoTime(). Je le remesure après. Je déduis la différence de ma fréquence pour savoir combien de temps je vais devoir mettre ma thread en sommeil.
Problème, je n'arrive pas à avoir un rapport 1:1 entre le moment réel de réexuction de ma thread et le moment souhaité. J'ai un écart (relativement constante) de 2,5%. En termes de ms, ce n'est pas énorme: ça fait 0,075ms.
Mais ça introduit un déphasage croissant avec les messages extérieures sur lesquelles j'essaye de me synchroniser.

Voici mon code:

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
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
    public void run() {
 
        // Tant que la Thread qui m'a démarrée est égale à la Thread voulue par Start() et Stop(), alors je continue.
        Thread me = Thread.currentThread();
 
        // Latence: initialition
        iterStartTime = 0;
 
        // Boucle de traitement qui tournera toutes les (RATE - Latence)  millisecondes
        while (ProcessingThread == me) {
 
            // Latence: initialition du calcul du temps mis par m'exécution
            iterStartTime = System.nanoTime();
 
            // Exécution du travail
            clEvent[] midiouts = Process(eventsStack, processFrom, processFrom);
	    ...	
 
            // On calcule le temps qu'on a pris pour cette exécution
            long iterLength = System.nanoTime() - iterStartTime;
 
 
            // on attend RATE (en microseconde)  - le temps qu'il a fallu pour processer (en nanosecondes)
            long r = RATE * 1000 - iterLength;
            if (r < 0) r = 0;
            long Rmilli = r / 1000000;
            int Rnano = (int) (r % 1000000);
 
            // On initilise pour la prochaine fois
            processFrom += RATE;
 
            try {
                Thread.sleep(Rmilli, Rnano);
            } catch (InterruptedException ex1) {
                ATVSTECentral.logger().log1.println("A problem occured while the thread is waiting:\n" + ex1.toString());
            }
        }
    }

Est-ce que quelqu'un y voir une raison de ce déphasage ?
Merci,

Laurent

[MrCba]

Il y a une possibilité que ton code :

Code :

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

1
2
3
4
5
6
7
8
// on attend RATE (en microseconde)  - le temps qu'il a fallu pour processer (en nanosecondes)
            long r = RATE * 1000 - iterLength;
            if (r < 0) r = 0;
            long Rmilli = r / 1000000;
            int Rnano = (int) (r % 1000000);
 
            // On initilise pour la prochaine fois
            processFrom += RATE;

prenne du temps non ?
Mais je suis pas expert.

alors :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
// on attend RATE (en microseconde)  - le temps qu'il a fallu pour processer (en nanosecondes)
            iterStartTime2 = System.nanoTime();
            long r = RATE * 1000 - iterLength;
            if (r < 0) r = 0;
            long Rmilli = r / 1000000;
            int Rnano = (int) (r % 1000000);
 
// On initilise pour la prochaine fois
            processFrom += RATE;
 
            Rnano+=-iterStartTime2+System.nanoTime();

Je pense cependant qu'il faille faire autrement.
En faite tu dois avoir plusieurs Thread de lecture qui se déclenche respectivement une tout de suite à 3ms à 6ms à 9ms. et ainsi de suite.
Tu dois avoir une boucle de cadencement de ces threads de lecture qui permet de connaitre excatement quand les déclenchés soit lancement du premier Thread + 3ms.... Disons que c'est une solution à étudier.

Il est certain que ton problème n'est pas évident. Il y a un tutoriel disponible sur ce site sur le temps réelle. Peut etre que cela peut etre utile

[CheryBen]

L'idéal serait d'utiliser un Timer ainsi qu'une TimerTask. C'est l'API java qui gère le cadencement, par contre je ne connais pas sa précision à la nanoseconde près mais dans la théorie cela fonctionne. Voila comment les utiliser :

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
public class Test {
    public void methodA() {
        new Updater().start();
    }
}
 
public class Updater extends Timer{
    public static final int UPDATE_PERIODE = 3;
    public void start() {
        schedule(new TonTraitement(), 0, UPDATE_PERIODE);
    }
 
    private class TonTraitement extends TimerTask {
 
        public void run() {
            // ton traitement
        }
    }
}

[lvr]

Merci. J'essaye dès que je rentre.

[lvr]

Bon je n'ai pas essayé le Timer, mais la doc indique un cadencement à la milliseconde, ce qui ne me convient pas. Il me faut un cadencement à la nanoseconde !!
Je vais essayer la solution proposée par MrCba.

[MrCba]

Bon je n'ai pas essayé le Timer, mais la doc indique un cadencement à la milliseconde, ce qui ne me convient pas. Il me faut un cadencement à la nanoseconde !!
Je vais essayer la solution proposée par MrCba.

Mon idée s'approche beaucoup de celle du timer.
Essaye de regarder les sources du timer, si cela se trouve il est facilement possible d'utiliser des Nanosecondes en l'adaptant.