// par
    {
        v_dest.clear();
        const some_time v_start = std::chrono::system_clock::now();
        std::copy_if(v_src.begin(), v_src.end(),
                     std::back_inserter(v_dest),
                     [](int x) { return !(x & 0b1); });
        std::transform(std::execution::par_unseq, v_dest.begin(), v_dest.end(), v_dest.begin(), [](int n){ return n/2;});

        const some_time v_stop = std::chrono::system_clock::now();
        std::cout << "par: "
        << std::chrono::duration_cast<std::chrono::microseconds>(v_stop - v_start)
        << '\n';
        //std::cout << v_dest << '\n';
    }

    // with mutex
    {
        v_dest.clear();
        const some_time v_start = std::chrono::system_clock::now();

        std::mutex mtx;
        std::for_each(std::execution::par_unseq, v_src.begin(), v_src.end(),
                      [&mtx, &v_dest](int n)
                      {
                        if ( !(n & 0b1) )
                        {
                          n /= 2;
                          std::lock_guard<std::mutex> lock(mtx);
                          v_dest.push_back(n);
                        }  
                      }
                     );

        const some_time v_stop = std::chrono::system_clock::now();
        std::cout << "par with mutex: "
        << std::chrono::duration_cast<std::chrono::microseconds>(v_stop - v_start)
        << '\n';
        //std::cout << v_dest << '\n';
    }

mcq: 6942us
mcq: 7745us
for: 8207us
for: 8221us
algo: 8282us
algo: 9553us
for div: 24985us
for div: 24839us
algo div: 34929us
algo div: 36110us
par: 6198us
check 1: 5840us
par with mutex: 5927us
check 2: 4767us

BFE>Добавил "многопоточность", а она ни на что не влияет . Что я делаю не так?:

#define PARALLEL
#include <execution>

BFE>Добавил "многопоточность", а она ни на что не влияет . Что я делаю не так?:

mcq: 8050
mcq: 7462
for: 10950
for: 10982
for div: 21935
for div: 18560
par: 7672
check 1: 6953
par with mutex: 203897
check 2: 8464

mcq: 2557us
mcq: 2257us
for loop: 2252us
for loop: 2627us
algo: 2456us (filter_view + transform)
algo: 2471us (filter_view + transform)
algo div: 21614us (transform div() + filter rem zero + transform quot)
algo div: 18330us (transform div() + filter rem zero + transform quot)
algo div custom: 13423us (transform my_div() + filter rem zero + transform quot)
algo div custom: 12781us (transform my_div() + filter rem zero + transform quot)
for div: 10058us
for div: 9904us
for div custom: 9812us
for div custom: 10002us
algo modified_copy_if: 1455us (custom algo)
algo modified_copy_if: 1453us (custom algo)

mcq: 3334us
mcq: 2005us
for loop: 2518us
for loop: 2351us
algo: 1681us (filter_view + transform)
algo: 1671us (filter_view + transform)
algo div: 12756us (transform div() + filter rem zero + transform quot)
algo div: 13324us (transform div() + filter rem zero + transform quot)
algo div custom: 1831us (transform my_div() + filter rem zero + transform quot)
algo div custom: 2302us (transform my_div() + filter rem zero + transform quot)
for div: 9182us
for div: 8855us
for div custom: 1635us
for div custom: 1606us
algo modified_copy_if: 1570us (custom algo)
algo modified_copy_if: 1517us (custom algo)

BFE>>Добавил "многопоточность", а она ни на что не влияет . Что я делаю не так?:

std::transform(std::execution::par_unseq, v_dest.begin(), v_dest.end(), v_dest.begin(), [](int n){ return n/2;});

#include <iostream>
#include <ranges>
#include <boost/phoenix.hpp>

int main() {
    using namespace std;
    using views::filter;
    using views::transform;
    using boost::phoenix::placeholders::_1;

    //===========================================================

    auto const v1 = { 1, 2, 3, 4, 5, 3 };

    auto rng = v1 | filter(_1 % 2 == 0) | transform(_1 / 2);
    auto const vec = rng | ranges::to<vector>();

    //===========================================================

    ostream_iterator<int> const out { cout, " " };

    ranges::copy(v1, out), cout << std::endl;
    ranges::copy(rng, out), cout << std::endl;
    ranges::copy(vec, out), cout << std::endl;

    return 0;
}

V>#include <iostream>
V>#include <ranges>
V>#include <boost/phoenix.hpp>

V>int main() {
V>    using namespace std;
V>    using views::filter;
V>    using views::transform;
V>    using boost::phoenix::placeholders::_1;

V>    //===========================================================

V>    auto const v1 = { 1, 2, 3, 4, 5, 3 };

V>    auto rng = v1 | filter(_1 % 2 == 0) | transform(_1 / 2);
V>    auto const vec = rng | ranges::to<vector>();

V>    //===========================================================

V>    ostream_iterator<int> const out { cout, " " };

V>    ranges::copy(v1, out), cout << std::endl;
V>    ranges::copy(rng, out), cout << std::endl;
V>    ranges::copy(vec, out), cout << std::endl;

V>    return 0;
V>}
V>

vec = v1 | filter(_1 % 2 == 0) | transform(_1 / 2) | ranges::to<vector>();
for( auto it : v1 ) if( it % 2 == 0 ) { vec.push_back(it / 2); }