Question

Per-frame I need to allocate some data that needs to stick around until the end of the frame.

Currently, I’m allocating the data off a different memory pool that allows me to mark it with the frame count. At the end of the frame, I walk the memory pool and delete the memory that was allocated in a particular frame.

The problem I’m running into is that in order to keep a hold on the data, I have to place it in a structure thusly:

struct FrameMemory
{
    uint32 frameIndex;
    bool allocatedType; //0 = new(), 1 = new[]
    void* pMemPtr;
}

So later, when i get around to freeing the memory, it looks something like this:

{
for(all blocks)
 if(block[i].frameIndex == targetIndex)
     if(block[i].allocatedType == 0)
          delete block[i].pMemPtr;
     else if (block[i].allocatedType ==1)
          delete[] block[i].pMemPtr;
}

The issue is that, because I have to overload the pointer to the memory as a void*, the DELETE operator doesn’t properly DELETE the memory as its’ native base type. IE the destructor NEVER gets called for the object.

I’ve attempted to find ways to use smart-pointer templated objects for the solution, but in order to do that, I have to overload the templated class to a non-templated base-type, which makes deletion even more difficult.

Does anyone have a solution to a problem like this?

Answer 1

If you don’t want to force all the objects to inherit from Destructible, you can store a pointer to a deleter function (or functor) along with the pointer to the data itself. The client code is responsible for providing a function that knows how to delete the data correctly, typically something like:

void xxx_deleter(void *data) { 
    xxx *ptr = static_cast<xxx *>(data);
    delete ptr;
}

Though the deleter will usually be a lot like the above, this also gives the client the option of storing complex data structures and still getting them deleted correctly.