Do memory deallocation routines touch the block being freed?

Question

Windows HeapFree, msvcrt free: do they cause the memory being freed to be paged-in? I am trying to estimate if not freeing memory at exit would speed up application shutdown significantly.

NOTE: This is a very specific technical question. It's not about whether applications should or should not call free at exit.

Answer 1

I'm almost certain the answer to the speed improvement question would be "yes". Freeing a block may or may not touch the actual block in question, but it will certainly have to update other bookkeeping information in any case. If you have zillions of small objects allocated (it happens), then the effort required to free them all could have a significant impact.

If you can arrange it, you might try setting up your application such that if it knows it's going to quit, save any pending work (configuration, documents, whatever) and exit ungracefully.

Answer 2

If you don't cleanly deallocate all your resources at application shutdown it will make it nigh on impossible to detect if you have any really serious problems - like memory leaks - which would be more of a problem than a slow shut down. If the UI disappears quickly, then the user will think the it has shut down quickly even if it has a lot of work still to do. With UI, perception of speed is more important than actual speed. When the user selects the 'Exit Application' option, the main application window should immediately disappear. It doesn't matter if the application takes a few seconds after that to free up everything an exit gracefully, the user won't notice.

Skizz

Answer 3

I ran a test for HeapFree. The following program has access violation inside HeapFree at i = 31999:

#include <windows.h>

int main() {

    HANDLE heap = GetProcessHeap();
    void * bufs[64000];

    // populate heap
    for (unsigned i = 0; i < _countof(bufs); ++i) {
        bufs[i] = HeapAlloc(heap, 0, 4000);
    }

    // protect a block in the "middle"
    DWORD dwOldProtect;
    VirtualProtect(
        bufs[_countof(bufs) / 2], 4000, PAGE_NOACCESS,
        &dwOldProtect);

    // free blocks
    for (unsigned i = 0; i < _countof(bufs); ++i) {
        HeapFree(heap, 0, bufs[i]);
    }
}

The stack is

ntdll.dll!_RtlpCoalesceFreeBlocks@16()  + 0x12b9 bytes  
ntdll.dll!_RtlFreeHeap@12()  + 0x91f bytes  
shutfree.exe!main()  Line 19    C++

So it looks like the answer is "Yes" (this applies to free as well, since it uses HeapFree internally)