Forum |  HardWare.fr | News | Articles | PC | S'identifier | S'inscrire | Shop Recherche
1665 connectés 

  FORUM HardWare.fr
  Programmation
  C

  variables effacées

 



 Mot :   Pseudo :  
 
Bas de page
Auteur Sujet :

variables effacées

n°790339
bibi218
Posté le 08-07-2004 à 14:44:07  profilanswer
 

bonjour à tous, me revoilà encore une fois avec un problème à la noix ...
donc je m'explique : j'ai une fonction de base qui initialise quelques variables, enfin rien de très sorcier jusque là. Jái vérifié, elles sont bien toutes là, avec leur bonne valeur. Ensuite elle appelle une autre fonction, qui fait son bout de chemin tranquille, et une fois celle-ci terminée, plus de trace des mes variables de départ  :cry:  
 
Cf. GDB pour le message d'erreur

Citation :

Program received signal SIGSEGV, Segmentation fault.
0x000160ec in odeint (ystart=???, nvar=???, t1=???, t2=???, eps=Cannot access memory at address 0xffffffd8


 
J'ai pensé à des tableaux, qui auraient pu écraser des variables voisines, mais je ne vois pas à priori où cela se situerait ... quelqu'un aurait-il une idée (autre cause éventuelle par exemple ....) je ne sais plus trop où chercher là  :pt1cable:

mood
Publicité
Posté le 08-07-2004 à 14:44:07  profilanswer
 

n°790344
theshockwa​ve
I work at a firm named Koslow
Posté le 08-07-2004 à 14:46:59  profilanswer
 

tu voudrais pas donner du code STP ?

n°790350
fodger
ARRRACHHEE TTAAA FFFOUUFFOUNE!
Posté le 08-07-2004 à 14:49:34  profilanswer
 

bosse avec des pointeurs ou des variables static...


Message édité par fodger le 08-07-2004 à 14:50:04
n°790360
bibi218
Posté le 08-07-2004 à 14:53:52  profilanswer
 

oui, bien sûr. Je l'ai pas mis de suite pour pas décourager lol  :ange:  
la fonction appelée est celle aui s'appelle systdiff. Voici le fichier qui la contient (c'est un petit peu long par contre)
 

