What useful things can I do with Visual C++ Debug CRT allocation hooks except finding reproduceable memory leaks?

Question

Visual C++ debug runtime library features so-called allocation hooks. Works this way: you define a callback and call _CrtSetAllocHook() to set that callback. No

Answer 1

The value "requestNumber" is not passed on to the function when deallocating (MS VS 2008). Without this number you cannot keep track of your allocation. However, you can peek into the heap header and extract that value from there:

Note: This is compiler dependent and may change without notice/ warning by the compiler.

// This struct is a copy of the heap header used by MS VS 2008.
// This information is prepending each allocated memory object in debug mode.
struct MsVS_CrtMemBlockHeader {
    MsVS_CrtMemBlockHeader * _next;
    MsVS_CrtMemBlockHeader * _prev;
    char * _szFilename;
    int _nLine;
    int _nDataSize;
    int _nBlockUse;
    long _lRequest;
    char _gap[4];
};


int MyAllocHook(..) { // same as in question
    if(nAllocType == _HOOK_FREE) {
        // requestNumber isn't passed on to the Hook on free. 
        // However in the heap header this value is stored.
        size_t headerSize = sizeof(MsVS_CrtMemBlockHeader);
        MsVS_CrtMemBlockHeader* pHead;
        size_t ptr = (size_t) pvData - headerSize;
        pHead = (MsVS_CrtMemBlockHeader*) (ptr);
        long requestNumber = pHead->_lRequest;
        // Do what you like to keep track of this allocation.
    }
}

Answer 2

You could keep record of every allocation request then remove it once the deallocation is invoked, for instance: This could help you tracking memory leak problems that are way much worse than this to track down.

Just the first idea that comes to my mind...

Answer 3

You could also use it to find unreproducible memory leaks:

• Make a data structure where you map the allocated pointer to additional information
• In the allocation hook you could query the current call stack (StackWalk function) and store the call stack in the data structure
• In the de-allocation hook, remove the call stack information for that allocation
• At the end of your application, loop over the data structure and report all call stacks. These are the places where memory was allocated but not freed.