attemp to free un pointer not allocated by malloc sauf que il l'est

attemp to free un pointer not allocated by malloc sauf que il l'est - C - Programmation

Marsh Posté le 23-04-2020 à 19:37:07    

Hello,
 
J'ai un soucis sur lequel je sèche et qui arrive au bout de mes compétences.
 
J'ai une fonctions qui utilise des tableaux de double (1D). ne connaissant pas la taille à la compil, je passe par des pointers.
J'allocate les pointer avec un calloc pour avoir une mise à zéro des vaelurs du tableau.
 
Mon code viens écrire des valeurs dedans en y accèdant comme un tableau normale.
Je viens de "lire" via des fonctions stdev et median mais je passe son adresse avec un +1.
 
Ensuite je viens le free.
 
On arrive au soucis. Par moment j'ai un non-fatal runtime error qui me dis que le pointer à free n'est pas allocated by malloc, calloc, ...
 
J'ai fait un memset juste avant de le free, il passe bien toute les case à 0, mais il pète en error quand meme de temps en temps.
Je ne comprends pas pourquoi des fois ça marche et des fois non.
 

Citation :

NON-FATAL RUN-TIME ERROR:   "Management_Measure.c", line 949, col 9, thread id 7672, function id 1:   Attempt to free pointer to memory not allocated by malloc() or calloc().


 
Le code code qui utilise le tableau. (rien de plus. Plein de code autour pour faire des calul qui permettent de remplir cette variable et la traiter, mais tout les "accès" a la variables sont là.:

Code :
  1. double *dPhaseShiftSamples = NULL;
  2.         dPhaseShiftSamples = (double*)calloc(PERIOD2PROCESS+2,sizeof(double));
  3. //bout de code autre
  4.         dPhaseShiftSamples[indice] = dX1 - dX2;
  5. //on est dans une for ici
  6.         if (dPhaseShiftSamples[indice] < 0) //on est dans une for ici
  7.     iPolarity[indice] = 1;
  8.    else if (dPhaseShiftSamples[indice] > 0)
  9.     iPolarity[indice] = 2;
  10.    else
  11.     iPolarity[indice] = 0;
  12. //fin de la for
  13. //bout de code autre
  14.         StdDev(dPhaseShiftSamples+1,indice-1,&mean,&stdev);
  15. //bout de code autre
  16. Median(dPhaseShiftSamples+1,indice-1,&dPhaseShiftSamplesMean);
  18. if(dPhaseShiftSamples)
  19. {
  21.  memset(dPhaseShiftSamples,0, (PERIOD2PROCESS+2)*sizeof(double));
  22.  free(dPhaseShiftSamples);
  23.  dPhaseShiftSamples = NULL;
  24. }


---------------
Monde de merde | Restez curieux
Reply

Marsh Posté le 23-04-2020 à 19:37:07   

Reply

Marsh Posté le 29-04-2020 à 08:22:44    

Affiche l'adresse obtenue à la sortie du calloc, et affiche la valeur contenue dans ta variable juste avant le free. Si la valeur a changé, tu as un écrasement mémoire quelque part.
 
edit  :
 

Code :
  1. double *dPhaseShiftSamples = NULL;
  2.         dPhaseShiftSamples = (double*)calloc(PERIOD2PROCESS+2,sizeof(double));
  3.         printf("adresse sortie de calloc : %X\n" , dPhaseShiftSamples  ) ;
  4. //bout de code autre
  5.         dPhaseShiftSamples[indice] = dX1 - dX2;
  6. //on est dans une for ici
  7.         if (dPhaseShiftSamples[indice] < 0) //on est dans une for ici
  8.     iPolarity[indice] = 1;
  9.    else if (dPhaseShiftSamples[indice] > 0)
  10.     iPolarity[indice] = 2;
  11.    else
  12.     iPolarity[indice] = 0;
  13. //fin de la for
  14. //bout de code autre
  15.         StdDev(dPhaseShiftSamples+1,indice-1,&mean,&stdev);
  16. //bout de code autre
  17. Median(dPhaseShiftSamples+1,indice-1,&dPhaseShiftSamplesMean);
  18. if(dPhaseShiftSamples)
  19. {
  20. memset(dPhaseShiftSamples,0, (PERIOD2PROCESS+2)*sizeof(double));
  21. printf("adresse avant free : %X\n" , dPhaseShiftSamples  ) ;
  22. free(dPhaseShiftSamples);
  23. dPhaseShiftSamples = NULL;
  24. }


Message édité par xilebo le 29-04-2020 à 08:23:58
Reply

Marsh Posté le 29-04-2020 à 10:40:52    

StdDev(dPhaseShiftSamples+1,indice-1,&mean,&stdev);
Median(dPhaseShiftSamples+1,indice-1,&dPhaseShiftSamplesMean);
 
Pourquoi passer l'adresse avec un +1 et passer l'indice avec un -1 :??:
 
Par ailleurs, ça serait pas mal d'avoir tout le code (au moins la partie boucle).


---------------
Astres, outil de help-desk GPL : http://sourceforge.net/projects/astres, ICARE, gestion de conf : http://sourceforge.net/projects/icare, Outil Planeta Calandreta : https://framalibre.org/content/planeta-calandreta
Reply

Marsh Posté le 30-04-2020 à 12:51:11    

Hello,
 
J'ai pas encore regardé si l'adresse change ou pas, j'essaie ça Lundi (chômage partiel cette semaine). En y repensant, que j'ai le crash, en débug je vois que l'adresse après le memset est du style 0x0000001. Avant que j'ajoute le memset l’adresse était plus "normale" mais pas fait gaffe si elle était modifiée.
Par contre je n'explique pas pourquoi l'adresse o(ou même le contenus) serais altéré. Normalement windows empèche d'autres variables de venir mettre le boxon et dans le code je viens n'y faire que de la lecture  en dehors de cette ligne oO :

Code :
  1. dPhaseShiftSamples[indice] = dX1 - dX2;


 
 
Je doit ajouter un check Timeout cet aprèm,je peu vous mettre le code complet de la boucle si vous voulez.
Le but de la fonction est de calculer un déphasage sur 2 types de signaux. J'ai voulu avoir un code générique en fonction des signaux. Comme ça en plus je peut le réutiliser dans d'autres programmes.
C'est sur les signaux d'un stator d'un moteur et du capteur de position du rotor.
Les signaux du stators ont une certaine forme et ceux du capteur de position une autre forme.
Je prends tout les déphasage sur les périodes "électriques" sur un tour mécanique. Ça donne un PERIODE2PROCESS à 6 et je prends un rab de 2 à cause des phases à l'origine suites aux débug.
La référence est la valeur médiane du signal. ça me permet de travailler en acquisition équivalent AC et de prendre le passage par 0 comme référence. (les max sont "écrêtés" et ne sont pas fiable)
 
le +1 / -1 : j'ai une table à 8 éléments mais seulement 6 utiles, le premier est toujours à 0.
Si je met le 0 dans l’écart type et la moyenne ça change tout le résultat.
J'ai des valeurs qui sont d'environ 30 000.

Message cité 1 fois

---------------
Monde de merde | Restez curieux
Reply

Marsh Posté le 30-04-2020 à 13:34:00    

jungledede a écrit :

Hello,
 
 
Par contre je n'explique pas pourquoi l'adresse o(ou même le contenus) serais altéré. Normalement windows empèche d'autres variables de venir mettre le boxon et dans le code je viens n'y faire que de la lecture  en dehors de cette ligne oO :


 
Absolument pas. Windows te garantit que tu ne vas pas taper dans l'espace d'adressage d'un autre processus, mais dans ton propre processus, tu fais ce que tu veux. Tu peux faire un écrasement mémoire via une autre variable sans problème. Je te donne un exemple :
 

Code :
  1. #include <stdio.h>
  2. #include <stdlib.h>
  4. int main()
  5. {
  6.   unsigned int   a;
  7.   unsigned int * b ;
  8.   b = (int *)malloc ( 10 * sizeof(unsigned int));
  9.   printf("adresse a : %X\n" , &a ); 
  10.   printf("adresse b : %X\n" , &b  );
  11.   printf("pointeur alloué : %X\n" , b  );
  12.   *(&a+1) = 0xDEADBEEF;
  13.   printf("pointeur alloué : %X\n" , b  );
  14.  
  15.   free(b);
  16.  
  17.   return 0;
  18.  
  19. }


 
result :  
 


adresse a : 427F5CB4                                                                                                                                                                                                                            
adresse b : 427F5CB8                                                                                                                                                                                                                            
pointeur alloué : 12AC010                                                                                                                                                                                                                        
pointeur alloué : DEADBEEF                                                                                                                                                                                                                      
Segmentation fault (core dumped)


 
J'ai écrasé la valeur de ce que j'ai alloué dans b en passant par la variable a
 
Je dis pas que c'est ce que t'as fait, en général , les écrasements mémoire sont plus subtils, mais le fait est que si ta valeur pointée a changé, c'est pas bon ^^
 
Pire, un écrasement de pile, et tu peux même pas debugguer avec un point d'arrêt car la pile est perdue.

Message cité 1 fois
Reply

Marsh Posté le 30-04-2020 à 13:43:39    

Je pense à truc : tu ne vérifies pas que valeur retour de l'alloc de mémoire comme si tu partais du principe que ça serait forcément alloué. Il faut toujours vérifier que l'alloc a bien fonctionné :o

Message cité 1 fois

---------------
Astres, outil de help-desk GPL : http://sourceforge.net/projects/astres, ICARE, gestion de conf : http://sourceforge.net/projects/icare, Outil Planeta Calandreta : https://framalibre.org/content/planeta-calandreta
Reply

Marsh Posté le 30-04-2020 à 15:49:11    

xilebo a écrit :


 
Absolument pas. Windows te garantit que tu ne vas pas taper dans l'espace d'adressage d'un autre processus, mais dans ton propre processus, tu fais ce que tu veux. Tu peux faire un écrasement mémoire via une autre variable sans problème. Je te donne un exemple :
 

Code :
  1. #include <stdio.h>
  2. #include <stdlib.h>
  4. int main()
  5. {
  6.   unsigned int   a;
  7.   unsigned int * b ;
  8.   b = (int *)malloc ( 10 * sizeof(unsigned int));
  9.   printf("adresse a : %X\n" , &a ); 
  10.   printf("adresse b : %X\n" , &b  );
  11.   printf("pointeur alloué : %X\n" , b  );
  12.   *(&a+1) = 0xDEADBEEF;
  13.   printf("pointeur alloué : %X\n" , b  );
  14.  
  15.   free(b);
  16.  
  17.   return 0;
  18.  
  19. }


 
result :  
 


adresse a : 427F5CB4                                                                                                                                                                                                                            
adresse b : 427F5CB8                                                                                                                                                                                                                            
pointeur alloué : 12AC010                                                                                                                                                                                                                        
pointeur alloué : DEADBEEF                                                                                                                                                                                                                      
Segmentation fault (core dumped)


 
J'ai écrasé la valeur de ce que j'ai alloué dans b en passant par la variable a
 
Je dis pas que c'est ce que t'as fait, en général , les écrasements mémoire sont plus subtils, mais le fait est que si ta valeur pointée a changé, c'est pas bon ^^
 
Pire, un écrasement de pile, et tu peux même pas debugguer avec un point d'arrêt car la pile est perdue.


 

rufo a écrit :

Je pense à truc : tu ne vérifies pas que valeur retour de l'alloc de mémoire comme si tu partais du principe que ça serait forcément alloué. Il faut toujours vérifier que l'alloc a bien fonctionné :o


 
ok, je comprends un peut plus. ça confirme le subtile. [:mr mala:1]  
Surtout que j'ai pas encore compris la "recurrence" du crash. Des fois ça fonctionne, des fois non, mais quand ça marche pas c'est toujours sur un signal "bizarre" (du moins une forme trop éloigné d'une sinus. A par ne pas trouver les index qu'il faut je comprends pas encore le lien de cause à effet).  
Je verrais lundis avec les debug supplémentaire ce que je peu trouver.
Après je suis pas vraiment programmeur de formation, je me démerde, mais des fois je sens bien que j'implémente des trucs qui sont pas les bonnes pratiques. (Typiquement ça ne fait que 15 jours que je typecast les malloc :o )
 
Pour le code entier:

Code :
  1. int PhaseAngle(eSignals iSignal1, eSignals iSignal2 ,double dFrequency, unsigned short iNumbPairsPoles, double *pdAngle)
  2. {
  4. // passage en AC      
  5. //TriggerDetection à 0V
  6. // 6 period processed
  7. const int PERIOD2PROCESS = iNumbPairsPoles*1+2;
  8. double  FREQSIGNAL = dFrequency;
  10. int FREQSAMPLE = DescripteurCourbe[iSignal1].frequenceApparenteEchantillonnage;
  12. int nbPoint;
  13. int nbSamplesToCheck = RoundRealToNearestInteger((FREQSAMPLE/FREQSIGNAL)*PERIOD2PROCESS);
  14. int width = nbSamplesToCheck / (PERIOD2PROCESS*3);
  15. int startSample = 0;
  16. double dMedian1,dMedian2;
  18. const int COEFSUPERSAMPLE = 200;
  19. const int SUPER_SAMPLES_MAX = nbSamplesToCheck*COEFSUPERSAMPLE;
  20. double *X = NULL;
  21. double *dSecondDerivative1 = NULL,*dSecondDerivative2 = NULL;
  22. int iSuperSample;
  23. double *dYSuperSampled1 = NULL, *dYSuperSampled2 = NULL;
  25. int *iIndices1 = NULL;
  26. int *iIndices2 = NULL;
  29. const int LINFITSAMPLES = 150*(0.5*COEFSUPERSAMPLE); //20 before
  30. double *dDataX1 = NULL,*dDataX2 = NULL,*dOut = NULL;
  31. int iNewStartSample1 = 0, iNewStartSample2 = 0;
  32. double dA1 = 0, dA2 = 0, dB1 = 0, dB2 = 0, dError1 = 0, dError2 = 0;
  33. double dX1 = 0, dX2 = 0;
  36. double *dPhaseShiftSamples = NULL;
  37. double dPhaseShiftSamplesMean = 0.;
  38. double *dPhaseShiftSamplesTrigger = NULL;
  40. double dPeriodSample = 0.;
  41. double *dPeriodSampleArray = NULL;
  42. int indice = 0;
  43. int iNbIndices1 = 0, iNbIndices2 = 0;
  44. int *iPolarity = NULL;
  45. int iFlagError = false;
  46. int SignalValid = false;
  47. unsigned char maxTryPhase = 1;
  48. int try = 0;
  49.  iPolarity = (int*)calloc(PERIOD2PROCESS+2,sizeof(int));
  53. iIndices1 = (int*)calloc(PERIOD2PROCESS+2,sizeof(int));
  54. iIndices2 = (int*)calloc(PERIOD2PROCESS+2,sizeof(int));
  56. dPhaseShiftSamples = (double*)calloc(PERIOD2PROCESS+2,sizeof(double));
  57. dPhaseShiftSamplesTrigger = (double*)calloc(PERIOD2PROCESS+2,sizeof(double));
  58. dPeriodSampleArray = (double*)calloc(PERIOD2PROCESS+2,sizeof(double));
  60. dDataX1 = (double*)calloc(LINFITSAMPLES+1,sizeof(double));//+2
  61. dDataX2 = (double*)calloc(LINFITSAMPLES+1,sizeof(double));
  62. dOut = (double*)calloc(LINFITSAMPLES+20,sizeof(double));
  64. //Recreate the real signal in super sampled signal (x1000).
  65. //Alow better accuracy
  66. X = (double*)calloc(nbSamplesToCheck,sizeof(double));
  67. dSecondDerivative1 = (double*)calloc(nbSamplesToCheck,sizeof(double));
  68. dSecondDerivative2 = (double*)calloc(nbSamplesToCheck,sizeof(double));
  69. dYSuperSampled1 = (double*)calloc(SUPER_SAMPLES_MAX,sizeof(double));
  70. dYSuperSampled2 = (double*)calloc(SUPER_SAMPLES_MAX,sizeof(double));
  72. double validity = 0;
  73. double stdev = 0;
  74. double mean = 0;
  76. do
  77. {
  78.  printf("debut boucle\n" );
  80.  CHECK_TIMEOUT;
  82.  //sometime the acquition is not finish for all signal, so we cue for the signal with the less of point in the curve.  
  83.  if(DescripteurCourbe[iSignal1].nombrePoints <= DescripteurCourbe[iSignal2].nombrePoints)
  84.   nbPoint = DescripteurCourbe[iSignal1].nombrePoints;
  85.  else
  86.   nbPoint = DescripteurCourbe[iSignal2].nombrePoints;
  88.  startSample = nbPoint - nbSamplesToCheck - 2;
  89.  printf("startSample %d\n",startSample);
  90. //SuperSample the signals  
  91.  Ramp(nbSamplesToCheck,startSample,startSample+nbSamplesToCheck,X);
  92.  Spline(X,DescripteurCourbe[iSignal1].identificateurPointsY.points+startSample, nbSamplesToCheck, 0.0, 0.0, dSecondDerivative1);
  93.  Spline(X,DescripteurCourbe[iSignal2].identificateurPointsY.points+startSample, nbSamplesToCheck, 0.0, 0.0, dSecondDerivative2);
  95.  for (iSuperSample = 0; iSuperSample < SUPER_SAMPLES_MAX; iSuperSample++)
  96.  {
  97.   SpInterp(X,DescripteurCourbe[iSignal1].identificateurPointsY.points+startSample, dSecondDerivative1, nbSamplesToCheck, startSample+iSuperSample*(1.0/COEFSUPERSAMPLE), &dYSuperSampled1[iSuperSample]);
  98.   SpInterp(X,DescripteurCourbe[iSignal2].identificateurPointsY.points+startSample, dSecondDerivative2, nbSamplesToCheck, startSample+iSuperSample*(1.0/COEFSUPERSAMPLE), &dYSuperSampled2[iSuperSample]);
  99.  }
  101. //Get the H1 harmonic for phases since the waveform at crossing 0 is not reliable anymore with rare earth magnet
  102.  if(iSignal1 < PSU1)
  103.  {
  104.   double dFreqResolution;
  105.   double dStartFreq;
  107.   double phaseFound;
  108.   double amplFound;
  109.   double freqFound;
  110.   SearchType Search;
  111.   double *dExportSpectre = (double*)malloc(SUPER_SAMPLES_MAX*sizeof(double));
  112.   double period = 1.0/(DescripteurCourbe[iSignal1].frequenceApparenteEchantillonnage * COEFSUPERSAMPLE);
  113.   Search.centerFrequency = dFrequency;
  114.   Search.frequencyWidth = 2;
  116.   SingleToneSignal (dYSuperSampled1, SUPER_SAMPLES_MAX, period
  117.        , &Search, TONE_EXPORT_DETECTED, &freqFound
  118.        , &amplFound, &phaseFound, dYSuperSampled1
  119.        , &period, dExportSpectre, &dStartFreq, &dFreqResolution);
  121.   free(dExportSpectre);
  122.   dExportSpectre = NULL;
  123.  }
  124.  if(iSignal2 < PSU1)
  125.  {
  126.   double dFreqResolution;
  127.   double dStartFreq;
  129.   double phaseFound;
  130.   double amplFound;
  131.   double freqFound;
  132.   SearchType Search;
  133.   double *dExportSpectre = (double*)malloc(SUPER_SAMPLES_MAX*sizeof(double));
  134.   double period = 1.0/(DescripteurCourbe[iSignal2].frequenceApparenteEchantillonnage * COEFSUPERSAMPLE);
  135.   Search.centerFrequency = dFrequency;
  136.   Search.frequencyWidth = 2;
  138.   SingleToneSignal (dYSuperSampled2, SUPER_SAMPLES_MAX, period
  139.        , &Search, TONE_EXPORT_DETECTED, &freqFound
  140.        , &amplFound, &phaseFound, dYSuperSampled2
  141.        , &period, dExportSpectre, &dStartFreq, &dFreqResolution);
  143.   free(dExportSpectre);
  144.   dExportSpectre = NULL;
  145.  }
  148. //Get the median value (avoid HighPass filter to AC or soustract the ac value)  
  149.  Median(DescripteurCourbe[iSignal1].identificateurPointsY.points+startSample,nbSamplesToCheck,&dMedian1);
  150.  Median(DescripteurCourbe[iSignal2].identificateurPointsY.points+startSample,nbSamplesToCheck,&dMedian2);
  152.  if(dMedian2 ==0)
  153.  {
  154.   //dor debug
  155.   Sleep(1);
  156.  }
  158. // Find the location of the next value over the median value (equivalent to 0V crossign value with AC signal)  
  160.  ThresholdPeakDetector (dYSuperSampled1,
  161.          SUPER_SAMPLES_MAX,
  162.          dMedian1, width,
  163.          iIndices1,&iNbIndices1);
  164.  ThresholdPeakDetector (dYSuperSampled2,
  165.          SUPER_SAMPLES_MAX,
  166.          dMedian2, width,
  167.          iIndices2,&iNbIndices2);
  168.  if (try >= maxTryPhase) //for debug
  169.  {
  170.           YGraphPopup("",dYSuperSampled2,SUPER_SAMPLES_MAX,VAL_DOUBLE);
  171.  }
  173. //Get the sample phase shift
  174.  for(indice = 1;indice < iNumbPairsPoles+1;indice ++)
  175.  {
  176.   if(iIndices1[indice] != 0 && iIndices2[indice] != 0)
  177.   {
  179. //We have samples position, but not acurate enought.
  180. //We get 80 samples around the index sample to process a lineFit.
  181. //With the ax+b line, we can compute the position for the triger position with a result in double.
  182. // (we know y = ax+b.  y = median value, need to find the x).  
  184.   //Create an array for the x axle
  185.    Ramp(LINFITSAMPLES,iIndices1[indice]-(LINFITSAMPLES/2),iIndices1[indice]+(LINFITSAMPLES/2),dDataX1);
  186.    Ramp(LINFITSAMPLES,iIndices2[indice]-(LINFITSAMPLES/2),iIndices2[indice]+(LINFITSAMPLES/2),dDataX2);
  187.   //Get the new start sample    
  188.    iNewStartSample1 = iIndices1[indice]-(LINFITSAMPLES/2);
  189.    if(iNewStartSample1 <0)
  190.     break;
  191.    iNewStartSample2 = iIndices2[indice]-(LINFITSAMPLES/2);
  192.    if(iNewStartSample2 <0)
  193.     break;
  194.   //Get the linear regression  
  195.    LinFit(dDataX1,dYSuperSampled1+iNewStartSample1,LINFITSAMPLES,dOut,&dA1,&dB1,&dError1);
  196.    LinFit(dDataX2,dYSuperSampled2+iNewStartSample2,LINFITSAMPLES,dOut,&dA2,&dB2,&dError2);
  198.   //compute the float number sample (the X at the median value)  
  199.    dX1 = (dMedian1 -dB1) / dA1;
  200.    dX2 = (dMedian2 -dB2) / dA2;
  201.    if(iSignal1 == U1)
  202.    {
  203.     //dor debug
  204.     Sleep(1);
  205.    }
  206.    //computed value  
  207.    dPhaseShiftSamples[indice] = dX1 - dX2;
  209.    if (dPhaseShiftSamples[indice] < 0)
  210.     iPolarity[indice] = 1;
  211.    else if (dPhaseShiftSamples[indice] > 0)
  212.     iPolarity[indice] = 2;
  213.    else
  214.     iPolarity[indice] = 0;
  216.    if(indice > 1)
  217.    {
  218.     if(iPolarity[indice] != iPolarity[indice-1])
  219.      iFlagError = true;
  221.    }
  223.    dPeriodSampleArray[indice] = iIndices1[indice+1] - iIndices1[indice];
  224.    printf("phase %3.2f, period %3.2f\n",dPhaseShiftSamples[indice],dPeriodSampleArray[indice]);
  225.   }
  227.   else
  228.    break;
  229.  }
  230.  //check that all index are almost the same.  
  231.  StdDev(dPhaseShiftSamples+1,indice-1,&mean,&stdev);
  232.  validity = stdev/mean;
  233.  validity = fabs(validity);
  234.  printf("std %f, mean %f, valid %f\n",stdev,mean,validity);
  235.  //(!iFlagError) &&
  236.  if( (validity < 0.01))// if we don't have error, means the index are all in the same order and check they have almost the same valeu.
  237.   SignalValid = TRUE;
  240.  try++;
  241.  printf("fin boucle\n" );
  242. }
  243. while (!SignalValid);
  246. Median(dPhaseShiftSamples+1,indice-1,&dPhaseShiftSamplesMean);
  248. Mean(dPeriodSampleArray+1,indice-1,&dPeriodSample);
  250. if(dPhaseShiftSamples)
  251. {
  253.  memset(dPhaseShiftSamples,0, (PERIOD2PROCESS+2)*sizeof(double));
  254.  free(dPhaseShiftSamples);
  255.  dPhaseShiftSamples = NULL;
  256. }
  259. if(dPeriodSampleArray)
  260. {
  261.  memset(dPeriodSampleArray,0, PERIOD2PROCESS+2);
  262.  free(dPeriodSampleArray);
  263.  dPeriodSampleArray = NULL;
  264. }
  267. if(X)
  268. {
  269.  memset(X,0, nbSamplesToCheck);
  270.  free(X);
  271.  X = NULL;
  272. }
  275. if(dSecondDerivative1)
  276. {
  277.  memset(dSecondDerivative1,0,nbSamplesToCheck);
  278.  free(dSecondDerivative1);
  279.  dSecondDerivative1 = NULL;
  280. }
  283. if(dSecondDerivative2)
  284. {
  285.  memset(dSecondDerivative2,0, nbSamplesToCheck);
  286.  free(dSecondDerivative2);
  287.  dSecondDerivative2 = NULL;
  288. }
  291. if(dYSuperSampled1)
  292. {
  293.  memset(dYSuperSampled1,0,SUPER_SAMPLES_MAX);
  294.  free(dYSuperSampled1);
  295.  dYSuperSampled1 = NULL;
  296. }
  299. if(dYSuperSampled2)
  300. {
  301.  memset(dYSuperSampled2,0, SUPER_SAMPLES_MAX);
  302.  free(dYSuperSampled2);
  303.  dYSuperSampled2 = NULL;
  304. }
  307. if(iIndices1)
  308. {
  309.  memset(iIndices1,0, PERIOD2PROCESS+2);
  310.  free(iIndices1);
  311.  iIndices1 = NULL;
  312. }
  315. if(iIndices2)
  316. {
  317.  memset(iIndices2,0, PERIOD2PROCESS+2);
  318.  free(iIndices2);
  319.  iIndices2 = NULL;
  320. }
  322. if(dDataX1)
  323. {
  324.  free(dDataX1);
  325.  dDataX1 = NULL;
  326. }
  329. if(dDataX2)
  330. {
  331.  free(dDataX2);
  332.  dDataX2 = NULL;
  333. }
  336. if(dOut)
  337. {
  338.  free(dOut);
  339.  dOut = NULL;
  340. }
  343. if(iPolarity)
  344. {
  345.  free(iPolarity);
  346.  iPolarity = NULL;
  347. }
  349. //Convert into angle value
  350. // get periods sample duration
  351. // scale in angle
  352. // dPeriodSample = iIndices1[2] - iIndices1[1];
  353. FREQSAMPLE = FREQSAMPLE*COEFSUPERSAMPLE;
  354. *pdAngle = 360.0*dPhaseShiftSamplesMean/dPeriodSample;
  356. printf("angle %3.2f\n",*pdAngle);
  357. return 0;
  358. }


---------------
Monde de merde | Restez curieux
Reply

Marsh Posté le 30-04-2020 à 17:28:06    

je regarderai plus tard mais y a pas tout :o
 
déjà ça :  
 

Code :
  1. if(iIndices1)
  2. {
  3. memset(iIndices1,0, PERIOD2PROCESS+2);
  4. free(iIndices1);
  5. iIndices1 = NULL;
  6. }


 
ca sert à rien de faire un memset juste avant un free.
 
 
edit : quand je dis y a pas tout, c'est le code complet ( le main, les autres fonctions qui manipulent tes tableaux ).
 

Message cité 1 fois
Message édité par xilebo le 30-04-2020 à 17:33:31
Reply

Marsh Posté le 30-04-2020 à 18:41:00    

Tu pourrais pas mettre le ficheir en téléchargement qq part parce que sans l'indentation, c'est chaud à lire.
 
Déjà, y'a un truc qui me chose si j'ai bien vu : tu fais des déclarations de variables à l'intérieur de ton do...while. C'est aps une bonne idée car à chaque tour de boucle, tu redéclares :/


---------------
Astres, outil de help-desk GPL : http://sourceforge.net/projects/astres, ICARE, gestion de conf : http://sourceforge.net/projects/icare, Outil Planeta Calandreta : https://framalibre.org/content/planeta-calandreta
Reply

Marsh Posté le 30-04-2020 à 19:07:19    

xilebo a écrit :

je regarderai plus tard mais y a pas tout :o

 

déjà ça :

 
Code :
  1. if(iIndices1)
  2. {
  3. memset(iIndices1,0, PERIOD2PROCESS+2);
  4. free(iIndices1);
  5. iIndices1 = NULL;
  6. }
 

ca sert à rien de faire un memset juste avant un free.

 


edit : quand je dis y a pas tout, c'est le code complet ( le main, les autres fonctions qui manipulent tes tableaux ).

 



Le memset on l'a mis en "debug".
On voulais voir si il arrive bien à remettre à zéro le tableau avant le free. Et en point d’arrêt on est bien à 0.
Mais on est d'accord qu'il ne sert à rien et qu'ils seront supprimés quand ça sera fiable.

 

Tout le code est là. Il n'y a que les structures de stockage des points (DescripteurCourbe) qui sont global. Le reste ça passe dans le prototype.

 

Je regarde pour vous mettre le fichier en lien. Je dois avoir un login Github qui traine


Message édité par jungledede le 30-04-2020 à 19:09:40

---------------
Monde de merde | Restez curieux
Reply

Sujets relatifs:

Leave a Replay

Make sure you enter the(*)required information where indicate.HTML code is not allowed