Chargement d'un grand nombre d'instances rapidement.

Version imprimable

23/02/2014, 18h14
Thomshao

Chargement d'un grand nombre d'instances rapidement.

Bonjour,

je n'ai pas trouvé sur le forum ni sur google de réponse à mon problème.

Je suis actuellement sur un projet nécessitant une initialisation d'un grand nombre d'instances d'une classe (~350). Pour des comparaison afin de choisir un candidat.

Disons que cette classe que l'on appellera Modele contient 2 vecteur de 30 et 15 instances de la classe Element ainsi que quelques valeurs double et un string. La classe Element contient 5 double.

Les classes Model et Element contiennent toute deux des méthodes qui leurs sont propres.

Cela vous donne une idée de la structure.

Je génère me modèles moi même. ce qui me permet des les enregistrer dans un fichier type json, xml ou tout autre format souhaité.

J'ai aussi générer du code avec les données des modèles pour ensuite l'inclure dans une méthode d'initialisation de mes modèles.

Mon problème est que cela prend beaucoup trop de temps à mon gout.

Pour tant l'initialisation de mes modèles ne comporte aucun traitement. Elle ne fait que définir les valeurs.

Connaissez une méthode de sérialisation efficace et simple (hors boost qui est lourd (code qui sera embarqué) ou un autre moyen d'initialiser très rapidement des centaines d'instances.

J'avais aussi pensé a déclarer un genre d'objet en static const avec toutes les valeurs et initialisation dans les constructeur imbriqués mais je trouve que ça fait un peu bricolage ;)

J'utilise visual studio pour la qualité de l'ide mais je souhaite un code poartable sous max et linux.

Merci d'avance.

Salut,

A vrai dire, 350 éléments, c'est peu!

Je crois que ton problème principal vient avant tout de vouloir utiliser json et xml. Ce sont des formats très utiles, mais ce sont des formats qui augmentent très largement les temps de lecture par rapport à de simple fichiers plats (par exemple). Et ils ne sont réellement intéressants que lorsqu'il s'agit de mettre différents éléments en relations les uns avec les autres. Et encore!

