Быстрая функция копирования блоков памяти memcpy с использованием AVX инструкций

#include <immintrin.h>
void avx_memcpy(void *  pvDest, void *pvSrc, size_t nBytes) {
  assert(nBytes % 32 == 0);
  assert((intptr_t(pvDest) & 31) == 0);
  assert((intptr_t(pvSrc) & 31) == 0);
  const __m256i *pSrc = reinterpret_cast<const __m256i*>(pvSrc);
  __m256i *pDest = reinterpret_cast<__m256i*>(pvDest);
  int64_t nVects = nBytes / sizeof(*pSrc);
  for (; nVects > 0; nVects--, pSrc++, pDest++) {
    const __m256i loaded = _mm256_stream_load_si256(pSrc);
    _mm256_stream_si256(pDest, loaded);
  }
  _mm_sfence();
}

    wchar_t fm1 alignas(32)[1024]{L"01234"};
    wchar_t fm2 alignas(32)[] = L"Тест быстрого копирования строки с помощью функции avx_memcpy, с использованием avx инструкций!";
    
    std::wcout << fm2 << L" L: " << (sizeof(fm2) /sizeof(wchar_t)) << L" %32: " << ((sizeof(fm2) /sizeof(wchar_t))   % 32) << std::endl;
    
    avx_memcpy(fm1, fm2, (sizeof(fm2)) );
        std::wcout << fm1  << std::endl;
        _wsystem(L"pause");
        exit(0);

    [[nodiscard]] bool upload_texture_data(ID3D11Texture2D* target, D3D11_MAP map_type, const void* src, int w, int h, size_t src_pitch_bytes, size_t bpp) noexcept
    {
        assert(target != nullptr && "upload_texture_data: target texture is null");
        assert(src != nullptr && "upload_texture_data: src data is null");
        assert(w > 0 && h > 0 && "upload_texture_data: invalid dimensions");
        D3D11_MAPPED_SUBRESOURCE ms{};
        HRESULT hr = ctx->Map(target, 0, map_type, 0, &ms);
        if (FAILED(hr)) [[unlikely]]
        {
            warn_hr("Map", hr);
            handle_device_lost(hr);
            return false;
        }
 
        const size_t row_bytes = static_cast<size_t>(w) * bpp;
        const size_t src_row_bytes = src_pitch_bytes;
 
        assert(src_row_bytes >= row_bytes);
        assert(src_row_bytes % 32 == 0);
        COM_ASSUME(src_row_bytes % 32 == 0); // C++23 AVX2 hint: caller гарантирует выравнивание
 
        const uint8_t* s = reinterpret_cast<const uint8_t*>(src);
        uint8_t* d = reinterpret_cast<uint8_t*>(ms.pData);
 
        const ptrdiff_t gpu_pitch = static_cast<ptrdiff_t>(ms.RowPitch);
        const ptrdiff_t src_pitch = static_cast<ptrdiff_t>(src_row_bytes);
        const uint32_t rows = static_cast<uint32_t>(h);
 
        if (ms.RowPitch == row_bytes && src_row_bytes == row_bytes) [[likely]]
        {
            memcpy_stream_avx2<false, true>(d, s, row_bytes * rows);
        }
        else
        {
            for (uint32_t y = 0; y < rows; ++y)
            {
                memcpy_stream_avx2<false, false>(d, s, row_bytes);
                s += src_pitch;
                d += gpu_pitch;
            }
            memcpy_stream_avx2_fence();
        }
 
        ctx->Unmap(target, 0);
        return true;
    }

// Вызывать один раз после всей пачки NT-записей, не внутри цикла.
FAST_FORCEINLINE void memcpy_stream_avx2_fence() noexcept { _mm_sfence(); }
 
