Не могу понять задание на многопоточку

        std::atomic<ForwardIt> smallest = first;
        std::atomic<ForwardIt> cmp = std::next(first);
        std::vector<std::thread> t_pool(thread_count - 1);
        for (size_t i = 0; i < thread_count - 1; i++){
            t_pool[i] = std::thread([&smallest, &cmp, last]{
                while (cmp.load() != last){
                    auto cur = cmp.load();
                    if (*smallest.load() > *cur){
                        smallest.store(cur);
                    }
                    cmp.store(++cur);
                }
            });
        }

template< class ExecutionPolicy, class ForwardIt >
ForwardIt pmin_element( ExecutionPolicy&& policy,
                        ForwardIt first, ForwardIt last ){
    policy_checker(ExecutionPolicy);
    if constexpr (std::is_same_v<typename std::decay<ExecutionPolicy>::type, sequenced_policy>){
        return min_element(first, last);
    } else if constexpr (std::is_same_v<typename std::decay<ExecutionPolicy>::type, parallel_policy>) {
        auto [threads_count, block_size] = tb_count(last - first);
        std::vector<boost::future<ForwardIt>> futures (threads_count);
        auto cur_first = first;
        auto cur_last = first + block_size;
        size_t i = 0;
        for (; i < threads_count - 1; i++){
            futures[i] = boost::async(boost::launch::async, [cur_first, cur_last] { return my_algos::min_element<ForwardIt>(cur_first, cur_last); });
            cur_first = cur_last;
            cur_last += block_size;
        }
        futures[i] = boost::async(boost::launch::async, [cur_first, last] { return my_algos::min_element<ForwardIt>(cur_first, last); });
        return boost::when_all(futures.begin(), futures.end()).then([](boost::future<std::vector<boost::future<ForwardIt>>> ready_results){
            auto result = ready_results.get();
            auto smallest = result.begin()->get();
            for (size_t i = 1; i < result.size(); i++){
                auto el = result[i].get();
                if (*smallest > *el)
                    smallest = el;
            }
            return smallest;
        }).get();
    } else if constexpr(std::is_same_v<typename std::decay<ExecutionPolicy>::type, parallel_unsequenced_policy>){
        auto [thread_count, block_count] = tb_count(last - first);
        std::vector<ForwardIt> smallests(thread_count, first);
        std::atomic<ForwardIt> cmp = std::next(first);
        std::vector<std::thread> t_pool(thread_count - 1);
        auto fun = [&cmp, last](ForwardIt & answer) {
            for (;;) {
                auto cur = cmp.load();
                if (cur == last)
                    break;
                if (*cur < *answer)
                    answer = cur;
                cmp.compare_exchange_weak(cur, std::next(cur));
            }
        };
        size_t i = 0;
        for (; i < thread_count - 1; i++){
            t_pool[i] = std::thread(fun, std::ref(smallests[i]));
        }
        fun(smallests[i]);
        ForwardIt smallest = *smallests.begin();
        for (auto & thread : t_pool)
            thread.join();
        for (size_t j = 0; j < thread_count; j++) {
            if (*smallests[j] < *smallest)
                smallest = smallests[j];
        }
        return smallest;
    } else if constexpr(std::is_same_v<typename std::decay<ExecutionPolicy>::type, unsequenced_policy>){
        auto [threads_count, block_size] = tb_count(last - first);
        std::vector<std::future<ForwardIt>> futures (threads_count);
        auto cur_first = first;
        auto cur_last = first + block_size;
        size_t i = 0;
        for (; i < threads_count - 1; i++){
            futures[i] = std::async(std::launch::deferred, [cur_first, cur_last] { return my_algos::min_element<ForwardIt>(cur_first, cur_last); });
            cur_first = cur_last;
            cur_last += block_size;
        }
        futures[i] = std::async(std::launch::deferred, [cur_first, last] { return my_algos::min_element<ForwardIt>(cur_first, last); });
        ForwardIt smallest = first;
        for (auto & el : futures){
            auto element = el.get();
            if (*smallest > *element){
                smallest = element;
            }
        }
        return smallest;
    }
}

    std::atomic<size_t> idx{0};
    size_t answer{0}, answer2{0};
    size_t const size = v.size();
    auto fun = [&idx, &v, size](size_t & answer) {
        for (;;) {
            const size_t i = idx++;
            if (v[i] < v[answer])
                answer = i;
            if (i >= size)
                break;
        }
    };

   for (;;) {
            const size_t i = idx++;
            if (i >= size)
                break;
 
            if (v[i] < v[answer])
                answer = i;
        }

    std::thread t1(fun, std::ref(answer)), t2(fun, std::ref(answer2));
    t1.join(); t2.join();
    std::cout << ((answer > answer2) ? v[answer2] : v[answer]);

   for (;;) {
            const size_t i = idx++;
            if (i >= size)
                break;
 
std::this_thread::sleep_for(std::chrono::milliseconds(1));
            if (v[i] < v[answer])
                answer = i;
        }

const size_t i = idx.fetch_add(1, std::memory_order_release);