Code :
  1. #include <math.h>
  2. #include <stdio.h>
  3. #include <stddef.h>
  4. #include <stdlib.h>
  5. #include "nrutil.h"
  6. #include "bandes.h"
  7. #include "fonctions.h"
  8. #include "data.h"
  9. typedef struct systeme {
  10. double h;
  11. double **a,**a1;
  12. unsigned long *indx;
  13. } Systeme;
  14. /* Calcul du champ electrique */
  15. double *calculE(long unsigned n, Systeme poisson, double *y)
  16. {
  17.   double *b;
  18.   double *_V;
  19.   double *E;
  20.   unsigned long i;
  21.   b=membre_poisson(y,n,poisson.h);
  22.   banbks(poisson.a,n-2,3,3,poisson.a1,poisson.indx,b);
  23.   _V=dvector(1,n);
  24.   for(i=2;i<n;i++) _V[i]=b[i-1];
  25.   free_dvector(b,1,n-2);
  26.   _V[1]=-V0;
  27.   _V[n]=-V1;
  28.   E=gradient(_V,n,poisson.h);
  29.   free_dvector(_V,1,n);
  30.   return E;
  31. }
  32. /* Generation des differents coefficients variant avec E */
  33. void coeffs(double *E, unsigned long n, double *Dn, double *Dp, double *Y)
  34. {
  35.   unsigned long i;
  36.  
  37.   *Dn=K*T/Q*MUn;
  38.   *Dp=K*T/Q*MUp0*exp(-0.6*Q/K/T);
  39.   for(i=1;i<=n;i++) {
  40.     Dp[i]=K*T/Q*MUp0*exp(-E[i]/K/T);
  41.     Y[i]=Y0+(1-Y0)*pow(E[i]/(1+Ec),1.1);
  42.   }
  43. }
  44. void sigma(double *E, unsigned long n, double *SIGMApt, double *SIGMApr, double *SIGMAnt, double *SIGMAnr)
  45. {
  46.   unsigned long i;
  47.  
  48.   for(i=1;i<=n;i++) {
  49.     SIGMApt[i]=8.83e-9*pow(fabs(E[i]),-0.6);
  50.     SIGMAnr[i]=SIGMApt[i];
  51.     if (fabs(E[i])<7e7) SIGMApr[i]=2.05e-5*pow(fabs(E[i]),-1.5);
  52.     else SIGMApr[i]=1.2e7*pow(fabs(E[i]),-3);
  53.   }
  54.   *SIGMAnt=3.1e-17;
  55. }
  56. /* Fonction donnant l'expression de l'EDO */
  57. void systdiff(double *y, double *dy, unsigned long n, Systeme poisson)
  58. {
  59.   double *E,*dE,*Y,*SIGMApt,*SIGMApr,*SIGMAnr;
  60.   double *N,*P,*Nt,*Pt,*dNdx,*dPdx,*dNtdx,*dPtdx,*d2Ndx2,*d2Pdx2;
  61.   double Dp,Dn,SIGMAnt;
  62.   unsigned long i;
  63.   /* allocation de memoire pour les coefficients et autres */
  64.   dE=dvector(1,n);
  65.   Y=dvector(1,n);
  66.   SIGMApt=dvector(1,n);
  67.   SIGMApr=dvector(1,n);
  68.   SIGMAnr=dvector(1,n);
  69.   N=dvector(1,n);
  70.   P=dvector(1,n);
  71.   Nt=dvector(1,n);
  72.   Pt=dvector(1,n);
  73.  
  74.   /* remplissage de ces coefficients */
  75.   for(i=1;i<=n;i++) {
  76.     N[i]=y[i];
  77.     P[i]=y[n+i];
  78.     Nt[i]=y[2*n+i];
  79.     Pt[i]=y[3*n+i];
  80.     dE[i]=Q/EPSILONox*(P[i]-N[i]+Pt[i]-Nt[i]);
  81.   }
  82.   dNdx=gradient(N,n,poisson.h);
  83.   dPdx=gradient(P,n,poisson.h);
  84.   dNtdx=gradient(Nt,n,poisson.h);
  85.   dPtdx=gradient(Pt,n,poisson.h);
  86.   d2Ndx2=lapl(N,n,poisson.h);
  87.   d2Pdx2=lapl(P,n,poisson.h); 
  88.  
  89.   E=calculE(n,poisson,y);
  90.   coeffs(E,n,&Dn,&Dp,Y);
  91.   sigma(E,n,SIGMApt,SIGMApr,&SIGMAnt,SIGMAnr);
  92.   /* generation du terme dy */
  93.   for(i=1;i<=n;i++) {
  94.     dy[i]=dNdx[i]*MUn*E[i] - N[i]*MUn*dE[i] - Dn*d2Ndx2[i] + g0*D*Y[i] -
  95.     fabs(N[i]*MUn*E[i]+Dn*dNdx[i])*(SIGMAnt*(Ntn-N[i])+SIGMAnr[i]*Pt[i]);
  96.     dy[n+i]=-dPdx[i]*MUp*E[i] - P[i]*MUp*dE[i] - Dp/K/T*dE[i] + Dp*d2Pdx2[i] + g0*D*Y[i] - fabs(P[i]*MUp*E[i]-Dp*dPdx[i])*(SIGMApt[i]*(Ntp-P[i])+SIGMApr[i]*Nt[i]);
  97.     dy[2*n+i]=SIGMAnt*fabs(N[i]*MUn*E[i]+Dn*dNdx[i])*(Ntn-Nt[i]) -
  98.     SIGMApr[i]*fabs(P[i]*MUp*E[i]-Dp*dPdx[i])*Nt[i];
  99.     dy[3*n+i]=SIGMApt[i]*fabs(P[i]*MUp*E[i]-Dp*dPdx[i])*(Ntp-Pt[i]) -
  100.     SIGMAnr[i]*fabs(N[i]*MUn*E[i]+Dn*dNdx[i])*Pt[i];
  101.   }
  102.   /* liberation de la memoire occupee par les vecteurs */
  103.   free_dvector(E,1,n);
  104.   free_dvector(dE,1,n);
  105.   free_dvector(Y,1,n);
  106.   free_dvector(SIGMApt,1,n);
  107.   free_dvector(SIGMApr,1,n);
  108.   free_dvector(SIGMAnr,1,n);
  109.   free_dvector(N,1,n);
  110.   free_dvector(P,1,n);
  111.   free_dvector(Nt,1,n);
  112.   free_dvector(Pt,1,n);
  113.   free_dvector(dNdx,1,n);
  114.   free_dvector(dPdx,1,n);
  115.   free_dvector(dNtdx,1,n);
  116.   free_dvector(dPtdx,1,n);
  117.   free_dvector(d2Ndx2,1,n);
  118.   free_dvector(d2Pdx2,1,n);
  119. }


 
