Improving my stack allocator

Try internally rounding the size parameter to the next multiple of 8 or whatever you choose for alignment. Also, ensure the beginning of the pool is aligned to begin with.

Should I use __alignof(type) to choose the correct alignment of each structure?

The memory allocator does not have a free function?
If the memory requested is smaller than 16 bytes, just make sure the chunk can fit within a 16 byte aligned chunk. If it is bigger than 16 bytes, make sure it is aligned on a 16 byte boundary.

If you want to check out my memory allocator that I wrote a while ago, check it out at http://nolimitsdesig...html/index.html
It can give you an idea of how to write an allocator to free memory, and make sure it is aligned to a specific byte alignment. The code is short and if you need anything explained, you can contact me. I dont currently support it, but if there are any errors in the code, I will correct them.

So if I have a struct like this:

struct Packing
{
int x; // 4-byte align
int y; // 4-byte align
short int z; // 2-byte align
char m; // 1-byte align;
char _pad[1]; // explicit padding
};

The size of this struct is 12 bytes. Since 12 is not a power of two how do I align this structure? What about a struct with size 36?
Or should I align the struct with the alignment that its members use? In the example 4-byte align?

I remember a topic we had a while ago about memory alignment. The short version is: the CPU loads chunks of memory in chunks of 16 bytes (generally). If the cpu is working on something that is overlapping the 16 byte boundary, it does more work.
Check this out http://msdn.microsoft.com/en-us/library/xh3e3fd0%28v=vs.80%29.aspx visual studio will help you with data member alignment.
Generally, you want the beginning of a structure to be aligned to a 16 byte boundary. So, in your example, the easiest way would be to add padding to make it exactly 16 bytes, and make sure the beginning is aligned to a 16 byte boundary.
Dont go overboard thought. What I mean is dont try to optimize all parts of your application to ensure everything is perfectly aligned all the time. if you are iterating over an array less than a hundred objects long and the memory is misaligned, it wont hurt performance. But, if you have a large array, then make sure it is aligned.

You don't need compiler intrinsics to align structure sizes if you're allocating one at a time. Allocate ((size + (align_bytes - 1)) - (size + (align_bytes - 1)) % align_bytes). If you allocate 16 bytes for a 12 byte structure, the last four just aren't use, and make no difference; the OS likely allocates aligned chunks of memory, anyway, so if you request an exact amount or an aligned amount, you'd likely consume just as much memory.