Масштабируемое распределение памяти с использованием INTEL TBB

Я могу хотя бы сказать вам, почему вы не получаете больше 25

Ваш ЦП имеет максимальную пропускную способность ОЗУ 51,2 ГБ / с, согласно Intel
DDR3-1600 имеет максимальную пропускную способность 25,6 ГБ / с согласно википедии

Это означает, что по крайней мере 2 канала ОЗУ должны быть использованы для ожидания более 25. Это почти постоянно, если вы хотите приблизиться к 40-50.

Для этого вам нужно знать, как ОС распределяет адрес памяти по слотам оперативной памяти, и парализовать цикл так, чтобы доступ к памяти параллельно осуществлялся по адресу 2 оперативной памяти, к которому можно получить доступ в parralel. Если распараллеливание обращается по «тем же» временным адресам, которые находятся рядом, они, вероятно, будут находиться на одной и той же оперативной памяти и использовать только один канал оперативной памяти, ограничивая тем самым скорость до теоретических 25 ГБ / с.
Вам может даже понадобиться что-то, что способно разделить распределение по блокам по разным адресам в нескольких слотах оперативной памяти, в зависимости от того, как адреса оперативной памяти распараллелены в слотах.

(продолжение из комментариев)

Вот некоторые тесты производительности встроенных функций для справки. Он измеряет время, необходимое для резервирования (по телефону VirtualAlloc) и занести в физическую память (позвонив VirtualLock) 40 ГБ блока памяти.

#include <sdkddkver.h>
#include <Windows.h>

#include <intrin.h>

#include <array>
#include <iostream>
#include <memory>
#include <fcntl.h>
#include <io.h>
#include <stdio.h>

void
Handle_Error(const ::LPCWSTR psz_what)
{
const auto error_code{::GetLastError()};
::std::array<::WCHAR, 512> buffer;
const auto format_result
(
::FormatMessageW
(
FORMAT_MESSAGE_FROM_SYSTEM
,   nullptr
,   error_code
,   0
,   buffer.data()
,   static_cast<::DWORD>(buffer.size())
,   nullptr
)
);
const auto formatted{0 != format_result};
if(!formatted)
{
const auto & default_message{L"no description"};
::memcpy(buffer.data(), default_message, sizeof(default_message));
}
buffer.back() = L'\0'; // just in case
_setmode(_fileno(stdout), _O_U16TEXT);
::std::wcout << psz_what << ", error # " << error_code << ": " << buffer.data() << ::std::endl;
system("pause");
exit(-1);
}

void
Enable_Previllege(const ::LPCWSTR psz_name)
{
::TOKEN_PRIVILEGES tkp{};
if(FALSE == ::LookupPrivilegeValueW(nullptr, psz_name, ::std::addressof(tkp.Privileges[0].Luid)))
{
Handle_Error(L"LookupPrivilegeValueW call failed");
}
const auto this_process_handle(::GetCurrentProcess()); // Returns pseudo handle (HANDLE)-1, no need to call CloseHandle
::HANDLE token_handle{};
if(FALSE == ::OpenProcessToken(this_process_handle, TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, ::std::addressof(token_handle)))
{
Handle_Error(L"OpenProcessToken call failed");
}
if(NULL == token_handle)
{
Handle_Error(L"OpenProcessToken call returned invalid token handle");
}
tkp.PrivilegeCount = 1;
tkp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
if(FALSE == ::AdjustTokenPrivileges(token_handle, FALSE, ::std::addressof(tkp), 0, nullptr, nullptr))
{
Handle_Error(L"AdjustTokenPrivileges call failed");
}
if(FALSE == ::CloseHandle(token_handle))
{
Handle_Error(L"CloseHandle call failed");
}
}

int main()
{
constexpr const auto bytes_count{::SIZE_T{40} * ::SIZE_T{1024} * ::SIZE_T{1024} * ::SIZE_T{1024}};
//  Make sure we can set asjust working set size and lock memory.
Enable_Previllege(SE_INCREASE_QUOTA_NAME);
Enable_Previllege(SE_LOCK_MEMORY_NAME);
//  Make sure our working set is sufficient to hold that block + some little extra.
constexpr const ::SIZE_T working_set_bytes_count{bytes_count + ::SIZE_T{4 * 1024 * 1024}};
if(FALSE == ::SetProcessWorkingSetSize(::GetCurrentProcess(), working_set_bytes_count, working_set_bytes_count))
{
Handle_Error(L"SetProcessWorkingSetSize call failed");
}
//  Start timer.
::LARGE_INTEGER start_time;
if(FALSE == ::QueryPerformanceCounter(::std::addressof(start_time)))
{
Handle_Error(L"QueryPerformanceCounter call failed");
}
//  Run test.
const ::SIZE_T min_large_page_bytes_count{::GetLargePageMinimum()}; // if 0 then not supported
const ::DWORD allocation_flags
{
(0u != min_large_page_bytes_count)
?
::DWORD{MEM_COMMIT | MEM_RESERVE} // | MEM_LARGE_PAGES} // need to enable large pages support for current user first
:
::DWORD{MEM_COMMIT | MEM_RESERVE}
};
if((0u != min_large_page_bytes_count) && (0u != (bytes_count % min_large_page_bytes_count)))
{
Handle_Error(L"bytes_cout value is not suitable for large pages");
}
constexpr const ::DWORD protection_flags{PAGE_READWRITE};
const auto p{::VirtualAlloc(nullptr, bytes_count, allocation_flags, protection_flags)};
if(!p)
{
Handle_Error(L"VirtualAlloc call failed");
}
if(FALSE == ::VirtualLock(p, bytes_count))
{
Handle_Error(L"VirtualLock call failed");
}
//  Stop timer.
::LARGE_INTEGER finish_time;
if(FALSE == ::QueryPerformanceCounter(::std::addressof(finish_time)))
{
Handle_Error(L"QueryPerformanceCounter call failed");
}
//  Cleanup.
if(FALSE == ::VirtualUnlock(p, bytes_count))
{
Handle_Error(L"VirtualUnlock call failed");
}
if(FALSE == ::VirtualFree(p, 0, MEM_RELEASE))
{
Handle_Error(L"VirtualFree call failed");
}
//  Report results.
::LARGE_INTEGER freq;
if(FALSE == ::QueryPerformanceFrequency(::std::addressof(freq)))
{
Handle_Error(L"QueryPerformanceFrequency call failed");
}
const auto elapsed_time_ms{((finish_time.QuadPart - start_time.QuadPart) * ::LONGLONG{1000u}) / freq.QuadPart};
const auto rate_mbytesps{(bytes_count * ::SIZE_T{1000}) / static_cast<::SIZE_T>(elapsed_time_ms)};
_setmode(_fileno(stdout), _O_U16TEXT);
::std::wcout << elapsed_time_ms << " ms " << rate_mbytesps << " MB/s " << ::std::endl;
system("pause");
return 0;
}

На моей системе, Windows 10 Pro, Xeon E3 1245 V5 @ 3,5 ГГц, 64 ГБ DDR4 (4×16), он выводит:

8188 мс 5245441250 МБ / с

Этот код, кажется, использует только одно ядро. Максимум от Характеристики процессора составляет 34,1 ГБ / с. Ваш первый фрагмент кода занимает ~ 11,5 секунд (в режиме выпуска VS не пропускает цикл).

Включение больших страниц, вероятно, немного улучшит это. Также обратите внимание, что с VirtualLock страницы не могут перейти на своп, в отличие от сценария с обнулением их вручную. Большие страницы не могут идти, чтобы поменяться вообще.