Currently there’s no compile-time optimisation; the values are padded to 8 bytes on x64. You can manually arrange structs to optimally utilise space; typically by going from larger types to smaller; 8 consecutive byte fields for example, will only use 8 bytes, but a single byte would be padded to an 8 byte alignment, consider … Read more
As long as you’re ok with having to call a special function to do the freeing, your approach is okay. I would do your #ifdefs the other way around though: start with the standards-specified options and fall back to platform-specific ones. For example If __STDC_VERSION__ >= 201112L use aligned_alloc. If _POSIX_VERSION >= 200112L use posix_memalign. … Read more
OK, the situation is more confusing than one would like. So, in an effort to clarify, here are the findings on this journey : accessing unaligned memory The only portable C standard solution to access unaligned memory is the memcpy one. I was hoping to get another one through this question, but apparently it’s the … Read more
This recommendation is architecture-specific. It is true for x86 & x86_64 (in a low-level programming). You should also check that compiler don’t reorder your code. You can use “compiler memory barrier” for that. Low-level atomic read and writes for x86 is described in Intel Reference manuals “The Intel® 64 and IA-32 Architectures Software Developer’s Manual” … Read more
From “Intel®64 and IA-32 Architectures Optimization Reference Manual”, section 4.4.2: “For best performance, the Streaming SIMD Extensions and Streaming SIMD Extensions 2 require their memory operands to be aligned to 16-byte boundaries. Unaligned data can cause significant performance penalties compared to aligned data.” From Appendix D: “It is important to ensure that the stack frame … Read more
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. This is due … Read more
I’ve been using Howard Hinnant’s stack allocator and it works like a charm, but some details of the implementation are a little unclear to me. Glad it’s been working for you. 1. Why are global operators new and delete used? The allocate() and deallocate() member functions use ::operator new and ::operator delete respectively. Similarly, the … Read more
You can try with something like: bool is_aligned(const volatile void *p, std::size_t n) { return reinterpret_cast<std::uintptr_t>(p) % n == 0; } assert(is_aligned(array, 16)); The above assumes a flat address space and that arithmetic on uintptr_t is equivalent to arithmetic on char *. While these conditions prevail for the majority of modern platforms, neither of which … Read more
Why is the compiler forbidden (by the standard) from reordering the struct? The basic reason is: for compatibility with C. Remember that C is, originally, a high-level assembly language. It is quite common in C to view memory (network packets, …) by reinterpreting the bytes as a specific struct. This has led to multiple features … Read more
x86 does not require alignment for a lock cmpxchg instruction to be atomic. However, alignment is necessary for good performance. This should be no surprise, backward compatibility means that software written with a manual from 14 years ago will still run on today’s processors. Modern CPUs even have a performance counter specifically for split-lock detection … Read more