les commandes dvector et free_dvector sont juste utilisées pour allouer et désallouer la mémoire. Elles sont sûres et ont déjà été testées (pas par moi loll).

n°790366
bibi218
Posté le 08-07-2004 à 14:55:59  profilanswer
 

j'ai essayé de faire aussi clair que possible. les résultats des fonctions gradient et lapl sont alloués à l'intérieur de ces fonctions, donc ca nápparaît pas ici

n°790380
theshockwa​ve
I work at a firm named Koslow
Posté le 08-07-2004 à 15:02:15  profilanswer
 

Code :
  1. for(i=1;i<=n;i++) {
  2.   N[i]=y[i];
  3. // ...


 
mmmh, je ne sais pas comment fonctionne ta fonction d'allocation, mais c'est déjà louche ...
 
ensuite, qu'elle soit fiable ou pas, cette fonction d'allocation, tu n'es pas à l'abris d'un manque de mem ... vérifie que tout a bien été alloué quoi :]
 
 
(Edit : étrange ce bug sur les paranthèses dans les sections de code -_-)


Message édité par theshockwave le 08-07-2004 à 15:03:36
n°790394
bibi218
Posté le 08-07-2004 à 15:07:46  profilanswer
 

la question est bête, mais comment on fait ca ?

n°790424
theshockwa​ve
I work at a firm named Koslow
Posté le 08-07-2004 à 15:21:58  profilanswer
 

:heink:  
 
been, tu regardes le retour de ta fonction, je suppose que le résultat sera NULL si la mémoire n'a pas pu être allouée
 
sinon, ... Pour tes tableaux, tu es sur que ce n'est pas plutôt de 0 à n-1 que tu devrais aller ?

n°790430
bibi218
Posté le 08-07-2004 à 15:25:39  profilanswer
 

non, le pointeur a été bidouillé afin que les indices puissent commencer à une valeur quelconque. par contre, je n'ai jamais de résultat null... tout se passe bien pendant quelques itérations (en tout cas, ca en a l'air), et dún coup, j'ai une variable qui soit n'est plus trouvé, soit prend une valeur (genre 10e304 pour les doubles)

n°790436
fodger
ARRRACHHEE TTAAA FFFOUUFFOUNE!
Posté le 08-07-2004 à 15:29:48  profilanswer
 

déjà ça c'est dégueulasse :

Code :
  1. typedef struct systeme {
  2.     double h;
  3.     double **a,**a1;
  4.     unsigned long *indx;
  5.   } Systeme;


 
c'est

Code :
  1. typedef struct
  2. {
  3.     double h;
  4.     double **a,**a1;
  5.     unsigned long *indx;
  6.   } Systeme;


Message édité par fodger le 08-07-2004 à 15:30:17
mood
Publicité
Posté le 08-07-2004 à 15:29:48  profilanswer
 

n°790438
theshockwa​ve
I work at a firm named Koslow
Posté le 08-07-2004 à 15:32:39  profilanswer
 

les structures non nommées, c'est standard, ca ?
 
Edit : okok, ca l'est :]


Message édité par theshockwave le 08-07-2004 à 15:37:00
n°790446
theshockwa​ve
I work at a firm named Koslow
Posté le 08-07-2004 à 15:39:14  profilanswer
 

bibi218 a écrit :

non, le pointeur a été bidouillé afin que les indices puissent commencer à une valeur quelconque. par contre, je n'ai jamais de résultat null... tout se passe bien pendant quelques itérations (en tout cas, ca en a l'air), et dún coup, j'ai une variable qui soit n'est plus trouvé, soit prend une valeur (genre 10e304 pour les doubles)


 
hum ... J'ai quelques doutes sur la manière dont ca a été fait, tu n'aurais pas le source de tes fonctions d'allocation ?

n°790452
bibi218
Posté le 08-07-2004 à 15:44:38  profilanswer
 

Code :
  1. double *dvector(long nl, long nh)
  2. /* allocate a double vector with subscript range v[nl..nh] */
  3. {
  4. double *v;
  5. v=(double *)malloc((size_t) ((nh-nl+1+NR_END)*sizeof(double)));
  6. if (!v) nrerror("allocation failure in dvector()" );
  7. return v-nl+NR_END;
  8. }


ca c'est pour l'allocation
 
et pour désallouer ...

Code :
  1. void free_dvector(double *v, long nl, long nh)
  2. /* free a double vector allocated with dvector() */
  3. {
  4. free((FREE_ARG) (v+nl-NR_END));
  5. }

n°790453
bibi218
Posté le 08-07-2004 à 15:45:27  profilanswer
 

