What is the recommended way to align memory in C++11

by

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 before what is returned to the actual alloc address to unallocate it.

[Memory returned][ptr to start of memory][aligned memory][extra memory]

(assuming no inheritence from RingBuffer) something like:

void * RingBuffer::operator new(size_t request)
{
     static const size_t ptr_alloc = sizeof(void *);
     static const size_t align_size = 64;
     static const size_t request_size = sizeof(RingBuffer)+align_size;
     static const size_t needed = ptr_alloc+request_size;

     void * alloc = ::operator new(needed);
     void *ptr = std::align(align_size, sizeof(RingBuffer),
                          alloc+ptr_alloc, request_size);

     ((void **)ptr)[-1] = alloc; // save for delete calls to use
     return ptr;  
}

void RingBuffer::operator delete(void * ptr)
{
    if (ptr) // 0 is valid, but a noop, so prevent passing negative memory
    {
           void * alloc = ((void **)ptr)[-1];
           ::operator delete (alloc);
    }
}

For the second requirement of having a data member of RingBuffer also 64 byte aligned, for that if you know that the start of this is aligned, you can pad to force the alignment for data members.

More Related Contents:

  1. Questions about Hinnant’s stack allocator
  2. Memory alignment : how to use alignof / alignas?
  3. Is it always the case that sizeof(T) >= alignof(T) for all object types T?
  4. std::tuple memory alignment
  5. How can you iterate over the elements of an std::tuple?
  6. Implementation C++14 make_integer_sequence
  7. Range based loop: get item by value or reference to const?
  8. Should the trailing return type syntax style become the default for new C++11 programs? [closed]
  9. How to automatically convert strongly typed enum into int?
  10. Why use non-member begin and end functions in C++11?
  11. How to implement multithread safe singleton in C++11 without using
  12. Replacement for deprecated register keyword C++ 11
  13. Why can I not brace initialize a struct derived from another struct?
  14. How to guarantee order of argument evaluation when calling a function object?
  15. Is it possible to std::move objects out of functions? (C++11)
  16. How do compilers treat variable length arrays
  17. Delayed start of a thread in C++ 11
  18. C++ Add months to chrono::system_clock::time_point
  19. Lookup table with constexpr
  20. Passing rvalues through std::bind
  21. When is a type in c++11 allowed to be memcpyed?
  22. C++11: the difference between memory_order_relaxed and memory_order_consume
  23. Why doesn’t emplace_back() use uniform initialization?
  24. Should I use shared_ptr or unique_ptr
  25. Do c++11 lambdas capture variables they don’t use?
  26. Legal to overwrite std::string’s null terminator?
  27. Difference between steady_clock vs system_clock?
  28. Initialization difference with or without curly braces in C++
  29. Should std::unique_ptr be permitted
  30. Initializing an std::array of non-default-constructible elements?

Leave a Comment