As tu, simplement, essayé de lire (et d'écrire) tes données dans un fichier plat :question: Après tout, peut être pourrais tu te contenter d'un
Code:

1 2 3 4 5 6 7 8 9 10 Modele model; ifs>>model.str>>model.double1>>model.double2 /* >> ... */; size_t elemCount; ifs>>elemCount; model.elems.reserve(elemCount); for(size_t i = 0;i<elemCount; ++i){ Element elem; ifs>>elem.double1>>elem.double2>>elem.double3>>elem.double4>>elem.double5; model.elems.push_back(elem); }
(c'est très certainement perfectible ;))Je serais surpris de voir la différence en termes de temps de chargements ;)

23/02/2014, 22h46
JolyLoic

Si l'utilisation d'un format classique est préférée, une autre voie de progrès est de tester différentes bibliothèques XML/JSON. Ces dernières ne sont en effet pas toutes égales en terme de rapidité de lecture.

A tester

Citation:
Envoyé par koala01
Salut,

A vrai dire, 350 éléments, c'est peu!

Je crois que ton problème principal vient avant tout de vouloir utiliser json et xml. Ce sont des formats très utiles, mais ce sont des formats qui augmentent très largement les temps de lecture par rapport à de simple fichiers plats (par exemple). Et ils ne sont réellement intéressants que lorsqu'il s'agit de mettre différents éléments en relations les uns avec les autres. Et encore!

As tu, simplement, essayé de lire (et d'écrire) tes données dans un fichier plat :question: Après tout, peut être pourrais tu te contenter d'un
Code:

1 2 3 4 5 6 7 8 9 10 Modele model; ifs>>model.str>>model.double1>>model.double2 /* >> ... */; size_t elemCount; ifs>>elemCount; model.elems.reserve(elemCount); for(size_t i = 0;i<elemCount; ++i){ Element elem; ifs>>elem.double1>>elem.double2>>elem.double3>>elem.double4>>elem.double5; model.elems.push_back(elem); }
(c'est très certainement perfectible ;))Je serais surpris de voir la différence en termes de temps de chargements ;)
Je test cette solution et reviens pour vous faire par du résultat.

En effet c'est très peu mais pourtant là ou une de-sérialisation des données en C# met environ 440ms. Cela met 3 minutes à s'instancier quand je codes les initialisation de ces objets en dur !!

Ce temps est peut être dut au débogueur de VS et au fait du nombre d'instruction présentes dans le fichier mais je trouve ça bizarre.

Pour le format de fichier, comme je le disais je ne souhait pas particulièrement du json ou xml. A vrai dire un format binaire le plus compact et occulte possible m'irait très bien ;)

Merci

24/02/2014, 11h58
JolyLoic

Les temps que tu indiques ont l'air extrêmement louches... Je pense qu'il y a un problème ailleurs... Ne ferais-tu pas plein de copies dans tous les sens ? Tu peux reproduire sur un cas simplifié à l’extrême (une vingtaine de lignes) la situation entre C++ et C# qu'on voit si on voit un loup ?
24/02/2014, 12h21
r0d

A noter que l'import/export en json est globalement (c'est à dire que ce n'est pas toujours le cas) plus rapide que le xml de par sa syntaxe un peu plus optimisée, en particulier pour la représentation des tableaux (et encore en particulier pour les tableaux d'objets).
24/02/2014, 13h38
dragonjoker59

Bonjour !

En quel mode effectues-tu tes tests de performance ?
Je te vois parler du débogueur de Visual Studio et ça m'inquiète.
En effet, tu ne pourras avoir un véritable aperçu des performances qu'en release et sans passer par le débogueur (Ctrl + F5 pour lancer ton programme).
24/02/2014, 14h07
white_tentacle

Même en debug, 3 minutes, c’est un temps totalement délirant. Comme le signale Loïc, il y a quelque chose qui ne va pas dans le code, et qui n’a absolument rien à voir avec le format de sérialisation.

Citation:

Envoyé par white_tentacle

Même en debug, 3 minutes, c’est un temps totalement délirant. Comme le signale Loïc, il y a quelque chose qui ne va pas dans le code, et qui n’a absolument rien à voir avec le format de sérialisation.

En lançant en release, on arrive à 65773 ms.

Pour le C# avec une seule instruction ça le fait en 440 ms :

Code:

modeles = (Modeles)new BinaryFormatter().Deserialize(file_stream_modeles);

Je vous met un exemple en C++ :

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
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
 
m = new Modele(); 
 m->nom = "a" ; 
 m->id_modele = 1 ; 
 m->prop_a = 6508.5; 
 m->prop_b = 85.41662601625049; 
 m->prop_c = 51; 
 m->prop_d = -3; 
 m->prop_e = 0; 
 m->prop_f = -20; 
 m->paire = Paire(87, 41); 
 m->elements = elements(30); 
 m->elements.tab.push_back(Elmt(-6, -16, -1.9295669970654687, 17.088007490635061, 292)); 
 m->elements.tab.push_back(Elmt(-6, -15, -1.9513027039072615, 16.15549442140351, 261)); 
 m->elements.tab.push_back(Elmt(-5, -15, -1.8925468811915389, 15.811388300841896, 250)); 
 m->elements.tab.push_back(Elmt(-6, -15, -1.9513027039072615, 16.15549442140351, 261)); 
 m->elements.tab.push_back(Elmt(-6, -16, -1.9295669970654687, 17.088007490635061, 292)); 
 m->elements.tab.push_back(Elmt(-6, -15, -1.9513027039072615, 16.15549442140351, 261)); 
 m->elements.tab.push_back(Elmt(-6, -15, -1.9513027039072615, 16.15549442140351, 261)); 
 m->elements.tab.push_back(Elmt(-5, -15, -1.8925468811915389, 15.811388300841896, 250)); 
 m->elements.tab.push_back(Elmt(2, -10, -1.3734007669450159, 10.198039027185569, 104)); 
 m->elements.tab.push_back(Elmt(13, 4, 0.29849893158617929, 13.601470508735444, 185)); 
 m->elements.tab.push_back(Elmt(5, 15, 1.2490457723982544, 15.811388300841896, 250)); 
 m->elements.tab.push_back(Elmt(6, 15, 1.1902899496825317, 16.15549442140351, 261)); 
 m->elements.tab.push_back(Elmt(12, 6, 0.46364760900080609, 13.416407864998739, 180)); 
 m->elements.tab.push_back(Elmt(15, 0, 0, 15, 225)); 
 m->elements.tab.push_back(Elmt(15, 0, 0, 15, 225)); 
 m->elements.tab.push_back(Elmt(15, 1, 0.066568163775823808, 15.033296378372908, 226)); 
 m->elements.tab.push_back(Elmt(7, -15, -1.1341691669813554, 16.552945357246848, 274)); 
 m->elements.tab.push_back(Elmt(6, -16, -1.2120256565243244, 17.088007490635061, 292)); 
 m->elements.tab.push_back(Elmt(8, -10, -0.89605538457134393, 12.806248474865697, 164)); 
 m->elements.tab.push_back(Elmt(15, 0, 0, 15, 225)); 
 m->elements.tab.push_back(Elmt(-6, 14, 1.9756881130799799, 15.231546211727817, 232)); 
 m->elements.tab.push_back(Elmt(-6, 16, 1.9295669970654687, 17.088007490635061, 292)); 
 m->elements.tab.push_back(Elmt(-6, 15, 1.9513027039072615, 16.15549442140351, 261)); 
 m->elements.tab.push_back(Elmt(-7, 15, 2.0074234866084382, 16.552945357246848, 274)); 
 m->elements.tab.push_back(Elmt(-6, 15, 1.9513027039072615, 16.15549442140351, 261)); 
 m->elements.tab.push_back(Elmt(-6, 16, 1.9295669970654687, 17.088007490635061, 292)); 
 m->elements.tab.push_back(Elmt(-6, 15, 1.9513027039072615, 16.15549442140351, 261)); 
 m->elements.tab.push_back(Elmt(-7, 15, 2.0074234866084382, 16.552945357246848, 274)); 
 m->elements.tab.push_back(Elmt(-8, 11, 2.1995926132103296, 13.601470508735444, 185)); 
 m->elements.tab.push_back(Elmt(-15, 0, 3.1415926535897931, 15, 225)); 
 m->elements.autre = Autre(36, 41, 126, 133) ; 
 m->auto_corr = elements(); 
 m->elements.tab.push_back(Elmt(1, 0, 0, 1, 1)); 
 m->elements.tab.push_back(Elmt(0.83360745614035092, -0.10951206140350878, -0.13062323719023991, 0.84077005329973131, 0.70689428252563302)); 
 m->elements.tab.push_back(Elmt(0.59484649122807021, -0.12335526315789473, -0.20447508759057573, 0.60750215561354193, 0.3690588690751001)); 
 m->elements.tab.push_back(Elmt(0.37623355263157893, -0.087582236842105268, -0.22871363748013804, 0.38629306793682655, 0.14922233433604568)); 
 m->elements.tab.push_back(Elmt(0.19709429824561403, -0.085800438596491224, -0.4105849598719305, 0.21496017692652125, 0.046207877664281319)); 
 m->elements.tab.push_back(Elmt(0.017543859649122806, -0.20038377192982457, -1.4834677042609015, 0.20115029968710479, 0.040461443064212066)); 
 m->elements.tab.push_back(Elmt(-0.15323464912280702, -0.32661732456140352, -2.0094661268099339, 0.360776571295087, 0.13015973439543899)); 
 m->elements.tab.push_back(Elmt(-0.30208333333333331, -0.40529057017543857, -2.2113147980120291, 0.50548470456672556, 0.25551478655090987)); 
 m->elements.tab.push_back(Elmt(-0.38706140350877194, -0.48149671052631576, -2.2478933853751535, 0.61778281971405058, 0.3816556123338431)); 
 m->elements.tab.push_back(Elmt(-0.41104714912280704, -0.54564144736842102, -2.2164241528184263, 0.68314299227050002, 0.46668434788829249)); 
 m->elements.tab.push_back(Elmt(-0.40501644736842107, -0.53508771929824561, -2.2187089914630791, 0.67108657413387063, 0.45035718998273511)); 
 m->elements.tab.push_back(Elmt(-0.33168859649122806, -0.47341008771929827, -2.1819496415854402, 0.57804362828139044, 0.33413443619671435)); 
 m->elements.tab.push_back(Elmt(-0.22834429824561403, -0.39459978070175439, -2.0953866949669884, 0.45590580767429861, 0.20785010547115457)); 
 m->elements.tab.push_back(Elmt(-0.13815789473684212, -0.2955043859649123, -2.0081342185427804, 0.32620614035087719, 0.1064104460026162)); 
 m->elements.tab.push_back(Elmt(-0.1084155701754386, -0.17269736842105263, -2.131390651960527, 0.20390761858258813, 0.041578316916022234)); 
 m->elements.autre = Autre(0, 0, 0, 0) ; 
 ls_m.push_back(f);

Je ne vous met d'une instance. En mettre plusieurs ne servirait à rien car ensuite seul les valeurs changent.

Donc ce code est répété 350 fois. Dans les classes instanciées, il n'y a aucun calcul, que des assignations de valeurs dans les constructeurs.

Effectivement es temps sont assez louches.

Je vais maintenant tester la sauvegarde / restauration dans un fichier plat.

24/02/2014, 15h29
white_tentacle

Citation:

Envoyé par Thomshao

En lançant en release, on arrive à 65773 ms.

Pour le C# avec une seule instruction ça le fait en 440 ms :

Ça reste beaucoup trop lent. Par rapport à la sérialisation binaire c#, qui est extrêmement optimisée, avoir plus qu’un facteur 10 de différence est signe d’une grosse anomalie.

Citation:

Je ne vous met d'une instance. En mettre plusieurs ne servirait à rien car ensuite seul les valeurs changent.

Donc ce code est répété 350 fois. Dans les classes instanciées, il n'y a aucun calcul, que des assignations de valeurs dans les constructeurs.

Effectivement es temps sont assez louches.

Je vais maintenant tester la sauvegarde / restauration dans un fichier plat.

Tu peux éventuellement poster les classes suivantes ?
- Elmt
- modele
- elements

Le problème doit vraisemblablement venir de l’une d’entre elles.

En fait, il faut vraiment voir comment tu gère le remplissage de tes tableaux.

Un simple exemple : en faisant en sorte que les tableaux ne soient redimensionnés qu'une seule fois, il est possible, en mode débug, de créer un fichier qui contient 1000 élement et de le lire (pour remplir un tableau de Modeles) en moins de 0.75 secondes.

Dans le code qui suit, la fonction createFile se contente d'écrire (modelCount) modèles identiques dans un fichier, et la fonction readFile s'occupe de leur récupération dans tofill. La fonction main demande d'écrire (et de récupérer par la suite) 1000 modèle. En mode debug, l'exécution prend à peu près 0.73 secondes. L'exécution descend à 0.42 secondes en mode release ;)

La lecture seule (une fois que le fichier est créé, il suffit de commenter l'appel à createFile) s'effectue en 0.5 secondes à peu près en mode debug et en à peu près 0.25 secondes en mode release. Impressionnant, non :question:

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
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
#include <iostream>
#include <vector>
#include <string>
#include <fstream>
class  Element{
    friend std::ostream & operator<<(std::ostream & , Element const &);
    friend std::istream & operator>>(std::istream &, Element &);
public:
    Element(){}
    Element(int one, int two, double three, double four, int five):
        one_(one),two_(two),five_(five),three_(three), four_(four){}
    int  one() const{return one_;}
    int two() const{return two_;}
    double three() const{return three_;}
    double four() const{return four_;}
    int five() const{return five_;}
private:
    int one_;
    int two_;
    int five_;
    double three_;
    double four_;
};
std::ostream & operator <<(std::ostream & ofs, Element const & elem){
   ofs<<elem.one_<<" "
      <<elem.two_<<" "
      <<elem.three_<<" "
      <<elem.four_<<" "
      <<elem.five_;
    return ofs;
}
std::istream & operator>>(std::istream & ifs, Element & elem){
   ifs>>elem.one_
      >>elem.two_
      >>elem.three_
      >>elem.four_
      >>elem.five_;
    return ifs;
}
class Model{
    friend void createFile(std::string const &, size_t);
    friend std::ostream & operator<<(std::ostream & , Model const &);
    friend std::istream & operator>>(std::istream &, Model &);
private:
    std::string name_;
    size_t id_;
    double a_;
    double b_;
    double c_;
    double d_;
    double e_;
    double f_;
    std::vector<Element> tab_;
};
 std::ostream & operator<<(std::ostream & ofs, Model const & model){
   ofs<<model.name_<<" "
      <<model.id_<<" "
      <<model.a_<<" "
      <<model.b_<<" "
      <<model.c_<<" "
      <<model.d_<<" "
      <<model.e_<<" "
      <<model.f_<<" "
      <<model.tab_.size()<<std::endl;
      for(auto const & it: model.tab_){
        ofs<<it<<std::endl;
      }
    return ofs;
}
std::istream & operator>>(std::istream &ifs, Model &model){
   ifs>>model.name_
      >>model.id_
      >>model.a_
      >>model.b_
      >>model.c_
      >>model.d_
      >>model.e_
      >>model.f_;
    size_t sizeTab;
    ifs>>sizeTab;
    model.tab_.reserve(sizeTab);
    Element elem;
    for(size_t i =0;i<sizeTab;++i){
        ifs>>elem;
        model.tab_.push_back(elem);
    }
    return ifs;
}
void createFile(std::string const & filename, size_t modelCount){
    Model m;
    m.name_="a";
    m.a_ = 6508.5;
    m.b_ = 85.41662601625049;
    m.c_ = 51;
    m.d_ = -3;
    m.e_ = 0;
    m.f_ = -20;
    m.tab_.reserve(30);
    m.tab_.push_back(Element(-6, -16, -1.9295669970654687, 17.088007490635061, 292));
    m.tab_.push_back(Element(-6, -15, -1.9513027039072615, 16.15549442140351, 261));
    m.tab_.push_back(Element(-5, -15, -1.8925468811915389, 15.811388300841896, 250));
    m.tab_.push_back(Element(-6, -15, -1.9513027039072615, 16.15549442140351, 261));
    m.tab_.push_back(Element(-6, -16, -1.9295669970654687, 17.088007490635061, 292));
    m.tab_.push_back(Element(-6, -15, -1.9513027039072615, 16.15549442140351, 261));
    m.tab_.push_back(Element(-6, -15, -1.9513027039072615, 16.15549442140351, 261));
    m.tab_.push_back(Element(-5, -15, -1.8925468811915389, 15.811388300841896, 250));
    m.tab_.push_back(Element(2, -10, -1.3734007669450159, 10.198039027185569, 104));
    m.tab_.push_back(Element(13, 4, 0.29849893158617929, 13.601470508735444, 185));
    m.tab_.push_back(Element(5, 15, 1.2490457723982544, 15.811388300841896, 250));
    m.tab_.push_back(Element(6, 15, 1.1902899496825317, 16.15549442140351, 261));
    m.tab_.push_back(Element(12, 6, 0.46364760900080609, 13.416407864998739, 180));
    m.tab_.push_back(Element(15, 0, 0, 15, 225));
    m.tab_.push_back(Element(15, 0, 0, 15, 225));
    m.tab_.push_back(Element(15, 1, 0.066568163775823808, 15.033296378372908, 226));
    m.tab_.push_back(Element(7, -15, -1.1341691669813554, 16.552945357246848, 274));
    m.tab_.push_back(Element(6, -16, -1.2120256565243244, 17.088007490635061, 292));
    m.tab_.push_back(Element(8, -10, -0.89605538457134393, 12.806248474865697, 164));
    m.tab_.push_back(Element(15, 0, 0, 15, 225));
    m.tab_.push_back(Element(-6, 14, 1.9756881130799799, 15.231546211727817, 232));
    m.tab_.push_back(Element(-6, 16, 1.9295669970654687, 17.088007490635061, 292));
    m.tab_.push_back(Element(-6, 15, 1.9513027039072615, 16.15549442140351, 261));
    m.tab_.push_back(Element(-7, 15, 2.0074234866084382, 16.552945357246848, 274));
    m.tab_.push_back(Element(-6, 15, 1.9513027039072615, 16.15549442140351, 261));
    m.tab_.push_back(Element(-6, 16, 1.9295669970654687, 17.088007490635061, 292));
    m.tab_.push_back(Element(-6, 15, 1.9513027039072615, 16.15549442140351, 261));
    m.tab_.push_back(Element(-7, 15, 2.0074234866084382, 16.552945357246848, 274));
    m.tab_.push_back(Element(-8, 11, 2.1995926132103296, 13.601470508735444, 185));
    m.tab_.push_back(Element(-15, 0, 3.1415926535897931, 15, 225));
    std::ofstream ofs(filename);
    ofs<<modelCount<<std::endl;
    for(size_t i= 1;i<=modelCount;++i){
        m.id_ = i;
        ofs<<m;
    }
 
}
void readFile(std::string const & filename, std::vector<Model> & tofill){
    tofill.clear();
    std::ifstream ifs(filename);
    size_t size;
    ifs>>size;
    tofill.resize(size);
        Model m;
    for(size_t i=0;i<size;++i){
        ifs>>m;
            tofill[i]=m;
    }
}
int main(){
    createFile("test.txt",1000);
    std::vector<Model> tab;
    readFile("test.txt",tab);
    std::cout<<tab.size();
 
    return 0;
}

25/02/2014, 10h00
Bousk

A vue de nez
- push_back en chaîne, réallocation dans tous les sens
- copies dans tous les sens (Paire, element, Elmt, ..)

Alors oui, C# sera "plus rapide" sur un mauvais code, parce qu'il cache tout ce qui fait la force d'un bon code
- utilisation des pointeurs et références et non des copies en cascade
- allouer la mémoire nécessaire pour éviter les réallocation
- ...
26/02/2014, 12h03
Thomshao

Merci à tous

Merci pour ces réponses.

J'ai tester ta méthode koala et c'est vrai que ça marche plutôt pas mal. J'ai des temps un plus long que ceux que tu as mais surement dus au matériel.

J'ai aussi fait un test auquel on ne devrait pas penser mais bon voici ce que ça donne :

Si on met 350 initialisations dans une fonction, la durée est de 70 sec
Si on met 35 initialisations dans 10 fonctions différentes, la durée est de 10 sec
Si on met 5 initialisations dans 70 fonctions différentes, la durée est de 4 sec
Si on met 1 initialisation par fonction, on obtient une durée de 1.5 sec

Cela est tout de même louche. je soupçonne le compilateur de vs d'avoir des petits soucis.

Bousk c'est gentil tout plein de constater que j'aurai pus faire mieux. Mais ton commentaire est inutile.
En savoir plus que son voisin, ne veut pas dire que l'on est plus intelligent.....

En tout cas merci. je marque le sujet comme résolu car je suis maintenant à un temps de chargement qui rentre dans mes contraintes. ;)
26/02/2014, 14h17
white_tentacle

Citation:

Envoyé par Thomshao

Cela est tout de même louche. je soupçonne le compilateur de vs d'avoir des petits soucis.

Ça fait bien longtemps que les compilateurs n’ont plus de petits soucis de ce genre, à fortiori quand on parle des compilateurs majeurs, et pas d’un truc exotique pour une archi particulière. Donc c’est ton code qui a un soucis (soucis que tu as occulté par chance en réorganisant deux trois choses dans le code).

Bousk t’a donné quelques pistes à creuser, pour le reste, soit tu peux montrer le code, et là on pourra t’expliquer ce qui ne va pas avec, soit il faudra faire avec les quelques indications qui t’ont été données.
26/02/2014, 14h30
Davidbrcz

Citation:

Si on met 350 initialisations dans une fonction, la durée est de 70 sec
Si on met 35 initialisations dans 10 fonctions différentes, la durée est de 10 sec
Si on met 5 initialisations dans 70 fonctions différentes, la durée est de 4 sec
Si on met 1 initialisation par fonction, on obtient une durée de 1.5 sec

Ces chiffres n'ont AUCUN sens (Voir edit 2).
Si au lieu de perdre du temps dans des élucubrations diverses, si on voyait le VRAI code qui te donne ces chiffres, on pourrait te dire ou ça coince...

Et Bousk pointe des pistes qui sont souvent concluantes. Sinon, tu peux mettre le sujet en résolu (c'est ton choix) mais sache qu'il ne l'est pas.
Edit : grille par white_tentacle

Edit 2: apres réflexion, on peut voir un gain de perf si le compilo fait de la (N)RVO et ou plus de fonction va se traduire par moins de (re)copies inutiles. Mais ca reste fondamentalement un problème de code.
26/02/2014, 15h48
Thomshao

Désolé pour bousk.

white_tentacle : Il y a peu de chance que le compilateur, et encore moins un très répandu, soit la cause du problème mais j'ai déjà vu des chose inexplicable du genre l'ajout d'un commentaire à la fin d'un fichier bloque ou débloque la compilation et autre trucs bizarre chez des compilateurs connus (Borland et gcc ) donc tout comme je n'hésite pas à me remettre en question, au bout d'un moment y a des fois ou je doute du compilateur mais c'est très très rare effectivement.

J'ai mis le sujet en résolu car je rentre dans les critères que je dois respecter pour le projet. Maintenant si la contrainte de temps est levée. Il est évident que je connais toujours pas le fond de la cause du problème.

Mes classes sont décrites dans le sujet et ne font que contenir des données avec un type de base. Je les posteraient plus tard pour voir si (surement) quelque chose n'est pas bon.

J'ai également tenté de tout repasser en pointeurs pour limiter les recopies mais les résultats restent les mêmes.

Merci

Citation:

J'ai également tenté de tout repasser en pointeurs pour limiter les recopies mais les résultats restent les mêmes.

Ca confirme que tu ne maitrises pas ce que tu fais et que tu tentes des trucs a l'aveuglette et que ce n'est qu'un coup de chance si ca marche. Quand ca sera un autre bout de ton application qui ne sera pas dans les temps a cause de TA mauvaise utilisation des outils, bah tu ne pourras rien y faire et tu feras a nouveau n'importe quoi en priant pour que ca retombe dans les clous.

L'informatique, c'est pas magique.

Citation:

Mes classes sont décrites dans le sujet et ne font que contenir des données avec un type de base

Ca ne suffit pas. Il faut aussi montrer comment tu les utilises, comment tu geres tes vecteurs, car c'est la qu'il a y un travail a faire.

Je vais recommencer avec un exemple alakon ou je push 10 millions de long (soit plus de données que toi) das un vector et je regarde l'influence dune pré-réservation de la mémoire.
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 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 #include <iostream> #include <chrono> #include <vector> using namespace std; namespace{ const long N=10000000; const int NBtry=10; } void with() { std::vector<long> v; v.reserve(N); for(long i=0;i<N;++i) { v.push_back(i); } } void withhalf() { std::vector<long> v; v.reserve(N/2); for(long i=0;i<N;++i) { v.push_back(i); } } void without() { std::vector<long> v; for(long i=0;i<N;++i) { v.push_back(i); } } template <class F> double bench(F f) { auto start = chrono::steady_clock::now(); f(); auto end = chrono::steady_clock::now(); auto diff = end - start; double d=chrono::duration <double, milli> (diff).count(); return d; } int main() { double t[3]={0,0,0}; for(int i=0;i<NBtry;++i) { t[0]+=bench(without); t[1]+=bench(withhalf); t[2]+=bench(with); } std::cout<<t[0]/NBtry<<"\t"<<t[1]/NBtry<<"\t"<<t[2]/NBtry<<std::endl; return 0; }
Sans optimisation Le worst-case prend pas plus de 250 ms, le meilleur (reservation totale des le debut) 187ms, soit plus de 25% de gain avec une seule ligne.
En activant les optimisations, ca tombe a respectivement a 80ms et 37ms soit plus de 50% de perf en plus !!

Je pense que tu puisses comprendre apres ca que les chiffres que tu montres n'ont aucun sens donc montre ton code entier.

PS : J'admets volontier qu'une lecture sur le disque rallongerait un peu les délais mais ca serait globalement une augmentation constante sur tous les cas.