11

よく踏まれた地面でのばかげた最初の投稿かもしれないことを前もってお詫び申し上げます。この主題に関する資料はたくさんありますが、決定的なものや私にとって理解できるものはほとんどありません。

任意のアラインメントでヒープにメモリを動的に割り当てるテンプレート クラスがAlignedArrayあります (AVX アセンブリ ルーチンには 32 バイトのアラインメントが必要です)。これには、見苦しいポインター操作が必要です。

Agner Fog は cppexamples.zip でサンプル クラスを提供しており、そのために共用体を悪用しています ( http://www.agner.org/optimize/optimization_manuals.zip )。ただし、ユニオンの 1 つのメンバーに書き込み、別のメンバーから読み取ると UB になることはわかっています。

AFAICT任意のポインター型を a にエイリアスしても安全ですがchar *、一方向のみです。これが私の理解が曖昧になるところです。これが私のAlignedArray クラスの要約版です（基本的に、私の理解を助けるためにAgnerのものを書き直しました）：

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

では、安全な方法はどれですか?

4

2 に答える 2

3

SIMD (つまり、SSE / AVX) に適した (置換) newand演算子を実装するコードがあります。delete便利な次の関数を使用します。

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)
}

これは簡単に適応できるはずです。グローバルおよび生（char）ストレージを使用しているため、明らかにmallocandを置き換えます。はアドレス演算に十分な幅があると想定しています - 実際にはそうですが、from の方がより正確です。freenewdeletesize_tuintptr_t<cstdint>

于 2013-03-07T16:09:43.177 に答える
2

あなたの質問に答えるために、これらの方法はどちらも安全です。本当に厄介な操作は と へのキャストの 2 つだけsize_tですnew char[stuff]。少なくとも最初はuintptr_tfromを使用する必要があります。2 番目の操作では、技術的にはコンストラクターが各要素で実行され、ポインターを介してデータにアクセスするため、<cstdint>唯一のポインター エイリアシングの問題が発生します。代わりに使用する必要があります。charcharcharmalloc

もう1つの想定される「ポインターエイリアシング」は問題ではありません。これは、操作以外ではnew、エイリアス ポインターを介してデータにアクセスしていないためです。T *アライメント後に取得したデータのみにアクセスしています。

もちろん、すべての配列要素を作成することを覚えておく必要があります。これは、あなたのバージョンでも当てはまります。Tどんな人がそこに入れるかは誰にもわかりません。もちろん、それを行う場合は、それらのデストラクタを呼び出すことを忘れないでください。また、それらをコピーするときに例外を処理することを忘れないでください (memcpyそれをカットしません)。

特定の C++11 機能がある場合、これを行う必要はありません。C++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;
        }
    }
};
于 2013-03-07T16:30:54.163 に答える