IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

C++ Discussion :

Chargement d'un grand nombre d'instances rapidement.


Sujet :

C++

  1. #1
    Membre averti
    Profil pro
    Inscrit en
    Octobre 2005
    Messages
    15
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Octobre 2005
    Messages : 15
    Par défaut 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.

  2. #2
    Expert éminent
    Avatar de koala01
    Homme Profil pro
    aucun
    Inscrit en
    Octobre 2004
    Messages
    11 644
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 53
    Localisation : Belgique

    Informations professionnelles :
    Activité : aucun

    Informations forums :
    Inscription : Octobre 2004
    Messages : 11 644
    Par défaut
    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 Après tout, peut être pourrais tu te contenter d'un
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    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
    A méditer: La solution la plus simple est toujours la moins compliquée
    Ce qui se conçoit bien s'énonce clairement, et les mots pour le dire vous viennent aisément. Nicolas Boileau
    Compiler Gcc sous windows avec MinGW
    Coder efficacement en C++ : dans les bacs le 17 février 2014
    mon tout nouveau blog

  3. #3
    Rédacteur/Modérateur
    Avatar de JolyLoic
    Homme Profil pro
    Développeur informatique
    Inscrit en
    Août 2004
    Messages
    5 463
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 50
    Localisation : France, Yvelines (Île de France)

    Informations professionnelles :
    Activité : Développeur informatique
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Août 2004
    Messages : 5 463
    Par défaut
    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.
    Ma session aux Microsoft TechDays 2013 : Développer en natif avec C++11.
    Celle des Microsoft TechDays 2014 : Bonnes pratiques pour apprivoiser le C++11 avec Visual C++
    Et celle des Microsoft TechDays 2015 : Visual C++ 2015 : voyage à la découverte d'un nouveau monde
    Je donne des formations au C++ en entreprise, n'hésitez pas à me contacter.

  4. #4
    Membre averti
    Profil pro
    Inscrit en
    Octobre 2005
    Messages
    15
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Octobre 2005
    Messages : 15
    Par défaut A tester
    Citation Envoyé par koala01 Voir le message
    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 Après tout, peut être pourrais tu te contenter d'un
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    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

  5. #5
    Rédacteur/Modérateur
    Avatar de JolyLoic
    Homme Profil pro
    Développeur informatique
    Inscrit en
    Août 2004
    Messages
    5 463
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 50
    Localisation : France, Yvelines (Île de France)

    Informations professionnelles :
    Activité : Développeur informatique
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Août 2004
    Messages : 5 463
    Par défaut
    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 ?
    Ma session aux Microsoft TechDays 2013 : Développer en natif avec C++11.
    Celle des Microsoft TechDays 2014 : Bonnes pratiques pour apprivoiser le C++11 avec Visual C++
    Et celle des Microsoft TechDays 2015 : Visual C++ 2015 : voyage à la découverte d'un nouveau monde
    Je donne des formations au C++ en entreprise, n'hésitez pas à me contacter.

  6. #6
    r0d
    r0d est déconnecté
    Membre expérimenté

    Homme Profil pro
    Développeur informatique
    Inscrit en
    Août 2004
    Messages
    4 293
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Ain (Rhône Alpes)

    Informations professionnelles :
    Activité : Développeur informatique

    Informations forums :
    Inscription : Août 2004
    Messages : 4 293
    Billets dans le blog
    2
    Par défaut
    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).

  7. #7
    Expert confirmé

    Avatar de dragonjoker59
    Homme Profil pro
    Software Developer
    Inscrit en
    Juin 2005
    Messages
    2 033
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 43
    Localisation : France, Bas Rhin (Alsace)

    Informations professionnelles :
    Activité : Software Developer
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Juin 2005
    Messages : 2 033
    Billets dans le blog
    12
    Par défaut
    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).
    Si vous ne trouvez plus rien, cherchez autre chose...

    Vous trouverez ici des tutoriels OpenGL moderne.
    Mon moteur 3D: Castor 3D, presque utilisable (venez participer, il y a de la place)!
    Un projet qui ne sert à rien, mais qu'il est joli (des fois) : ProceduralGenerator (Génération procédurale d'images, et post-processing).

  8. #8
    Membre Expert
    Avatar de white_tentacle
    Profil pro
    Inscrit en
    Novembre 2008
    Messages
    1 505
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Novembre 2008
    Messages : 1 505
    Par défaut
    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.

  9. #9
    Membre averti
    Profil pro
    Inscrit en
    Octobre 2005
    Messages
    15
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Octobre 2005
    Messages : 15
    Par défaut
    Citation Envoyé par white_tentacle Voir le message
    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 : Sélectionner tout - Visualiser dans une fenêtre à part
    modeles = (Modeles)new BinaryFormatter().Deserialize(file_stream_modeles);
    Je vous met un exemple en C++ :
    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
    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.

  10. #10
    Membre Expert
    Avatar de white_tentacle
    Profil pro
    Inscrit en
    Novembre 2008
    Messages
    1 505
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Novembre 2008
    Messages : 1 505
    Par défaut
    Citation Envoyé par Thomshao Voir le message
    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.

    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.

  11. #11
    Expert éminent
    Avatar de koala01
    Homme Profil pro
    aucun
    Inscrit en
    Octobre 2004
    Messages
    11 644
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 53
    Localisation : Belgique

    Informations professionnelles :
    Activité : aucun

    Informations forums :
    Inscription : Octobre 2004
    Messages : 11 644
    Par défaut
    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
    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
    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;
    }
    A méditer: La solution la plus simple est toujours la moins compliquée
    Ce qui se conçoit bien s'énonce clairement, et les mots pour le dire vous viennent aisément. Nicolas Boileau
    Compiler Gcc sous windows avec MinGW
    Coder efficacement en C++ : dans les bacs le 17 février 2014
    mon tout nouveau blog

  12. #12
    Rédacteur/Modérateur


    Homme Profil pro
    Network game programmer
    Inscrit en
    Juin 2010
    Messages
    7 147
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 38
    Localisation : Canada

    Informations professionnelles :
    Activité : Network game programmer

    Informations forums :
    Inscription : Juin 2010
    Messages : 7 147
    Billets dans le blog
    4
    Par défaut
    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
    - ...
    Pensez à consulter la FAQ ou les cours et tutoriels de la section C++.
    Un peu de programmation réseau ?
    Aucune aide via MP ne sera dispensée. Merci d'utiliser les forums prévus à cet effet.

  13. #13
    Membre averti
    Profil pro
    Inscrit en
    Octobre 2005
    Messages
    15
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Octobre 2005
    Messages : 15
    Par défaut 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.

  14. #14
    Membre Expert
    Avatar de white_tentacle
    Profil pro
    Inscrit en
    Novembre 2008
    Messages
    1 505
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Novembre 2008
    Messages : 1 505
    Par défaut
    Citation Envoyé par Thomshao Voir le message
    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.

  15. #15
    Rédacteur

    Avatar de Davidbrcz
    Homme Profil pro
    Ing Supaéro - Doctorant ONERA
    Inscrit en
    Juin 2006
    Messages
    2 307
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 33
    Localisation : Suisse

    Informations professionnelles :
    Activité : Ing Supaéro - Doctorant ONERA

    Informations forums :
    Inscription : Juin 2006
    Messages : 2 307
    Par défaut
    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.
    "Never use brute force in fighting an exponential." (Andrei Alexandrescu)

    Mes articles dont Conseils divers sur le C++
    Une très bonne doc sur le C++ (en) Why linux is better (fr)

  16. #16
    Membre averti
    Profil pro
    Inscrit en
    Octobre 2005
    Messages
    15
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Octobre 2005
    Messages : 15
    Par défaut
    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

  17. #17
    Rédacteur

    Avatar de Davidbrcz
    Homme Profil pro
    Ing Supaéro - Doctorant ONERA
    Inscrit en
    Juin 2006
    Messages
    2 307
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 33
    Localisation : Suisse

    Informations professionnelles :
    Activité : Ing Supaéro - Doctorant ONERA

    Informations forums :
    Inscription : Juin 2006
    Messages : 2 307
    Par défaut
    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.

    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 : 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
    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.
    "Never use brute force in fighting an exponential." (Andrei Alexandrescu)

    Mes articles dont Conseils divers sur le C++
    Une très bonne doc sur le C++ (en) Why linux is better (fr)

+ Répondre à la discussion
Cette discussion est résolue.

Discussions similaires

  1. Creer un grand nombre de fichier rapidement
    Par exeroc dans le forum Général Python
    Réponses: 19
    Dernier message: 19/07/2011, 13h14
  2. Réponses: 2
    Dernier message: 13/09/2010, 11h24
  3. requete sql sur un grand nombre d enregistrement
    Par marielaure dans le forum Langage SQL
    Réponses: 5
    Dernier message: 13/08/2004, 11h53
  4. Traitement d'un grand nombre de champ
    Par k-lendos dans le forum Langage SQL
    Réponses: 8
    Dernier message: 17/03/2004, 15h13
  5. Une unité pour gérer des très grands nombres
    Par M.Dlb dans le forum Langage
    Réponses: 2
    Dernier message: 09/09/2003, 12h07

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo