Why does Malloc() care about boundary alignments?

Question

I've heard that malloc() aligns memory based on the type that is being allocated. For example, from the book Understanding and Using C Pointers :

The memory allocated will be aligned according to the pointer's data type. Fore example, a four-byte integer would be allocated on an address boundary evenly divisible by four.

If I follow, this means that int *integer=malloc(sizeof(int)); will be allocated on an address boundary evenly divisible by four. Even without casting (int *) on malloc.

I was working on a chat server; I read of a similar effect with struct s.

And I have to ask: logically, why does it matter what the address boundary itself is divisible on? What's wrong with allocating a group of memory to the tune of n*sizeof(int) using an integer on address 129 ?

I know how pointer arithmetic works *(integer+1) , but I can't work out the importance of boundaries...

Answer 1

The memory allocated will be aligned according to the pointer's data type.

If you are talking about malloc , this is false. malloc doesn't care what you do with the data and will allocate memory aligned to fit the most stringent native type of the implementation.

From the standard:

The pointer returned if the allocation succeeds is suitably aligned so that it may be assigned to a pointer to any type of object with a fundamental alignment requirement and then used to access such an object or an array of such objects in the space allocated (until the space is explicitly deallocated)

And:

Logically, why does it matter what the address boundary itself is divisible on

Due to the workings of the underlying machine, accessing unaligned data might be more expensive (eg x86) or illegal (eg arm). This lets the hardware take shortcuts that improve performance / simplify implementation.

Answer 2

In many processors, data that isn't aligned will cause a "trap" or "exception" (this is a different form of exception than those understood by the C++ compiler. Even on processors that don't trap when data isn't aligned, it is typically slower (twice as slow, for example) when the data is not correctly aligned. So it's in the compiler's/runtime library's best interest to ensure that things are nicely aligned.

And by the way, malloc (typically) doesn't know what you are allocating. Insteat, malloc will align ALL data, no matter what size it is, to some suitable boundary that is "good enough" for general data-access - typically 8 or 16 bytes in modern OS/processor combinations, 4 bytes in older systems.

This is because malloc won't know if you do char* p = malloc(1000); or double* p = malloc(1000); , so it has to assume you are storing double or whatever is the item with the largest alignment requirement.

Answer 3

The importance of alignment is not a language issue but a hardware issue. Some machines are incapable of reading a data value that is not properly aligned. Others can do it but do so less efficiently, eg, requiring two reads to read one misaligned value.

Answer 4

The book quote is wrong; the memory returned by malloc is guaranteed to be aligned correctly for any type. Even if you write char *ch = malloc(37); , it is still aligned for int or any other type.

You seem to be asking "What is alignment?" If so, there are several questions on SO about this already, eg here , or a good explanation from IBM here .

Answer 5

It depends on the hardware. Even assuming int is 32 bits, malloc(sizeof(int)) could return an address divisible by 1, 2, or 4. Different processors handle unaligned access differently.

Processors don't read directly from RAM any more, that's too slow (it takes hundreds of cycles). So when they do grab RAM, they grab it in big chunks, like 64 bytes at a time. If your address isn't aligned, the 4-byte integer might straddle two 64-byte cache lines, so your processor has to do two loads and fix up the result. Or maybe the engineers decided that building the hardware to fix up unaligned loads isn't necessary, so the processor signals an exception: either your program crashes, or the operating system catches the exception and fixes up the operation (hundreds of wasted cycles).

Aligning addresses means your program plays nicely with hardware.

Answer 6

Because it's more fast; Most processor likes data which is aligned. Even, Some processor CANNOT access data which is not aligned! (If you try to access this data, processor may occur fault)