How to determine if memory is aligned?

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

The cast to void * (or, equivalenty, char *) is necessary because the standard only guarantees an invertible conversion to uintptr_t for void *.

If you want type safety, consider using an inline function:

static inline _Bool is_aligned(const void *restrict 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.

Why do we need to convert to void * ?

The C language allows different representations for different pointer types, eg you could have a 64-bit void * type (the whole address space) and a 32-bit foo * type (a segment).

The conversion foo * -> void * might involve an actual computation, eg adding an offset. The standard also leaves it up to the implementation what happens when converting (arbitrary) pointers to integers, but I suspect that it is often implemented as a noop.

For such an implementation, foo * -> uintptr_t -> foo * would work, but foo * -> uintptr_t -> void * and void * -> uintptr_t -> foo * wouldn’t. The alignment computation would also not work reliably because you only check alignment relative to the segment offset, which might or might not be what you want.

In conclusion: Always use void * to get implementation-independant behaviour.

More Related Contents:

  1. Fastest Implementation of the Natural Exponential Function Using SSE
  2. print a __m128i variable
  3. What’s missing/sub-optimal in this memcpy implementation?
  4. Efficient 4×4 matrix vector multiplication with SSE: horizontal add and dot product – what’s the point?
  5. What’s the difference between logical SSE intrinsics?
  6. Fast counting the number of set bits in __m128i register
  7. Do I get a performance penalty when mixing SSE integer/float SIMD instructions
  8. C++ error: ‘_mm_sin_ps’ was not declared in this scope
  9. Count each bit-position separately over many 64-bit bitmasks, with AVX but not AVX2
  10. Getting started with Intel x86 SSE SIMD instructions
  11. Compare 16 byte strings with SSE
  12. Efficient 4×4 matrix multiplication (C vs assembly)
  13. inlining failed in call to always_inline ‘_mm_mullo_epi32’: target specific option mismatch
  14. Intel SSE: Why does `_mm_extract_ps` return `int` instead of `float`?
  15. Why does mulss take only 3 cycles on Haswell, different from Agner’s instruction tables? (Unrolling FP loops with multiple accumulators)
  16. AVX2 what is the most efficient way to pack left based on a mask?
  17. Why does the order of the loops affect performance when iterating over a 2D array?
  18. Where in memory are my variables stored in C?
  19. Order of local variable allocation on the stack
  20. How much memory would be freed if pointer is changed in C?
  21. Reducing memory usage of .NET applications?
  22. Segmentation Fault when writing to a string [duplicate]
  23. Loading 8 chars from memory into an __m256 variable as packed single precision floats
  24. faster equivalent of gettimeofday
  25. Getting max value in a __m128i vector with SSE?
  26. Micro Optimization of a 4-bucket histogram of a large array or list
  27. Very fast memcpy for image processing?
  28. What’s the proper implementation for hardware emulation?
  29. Produce loops without cmp instruction in GCC
  30. Bit popcount for large buffer, with Core 2 CPU (SSSE3)

Leave a Comment