Memory error: free(): invalid next size (fast)

Question

I'm trying to implement a radix sort, and this code produce a memory failure:

(free(): invalid next size (fast))

The code is the following:

unsigned int * radix(unsigned int *x,int n, int g,bool verbose)
{
    int elem_size = sizeof(unsigned int)*8;
    int mask = ((1<<g)-1);    
    float num_rounds= ((float)elem_size/(float)g);
    int B = 1 << g; // 2^g BTW

    vector<unsigned int> buckets[B];

    // begin radix sort
    for( unsigned int round=0 ; round<num_rounds ; ++round)
      {

        // count
        for(int elem=0 ; elem<n ; ++elem)
        {
            // calculate the bucket number:
            unsigned int const bucket_num = ( x[elem] >> g*round) & mask;
    --->        buckets[bucket_num].push_back(x[elem]);
        }
        // more stuff
    }
    return x;
}

GDB states that the error is inside push_back, but elem is always smaller than n (where n is the size of x[]). So, I thought that it could only be on bucket_num. However, just before it crashes GDB gives me their values:

Breakpoint 1, radix (x=0x604010, n=50, g=4, verbose=true)
    at radix.mpi.seq.cpp:38
38                buckets[bucket_num].push_back(x[elem]);
2: B = 16
1: bucket_num = 2

any ideas?

Answer 1

From your comment, it's clear that: accessing unsigned int *x is the reason for the invalid write error you get when you access it in your radix function.

unsigned int *x = new unsigned int(n); allocates a single unsigned int and assigns the value n to it. You really wanted an array of unsigned ints: unsigned int *x = new unsigned int[n];

In general, running through Valgrind helps find memory leaks and where exactly the problem lies. Because, often the error message you get hardly happens at a line where it appears to happen.