Discussion :

[salseropom]

Bonjour, j'ai une question quant à l'utilisation des pointeurs. Lorsque j'avais appris le C++, nous avons bien entendu eu un chapitre sur les pointeurs mais je me rappelle très bien que le prof nous avait dit qu'il faut limiter au maximum leur utilisation bien que dans tous les TP nous les utilisions.
En lisant les réponses des messages de ce forum, dès qu'une question contient un int*, il y a presque toujours une réponse qui contient un std::vector.
Or, j'ai l'impression que les pointeurs peuvent tout faire.
Dans mon cas, j'ai un prgm qui contient une boucle pour i=1...1e6 et je calcule des sommes et produits de tableaux.
J'avais commencé par faire des double * tab[27] puis je suis passé au vector v(27) (d'après vos conseils). Mais le temps d'exécution est bcp plus long donc je suis retourné au double * tab[27] (j'ai essayé d'installer la bibliothèque blitz++ (d'après vos conseils) mais je n'y arrive pas. Il me manque à chaque fois un fichier et les gars du réseau ne veulent pas me l'installer).

Donc, faut-il utiliser les pointeurs, et si j'ai le choix entre pointeurs et autre chose, dois-je choisir les pointeurs ou l'autre chose ?

Je pense bien que dans les std::vector, il y a tous plein de pointeurs (comme dans blitz++) mais on ne les voit pas, c'est bien ca ?

Merci, et bonne fin de journée.

[Laurent Gomila]

Oui, en général on préfère utiliser des outils qui utilisent les pointeurs à notre place sans nous les montrer. Si std::vector n'est pas assez performant alors il existera sans doute un autre outil plus adapté, comme par exemple Blitz++ que tu cites.

Tu peux nous en dire plus sur ton application en particulier, nous montrer le code qui fâche ?

[salseropom]

Salut Loulou24, le main fait à peu près 800 lignes donc je ne vais pas l'envoyer. Mais tout ce que je fais ce sont des sommes et produits de tableaux, extractions de lignes ou colonnes etc... Bref, des trucs très basiques. Mais comme j'ai un pas de discrétisation extrémement petit, je fais énormément d'itérations. Donc au début je m'étais fait une classe de Matrice, mais j'avais énormément de recopie temporaire. Pour faire A=B+C, en gros je faisais une matrice temporaire D=B+C puis je faisais A=D.
Donc pour éviter cela, je fais à chaque fois des boucles "for" (d'où les 800 lignes de codes). Mais au moins, mon temps de calcul est très amélioré.

Avec les std::vector, pour 3000 itérations j'en suis à 17 s. Avec mes double * j'en suis à 2 secondes ! Donc j'ai laché les vector pour faire des double * (d'où ma question sur les pointeurs).

J'ai bien lu ton cours sur la métaprogrammation. Il m'intéresse énormément mais j'avoue que ca me dépasse encore un peu. Donc je voulais installé blitz++ (sur les conseils de ce forum) mais bien que je suive la procédure, ca ne marche pas. Il me manque des fichiers.
Donc, pour coder A=B+C, je dois faire des boucles "for" ce qui est très long à écrire et diminue la lisibilité du code.

[Laurent Gomila]

Ok je vois. Effectivement, pour les opérations matricielles les vector ne sont pas ce qui se fait de mieux niveaux performances (quoique, par rapport à un bête double* tu devrais pouvoir t'en tirer avec des performances égales).

Essaie de chercher d'autres bibliothèques qui proposent du calcul matriciel performant (boost::uBlas ? MTL ?), sinon effectivement dérouler les boucles toi-même reste la dernière solution je pense.

[salseropom]

Re-salut, OK, je vais voir les bibliothèques boost::uBlas et MTL. Y en a-t-il une "meilleure" qu'une autre ? Et par rapport à blitz++ ?

Merci encore

[Luc Hermitte]

Blitz++ semble être la référence. boost.uBlas est batie sur la même technologie -- je ne suis pas sûr d'avoir compris pourquoi ils reprennent à 0. MTL semble être moins poussée (dans l'optimisation), et la dernière fois (il y a un moment maintenant) que j'avais vérifié, ce n'avait plus trop l'air maintenu (pareil pour Blitz++)

