memory-alignment

I'm currently trying to build a code which is supposed to work on a wide range of machines, from handheld pockets and sensors to big servers in data centers. One of the (many) differences between these architectures is the requirement for aligned memory access. Aligned memory access is not required on "standard" x86 CPU, but many other CPU need it and produce an exception if the rule is not respected. Up to now, i've been dealing with it by forcing the compiler to be cautious on specific data accesses which are known to be risky, using the packed attribute (or pragma). And it works fine. The

C++17 introduces std::aligned_alloc and alignment-aware new that can do over-aligned allocations, but what about std::allocator ? Does it handle over-aligned types? In N4659(C++17 DIS), 23.10.9.1 [allocator.members], bullet 2 T* allocate(size_t n); Returns: A pointer to the initial element of an array of storage of size n * sizeof(T), aligned appropriately for objects of type T . Compared to C++14, the sentence It is implementation-defined whether over-aligned types are supported has been removed. So std::allocator should support over-aligned types in C++17. 来源： https://stackoverflow.com

I have a C library that is compiled to a shared object and want to build a ctypes interface around it to call the C functions from Python. In general it works fine but there is this definition of a double array in the C library: typedef double __attribute__ ((aligned (32))) double_array[512]; I found no way to access this type directly, so I defined in Python: DoubleArray = ctypes.c_double * 512 While this works out in most cases, sometimes the C library segfaults and I guess this happens because DoubleArray is not aligned to 32 bytes (maybe the library expects this because the data is passed

I write an image processing app that needs to do multiple things and it has to do them as much real-time as possible. Acquisition of the data and their processing runs in separate processes (mainly for performance reasons). The data itself is quite large (2MPix 16-bit grayscale images). I can share arrays between processes as it is described in this post: How do I pass large numpy arrays between python subprocesses without saving to disk? (I use the shmarray script from the numpy-shared package). I can perform the supplied Numpy FFT on those data without problem, but it is quite slow. Calling

There is a quote from cppreference : Every object type has the property called alignment requirement, which is an integer value (of type std::size_t, always a power of 2) representing the number of bytes between successive addresses at which objects of this type can be allocated. I understand, this reference is non-normative. But there is no something about value of alignof(T) in the standard, rather than it is no more than alignof(std::max_align_t) . It is not obviously, that alignment is power of 2. Why does alignment not be a 3? Deduplicator The standard has the final word for the language,