Bonjour,

Dans un soft que je developpe actuellement, j'ai une section de code qui doit pouvoir s'excuter le plus rapidement possible.

Il s'agit d'un sequenceur musical.

Dans mon architecture, il y a un objet cSequencer qui contient :
- un buffer avec les evenements à traiter
- les parametres de timing
- un vecteur de "patterns" qui sont en cours de lecture, qui contient un vecteur des différentes pistes de ce pattern
- une fonction appellée très souvent qui sert à calculer le contenu du buffer.

Voici mon code (à peu près, je passe les détails)

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
 
class cSequencer
{
    void *buffer;
    int  paramTiming1;
    int  paramTiming2;
    int  paramTiming3;
    std::vector<cPattern*> vPatterns;
 
    void remplirBuffer();
}
 
class cPattern
{
    std::vector<cPiste*> vPistes;
    cSequencer *sequencer;           // pointeur vers le sequenceur
    void remplirBuffer();
}
 
class cPiste
{
    cPattern *pattern;           // pointeur vers le pattern
    void remplirBuffer();
}
Actuellement, j'ai ceci comme implémentation :

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
 
void cSequencer::remplirBuffer()
{
    std::vector<cPattern*>::const_iterator It;
    for(It=vPatterns.begin();It!=vPatterns.end();It++)
        (*It)->remplirBuffer();
}
 
void cPattern::remplirBuffer()
{
    std::vector<cPiste*>::const_iterator It;
    for(It=vPistes.begin();It!=vPistes.end();It++)
        (*It)->remplirBuffer();
}
 
void cPiste::remplirBuffer()
{
    // On calcule le contenu du buffer, en utilisant les infos de timing :
 
    pattern->sequencer->paramTiming1;
    pattern->sequencer->paramTiming2;
    pattern->sequencer->paramTiming3;
 
    // Et on remplit le buffer situé à l'adresse pointée par :
    pattern->sequencer->buffer;
}

Questions :
-----------

1/ Est-il plus efficace de passer les variables paramTiming1,paramTiming2,paramTiming3,*buffer à chaque fonction remplirBuffer ou est-ce plus rapide de récuperer ces valeurs par pointeur comme je le fait actuellement ?

2/ Quel conteneur STL est le plus rapide pour parcourir toute sa liste par un itérateur ?

Merci !