How to determine if memory is aligned? ( *testing* for alignment, not aligning )

Question

Hi there,

I am new to optimizing code with SSE/SSE2 instructions and until now I have not gotten very far. To my knowledge a common SSE-optimized function would look like this:

void sse_func(const float* const ptr, int len){
    if( ptr is aligned )
    {
        for( ... ){
            // unroll loop by 4 or 2 elements
        }
        for( ....){
            // handle the rest
            // (non-optimized code)
        }
    } else {
        for( ....){
            // regular C code to handle non-aligned memory
        }
    }
}

However, how do I correctly determine if the memory ptr points to is aligned by e.g. 16 Bytes? I think I have to include the regular C code path for non-aligned memory as I cannot make sure that every memory passed to this function will be aligned. And using the intrinsics to load data from unaligned memory into the SSE registers seems to be horrible slow (Even slower than regular C code).

Thank you in advance...

Answer 1

EDIT: casting to long is a cheap way to protect oneself against the most likely possibility of int and pointers being different sizes nowadays.

As pointed out in the comments below, there are better solutions if you are willing to include a header...

A pointer p is aligned on a 16-byte boundary iff ((unsigned long)p) & 15 == 0.

Answer 2

Can you just 'and' the ptr with 0x03 (aligned on 4s), 0x07 (aligned on 8s) or 0x0f (aligned on 16s) to see if any of the lowest bits are set?

Answer 3

Try this:

if (((int)ptr & (sizeof(*ptr) - 1)) == 0) {
    // ptr is aligned
}

This assumes that sizeof(*ptr) is a power of two (2ⁿ), and checks that the lowest n bits of ptr are all zero.

Answer 4

Other answers suggest an AND operation with low bits set, and comparing to zero.

But a more straight-forward test would be to do a MOD with the desired alignment value, and compare to zero.

#define ALIGNMENT_VALUE     16u

if (((uintptr_t)ptr % ALIGNMENT_VALUE) == 0)
{
    // ptr is aligned
}

Answer 5

#define is_aligned(POINTER, BYTE_COUNT) \
    (((uintptr_t)(void *)&*(POINTER)) % (BYTE_COUNT) == 0)

The cast to void * is necessary because the standard requires only for void * to produce integer values in range of uintptr_t.

The &* is there to produce a compilation error for non-pointer arguments.

edit:

I added &* to add ameasure of type-safety to the code; problem is that it now won't work for void * arguments as these can't be dereferenced.

If you want type safety, you're probably better of with an inline function like this

static inline _Bool is_aligned(void *pointer, size_t byte_count)
{ return (uintptr_t)pointer % byte_count == 0; }

and hope for compiler optimizations if byte_count is a compile-time constant.