=> essaies les par toi même. Vois d'abord si ton compilateur les supporte et fais ensuite des tests de perfs.

[salseropom]

Bonjour,
bon, je vais essayé de voir comment installer ces bibliothèques. Car pour blitz++, je suis bien les directives, (tar xvf machin, make, make install), mais lors du make, j'ai un message d'erreur comme quoi il me manque un certain fichier et donc les make install plantent... et je suis fou de rage car ca ne doit pas être trop dur à installer tout de même !

Merci pour les infos. Je ferai mes tests (une fois l'installation effectuée bien entendu....)

[Luc Hermitte]

A tout hasard (x): quel est ton compilateur et quel est le fichier qui manquerait ?

(x) Je ne garantis pas de pouvoir résoudre quoi que ce soit.

[salseropom]

Salut, mon compilateur est g++ (red Hat 9)

Je me suis mis sous mon local et non plus sur le réseau.

Voic mes commandes que j'ai tapées :
tar xvf blitz-0.6.tar
cd blitz-0.6
./configure --with-cxx=gcc:eg++ --prefix=/local/MON_NOM

et voici l'erreur (ce n'est plus un fichier manquant)

checking build system type... i686-pc-linux-gnu
checking host system type... i686-pc-linux-gnu
checking target system type... i686-pc-linux-gnu
checking for a BSD-compatible install... /usr/bin/install -c
checking whether build environment is sane... yes
checking for gawk... gawk
checking whether make sets ${MAKE}... yes
checking whether make sets ${MAKE}... (cached) yes

Configuring Blitz++ for i686-pc-linux-gnu

Configuring for gcc (wahoo!)
Linux: assuming g++/g77 or icc/icf

checking for ar... ar
checking for ranlib... ranlib
checking for C++ compiler default output... configure: error: C++ compiler cannot create executables
Exit 77

Mais avant, il me manquait le fichier ./NEWS

Merci

[JolyLoic]

Tes différences de perfs entre double* et vector<double> me surprennent... Est-tu certain d'avoir testé ton code en mode optimisé et avec inlining on ? (j'ai effectivement ce genre de ration en debug, mais en optimisé, je ne vois en moyenne pas de différence). Sinon, peux tu poster ton code de test ?

[Luc Hermitte]

Hum... Je ne préciserai pas le compilo lors du configure. C'est à se demander si tu ne lui aurait pas dit qu'il fallait utiliser gcc pour compiler du C++. En général configure se débrouille très bien pour détecter le compilateur.

Au pire, tu devrais pouvoir jeter un oeil dans le config.log (nom à vérifier) pour voir la commande et le fichier qui ont posé problème, et corriger en conséquence ton appel à ./configure ou ton installation.

[salseropom]

Salut JolyLoic, voici mon code :

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
 
#include<iostream>
#include<vector>
#include<ctime>
using namespace std;
 
int main()
{
  unsigned int N=10000;
 
  double tab1[27][27],tab2[27][27];
  for(int i=0;i<27;i++)
    for(int j=0;j<27;j++)
      tab1[i][j]=i+j+2.3;
 
  double s=0.;
  time_t debut_calcul, fin_calcul;
 
  for(uint c=0;c<N;c++)
    {
      time(&debut_calcul);
      for(int i=0;i<27;i++)
	{
	  double aux=0.;
	  for(int j=0;j<27;j++)
	    {
	      for(int k=0;k<27;k++)
		aux+=tab1[i][k]*tab1[k][j];
 
	      tab2[i][j]=aux;
	    }
	}
      time(&fin_calcul);
      s+=difftime(fin_calcul,debut_calcul);
    }
 
  cout<<s/N<<endl;
 
 
  vector<vector<double> > v1(27,vector<double>(27));
  vector<vector<double> > v2(27,vector<double>(27));
 
  for(int i=0;i<27;i++)
    for(int j=0;j<27;j++)
      v1[i][j]=i+j+2.3;
 
  s=0.;
 
  for(uint c=0;c<N;c++)
    {
      time(&debut_calcul);
      for(int i=0;i<27;i++)
	{
	  double aux=0.;
	  for(int j=0;j<27;j++)
	    {
	      for(int k=0;k<27;k++)
		aux+=v1[i][k]*v1[k][j];
 
	      v2[i][j]=aux;
	    }
	}
      time(&fin_calcul);
      s+=difftime(fin_calcul,debut_calcul);
    }
 
  cout<<s/N<<endl;
 
  return 0;
}

