transform_reduced 의 결과값이 틀립니다.

아무리 봐도 코드 오류가 잘 안보이네요,
어느부분이 잘못되었는지 짚어주실수 있을까요?

#include <iostream>
#include <thread>
#include <mutex>
#include <utility>
#include <vector>
#include <atomic>
#include <chrono>
#include <numeric>
#include <random>
#include <execution>
#include <future>

using namespace std;

auto dotProductNaive(const vector<int>& v0, const vector<int>& v1,
    const unsigned i_start, const unsigned i_end, unsigned long long & sum)
{

    for(unsigned i = i_start; i < i_end; ++i)
        sum += v0[i] * v1[i]; 
    return sum;   
}

mutex mtx; 
auto dotProductLock(const vector<int>& v0, const vector<int>& v1,
    const unsigned i_start, const unsigned i_end, unsigned long long & sum)
{
    for(unsigned i = i_start; i < i_end;++i)
    {
        std::scoped_lock lock(mtx); //c++17
        sum += v0[i] * v1[i];
    }
    return sum;
    
}

auto dotProductAtomic(const vector<int>& v0, const vector<int>& v1,
    const unsigned i_start, const unsigned i_end, atomic<unsigned long long>& sum)
{
    for(unsigned i = i_start; i < i_end;++i)
    {
        sum += v0[i] * v1[i];
    }
}

auto dotProductFuture(const vector<int>& v0, const vector<int>& v1,
    const unsigned i_start, const unsigned i_end)
{
    int sum = 0;
    for(unsigned i=i_start; i<i_end; ++i)
    {
        sum += v0[i] * v1[i];
    }
    return sum;
}

int main()
{
    const long long n_data = 100'000'000;
    const unsigned n_threads = 4;

    //init vectors
    std::vector<int> v0, v1;
    v0.reserve(n_data);
    v1.reserve(n_data);

    random_device seed;
    mt19937 engine(seed());

    uniform_int_distribution<> uniformDist(1, 10);

    for(long long i = 0; i < n_data; ++i)
    {
        v0.push_back(uniformDist(engine));
        v1.push_back(uniformDist(engine));
    }


    cout << "std::inner_product" << endl;
    {
        const auto sta = chrono::steady_clock::now();

        const auto sum = std::inner_product(v0.begin(), v0.end(), v1.begin(), 0ull);//unsigned long long

        const chrono::duration<double> dur = chrono::steady_clock::now() - sta;

        cout << dur.count() << endl;
        cout << sum << endl;
        cout << endl;
    }


    // cout << "Naive" << endl;
    // {
    //     const auto sta = std::chrono::steady_clock::now();

    //     std::vector<thread> threads;
    //     threads.resize(n_threads);

    //     const unsigned n_per_thread = n_data / n_threads;

    //     unsigned long long sum = 0;
    //     for(unsigned t = 0; t < n_threads; ++t)
    //     {
    //         threads[t] = std::thread(dotProductNaive, std::ref(v0), 
    //                         std::ref(v1), t*n_per_thread, (t+1)*n_per_thread, std::ref(sum));
    //     }

    //     for(unsigned t = 0; t < n_threads; ++t)
    //         threads[t].join();
    //     const auto dur = std::chrono::steady_clock::now() - sta;

    //     cout << dur.count() << endl;
    //     cout << sum << endl;
    //     cout << endl;

    // }

    // cout << "Lock Guard" << endl;
    // {
    //     const auto sta = std::chrono::steady_clock::now();
        
    //     unsigned long long sum = 0; 
    //     std::vector<thread> threads;
    //     threads.resize(n_threads);

    //     const unsigned n_per_thread = n_data / n_threads;

        
    //     for(unsigned t = 0; t < n_threads; ++t)
    //     {
    //         threads[t] = std::thread(dotProductLock, std::ref(v0), 
    //                         std::ref(v1), t*n_per_thread, (t+1)*n_per_thread, std::ref(sum));
    //     }

    //     for(unsigned t = 0; t < n_threads; ++t)
    //         threads[t].join();

    //     const chrono::duration<double> dur = std::chrono::steady_clock::now() - sta;

    //     cout << dur.count() << endl;
    //     cout << sum << endl;
    //     cout << endl;
    // }

    // cout << "Atomic" << endl;
    // {
    //     const auto sta = std::chrono::steady_clock::now();
        
    //     atomic<unsigned long long> sum = 0;
    //     std::vector<thread> threads;
    //     threads.resize(n_threads);

    //     const unsigned n_per_thread = n_data / n_threads;

        
    //     for(unsigned t = 0; t < n_threads; ++t)
    //     {
    //         threads[t] = std::thread(dotProductAtomic, std::ref(v0), 
    //                         std::ref(v1), t*n_per_thread, (t+1)*n_per_thread, std::ref(sum));
    //     }

    //     for(unsigned t = 0; t < n_threads; ++t)
    //         threads[t].join();
    //     const chrono::duration<double> dur = chrono::steady_clock::now() - sta;

    //     cout << dur.count() << endl;
    //     cout << sum << endl;
    //     cout << endl;
    // }

    // cout << "Future" << endl;
    // {
    //     const auto sta = chrono::steady_clock::now();

    //     unsigned long long sum = 0;

    //     vector<std::future<int>> futures;
    //     futures.resize(n_threads);

    //     const unsigned n_per_threads = n_data / n_threads;
    //     for(unsigned t=0; t<n_threads; ++t)
    //     {
    //         futures[t] = std::async(dotProductFuture, std::ref(v0), std::ref(v1),
    //                         t*n_per_threads, (t+1)*n_per_threads);
    //     }

    //     for(unsigned t=0; t<n_threads; ++t)
    //         sum += futures[t].get();

    //     const chrono::duration<double> dur = chrono::steady_clock::now() - sta;

    //     cout << dur.count() << endl;
    //     cout << sum << endl;
    //     cout << endl;

    // }

    cout << "std::transform_reduce" << endl;
    {
        const auto sta = chrono::steady_clock::now();

        const auto sum = std::transform_reduce(std::execution::par, v0.begin(), v0.end(), v1.begin(), 0ull);

        const chrono::duration<double> dur = chrono::steady_clock::now() - sta;

        cout << dur.count() << endl;
        cout << sum << endl;
        cout << endl;
    }


    return 0; 
}


 

C:\Users\AMS_1\Documents\codingtest> cmd /C "c:\Users\AMS_1\.vscode\extensions\ms-vscode.cpptools-1.17.5-win32-x64\debugAdapters\bin\WindowsDebugLauncher.exe --stdin=Microsoft-MIEngine-In-psejqjgn.yij --stdout=Microsoft-MIEngine-Out-gdugqoqf.tdl --stderr=Microsoft-MIEngine-Error-5nxrq2hy.db4 --pid=Microsoft-MIEngine-Pid-2bsw1qyg.cip --dbgExe=C:\msys64\mingw64\bin\gdb.exe --interpreter=mi "
std::inner_product
0.741454
3025100156

std::transform_reduce
0.951753
18446744072439684476

const auto sum = std::transform_reduce(
    std::execution::par, 
    v0.begin(), 
    v0.end(), 
    v1.begin(), 
    0ull, 
    std::plus<>(), 
    [](int a, int b) { return static_cast<unsigned long long>(a) * b; }
);