Распараллеливание циклов

std::list<int>::iterator iter;
std::list<int>_paramsFFT;
 
for(iter = _paramsFFT.begin(); iter != _paramsFFT.end(); ++ iter)
    {
 
        if ((*iter).isign != fft_ward)
            continue;
 
        if ((*iter).length != mas.size())
            continue;
 
        isGo = true;
        break;
    }

for (auto it = localParamsBegin; it != localParamsEnd && !isGo.load(std::memory_order_acquire); ++it) {
   if (it->isign == fft_ward && it->length == mas.size()) {
      isGo.store(true, std::memory_order_release);
      break;
   }
};

#include <iostream>
#include <algorithm>
 
#include <omp.h>
 
int main()
{
    bool found = false;
    const uint8_t threads_count = 4;
    const size_t size = 100 * 1000 * 1000;
    ::std::vector<int> v(size, 1);
 
    double start = omp_get_wtime();
    ::omp_set_num_threads(threads_count);
#pragma omp parallel for reduction(|:found)
    for (int i = 0; i < size; ++i)
        if (v[i] == 1)
            found = true;
    double end = omp_get_wtime();
    ::std::cout << "time: " << end - start << ::std::endl;
}

#include <iostream>
#include <algorithm>
 
#include <omp.h>
 
int main()
{
    bool found = false;
    const uint8_t threads_count = 4;
    const size_t size = 100 * 1000 * 1000;
    ::std::vector<int> v(size, 1);
 
    double start = omp_get_wtime();
    ::omp_set_num_threads(threads_count);
#pragma omp parallel
    {
        const auto cend = v.end();
#pragma omp for reduction(|| : found)
        for (auto it = v.begin(); it < cend; ++it)
            if (*it == 1)
                found = true;
    }
    double end = omp_get_wtime();
    ::std::cout << "time: " << end - start << ::std::endl;
}

#include <iostream>
#include <algorithm>
 
#include <omp.h>
 
template <class BidirectionalIterator>
bool check(BidirectionalIterator first,
           const BidirectionalIterator &last,
           const size_t &step)
{
    while (first < last)
    {
        if (*first == 1)
            return true;
        first += step;
    }
    return false;
}
 
int main()
{
    const uint8_t threads_count = 4;
    const size_t size = 100 * 1000 * 1000;
    const ::std::vector<int> v(size, 1);
 
    bool found = false;
    size_t step;
 
    ::omp_set_num_threads(threads_count);
    double start = omp_get_wtime();
#pragma omp parallel
    {
#pragma omp single
        step = ::omp_get_num_threads();
        size_t id = ::omp_get_thread_num();
        bool value = ::check(v.begin() + id, v.end(), step);
#pragma omp critical
        found |= value;
    }
    double end = omp_get_wtime();
    ::std::cout << "time: " << end - start << ", found: " << found << ::std::endl;
}

auto const it = std::find_if(std::begin(_fftParams), std::end(_fftParams), [&] (auto const& v) { return v.isign == fft_end && v.length == mas.size(); };
isGo = it != std::end(_fftParams);

#include <iostream>
#include <list>
#include <thread>
#include <iterator>
#include <vector>
#include <atomic>
#include <ctime>
#include <string>
 
 
void func(std::atomic<bool>& isgo, std::list<std::string>::iterator ib, std::list<std::string>::iterator ie)
{
    for (; ib != ie; ++ib)
    {
        if (*ib == "aaab")
        {
            std::cout << "yes " << int(ib == ie) << '\n';
            isgo = true;
            break;
        }
        else if (isgo)
        {
            std::cout << "already " << int(ib == ie) << '\n';
            break;
        }
    }
    if(!isgo)
    {
        std::cout << "no " << int(ib == ie) << '\n';
    }
}
 
int main()
{
    std::list<std::string> lst(5'000'000, "aaaa");
    
    std::list<std::string>::iterator ib = lst.begin(), ie = lst.end();
 
    ie = lst.begin();
    std::advance(ie, 2);
 
    *--ie = "aaab";
    ie = lst.begin();
 
    std::atomic<bool> isgo = false;
    int tc = 3; // 4 - 199; 3 - 265; 2 - 201; 1 - 2  // 4 - 1100; 3 - 1330; 2 - 1800; 1 - 3140
    std::vector<std::thread> vec;
    vec.reserve(tc);
    int istep = lst.size() / tc;
    clock_t t1 = clock();
    for (int i = 0; i < tc; ++i)
    {
        if (isgo)
        {
            break;
        }
        ib = ie;
        if (i == tc - 1)
        {
            ie = lst.end();
        }
        else
        {
            std::advance(ie, istep);
        }
        vec.emplace_back(func, std::ref(isgo), ib, ie);
    }
    for (auto& val : vec)
    {
        val.join();
    }
    clock_t t2 = clock();
    std::cout << "time spent: " << t2 - t1 << std::endl;
}