avec les double * j'ai s=0.0004 et avec les vector j'ai s=0.0078. La différence est grande tout de même.

Luc Hermitte, au fait j'ai voulu dire à ./configure que je compilais avec g++ et non g++ (même si c'est presque la meme chose tu vas me dire). Je m'étais aidé de la documentation de blitz++ pour ces lignes de commandes.

Merci encore de votre aide.

[Laurent Gomila]

On peut comparer les performances d'un double* et d'un vector<double>, mais effectivement pas celles d'un vector<vector<double> > et d'un double[][]. Ce dernier sera sur la pile (accès plus rapide) et l'indexation sera directe. Ce qui n'est pas le cas du vector<vector>.

Donc je dirais que là oui, c'est normal.

[salseropom]

OK, merci de tes explications Loulou24. Mais si j'utilise blitz++ (une fois que j'aurais résolu mon foutu pb pour l'installation, pb de root, pb de local etc...) vais-je gagner du temps (car mon but est tout de même d'avoir un code plus lisible et plus court) ?

Enfin, est-ce que blitz++ utilise la métaprogrammation (ou évite toutes les recopies temporaires, du genre pour faire A=B*C, je faisais D=B*C puis A=D) ?

Merci

[Laurent Gomila]

Mais si j'utilise blitz++ (une fois que j'aurais résolu mon foutu pb pour l'installation, pb de root, pb de local etc...) vais-je gagner du temps (car mon but est tout de même d'avoir un code plus lisible et plus court) ?

Oui bien sûr, si les opérations que tu effectues sur tes matrices sont bien des opérations mathématiques (ce qui a l'air d'être le cas), tu y gagneras en performances. C'est étudié pour

Enfin, est-ce que blitz++ utilise la métaprogrammation (ou évite toutes les recopies temporaires, du genre pour faire A=B*C, je faisais D=B*C puis A=D) ?

Un peu de recherche sur Google me dit que oui.

[salseropom]

Merci.
Reste à comprendre le fonctionnement de la métaprogrammation (et à appliquer !)

[Laurent Gomila]

Normalement ces bibliothèques utilisent la metaprog de manière invisible, mais si c'est un sujet qui t'interesse :

http://loulou.developpez.com/tutoriels/cpp/metaprog

[salseropom]

Salut, oui j'ai déjà lu tes articles. La métaprogrammation m'a l'air d'être un outils extremement puissant. Mais pour l'instant j'avoue que ca me dépasse encore un peu.

J'aimerais bien me coder une classe de matrice (uniquement pour apprendre, car je pense que quoi que je fasse, blitz++ ou la MTL seront meilleures que ma classe) en utilisant la métaprogrammtion afin d'éviter toutes les matrices temporaires lors des A=B*C+2*D-5*E par exemple.
Mais j'ai du mal à m'imaginer l'arbre (référence à ton article).

En tout les cas, je te tire mon chapeau !
Cordialement

[Laurent Gomila]

Ca peut être un bon exericice, oui. Par contre mieux vaut être familier avec les templates avant de se lancer dans les expression templates. Ce que tu peux faire, c'est coder une version sans meta-programmation, puis si tu te sens en forme tenter d'ajouter cette fonctionnalité plus tard. Ca ne demande pas beaucoup de modification du code, simplement de réécrire les divers opérateurs.

[salseropom]

salut, oui tu as raison, je vais tout d'abord recoder ma "pauvre" classe matrice avec des template.
Mais pour passer à la métaprogrammation, il va falloir que je me code tous les operateurs bianire, unaire etc non ? a mon avis, c'est tout de meme plus qu'une "simple" modification.

Mais je vais me lancer dedans en tout cas !