C内存管理问题

Question

I have traced an EXC_BAD_ACCESS to the following allocation and deallocation of memory. It involves the accelerate framework in Xcode. The main issue is that this code is in a loop. If i force the loop to only iterate once then it works fine. But when it loops (7 times) it causes an error on the second iteration. Does any of this look incorrect?

EDIT: *added actual code. This segment runs if I remove certain parts and such but seems to have poor memory management which results in issues

#import <Foundation/Foundation.h>
#include <math.h>
#include <Accelerate/Accelerate.h>

  for(int i = 0; i < 8; i++)
    {

   int XX[M][m];  //M and m are just 2 ints

   for(int kk = 0; kk < M; kk++)
            {
                for (int kk1 = 0; kk1 < m; kk1++)
                {
                    XX[kk][kk1] = [[x objectAtIndex: (kk + kk1 * J)] intValue];  //x is a NSMutableArray of NSNumber objects
                }

            }

            double FreqRes = (double) freqSamp/n;

            NSMutableArray *freqs = [[NSMutableArray alloc] initWithCapacity: round((freqSamp/2 - FreqRes) - 1)];

            int freqSum = 0;

            for(double i = -1 * freqSamp/2; i < (freqSamp/2 - FreqRes); i+= FreqRes)
            {

                [freqs addObject: [NSNumber numberWithInt: i]];

                if(i == 0)
                {
                    freqSum++;
                }

            }

            int num = [x count];
            int log2n = (int) log2f(num);
            int nOver2 = n / 2;

            FFTSetupD fftSetup = vDSP_create_fftsetupD (log2n, kFFTRadix2);

            double ffx[num];

            DSPDoubleSplitComplex fft_data;
            fft_data.realp = malloc(nOver2 * sizeof(double)); //Error usually thrown on this line in the second iteration.  Regardless of what I put there.  If I add an NSLog here it throws the error on that NSLog
            fft_data.imagp = malloc(nOver2 * sizeof(double));


            for (int i = 0; i < n; ++i)
            {
                ffx[i] = [[x objectAtIndex:i] doubleValue];
            }


            vDSP_ctozD((DSPDoubleComplex *) ffx, 2, &fft_data, 1, nOver2);

            vDSP_fft_zripD (fftSetup, &fft_data, 1, log2n, kFFTDirection_Forward);

            for (int i = 0; i < nOver2; ++i)
            {
                fft_data.realp[i] *= 0.5;
                fft_data.imagp[i] *= 0.5;
            }   

            int temp = 1;

            ffx[0] = abs(fft_data.realp[0]);
            for(int i = 1; i < nOver2; i++)
                ffx[i] = sqrt((fft_data.realp[i] * fft_data.realp[i]) + (fft_data.imagp[i] * fft_data.imagp[i]));
            ffx[nOver2] = abs(fft_data.imagp[0]);
            for(int i = nOver2-1; i > 0; i--)
            {
                ffx[nOver2 + temp] = sqrt((fft_data.realp[i] * fft_data.realp[i]) + (fft_data.imagp[i] * fft_data.imagp[i]));
                temp++;
            }

            //clear Fxx and freqs data
            vDSP_destroy_fftsetupD(fftSetup);
            free(fft_data.imagp);
            free(fft_data.realp);
            [freqs release];
}

Answer 1

Your problem could be that you are casting malloc to a value. As you're tagging this c, I'm assuming that you are compiling in c in which case you should see this answer to a previous question as to why casting with malloc is bad:

https://stackoverflow.com/a/1565552/1515720

you can get an unpredictable runtime error when using the cast without including stdlib.h.

So the error on your side is not the cast, but forgetting to include stdlib.h. Compilers may assume that malloc is a function returning int, therefore converting the void* pointer actually returned by malloc to int and then to your your pointer type due to the explicit cast. On some platforms, int and pointers may take up different numbers of bytes, so the type conversions may lead to data corruption.

Regardless though, as the answer says, YOU SHOULD NOT BE CASTING MALLOC RETURNS, because void*'s are safely implicitly converted to whatever you are assigning it to.

As another answerer stated:

vDSP_destroy_fftsetupD(fftSetup);

Could be also free'ing the memory you allocated on accident.

Answer 2

Any chance the destructor of DSPDoubleSplitComplex is freeing up those two allocated blocks?

It could also be that you are only allowed to call vDSP_create_fftsetupD and vDSP_destroy_fftsetupD once during your process's lifetime