Allocating memory aligned on a given boundary

[K. Jennings]

I would like to get the result of malloc() such that it is
aligned on a given boundary - 8, in this case. Assuming that sizeof(u64)
is 8, will

u64 *p = malloc(N) ;

do the trick in general?

Here N is a positive integer, and I am assuming that malloc()
succeeds in allocating the chunk of memory specified.

This seems to work, but I do not know whether it is just my
compiler, or a general rule in C.

[Richard Heathfield]

K. Jennings said:

I would like to get the result of malloc() such that it is
aligned on a given boundary - 8, in this case. Assuming that
sizeof(u64) is 8, will

u64 *p = malloc(N) ;

do the trick in general?

The C Standard guarantees that malloc's result (if not NULL) is always
correctly aligned for any object type.

--
Richard Heathfield
"Usenet is a strange place" - dmr 29/7/1999
http://www.cpax.org.uk
email: rjh at the above domain, - www.

[Walter Roberson]

In article <7K************ *************** ***@bt.com>,
Richard Heathfield <rj*@see.sig.in validwrote:

>K. Jennings said:

>I would like to get the result of malloc() such that it is
aligned on a given boundary - 8, in this case. Assuming that
sizeof(u64) is 8, will

>u64 *p = malloc(N) ;

>do the trick in general?

>The C Standard guarantees that malloc's result (if not NULL) is always
correctly aligned for any object type.

Expanding slightly:

This means that if the particular implementation is able and
willing to handle u64's (and everything else) on (say) 4 byte boundaries,
then malloc(sizeof u64) is not guaranteed to be aligned on a multiple
of sizeof u64. The guarantee is only that it will be allocated on
an accessible boundary. The difference between accessible boundaries
and specific alignment boundaries (e.g., 8) can sometimes be of
concern, such as if you are trying to take into account cache effects.
--
Is there any thing whereof it may be said, See, this is new? It hath
been already of old time, which was before us. -- Ecclesiastes

[Flash Gordon]

Richard Heathfield wrote, On 24/04/07 17:41:

K. Jennings said:

>I would like to get the result of malloc() such that it is
aligned on a given boundary - 8, in this case. Assuming that
sizeof(u64) is 8, will

u64 *p = malloc(N) ;

do the trick in general?

The C Standard guarantees that malloc's result (if not NULL) is always
correctly aligned for any object type.

However it makes no guarantees about what the alignment might be nor any
way to find out. So if you really want a specific alignment, for example
so that you can use some highly system specific tricks, you will need to
use some highly system specific method. Any such methods and tricks
would be off topic here so you would have to ask in a group dealing with
the specific platform(s) of interest.
--
Flash Gordon

[Army1987]

"K. Jennings" <kj*******@resu rgence.netha scritto nel messaggio
news:pa******** *************@r esurgence.net.. .

I would like to get the result of malloc() such that it is
aligned on a given boundary - 8, in this case. Assuming that sizeof(u64)
is 8, will

u64 *p = malloc(N) ;

do the trick in general?

Here N is a positive integer, and I am assuming that malloc()
succeeds in allocating the chunk of memory specified.

Is the real question "What happens if N isn't a multiple of 8?"?

[K. Jennings]

On Tue, 24 Apr 2007 21:26:05 +0200, Army1987 wrote:

"K. Jennings" <kj*******@resu rgence.netha scritto nel messaggio
news:pa******** *************@r esurgence.net.. .

>I would like to get the result of malloc() such that it is aligned on a
given boundary - 8, in this case. Assuming that sizeof(u64) is 8, will

u64 *p = malloc(N) ;

do the trick in general?

Here N is a positive integer, and I am assuming that malloc() succeeds
in allocating the chunk of memory specified.

Is the real question "What happens if N isn't a multiple of 8?"?

No. The actual value of N is irrelevant, as far as that is
concerned.

[Eric Sosman]

K. Jennings wrote On 04/24/07 15:43,:

On Tue, 24 Apr 2007 21:26:05 +0200, Army1987 wrote:

>>"K. Jennings" <kj*******@resu rgence.netha scritto nel messaggio
news:pa****** *************** @resurgence.net ...

>>>I would like to get the result of malloc() such that it is aligned on a
given boundary - 8, in this case. Assuming that sizeof(u64) is 8, will

u64 *p = malloc(N) ;

do the trick in general?

Here N is a positive integer, and I am assuming that malloc() succeeds
in allocating the chunk of memory specified.

Is the real question "What happens if N isn't a multiple of 8?"?

No. The actual value of N is irrelevant, as far as that is
concerned.

Are you still seeking answers, and if so, to what?
To summarize what's appeared thus far: A successful malloc()
allocates memory that is suitably aligned for all C data
types (but not necessarily for non-C "types" like "pages"),
and there is no portable way to discover what the "suitable
for all types" alignment requirement is, nor even to discover
the alignment of any particular allocation. Does this answer
your question, or is there something else you hope to learn?

--
Er*********@sun .com

