Optimisation du nombre d'instruction: Contrainte de temps

Version imprimable

Bonjour,

Je cherche à optimiser un temps d'exécution de code qui devient critique, je dois faire des tests sur une variable qui s'incrémente et faire changer l'état d'une sortie en conséquent, le code est le suivant:

Code:

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
if(Data_transmitted < 100)     //1 clock=104µs so approximately 10 ms
    {
            LATAbits.LATA2=0b1;
            a1=1;
     }
else if(Data_transmitted == 100)// End//Start
    {
            LATAbits.LATA2=0;
    }
 
else if(Data_transmitted == 101)// End//Start
    {
            LATAbits.LATA2=1;
    }
else if(Data_transmitted == 118)// End//Start
    {
            LATAbits.LATA2=1;
    }
else if(Data_transmitted == 119)
    {
            LATAbits.LATA2=0;
    }
else if(Data_transmitted == 120)
    {
            LATAbits.LATA2=0;
    }
else if(Data_transmitted == 121)
    {
            LATAbits.LATA2=1;
    }
else
   {
            LATAbits.LATA2=1;
    }
}

Avez vous des pistes pour optimiser ce code ?

Je n'ai pas testé, mais avec un dictionnaire (pour les valeurs > 100). Avec la valeur sur laquelle ti fais tes "if" en clé, et 1 ou 0 comme valeur de cette clé. Genre :
Code:

1 2 3 4 5 6 7 8 9 10 11 var dict = new Dictionary<int,int> {{100,1},{101,0}}; var example = 101; int i; LATAbits.LATA2 = (dict.TryGetValue(example, out i)) ? i : 1; // 1 semble être la valur par défaut dans ton example

17/08/2015, 20h05
Kangourex

1) Je ne sais pas si ça un réel impact de temps mais peut-être qu'un switch à la place de tes nombreux else if pourrait se faire dépend comment à bas niveau cela est géré.
Mais déjà cela rendrait le code plus propre à voir ^^

2) Vu ta structure que tu présentes tu peux :

If( < 100) LATAbits.LATA2 = 0b1;
Else if(Data == 100 || == 118 || ==119) LATAbits.LATA2 = 0;
Else LATAbits.LATA2 = 1;

3) Ou t'arranger pour faire en sorte que le = 0 soit sur les data paires et = 1 quand elles sont impaires comme ça tu pourrais faire un truc comme ça

If( < 100) LATAbits.LATA2 = 0b1;
Else LATAbits.LATA2 = Data % 2;
18/08/2015, 11h55
StringBuilder

Je suis un peu perplexe sur le fait que ce bout de code puisse mettre plus de... allez, 4 cycles CPU ?

Il n'y aura rien de plus rapide qu'un if / else if / else.

Un switch reviendra, d'un point de vue performances (et code machine) rigoureusement au même.

Une recherche dans un dictionnaire se traduira forcément par une itération, ce qui sera infiniment plus lent (non pas que ce soit lent, mais que 100 cycles CPU est "infiniment" plus lent que 4 cycles...)

Avez-vous benchmarké ce bout de code ?

Est-ce que Data_transmitted est un type simple (int) ? Ou bien est-ce que ça cache du monde ? Genre une propriété avec un GET extrêmement coûteux (genre un .Count sur un List<T>) ?

Car là, autant on peut redire sur la lisibilité d'un if à rallonge, autant on ne peut rien dire quant à ses performances.
18/08/2015, 11h57
StringBuilder
Sinon, j'ai pas tout pigé...
Code:

1 2 //1 clock=104µs so approximately 10 ms
Chez moi, 104 µs, ça fait 0,104 ms...

Et ça rebondi bien sur ce que je dis, à mon avis, c'est pas là que ça bloque votre truc...
18/08/2015, 17h38
mansgueg

Je viens de changer le code en passant par des switch case. Cela résout le probleme. Merci pour votre aide !
18/08/2015, 20h50
Pol63

Citation:

Envoyé par StringBuilder

Une recherche dans un dictionnaire se traduira forcément par une itération

le dictionnaire utilise un index par hashage, ce qui en lecture est très efficace (pas de parcours de toute la collection)
19/08/2015, 10h26
DonQuiche

Citation:

Envoyé par StringBuilder

Je suis un peu perplexe sur le fait que ce bout de code puisse mettre plus de... allez, 4 cycles CPU ?

Je suis également circonspect, je parie que le problème est mal diagnostiqué. A moins d'utiliser un CPU rudimentaire avec une prédiction de branchement limitée.

Par contre un switch sera presque toujours plus rapide. Souvent ils sont très optimisés, avec par exemple une approche dichotomique quand c'est pertinent. Ici il y a de bonnes chances que le compilateur décide d'utiliser un switch matériel (un lookup dans un tableau), ce qui est clairement le plus rapide.

Certes un compilateur pourrait réaliser que ces if enchaînés se prêtent aux mêmes optimisations. Mais les compilos JIT doivent s'exécuter rapidement et se fixent des objectifs limités.

Citation:

Envoyé par Pol63

le dictionnaire utilise un index par hashage, ce qui en lecture est très efficace (pas de parcours de toute la collection)

La notion d'efficacité est relative. Ça reste du 20ns par accès pour un petit dico. C'est très rapide pour la majorité des besoins, néanmoins pendant cette période un coeur peut idéalement traiter 400 instructions. Nul doute qu'un dictionnaire serait ici beaucoup plus inefficace qu'un switch bien optimisé.

Plus qu'un problème de perf sj 'y vois aussi un problème de lisibilité.
concernant les perfs tout dépend aussi de la fréquence d'appel.
j 'écrirais ton code de la manière suivante au vue de ce que tu as écris.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
         switch(Data_transmitted)
        {
            case 100:
            case 119:
            case 120:
                LATAbits.LATA2=0;
 
            default:
             LATAbits.LATA2=1;
 
        }
         if(Data_transmitted < 100)     //1 clock=104µs so approximately 10 ms
        {
                LATAbits.LATA2=0b1;
                a1=1;
        }