It means that the address being pointed at is evenly divisible by some factor. Sometimes the term “natural alignment” is used, which generally means that objects having natural alignment need to be placed at addresses that are evenly divisble by the object’s size. Alignment is somestimes very important, since many hardware-related things place restrictions on … Read more
Here are three excerpts from P1413R3: Background aligned_* are harmful to codebases and should not be used. At a high level: Using aligned_* invokes undefined behavior (The types cannot provide storage.) The guarantees are incorrect (The standard only requires that the type be at least as large as requested but does not put an upper … Read more
At least on most machines, a type is only ever aligned to a boundary as large as the type itself [Edit: you can’t really demand any “more” alignment than that, because you have to be able to create arrays, and you can’t insert padding into an array]. On your implementation, short is apparently 2 bytes, … Read more
C++ standard requires allocation functions (malloc() and operator new()) to allocate memory suitably aligned for any standard type. As these functions don’t receive the alignment requirement as an argument, in practice it means that the alignment for all allocations is the same, and is that of a standard type with the largest alignment requirement, which … Read more
Edit: I removed the inheritance of std::allocator as suggested by GManNickG and made the alignment parameter a compile time thing. I recently wrote this piece of code. It’s not tested as much as I would like it so go on and report errors. 🙂 enum class Alignment : size_t { Normal = sizeof(void*), SSE = … Read more
(Don’t apply these rules without thinking. See ESR’s point about cache locality for members you use together. And in multi-threaded programs, beware false sharing of members written by different threads. Generally you don’t want per-thread data in a single struct at all for this reason, unless you’re doing it to control the separation with a … Read more
Alignment requirements are recursive: The alignment of any struct is simply the largest alignment of any of its members, and this is understood recursively. For example, and assuming that each fundamental type’s alignment equals its size (this is not always true in general), the struct X { int; char; double; } has the alignment of … Read more
Assume the stack looks like this on entry to _main (the address of the stack pointer is just an example): | existing | | stack content | +—————–+ <— 0xbfff1230 Push %ebp, and subtract 8 from %esp to reserve some space for local variables: | existing | | stack content | +—————–+ <— 0xbfff1230 | … Read more
I am using Linux and 8-core x86 platform. First how do I find the cache line size. $ getconf LEVEL1_DCACHE_LINESIZE 64 Pass the value as a macro definition to the compiler. $ gcc -DLEVEL1_DCACHE_LINESIZE=`getconf LEVEL1_DCACHE_LINESIZE` … At run-time sysconf(_SC_LEVEL1_DCACHE_LINESIZE) can be used to get L1 cache size.
Unfortunately the best I have found is allocating extra space and then using the “aligned” part. So the RingBuffer new can request an extra 64 bytes and then return the first 64 byte aligned part of that. It wastes space but will give the alignment you need. You will likely need to set the memory … Read more