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 :

Probleme temps de calcul sur un vector


Sujet :

C++

  1. #1
    Membre du Club
    Profil pro
    Inscrit en
    Janvier 2008
    Messages
    91
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Janvier 2008
    Messages : 91
    Points : 50
    Points
    50
    Par défaut Probleme temps de calcul sur un vector
    Bonjour à tous, j'ai un petit soucis concernant la gestion d'un tableau.

    Dans le code de base de ma fonction, j'utilise un tableau de float :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    int     nbPix           =   width*height;
    float   * A  = new float [nbPix];
    float   * B  = new float [nbPix];
    int   * C  = new int [nbPix];
    for (int i=0; i<nbPix; ++i)
          A[i]  = 10000000;
          B[i]  = 10000000;
          C[i]  = 453;
    et si j'utilise les vector ça me donne tout simplement ça :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
     
    vector<float> A(nbPix,10000000);
    vector<float> B(nbPix,10000000);
    vector<int> C(nbPix, 453);
    le temps de calcul est plus long pour la solution vector, est-ce normal ?
    y a t-il une solution plus rapide ?

  2. #2
    Membre averti Avatar de Nogane
    Profil pro
    Inscrit en
    Juin 2008
    Messages
    241
    Détails du profil
    Informations personnelles :
    Âge : 43
    Localisation : France

    Informations forums :
    Inscription : Juin 2008
    Messages : 241
    Points : 323
    Points
    323
    Par défaut
    Bonjour,
    Si votre premier code compile, c'est que vous êtes sous un vieux Visual. Il ne devrait pas car 'i' n'existe plus lors des deux dernières lignes.
    Vous avez oubliez les accolades après le for (on est pas en python ), et du cou les deux dernière ligne ne passe pas dans la boucle. Donc c'est normale que ca n'aille pas a la même vitesse.

  3. #3
    Membre du Club
    Profil pro
    Inscrit en
    Janvier 2008
    Messages
    91
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Janvier 2008
    Messages : 91
    Points : 50
    Points
    50
    Par défaut
    oui en fait je n'ai pas recopié les acolades dans la citation mais elles sont bien présentes dans le code (dslé de l'oubli).

  4. #4
    Membre émérite

    Inscrit en
    Mai 2008
    Messages
    1 014
    Détails du profil
    Informations forums :
    Inscription : Mai 2008
    Messages : 1 014
    Points : 2 252
    Points
    2 252
    Par défaut
    olivier21c, est-ce que tu es bien en mode release ?

  5. #5
    Membre éclairé

    Profil pro
    Inscrit en
    Septembre 2006
    Messages
    717
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Septembre 2006
    Messages : 717
    Points : 858
    Points
    858
    Par défaut
    Aussi, le premier code ne contient pas de delete alors que le second si.

    A part cela et ce qui à été dit dans les messages précédents, les deux codes devraient avoir à peu près les même performances.

  6. #6
    Membre du Club
    Profil pro
    Inscrit en
    Janvier 2008
    Messages
    91
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Janvier 2008
    Messages : 91
    Points : 50
    Points
    50
    Par défaut
    non j'étais ne mode debug,
    si je passe en mode release, l'utilisation des vector est toujours plus lente mais l'écart est proportionnellement baissé par rapport au temps d'exécution final :

    différence de 100ms sur l'exécution en mode debug (440ms pour la fonction totale)
    différence de 10ms sur l'exécution en mode release (90ms pour la fonction totale)
    il est encore plus intéressant d'utiliser float* ici.
    par contre si j'initialise comme suit :

    memset(A, 10000000.0f, nbPix);
    memcpy(B, A, nbPix * sizeof(float));
    memset(C, _453, nbPix);
    je gagne encore près de 10ms (mais mon 10000000.0f passe en int).

    sinon pour ma culture, quelle la différence en mode debug et mode release ? qd utiliser l'un ou l'autre?

  7. #7
    Membre du Club
    Profil pro
    Inscrit en
    Janvier 2008
    Messages
    91
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Janvier 2008
    Messages : 91
    Points : 50
    Points
    50
    Par défaut
    le delete est présent à la fin de la fonction pour l'utilisation de float* (et int* bien sur).

    je pensait qu'utiliser des vector améliorerait la rapidité de mon exécution, mais la je ne vois comment améliorer.

  8. #8
    Membre chevronné
    Avatar de Joel F
    Homme Profil pro
    Chercheur en informatique
    Inscrit en
    Septembre 2002
    Messages
    918
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 43
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Chercheur en informatique
    Secteur : Service public

    Informations forums :
    Inscription : Septembre 2002
    Messages : 918
    Points : 1 921
    Points
    1 921
    Par défaut
    vector n'accelere rien hein.

    si t'es sous visual, quelle version ? La STL de MSVC est notoirement mauvaise.

  9. #9
    Membre du Club
    Profil pro
    Inscrit en
    Janvier 2008
    Messages
    91
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Janvier 2008
    Messages : 91
    Points : 50
    Points
    50
    Par défaut
    je suis sous visual 2005 pro

  10. #10
    Membre averti Avatar de Nogane
    Profil pro
    Inscrit en
    Juin 2008
    Messages
    241
    Détails du profil
    Informations personnelles :
    Âge : 43
    Localisation : France

    Informations forums :
    Inscription : Juin 2008
    Messages : 241
    Points : 323
    Points
    323
    Par défaut
    L'efficacité des vector dépend le l'implémentation. Par exemple chez moi les deux méthode vont a la même vitesse, avec un minGW récent.
    Après, un autre intérêt des vector c'est de gérer proprement le mémoire. Par exemple votre code avec des new n'as pas de delete. Et même si il les avait, il ne serait pas exception-safe.

    Autre chose, la manière dont vous utilisez memset ne peut pas marcher car memset initialise char par char et non float par float. Elle n'est pas template, il faut don plutôt utiliser std::fill, et std::copy.

    Pour la difference release/debug, en general le mode debug contient des donnée supplémentaire pour pouvoir débugger (faire du pas a pas surtout). Le mode release n'est pas fait pour debuger, le compilateur peut donc optimiser beaucoup plus.

  11. #11
    Membre du Club
    Profil pro
    Inscrit en
    Janvier 2008
    Messages
    91
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Janvier 2008
    Messages : 91
    Points : 50
    Points
    50
    Par défaut
    d'accord d'accord
    je te remercie pour l'explication, et du temps passé à mon pb.
    bonne journée

  12. #12
    Modérateur
    Avatar de bruno_pages
    Homme Profil pro
    ingénieur informaticien à la retraite
    Inscrit en
    Juin 2005
    Messages
    3 533
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 64
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : ingénieur informaticien à la retraite
    Secteur : High Tech - Produits et services télécom et Internet

    Informations forums :
    Inscription : Juin 2005
    Messages : 3 533
    Points : 6 709
    Points
    6 709
    Par défaut
    Citation Envoyé par olivier21c Voir le message
    sinon pour ma culture, quelle la différence en mode debug et mode release ? qd utiliser l'un ou l'autre?
    en mode release le compilateur produit un code optimisé plus court et donc rapide
    en mode debug le code produit est plus 'standard' avec une exécution moins 'surprenante' sous debugger

    ceci dit cela concerne visual C++ qui offre moins de possibilités que g++ par exemple

    on compile en mode debug ... quand on veut debugger

    Citation Envoyé par olivier21c Voir le message
    je pensait qu'utiliser des vector améliorerait la rapidité de mon exécution,
    et non, vector facilite l'écriture du code lorsque le vecteur est de taille variable, mais vector est un peu plus lent, on n'a rien sans rien

    [edit]et bien, que de collisions de réponse simultanées [/edit]
    Bruno Pagès, auteur de Bouml (freeware), mes tutoriels sur DVP (vieux, non à jour )

    N'oubliez pas de consulter les FAQ UML et les cours et tutoriels UML

  13. #13
    Membre du Club
    Profil pro
    Inscrit en
    Janvier 2008
    Messages
    91
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Janvier 2008
    Messages : 91
    Points : 50
    Points
    50
    Par défaut
    merci aussi pour cette réponse ^^

  14. #14
    Membre éclairé

    Profil pro
    Inscrit en
    Septembre 2006
    Messages
    717
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Septembre 2006
    Messages : 717
    Points : 858
    Points
    858
    Par défaut
    Citation Envoyé par bruno_pages Voir le message
    et non, vector facilite l'écriture du code lorsque le vecteur est de taille variable, mais vector est un peu plus lent, on n'a rien sans rien
    Moi je ne vois pas de raison pour que vector soit plus lent que l'équivalent avec new[]/delete[]. Et même avec la STL de MSVC il ne devrait pas.

  15. #15
    Modérateur
    Avatar de bruno_pages
    Homme Profil pro
    ingénieur informaticien à la retraite
    Inscrit en
    Juin 2005
    Messages
    3 533
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 64
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : ingénieur informaticien à la retraite
    Secteur : High Tech - Produits et services télécom et Internet

    Informations forums :
    Inscription : Juin 2005
    Messages : 3 533
    Points : 6 709
    Points
    6 709
    Par défaut
    et pourtant si, au niveau principe et sans rentrer dans des détails d'implémentation on remarque que type[] est un conteneur à un seul niveau, une fois qu'on a l'adresse dans un registre et l'index dans un autre l'accès ne demande qu'une unique instruction machine. Par contre un vecteur est un conteneur à deux niveaux, un accès demande donc une lecture de plus, c'est donc au minimum deux fois plus cher.

    si on regarde ensuite le code de la stl on voit que cet accès passe par la création d'un itérateur temporaire désignant le nième éléments, puis on 'traverse' cet itérateur , au total on exécute donc un code assez invraisemblable ... heureusement très très optimisé par un g++ en mode O2 comme on va le voir

    soit le code suivant :

    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
    #include <vector>
    using namespace std;
     
    int f(int * v, int i, int j)
    {
      v[i] = i;
      return v[j];
    }
     
    int f(vector<int> & v, int i, int j)
    {
      v[i] = i;
      return v[j];
    }
     
    int main(int, char ** argv)
    {
      long n;
      int * v1 = new int[1];
      vector<int> v2;
     
      v2.push_back(0);
     
      for (n = atol(argv[1]); n; n -= 1)
        f(v1, 0, 0);
     
      system("ps x | grep a.out | grep -v grep");
     
      for (n = atol(argv[1]); n; n -= 1)
        f(v2, 0, 0);
     
      system("ps x | grep a.out | grep -v grep");
     
      return 0;
    }
    utilisation compilé optimisé et non optimisé :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    vxl15036 /tmp % g++ -O2 wxc.c
    vxl15036 /tmp % ./a.out 10000000000
     6944 pts/12   S+     0:10 ./a.out 10000000000
     6944 pts/12   S+     0:26 ./a.out 10000000000      donc 16 sec
    vxl15036 /tmp % g++  wxc.c
    vxl15036 /tmp % ./a.out 1000000000
     7106 pts/12   S+     0:08 ./a.out 1000000000
     7106 pts/12   S+     1:25 ./a.out 1000000000        donc 77 sec
    et là on comprend que la compilation O2 à vraiment du mérite et élague incroyablement les 'divagations' de la stl
    Bruno Pagès, auteur de Bouml (freeware), mes tutoriels sur DVP (vieux, non à jour )

    N'oubliez pas de consulter les FAQ UML et les cours et tutoriels UML

  16. #16
    Membre éclairé

    Profil pro
    Inscrit en
    Septembre 2006
    Messages
    717
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Septembre 2006
    Messages : 717
    Points : 858
    Points
    858
    Par défaut
    C'est sûr il y a quelques cas ou il faut faire attention, comme le passage d'argument.

    Si la fonction ne modifie pas la taille du vecteur et que les performances sont importantes il ne faut pas passer le vecteur en entier, juste un pointeur vers son premier élément ou un couple d'iterateurs comme dans les algorithmes de la STL.

    Donc oui, une utilisation "à la C" de std::vector peut être plus lente, mais il existe souvent un équivalent aussi rapide, std::vector a été conçu pour.

  17. #17
    Membre chevronné
    Avatar de Joel F
    Homme Profil pro
    Chercheur en informatique
    Inscrit en
    Septembre 2002
    Messages
    918
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 43
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Chercheur en informatique
    Secteur : Service public

    Informations forums :
    Inscription : Septembre 2002
    Messages : 918
    Points : 1 921
    Points
    1 921
    Par défaut
    Citation Envoyé par Sylvain Togni Voir le message
    Si la fonction ne modifie pas la taille du vecteur et que les performances sont importantes il ne faut pas passer le vecteur en entier, juste un pointeur vers son premier élément ou un couple d'iterateurs comme dans les algorithmes de la STL.
    les réferences font la tête, tu les as méchamment oubliés :o

  18. #18
    Membre chevronné
    Avatar de Goten
    Profil pro
    Inscrit en
    Juillet 2008
    Messages
    1 580
    Détails du profil
    Informations personnelles :
    Âge : 33
    Localisation : France

    Informations forums :
    Inscription : Juillet 2008
    Messages : 1 580
    Points : 2 205
    Points
    2 205
    Par défaut
    Y'a un bench de Mr Stepanov (hébergé chez adobe me semble) nommé : " The cost of encapsulation" (quelque chose comme ça). Et dans ce jeu de bench y'en a un justement sur la différence itérateur / raw pointer. Sur l'implémentation de gcc les deux sont aussi rapides, la STL de VS est un poil plus lente par contre il me semble. Et chez borland c'est kif kif.
    "Hardcoded types are to generic code what magic constants are to regular code." --A. Alexandrescu

  19. #19
    Membre chevronné
    Avatar de Joel F
    Homme Profil pro
    Chercheur en informatique
    Inscrit en
    Septembre 2002
    Messages
    918
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 43
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Chercheur en informatique
    Secteur : Service public

    Informations forums :
    Inscription : Septembre 2002
    Messages : 918
    Points : 1 921
    Points
    1 921
    Par défaut
    le stepanov-penalty-test:

    http://codepad.org/kIxv9Oqt

  20. #20
    Membre chevronné
    Avatar de Goten
    Profil pro
    Inscrit en
    Juillet 2008
    Messages
    1 580
    Détails du profil
    Informations personnelles :
    Âge : 33
    Localisation : France

    Informations forums :
    Inscription : Juillet 2008
    Messages : 1 580
    Points : 2 205
    Points
    2 205
    Par défaut
    Ah yep, abstraction penalty bench :
    http://www.stepanovpapers.com/Abstra...yBenchmark.cpp (contexte original).

    Le benchmark de chez adobe était plus fourni et comprends celui là en fait.
    "Hardcoded types are to generic code what magic constants are to regular code." --A. Alexandrescu

+ Répondre à la discussion
Cette discussion est résolue.
Page 1 sur 2 12 DernièreDernière

Discussions similaires

  1. Réponses: 5
    Dernier message: 23/02/2012, 13h25
  2. Réponses: 5
    Dernier message: 06/06/2011, 02h04
  3. Calcul temps de Marche sur front montant
    Par ARAGORN93 dans le forum MS SQL Server
    Réponses: 2
    Dernier message: 13/02/2008, 00h01
  4. Réponses: 15
    Dernier message: 20/09/2005, 10h54
  5. [Math]probleme de precision de calcul sur les float
    Par calvin dans le forum Langage
    Réponses: 6
    Dernier message: 26/05/2005, 08h53

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