memory-alignment

I read somewhere that before performing unaligned load or store next to page boundary (e.g. using _mm_loadu_si128 / _mm_storeu_si128 intrinsics), code should first check if whole vector (in this case 16 bytes) belongs to the same page, and switch to non-vector instructions if not. I understand that this is needed to prevent coredump if next page does not belong to process. But what if both pages belongs to process (e.g. they are part of one buffer, and I know size of that buffer)? I wrote small test program which performed unaligned load and store that crossed page boundary, and it did not

This question already has answers here : Purpose of memory alignment (8 answers) Possible Duplicate: Purpose of memory alignment I read some articles on net about memory alignment and could understand that from properly aligned memory (take 2-byte alignment) we can fetch data fastly in one go. But if we have memory like a single hardware piece, then given an address, why cannot we read 2-byte directly from that position. like: I thought over it. I think that if the memory is in odd-even banks kind of then the theory would apply. What am i missing ? Your pictures describe how we (humans)

Consider the following struct that contains some environment values: struct environment_values { uint16_t humidity; uint16_t temperature; uint16_t charging; }; I would like to add some additional information to those values with a phantom type* and make their types distinct at the same time: template <typename T, typename P> struct Tagged { T value; }; // Actual implementation will contain some more features struct Celsius{}; struct Power{}; struct Percent{}; struct Environment { Tagged<uint16_t,Percent> humidity; Tagged<uint16_t,Celsius> temperature; Tagged<uint16_t,Power> charging; }; Is the

To make it specific, I only want to know why on my 64 bit mac, the Swift compiler says the alignment of some types like Float80 is 16. To check the memory alignment requirement of a type, I use the alignof function. sizeof(Float80) // ~> 16 bytes, it only needs 10 bytes, but because of hardware design decisions it has to be a power of 2 strideof(Float80) // ~> 16 bytes, clear because it is exact on a power of 2, struct types with Float80 in it, can be bigger alignof(Float80) // ~> 16 bytes, why not 8 bytes, like String ? I understand the memory alignment of types less or equal the size of the

I've recently encountered what I think is a false-sharing problem in my application, and I've looked up Sutter's article on how to align my data to cache lines. He suggests the following C++ code: // C++ (using C++0x alignment syntax) template<typename T> struct cache_line_storage { [[ align(CACHE_LINE_SIZE) ]] T data; char pad[ CACHE_LINE_SIZE > sizeof(T) ? CACHE_LINE_SIZE - sizeof(T) : 1 ]; }; I can see how this would work when CACHE_LINE_SIZE > sizeof(T) is true -- the struct cache_line_storage just ends up taking up one full cache line of memory. However, when the sizeof(T) is larger than

How do you allocate memory that's aligned to a specific boundary in C (e.g., cache line boundary)? I'm looking for malloc/free like implementation that ideally would be as portable as possible --- at least between 32 and 64 bit architectures. Edit to add: In other words, I'm looking for something that would behave like (the now obsolete?) memalign function, which can be freed using free. Jerome Here is a solution, which encapsulates the call to malloc, allocates a bigger buffer for alignment purpose, and stores the original allocated address just before the aligned buffer for a later call to