// Safe=true — рантайм-проверки на null/размер; Fence=true — sfence перед выходом.
template <bool Safe = false, bool Fence = true>
FAST_FORCEINLINE void memcpy_stream_avx2(void* __restrict dstv, const void* __restrict srcv, size_t bytes) noexcept
{
    assert(dstv != nullptr && "memcpy_stream_avx2: dst is null");
    assert(srcv != nullptr && "memcpy_stream_avx2: src is null");
#ifndef NDEBUG
    const uintptr_t d_ptr = reinterpret_cast<uintptr_t>(dstv);
    const uintptr_t s_ptr = reinterpret_cast<uintptr_t>(srcv);
    assert((d_ptr >= s_ptr + bytes || s_ptr >= d_ptr + bytes) && "memcpy_stream_avx2: memory regions overlap! Undefined Behavior.");
#endif
 
    if constexpr (Safe)
    {
        if (bytes == 0 || !dstv || !srcv) [[unlikely]] return;
    } else {
        COM_ASSUME(dstv != nullptr);
        COM_ASSUME(srcv != nullptr);
    }
    auto*       dst = static_cast<uint8_t*>(dstv);
    auto* const src = static_cast<const uint8_t*>(srcv);
 
    // < 1 KB — через L1 дешевле NT-stores
    if (bytes < 1024) [[likely]]
    {
        std::memcpy(dst, src, bytes);
        // [ВАЖНО] sfence здесь НЕ ошибка и строго обязателен!
        // Целевая память (dst) при загрузке на GPU (D3D11_MAP) помечена как Write-Combining (WC).
        // При записи в WC-память даже обычные инструкции (используемые внутри std::memcpy)
        // игнорируют кэш L1/L2 и оседают в скрытых Write-Combining буферах (WCB) процессора.
        // Если не сделать принудительный сброс (flush) через sfence, вызов D3D11 Unmap 
        // может произойти до того, как данные физически улетят по шине PCIe в VRAM.
        // Результат отсутствия sfence: разорванные текстуры и мерцающие артефакты.
        if constexpr (Fence) { _mm_sfence(); }
        return;
    }
 
    constexpr size_t A    = 32;
    const uintptr_t addr  = reinterpret_cast<uintptr_t>(dst);
    const size_t    head  = (A - (addr & (A - 1))) & (A - 1);
    const uint8_t*  current_src = src;
 
    // Выравниваем dst на 32 байта
    if (head) [[unlikely]]
    {
        std::memcpy(dst, current_src, head);
        dst         += head;
        current_src += head;
        bytes       -= head;
    }
 
    auto* aligned_dst = std::assume_aligned<32>(dst);
    assert((reinterpret_cast<uintptr_t>(aligned_dst) & 31) == 0);
    size_t qwords     = bytes >> 5;
 
    // 256 байт за итерацию, prefetch на 2 блока вперёд
    while (qwords >= 8) {
        PREFETCH_HINT((current_src + 256), true, PrefetchHint::NTA);
        PREFETCH_HINT((current_src + 320), true, PrefetchHint::NTA);
 
        _mm256_stream_si256(reinterpret_cast<__m256i*>(aligned_dst +   0), _mm256_loadu_si256(reinterpret_cast<const __m256i*>(current_src +   0)));
        _mm256_stream_si256(reinterpret_cast<__m256i*>(aligned_dst +  32), _mm256_loadu_si256(reinterpret_cast<const __m256i*>(current_src +  32)));
        _mm256_stream_si256(reinterpret_cast<__m256i*>(aligned_dst +  64), _mm256_loadu_si256(reinterpret_cast<const __m256i*>(current_src +  64)));
        _mm256_stream_si256(reinterpret_cast<__m256i*>(aligned_dst +  96), _mm256_loadu_si256(reinterpret_cast<const __m256i*>(current_src +  96)));
        _mm256_stream_si256(reinterpret_cast<__m256i*>(aligned_dst + 128), _mm256_loadu_si256(reinterpret_cast<const __m256i*>(current_src + 128)));
        _mm256_stream_si256(reinterpret_cast<__m256i*>(aligned_dst + 160), _mm256_loadu_si256(reinterpret_cast<const __m256i*>(current_src + 160)));
        _mm256_stream_si256(reinterpret_cast<__m256i*>(aligned_dst + 192), _mm256_loadu_si256(reinterpret_cast<const __m256i*>(current_src + 192)));
        _mm256_stream_si256(reinterpret_cast<__m256i*>(aligned_dst + 224), _mm256_loadu_si256(reinterpret_cast<const __m256i*>(current_src + 224)));
 
        aligned_dst += 256;
        current_src += 256;
        qwords      -= 8;
    }
 
    for (; qwords > 0; --qwords)
    {
        _mm256_stream_si256(reinterpret_cast<__m256i*>(aligned_dst), _mm256_loadu_si256(reinterpret_cast<const __m256i*>(current_src)));
        aligned_dst += 32;
        current_src += 32;
    }
 
    const size_t tail = bytes & 31;
    if (tail) [[unlikely]]
    {
        std::memcpy(aligned_dst, current_src, tail);
    }
 
    if constexpr (Fence)
    {
        _mm_sfence();
    }
}