simple.hpp

Go to the documentation of this file.

#ifndef SUBPAR_SIMPLE_HPP
#define SUBPAR_SIMPLE_HPP
 
#include "range.hpp"
 
#ifndef SUBPAR_CUSTOM_PARALLELIZE_SIMPLE
#include <vector>
#include <stdexcept>
#include <thread>
#include <type_traits>
#endif
 
namespace subpar {
 
template<bool nothrow_ = false, typename Task_, class Run_>
void parallelize_simple(const Task_ num_tasks, const Run_ run_task) {
#ifdef SUBPAR_CUSTOM_PARALLELIZE_SIMPLE
    if constexpr(nothrow_) {
#ifdef SUBPAR_CUSTOM_PARALLELIZE_SIMPLE_NOTHROW
        SUBPAR_CUSTOM_PARALLELIZE_SIMPLE_NOTHROW(num_tasks, run_task);
#else
        SUBPAR_CUSTOM_PARALLELIZE_SIMPLE(num_tasks, run_task);
#endif
    } else {
        SUBPAR_CUSTOM_PARALLELIZE_SIMPLE(num_tasks, run_task);
    }
 
#else
    if (num_tasks <= 0) {
        return;
    } else if (num_tasks == 1) {
        run_task(0);
        return;
    }
 
    // Avoid instantiating a vector if it is known that the function can't throw.
    auto errors = [&]{
        if constexpr(nothrow_) {
            return true;
        } else {
            return sanisizer::create<std::vector<std::exception_ptr> >(num_tasks);
        }
    }();
 
#if defined(_OPENMP) && !defined(SUBPAR_NO_OPENMP_SIMPLE)
#define SUBPAR_USES_OPENMP_SIMPLE 1
 
    // OpenMP doesn't guarantee that we'll actually start 'num_tasks' workers,
    // so we need to do a loop here to ensure that each task is executed.
    #pragma omp parallel for num_threads(num_tasks)
    for (Task_ w = 0; w < num_tasks; ++w) {
        if constexpr(nothrow_) {
            run_task(w);
        } else {
            try { 
                run_task(w);
            } catch (...) {
                errors[w] = std::current_exception();
            }
        }
    }
 
#else
// Wiping it out, just in case.
#undef SUBPAR_USES_OPENMP_SIMPLE
 
    // We run the first job on the current thread, to avoid having to spin up an unnecessary worker.
    std::vector<std::thread> workers;
    sanisizer::reserve(workers, num_tasks - 1); // make sure we don't get alloc errors during emplace_back().
 
    for (Task_ w = 1; w < num_tasks; ++w) {
        if constexpr(nothrow_) {
            workers.emplace_back(run_task, w);
        } else {
            workers.emplace_back([&run_task,&errors](int w) -> void {
                try {
                    run_task(w);
                } catch (...) {
                    errors[w] = std::current_exception();
                }
            }, w);
        }
    }
 
    {
        if constexpr(nothrow_) {
            run_task(0);
        } else {
            try {
                run_task(0);
            } catch (...) {
                errors[0] = std::current_exception();
            }
        }
    }
 
    for (auto& wrk : workers) {
        wrk.join();
    }
#endif
 
    if constexpr(!nothrow_) {
        for (const auto& e : errors) {
            if (e) {
                std::rethrow_exception(e);
            }
        }
    }
#endif
}
 
}
 
#endif