указатели — C ++: строгое псевдонимы против злоупотребления объединением
Заранее извиняюсь за то, что может быть глупым первым постом на проторенной земле. В то время как есть много материала на эту тему, очень мало из этого является окончательным и / или понятным для меня.
у меня есть AlignedArray Шаблонный класс для динамического выделения памяти в куче с произвольным выравниванием (мне нужно 32-байтовое выравнивание для процедур сборки AVX). Это требует некрасивых манипуляций с указателями.
Agner Fog предоставляет пример класса в cppexamples.zip, который использует для этого объединение (http://www.agner.org/optimize/optimization_manuals.zip). Тем не менее, я знаю, что если вы пишете одному члену профсоюза, а потом читаете другого, это приводит к UB.
AFAICT это безопасно для псевдонима любого типа указателя на char *, но только в одном направлении. Это где мое понимание становится нечетким. Вот сокращенная версия моего AlignedArray
класс (по сути, переписать Агнера, чтобы помочь моему пониманию):
template <typename T, size_t alignment = 32>
class AlignedArray
{
size_t m_size;
char * m_unaligned;
T * m_aligned;
public:
AlignedArray (size_t const size)
: m_size(0)
, m_unaligned(0)
, m_aligned(0)
{
this->size(size);
}
~AlignedArray ()
{
this->size(0);
}
T const & operator [] (size_t const i) const { return m_aligned[i]; }
T & operator [] (size_t const i) { return m_aligned[i]; }
size_t const size () { return m_size; }
void size (size_t const size)
{
if (size > 0)
{
if (size != m_size)
{
char * unaligned = 0;
unaligned = new char [size * sizeof(T) + alignment - 1];
if (unaligned)
{
// Agner:
/*
union {
char * c;
T * t;
size_t s;
} aligned;
aligned.c = unaligned + alignment - 1;
aligned.s &= ~(alignment - 1);
*/
// Me:
T * aligned = reinterpret_cast<T *>((reinterpret_cast<size_t>(unaligned) + alignment - 1) & ~(alignment - 1));
if (m_unaligned)
{
// Agner:
//memcpy(aligned.c, m_aligned, std::min(size, m_size));
// Me:
memcpy(aligned, m_aligned, std::min(size, m_size));
delete [] m_unaligned;
}
m_size = size;
m_unaligned = unaligned;
// Agner:
//m_aligned = aligned.t;
// Me:
m_aligned = aligned;
}
return;
}
return;
}
if (m_unaligned)
{
delete [] m_unaligned;
m_size = 0;
m_unaligned = 0;
m_aligned = 0;
}
}
};
Так какой метод безопасен (т)?
Решение
У меня есть код, который реализует (замена) new а также delete операторы, подходящие для SIMD (т.е. SSE / AVX). Он использует следующие функции, которые могут оказаться полезными:
static inline void *G0__SIMD_malloc (size_t size)
{
constexpr size_t align = G0_SIMD_ALIGN;
void *ptr, *uptr;
static_assert(G0_SIMD_ALIGN >= sizeof(void *),
"insufficient alignment for pointer storage");
static_assert((G0_SIMD_ALIGN & (G0_SIMD_ALIGN - 1)) == 0,
"G0_SIMD_ALIGN value must be a power of (2)");
size += align; // raw pointer storage with alignment padding.
if ((uptr = malloc(size)) == nullptr)
return nullptr;
// size_t addr = reinterpret_cast<size_t>(uptr);
uintptr_t addr = reinterpret_cast<uintptr_t>(uptr);
ptr = reinterpret_cast<void *>
((addr + align) & ~(align - 1));
*(reinterpret_cast<void **>(ptr) - 1) = uptr; // (raw ptr)
return ptr;
}static inline void G0__SIMD_free (void *ptr)
{
if (ptr != nullptr)
free(*(reinterpret_cast<void **>(ptr) - 1)); // (raw ptr)
}
Это должно быть легко адаптироваться. Очевидно, вы бы заменить malloc а также free, так как вы используете глобальный new а также delete для хранения сырья Предполагается, что size_t достаточно широк для адресной арифметики — правда на практике, но uintptr_t от <cstdint> было бы правильнее.
Другие решения
Чтобы ответить на ваш вопрос, оба эти метода одинаково безопасны. Только две вонючие операции — это приведение к size_t а также new char[stuff], Вы должны по крайней мере использовать uintptr_t от <cstdint> для первого. Вторая операция создает единственную проблему с наложением указателей, поскольку технически char конструктор запускается на каждом char элемент и который представляет собой доступ к данным через char указатель. Вы должны использовать malloc вместо.
Другой предполагаемый «псевдоним указателя» не является проблемой. И это потому, что кроме new операция вы не получаете доступ к данным через псевдонимы-указатели. Вы получаете доступ к данным только через T * Вы получаете после выравнивания.
Конечно, вы должны помнить, чтобы создать все элементы массива. Это верно даже в вашей версии. Кто знает что за T люди положат туда. И, конечно же, если вы это сделаете, вам придется помнить, чтобы вызывать их деструкторы, и не забывать обрабатывать исключения при их копировании (memcpy не режет)
Если у вас есть особая функция C ++ 11, вам не нужно это делать. C ++ 11 имеет функцию, специально предназначенную для выравнивания указателей на произвольные границы. Интерфейс немного прикольный, но он должен делать свою работу. Вызов ::std::align определяется в <memory>.Благодаря Р. Мартиньо Фернандес для указания на это.
Вот версия вашей функции с предложенным исправленным:
#include <cstdint> // For uintptr_t
#include <cstdlib> // For malloc
#include <algorithm>
template <typename T, size_t alignment = 32>
class AlignedArray
{
size_t m_size;
void * m_unaligned;
T * m_aligned;
public:
AlignedArray (size_t const size)
: m_size(0)
, m_unaligned(0)
, m_aligned(0)
{
this->size(size);
}
~AlignedArray ()
{
this->size(0);
}
T const & operator [] (size_t const i) const { return m_aligned[i]; }
T & operator [] (size_t const i) { return m_aligned[i]; }
size_t size() const { return m_size; }
void size (size_t const size)
{
using ::std::uintptr_t;
using ::std::malloc;
if (size > 0)
{
if (size != m_size)
{
void * unaligned = 0;
unaligned = malloc(size * sizeof(T) + alignment - 1);
if (unaligned)
{
T * aligned = reinterpret_cast<T *>((reinterpret_cast<uintptr_t>(unaligned) + alignment - 1) & ~(alignment - 1));
if (m_unaligned)
{
::std::size_t constructed = 0;
const ::std::size_t num_to_copy = ::std::min(size, m_size);
try {
for (constructed = 0; constructed < num_to_copy; ++constructed) {
new(aligned + constructed) T(m_aligned[constructed]);
}
for (; constructed < size; ++constructed) {
new(aligned + constructed) T;
}
} catch (...) {
for (::std::size_t i = 0; i < constructed; ++i) {
aligned[i].T::~T();
}
::std::free(unaligned);
throw;
}
for (size_t i = 0; i < m_size; ++i) {
m_aligned[i].T::~T();
}
free(m_unaligned);
}
m_size = size;
m_unaligned = unaligned;
m_aligned = aligned;
}
}
} else if (m_unaligned) { // and size <= 0
for (::std::size_t i = 0; i < m_size; ++i) {
m_aligned[i].T::~T();
}
::std::free(m_unaligned);
m_size = 0;
m_unaligned = 0;
m_aligned = 0;
}
}
};