j'avoue ne pas comprendre toutes les subtilités ...

n°790470
theshockwa​ve
I work at a firm named Koslow
Posté le 08-07-2004 à 15:57:04  profilanswer
 

que vaut NR_END, juste pour info ?

n°790482
bibi218
Posté le 08-07-2004 à 16:01:13  profilanswer
 

d'après les instructions en préprocesseur, la valeur est à 1

n°790491
theshockwa​ve
I work at a firm named Koslow
Posté le 08-07-2004 à 16:06:24  profilanswer
 

bon, quoi qu'il en soit, j'ai de sérieux doutes sur la personne qui a écrit ca (qui caste le retour de malloc :o )
Utilise des indices plus "classiques", ce sera mieux pour tout le monde.
 
... ou alors utilise plutôt quelque chose de ce genre, même si je n'ai pas envie de le conseiller tant c'est risqué -_- (cas où le retour pourrait être négatif ....)
 
Edit en fait, je cache, c'est encore mieux ... Utilise des indices conventionnels, c'est pas la mort d'utiliser i-nl au lieu de i, quand même


Message édité par theshockwave le 08-07-2004 à 16:07:40
n°791236
darkoli
Le Petit Dinosaure Bleu
Posté le 09-07-2004 à 10:22:01  profilanswer
 

J'ai eu un problème similaire, j'avais un indice de tableau (i) que je mettais à jour en fonction du résultat d'une recherche, entre 0 et N-1 si l'element recherché existait dans mon tableau ou -1 sinon et donc quand je voulais incrémenter le nombre d'apparitions de l'element je faisais liste[i].nb++; mais j'avais oublié de vérifier que i était bien supérieur à -1 !
 
Et en fait dans le cas où i était à -1 ça modifiait une autre variable ce qui foutait le bordel dans mon code ! Je n'avais ce problème que sur la machine de production, sur mon PC ça fonctionnait "bien" ! :sweat:


Message édité par darkoli le 09-07-2004 à 10:23:42
n°792576
el muchach​o
Comfortably Numb
Posté le 10-07-2004 à 17:35:41  profilanswer
 

"nrutil.h" --> tu utilises Numerical Recipes, c'est ça ?
Si oui, je suppose que les fonctions d'alloc et de désalloc de vecteurs sont bonnes. Par contre, il faut se méfier parce qu'il me semble qu'ils utilisent la convention Fortran, à savoir que les indices commencent à 1 et non 0 (d'ailleurs c'est bien ce que tu fais).
 
Pour la détection d'écrasements mémoire ou de memory leaks, utilise un malloc debugger comme Valgrind si t'es sous Linux.
Sinon mpatrol, ou autre truc du même genre.
Pour le genre d'applis que tu fais, ça ne sera pas inutile.


Message édité par el muchacho le 10-07-2004 à 17:48:23
n°792841
Carbon_14
Posté le 11-07-2004 à 10:38:39  profilanswer
 

Y a quoi dans membre_poisson() ? Je veux dire la déclaration et allocation de b ? Si on fait un free_dvector(), il faut espérer que la déclaration interne est conforme/compatible avec le free (on peut pas débobiner qq chose bobiné autrement).
 
      b=membre_poisson(y,n,poisson.h);
      ....  
      free_dvector(b,1,n-2);
-------------------------
dy[3*n+i] : dy est suffisament alloué en taille pour pas risquer de déborder ?
-----------------
les for i = sans (, ça fait bizarre
 
calculE(long unsigned n, faut que j'essaie, long et unsigned doivent être interchangeables. Quand on n'a pas l'habitude de lire dans ce sens..
 
 
C'est le code affiché qui, une fois exécuté, provoque la disparition des variables mentionnées ? En inhibant ce traitement, c'est bon ?
Elles sont globales les variables qui disparaissent ? C'est pas le compilo qui les a optimisées (servent plus => pschittt) ?


Aller à :
Ajouter une réponse
  FORUM HardWare.fr
  Programmation
  C

  variables effacées

 

Sujets relatifs
variables dans un fichiertutorial variables de sessions
melange de variables javascript dans du phpProblème avec la copie de variables
variables inaccessibles (easyPHP 1.7)recuperer des variables de session lors du timeout par un listener
pb concaténation et variablesprob lors de l'affichage de variables de session
Variables de type variable, c'est possible ?incrementation dans les noms de variables
Plus de sujets relatifs à : variables effacées


Copyright © 1997-2018 Hardware.fr SARL (Signaler un contenu illicite / Données personnelles) / Groupe LDLC / Shop HFR