С++: строгое сглаживание против профсоюзного насилия

Ответ 1

У меня есть код, который реализует операторы (замены) 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 для raw (char). Он предполагает, что size_t достаточно широк для адресной арифметики - истинно на практике, но uintptr_t из <cstdint> будет более правильным.

Ответ 2

Чтобы ответить на ваш вопрос, оба этих метода так же безопасны. Единственные две операции, которые действительно вонючие, - это отличные от size_t и new char[stuff]. По крайней мере, вы должны использовать uintptr_t из <cstdint> для первого. Вторая операция создает единственную проблему с псевдонимом указателя, так как технически конструктор char запускается на каждом элементе char и который представляет собой доступ к данным с помощью указателя char. Вместо этого следует использовать malloc.

Другой предполагаемый "сглаживание указателей" не является проблемой. И это потому, что кроме операции new вы не получаете доступа к каким-либо данным с помощью указателей с псевдонимом. Вы получаете доступ только к данным через T *, которые вы получаете после выравнивания.

Конечно, вам нужно запомнить все элементы массива. Это верно даже в вашей версии. Кто знает, какие люди T будут там помещать. И, конечно же, если вы это сделаете, вам придется не забыть называть их деструкторов и не забывать обрабатывать исключения при их копировании (memcpy не разрезает его).

Если у вас есть определенная функция С++ 11, вам не нужно это делать. С++ 11 имеет функцию специально для выравнивания указателей с произвольными границами. Интерфейс немного напуган, но он должен выполнять эту работу. Вызов ::std::align, определенный в <memory>. Спасибо за R. Martinho Fernandes, указав это.

Вот версия вашей функции с предложенным исправлением:

#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;
        }
    }
};