Deleting a pointer a different places results in different behaviors (crash or not)

Question

This question is a refinement of this one, which went in a different direction than expected.

In my multithreaded application, the main thread creates parameters and stores them :

typedef struct {
    int parameter1;
    double parameter2;
    float* parameter3;
} jobParams;

typedef struct {
    int ID;
    void* params;
} jobData;

std::vector<jobData> jobs;

// main thread
for (int i = 0; i < nbJobs; ++i) {
    jobParams* p = new jobParams;
    // fill and store params

    jobData data;
    data.ID = i;
    data.params = p;

    jobs.push_back(data);
}

// start threads and wait for their execution

// delete parameters
for (int i = 0; i < jobs.size(); ++i) {
    delete jobs[i].params;
}

Then, each thread gets a pointer to a set of parameters, and calls a job function with it :

// thread (generic for any job function and any type of params)
jobData* job = main->getNextParams();
jobFunction(job->ID, job->params);

The whole thing takes void* as argument to be able to use any structure for the parameters, but then the job function casts it back to the right struct :

void* jobFunction(void* param) {
    jobParams* params = (jobParams*) param;
    // do stuff
    return 0;
}

My problem is the following : if I delete params at the end of jobFunction(), it works perfectly. However, I'd prefer to have the deletion taken care of by the threads or the main thread, such that I don't have to remember to delete the params for each jobFunction() that I write.

If I try to delete params just after calling jobFunction() in the treads, or even in the main thread after being sure that all threads are done (and thus the params are not needed anymore), I get a heap corruption error :

HEAP[prog]: Invalid Address specified to RtlFreeHeap( 02E90000, 03C2EE38 )

I'm using Visual Studio 2008 Pro, and I thus can't use valgrind or other *nix tools for debugging. All access to the main thread from the "child threads" are synchronized using a mutex, so the problem is not that I delete the same parameters twice.

In fact, by using VS memory viewer, I know that the memory pointed by the jobParams pointer does not change between the end of jobFunction() and the point where I try do delete it (either in the main thread or in the "child threads").

EDIT: I added the definition of both structures, as well as the way I'd like to delete the params.

Answer 1

That sort of bug generally means you have a data race somewhere. Does main->getNextParams() do the right thing even if it's called by several threads at once? If it gives the same params to both, you could have a double-free in your hands.

Also, instead of

jobFunction(jobData->ID, jobData->params);

You probably meant

jobFunction(job->ID, job->params);

Answer 2

To debug it you could add a deleted member to the jobParams class and set that to true instead of actually deleting the object. Then see check the deleted flag in every method of jobParams and throw an exception if it's true. Then see where the exception gets thrown.

Answer 3

Just as a thought .. can you try

for (int i = 0; i < jobs.size(); ++i) {
    delete (jobParams*)jobs[i].params;
}

newing a type jobParams and then deleteing a void* might be the cause of your problems.

Is there any reason you store params as a void* in jobData? I'd argue if you wish to have different types of jobParams then you should be using an inheritance hierarchy and not blindly casting to a void*.