What alignment does HeapAlloc use

Question

I'm developing a general purpose library which uses Win32's HeapAlloc

MSDN doesn't mention alignment guarantees for Win32's HeapAlloc, but I really need to know what alignment it uses, so I can avoid excessive padding.

On my machine (vista, x86), all allocations are aligned at 8 bytes. Is this true for other platforms as well?

Answer 1

The HeapAlloc function does not specify the alignment guarantees in the MSDN page, but I'm inclined to think that it should have the same guarantees of GlobalAlloc, which is guaranteed to return memory 8-byte aligned (although relying on undocumented features is evil); after all, it's explicitly said that Global/LocalAlloc are just wrappers around HeapAlloc (although they may discard the first n bytes to get aligned memory - but I think that it's very unlikely).

The documentation page got updated in the meantime, and it now gives a precise indication:

The alignment of memory returned by HeapAlloc is MEMORY_ALLOCATION_ALIGNMENT in WinNT.h:

#if defined(_WIN64) || defined(_M_ALPHA)
#define MEMORY_ALLOCATION_ALIGNMENT 16
#else
#define MEMORY_ALLOCATION_ALIGNMENT 8
#endif

So, it's 16 byte on 64 bit Windows, 8 on 32 bit Windows, at least on the OS versions to which the documentation refers (Windows XP onwards).

If you really want to be sure, justIn particular cases, you can also use GlobalAlloc, or even VirtualAlloc, whose granularity is the page granularity, which is usually 4 KB (IIRC), but in this case for small allocations you'll waste a lot of memory.

By the way, if you use C++ new operator, you are guaranteed to get memory aligned correctly for the type you specified: this could be the way to go. this too is not really correct; until C++17, new didn't have the necessary plumbing to deal with "over-aligned" types (i.e. types with alignment requirements greater than those for std::max_align_t, which generally is double), so in practice generally it just provided 8 or 16 byte alignment. This is fixed since C++17, where the new that is provided in the standard library should be able to deal with such types. See P0035R4, std::max_align_t, std::align_val_t for more information.

Answer 2

The alignment will be such that the returned address can be cast to a pointer of any type. Otherwise you will not be able to use the memory in your application.

Answer 3

Surprisingly, Google turns up evidence that HeapAlloc is not always SSE-compliant:

HeapAlloc() has all the objects always 8-byte aligned, no matter what their size is (but not 16-byte-aligned, for SSE).

The post is from mid 2008, suggesting that recent Windows XP suffers from this bug.

See also http://support.microsoft.com/kb/286470:

The Windows heap managers (all versions) have always guaranteed that the heap allocations have a start address that is 8-byte aligned (on 64-bit platforms the alignment is 16-bytes).

Answer 4

Amd64 heap alignment is documented here:

https://learn.microsoft.com/en-us/cpp/build/x64-calling-convention?view=msvc-160

...stack pointer and malloc or alloca memory, which are 16-byte aligned to aid performance.