Bonjour à tous,
J'ai un problème d'optimisation au niveau de mon programme c++ :
voici une partie de mon programme ou je pense que le problème se situe :
 
Dans la fonction “Loader::minOfMin_maxOfMax”  si je remplace le code  
 
       mmin = min(min(c1,c2), min(c3,c4));  
 mmax = max(max(c1,c2), max(c3,c4));
 
par :
 
mmin  = 0;  float m =  min(min(c1,c2), min(c3,c4));
mmax = 0 ;  float n = max(max(c1,c2),min(c3,c4))) ;
 
Le programme devient rapide, sinon mon programme est vraiment long.
 
 
inline void Loader::minOfMin_maxOfMax(int idVertex, float theta, float phi, int
numFace, float &mmin, float &mmax)
{
 float c1, c2, c3, c4;
 c1 = rho(idVertex, theta,   phi,  numFace);
 c2 = rho(idVertex, theta,   phi+degPhi, numFace);
 c3 = rho(idVertex, theta+degTheta, phi+degPhi, numFace);
 c4 = rho(idVertex, theta+degTheta, phi,   numFace);
 
 mmin = min(min(c1,c2), min(c3,c4));  
 mmax = max(max(c1,c2), max(c3,c4));
}
 
 
void Loader::remplirContributionPenalite()
{
 
 for(int F=0; F<nbrfaces; F++)
 {
  for(int i=0; i<(maxTheta-minTheta)/pasTheta; i++)
  {
   float theta = (minTheta + i*pasTheta) * PI_180;
   for(int j=0; j<(maxPhi-minPhi)/pasPhi; j++)
   {
    float phi = (minPhi+j*pasPhi)*PI_180;
     
    // min des min et max des max pour le vertices I
 
    float minRho1, maxRho1, minRho2, maxRho2, minRho3, maxRho3;
    minOfMin_maxOfMax(1, theta, phi, F, minRho1, maxRho1);
    minOfMin_maxOfMax(2, theta, phi, F, minRho2, maxRho2);
    minOfMin_maxOfMax(3, theta, phi, F, minRho3, maxRho3);
 
                         }
                 }
         }
}
 
Je n'arrive pas à localiser le problème.
Merci d'avance

Pas de réponse........... SVP j'ai vraiment besoin de la solution

 
Donc en sortie de minOfMin_maxOfMax tu as mmin =0 et mmax =0  
Et donc quelque part ailleurs je suppose que tu boucles entre mmin et mmax?
 

gprof c'est pas pour les lévriers ousbeques
ce code n'a aucune réison de ralentir quoi que ce soit ...

Moi ce que je veux exécuter c'est le bloc en rouge mais ce que je n'arrive pas à comprendre le temps fou qui prend pour s'exécute (se qui guère m'arrange) , alors qu'on remplaçant se bout de code avec le meme nombre d'opération le temps d'exécution devient trop rapide
 
est ce que quelqu'un peut m'aider ?  

@ GrosBoc : oui exact mais j'ai mis la boucle en commentaire donc ça ne vient pas de la boucle

 
Ha. Bon.
Le compileur te dit peut-être que m et n ne sont pas utilisés et supprime simplement le code?
 
Goto solution de Joel.

Merci de votre participation à mon problème en fin j'ai trouvé la solution, le problème se trouvait au niveau des variable d'entrée sortie, il fallait juste faire un retourne par @ pour accélérer le code :
 
float * Loader::minOfMin_maxOfMax(int idVertex, float theta, float phi, int numFace)
{
 float c1, c2, c3, c4,c12min,c12max,c34min,c34max,min14,max14;
 float minmax[2];
 c1 = rho(idVertex, theta,   phi,  numFace);
 c2 = rho(idVertex, theta,   phi+degPhi, numFace);
 c3 = rho(idVertex, theta+degTheta, phi+degPhi, numFace);
 c4 = rho(idVertex, theta+degTheta, phi,   numFace);
 
 minmax[0]=minimum(minimum(c1,c2), minimum(c3,c4));
 minmax[1]=maximum(maximum(c1,c2), maximum(c3,c4));
 
 return minmax;
}
 
j'espère que cela aidera d'autre personne

Retourner un pointeur vers une variable locale n'est pas la chose a faire.