Objet de transition / Optimisation de code
Bonjour,
J'aimerais vous soumettre le problème suivant :
L'un des programmes que j'utilise lit des fichiers dans divers formats.
Une première couche génère à partir de ces fichiers, des objets temporaires qu'il passe ensuite à une seconde couche qui les vérifie et instancie mon modèle de donnée.
Code:
1
2
3
| fichier format A --> [Brique A] -\
fichier format B --> [Brique B] ----> Objet intermédiaire ---> [traducteur] ---> Mon Modèle
fichier format C --> [Brique C] -/ |
L'intérêt de passer par cette couche intermédiaire réside dans le fait que les différents formats lus sont stables, alors que mon modèle est sujet à variations, je n'ai donc qu'une unique brique à modifier lorsque je change mon modèle.
Les inconvénients sont nombreux, mais il n'en est pas question ici.
Mon problème est d'optimiser l'une des briques qui lit les objets temporaire.
Cette brique utilise un unique objet de chaque type, le remplit au fur et à mesure, avant de la passer à ma seconde couche.
Elle le réinitialise ensuite, puis recommençe sa lecture.
Pour le moment, la réinitialisation est faite atomiquement, c'est à dire qu'elle ressemble à ça :
Code:
1
2
3
4
5
6
7
8
| MonObjetTemporaireDeTypeCapitaine::Reinit()
{
m_iAgeDuCapitaine = -1;
m_fTailleDuCapitaine = -1.0F;
m_pFemmeDuCapitaine = NULL;
m_sNomDuCapitaine = "unamed";
...
} |
Mais je me disais que je pourrais gagner du temps en créant un second objet temporaire avec mes valeurs par défaut avec ces valeurs et le copier à chaque fois pour réinitialiser l'autre (Je pense même qu'il s'agit d'un DP de création).
L'idée étant que la copie d'un bloc de mémoire de n octets est plus rapide que la copie de n blocks de mémoire de 1 octet. Il faut donc que je veille à ce que mon constructeur par recopie utilise bien une copie d'un block.
Je peux m'en sortir en faisant quelque chose comme ça :
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
|
struct SDonneeCopiablesDuCapitaine
{
int m_iAgeDuCapitaine;
float m_fTailleDuCapitaine;
Individu* m_pFemmeDuCapitaine;
};
struct SDonneeNonCopiablesDuCapitaine
{
std::string m_sNomDuCapitaine;
};
struct SDonneesDuCapitaine
{
SDonneeCopiablesDuCapitaine dc;
SDonneeNonCopiablesDuCapitaine dnc;
};
struct SDonneesAlternativesDuCapitaine
{
char dc[sizeof(SDonneeCopiablesDuCapitaine )];
SDonneeNonCopiablesDuCapitaine dnc;
};
class MonObjetTemporaireDeTypeCapitaine
{
union
{
SDonneesDuCapitaine dc;
SDonneesAlternativesDuCapitaine dac;
}
}; |
ce qui me permettrait de construire mon constructeur par recopie comme ça :
Code:
1
2
3
4
5
6
|
MonObjetTemporaireDeTypeCapitaine::MonObjetTemporaireDeTypeCapitaine(MonObjetTemporaireDeTypeCapitaine& toCopy)
{
dac.dc = tocopy.dac.dc; // ceci est une copie de tableau plus rapide qu'une somme de copies atomiques.
dac.dnc = tocopy.dac.dnc ; // ceci est une suite de copies atomiques.
} |
Cette façon de faire est un peu pénible car elle rend assez difficilement accessible mes données, et elle semble assez peu évolutive.
Les questions que je me pose avant de commençer à réaliser cette optimisation sont :
- Existe-t-il une façon plus élégante de gérer ce problème ?
- Est-ce seulement intelligent de le faire (peut-être le compilateur le fait-il pour moi sans que je le sache) ?
- Y a-t-il moyen d'automatiser la création des structures et des accesseurs en utilisant des template et des typelist. Le principal obstacle que je discerne étant, dans un typelist : comment reconnaitre un type copiable d'un type non-copiable ?
Merci d'avoir lu.
Merci à ceux qui répondront.