[K. Jennings]

On Tue, 24 Apr 2007 16:49:14 -0400, Eric Sosman wrote:

K. Jennings wrote On 04/24/07 15:43,:

>On Tue, 24 Apr 2007 21:26:05 +0200, Army1987 wrote:

>>>"K. Jennings" <kj*******@resu rgence.netha scritto nel messaggio
news:pa***** *************** *@resurgence.ne t...

I would like to get the result of malloc() such that it is aligned on
a given boundary - 8, in this case. Assuming that sizeof(u64) is 8,
will

u64 *p = malloc(N) ;

do the trick in general?

Here N is a positive integer, and I am assuming that malloc() succeeds
in allocating the chunk of memory specified.

Is the real question "What happens if N isn't a multiple of 8?"?

No. The actual value of N is irrelevant, as far as that is
concerned.

Are you still seeking answers, and if so, to what?
To summarize what's appeared thus far: A successful malloc() allocates
memory that is suitably aligned for all C data types (but not
necessarily for non-C "types" like "pages"), and there is no portable
way to discover what the "suitable for all types" alignment requirement
is, nor even to discover the alignment of any particular allocation.
Does this answer your question, or is there something else you hope to
learn?

I think I have the info that I wanted. If I understand it
correctly, it makes no difference whether you do

u64 *p = malloc(N) ;

or

char *p = malloc(N) ;

the address returned, when non-NULL, will be aligned on a boundary equal
to the largest basic data size supported. Thus, for 32-bit architectures
it might be either 4 or 8 bytes, whereas for 64-bit ones it would be 8.
Or am I missing something?

[Ian Collins]

K. Jennings wrote:

On Tue, 24 Apr 2007 16:49:14 -0400, Eric Sosman wrote:

>>K. Jennings wrote On 04/24/07 15:43,:

>>>On Tue, 24 Apr 2007 21:26:05 +0200, Army1987 wrote:

"K. Jennings" <kj*******@resu rgence.netha scritto nel messaggio
news:pa**** *************** **@resurgence.n et...
>I would like to get the result of malloc() such that it is aligned on
>a given boundary - 8, in this case. Assuming that sizeof(u64) is 8,
>will
>
>u64 *p = malloc(N) ;
>
>do the trick in general?
>
>Here N is a positive integer, and I am assuming that malloc() succeeds
>in allocating the chunk of memory specified.

Is the real question "What happens if N isn't a multiple of 8?"?
No. The actual value of N is irrelevant, as far as that is
concerned.

Are you still seeking answers, and if so, to what?
To summarize what's appeared thus far: A successful malloc() allocates
memory that is suitably aligned for all C data types (but not
necessarily for non-C "types" like "pages"), and there is no portable
way to discover what the "suitable for all types" alignment requirement
is, nor even to discover the alignment of any particular allocation.
Does this answer your question, or is there something else you hope to
learn?

I think I have the info that I wanted. If I understand it
correctly, it makes no difference whether you do

u64 *p = malloc(N) ;

or

char *p = malloc(N) ;

the address returned, when non-NULL, will be aligned on a boundary equal
to the largest basic data size supported. Thus, for 32-bit architectures
it might be either 4 or 8 bytes, whereas for 64-bit ones it would be 8.
Or am I missing something?

Or it might be something else if there is a bigger type (long double for
example). On my boxes, the alignment is 16 on 32 and 64 bit
(sizeof(long double) == 12 ).

--
Ian Collins.

[Richard Bos]

"K. Jennings" <kj*******@resu rgence.netwrote :

I think I have the info that I wanted. If I understand it
correctly, it makes no difference whether you do

u64 *p = malloc(N) ;

or

char *p = malloc(N) ;

the address returned, when non-NULL, will be aligned on a boundary equal
to the largest basic data size supported.

No, it will be aligned at least on the strictest required alignment
boundary. Often, that will be the same as the largest basic type size,
but that's not necessarily true. For example...

Thus, for 32-bit architectures it might be either 4 or 8 bytes, whereas
for 64-bit ones it would be 8.

....that 8-byte type might only need an alignment of 4 bytes, i.e., it
could be legally aligned on boundaries that are only half its own size
apart.
On some systems, there might not be any alignment requirements at all.
All objects, regardless of size, could be located anywhere in memory. On
that system, malloc() could return pointers at any position.
OTOH, on some systems, malloc() could return pointers that are more
widely aligned than the most restrictive basic type needs. Apart from a
requirement of the underlying hardware, I cannot think of any good
reason why it should, but you can't assume that it doesn't.

And then there are the _really_ wild systems, where long ints are 4
bytes but doubles are 5 bytes, and void *s 7... in which case, malloc()
would need to return pointers aligned to 4*5*7==140 byte boundaries. I
don't know of any example of this in practice, but it could exist, there
might be good reasons for it to exist, and the Standard doesn't forbid
it. So really, my first sentence in this post should be "No, it will be
aligned to the least common multiple of all basic object type sizes".

Richard