It used to be that ARM processors were unable to properly handle unaligned memory access (ARMv5 and below). Something like u32 var32 = *(u32*)ptr;
would just fail (raise exception) if ptr
was not properly aligned on 4-bytes.
Writing such a statement would work fine for x86/x64 though, since these CPU have always handled such situation very efficiently. But according to C standard, this is not a "proper" way to write it. u32
is apparently equivalent to a structure of 4 bytes which must be aligned on 4 bytes.
A proper way to achieve the same result while keeping the orthodoxy correctness and ensuring full compatibility with any cpu is :
u32 read32(const void* ptr) { u32 result; memcpy(&result, ptr, 4); return result; }
This one is correct, will generate proper code for any cpu able or not to read at unaligned positions. Even better, on x86/x64, it's properly optimized to a single read operation, hence has the same performance as the first statement. It's portable, safe, and fast. Who can ask more ?
Well, problem is, on ARM, we are not so lucky.
Writing the memcpy
version is indeed safe, but seems to result in systematic cautious operations, which are very slow for ARMv6 and ARMv7 (basically, any smartphone).
In a performance oriented application which heavily relies on read operations, the difference between the 1st and 2nd version could be measured : it stands at > 5x at gcc -O2
settings. This is way too much to be ignored.
Trying to find a way to use ARMv6/v7 capabilities, I've looked for guidance on a few example codes around. Unfortunatley, they seem to select the first statement (direct u32
access), which is not supposed to be correct.
That's not all : new GCC versions are now trying to implement auto-vectorization. On x64, that means SSE/AVX, on ARMv7 that means NEON. ARMv7 also supports some new "Load Multiple" (LDM) and "Store Multiple" (STM) opcodes, which require pointer to be aligned.
What does that mean ? Well, the compiler is free to use these advanced instructions, even if they were not specifically called from the C code (no intrinsic). To take such decision, it uses the fact the an u32* pointer
is supposed to be aligned on 4 bytes. If it's not, then all bets are off : undefined behavior, crashes.
What that means is that even on CPU which support unaligned memory access, it's now dangerous to use direct u32
access, as it can lead to buggy code generation at high optimization settings (-O3
).
So now, this is a dilemna : how to access the native performance of ARMv6/v7 on unaligned memory access without writing the incorrect version u32
access ?
PS : I've also tried __packed()
instructions, and from a performance perspective, they seem to work exactly the same as the memcpy
method.
[Edit] : Thanks for the excellent elements received so far.
Looking at the generated assembly, I could confirm @Notlikethat finding that memcpy
version does indeed generate proper ldr
opcode (unaligned load). However, I also found that the generated assembly uselessly invokes str
(command). So the complete operation is now an unaligned load, an aligned store, and then a final aligned load. That's a lot more work than necessary.
Answering @haneefmubarak, yes the code is properly inlined. And no, memcpy
is very far from providing the best possible speed, since forcing the code to accept direct u32
access translates into huge performance gains. So some better possibility must exist.
A big thank to @artless_noise. The link to godbolt service is unvaluable. I've never been able to see so clearly the equivalence between a C source code and its assembly representation. This is highly inspiring.
I completed one of @artless examples, and it gives the following :
#include <stdlib.h> #include <memory.h> typedef unsigned int u32; u32 reada32(const void* ptr) { return *(const u32*) ptr; } u32 readu32(const void* ptr) { u32 result; memcpy(&result, ptr, 4); return result; }
once compiled using ARM GCC 4.8.2 at -O3 or -O2 :
reada32(void const*): ldr r0, [r0] bx lr readu32(void const*): ldr r0, [r0] @ unaligned sub sp, sp, #8 str r0, [sp, #4] @ unaligned ldr r0, [sp, #4] add sp, sp, #8 bx lr
Quite telling ....
ARM processors do not provide support for unaligned doubleword accesses, for example unaligned accesses to long long integers. Doubleword accesses must be either eight-byte or four-byte aligned. The compiler does not provide support for modulo eight-byte alignment checking.
Unaligned memory accesses occur when you try to read N bytes of data starting from an address that is not evenly divisible by N (i.e. addr % N != 0). For example, reading 4 bytes of data from address 0x10000004 is fine, but reading 4 bytes of data from address 0x10000005 would be an unaligned memory access.
Alignment helps the CPU fetch data from memory in an efficient manner: less cache miss/flush, less bus transactions etc. Some memory types (e.g. RDRAM, DRAM etc.) need to be accessed in a structured manner (aligned "words" and in "burst transactions" i.e. many words at one time) in order to yield efficient results.
OK, the situation is more confusing than one would like. So, in an effort to clarify, here are the findings on this journey :
memcpy
one. I was hoping to get another one through this question, but apparently it's the only one found so far.Example code :
u32 read32(const void* ptr) { u32 value; memcpy(&value, ptr, sizeof(value)); return value; }
This solution is safe in all circumstances. It also compiles into a trivial load register
operation on x86 target using GCC.
However, on ARM target using GCC, it translates into a way too large and useless assembly sequence, which bogs down performance.
Using Clang on ARM target, memcpy
works fine (see @notlikethat comment below). It would be easy to blame GCC at large, but it's not that simple : the memcpy
solution works fine on GCC with x86/x64, PPC and ARM64 targets. Lastly, trying another compiler, icc13, the memcpy version is surprisingly heavier on x86/x64 (4 instructions, while one should be enough). And that's just the combinations I could test so far.
I have to thank godbolt's project to make such statements easy to observe.
__packed
structures. This solution is not C standard, and entirely depends on compiler's extension. As a consequence, the way to write it depends on the compiler, and sometimes on its version. This is a mess for maintenance of portable code.That being said, in most circumstances, it leads to better code generation than memcpy
. In most circumstances only ...
For example, regarding the above cases where memcpy
solution does not work, here are the findings :
__packed
solution works__packed
solution workson ARMv6 with GCC : does not work. Assembly looks even uglier than memcpy
.
u32
access to unaligned memory positions. This solution used to work for decades on x86 cpus, but is not recommended, as it violates some C standard principles : compiler is authorized to consider this statement as a guarantee that data is properly aligned, leading to buggy code generation.Unfortunately, in at least one case, it is the only solution able to extract performance from target. Namely for GCC on ARMv6.
Do not use this solution for ARMv7 though : GCC can generate instructions which are reserved for aligned memory accesses, namely LDM
(Load Multiple), leading to crash.
Even on x86/x64, it becomes dangerous to write your code this way nowadays, as the new generation compilers may try to auto-vectorize some compatible loops, generating SSE/AVX code based on the assumption that these memory positions are properly aligned, crashing the program.
As a recap, here are the results summarized as a table, using the convention : memcpy > packed > direct.
| compiler | x86/x64 | ARMv7 | ARMv6 | ARM64 | PPC | |-----------|---------|--------|--------|--------|--------| | GCC 4.8 | memcpy | packed | direct | memcpy | memcpy | | clang 3.6 | memcpy | memcpy | memcpy | memcpy | ? | | icc 13 | packed | N/A | N/A | N/A | N/A |
Part of the issue is likely that you are not allowing for easy inlinability and further optimization. Having a specialized function for the load means that a function call may be emitted upon each call, which could reduce the performance.
One thing you might do is use static inline
, which will allow the compiler to inline the function load32()
, thus increasing performance. However, at higher levels of optimization, the compiler should already be inlining this for you.
If the compiler inlines a 4 byte memcpy, it will likely transform it into the most efficient series of loads or stores that will still work on unaligned boundaries. Therefore, if you are still seeing low performance even with compiler optimizations enabled, it may be so that that is the maximum performance for unaligned reads and writes on the processors you are using. Since you said "__packed
instructions" are yielding identical performance to memcpy()
, this would seem to be the case.
At this point, there is very little that you can do except to align your data. However, if you are dealing with a contiguous array of unaligned u32
's, there is one thing you could do:
#include <stdint.h> #include <stdlib.h> // get array of aligned u32 uint32_t *align32 (const void *p, size_t n) { uint32_t *r = malloc (n * sizeof (uint32_t)); if (r) memcpy (r, p, n); return r; }
This just uses allocates a new array using malloc()
, because malloc()
and friends allocate memory with correct alignment for everything:
The malloc() and calloc() functions return a pointer to the allocated memory that is suitably aligned for any kind of variable.
-
malloc(3)
, Linux Programmer's Manual
This should be relatively fast, as you should only have to do this once per set of data. Also, while copying it, memcpy()
will be able to adjust only for the initial lack of alignment and then use the fastest aligned load and store instructions available, after which you will be able to deal with your data using the normal aligned reads and writes at full performance.
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With