OctaForge
/
libostd
1
0
Fork 1
Code Issues Pull Requests Releases Wiki Activity

always use packaged_task for thread_pool push

master
Daniel Kolesa 2017-03-20 03:11:59 +01:00
parent e50a86f339
commit c1c68fb339
1 changed files with 18 additions and 45 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

63
ostd/thread_pool.hh
View File

@ -11,6 +11,7 @@
#include <utility> #include <utility>
#include <vector> #include <vector>
#include <queue> #include <queue>
#include <memory>
#include <thread> #include <thread>
#include <future> #include <future>
#include <mutex> #include <mutex>
@ -18,13 +19,6 @@
namespace ostd { namespace ostd {
namespace detail {
template<typename T>
using task_result_of = std::conditional_t<
std::is_same_v<T, void>, void, std::future<T>
>;
}
struct thread_pool { struct thread_pool {
void start(size_t size = std::thread::hardware_concurrency()) { void start(size_t size = std::thread::hardware_concurrency()) {
p_running = true; p_running = true;
@ -61,48 +55,27 @@ struct thread_pool {
template<typename F, typename ...A> template<typename F, typename ...A>
auto push(F &&func, A &&...args) -> auto push(F &&func, A &&...args) ->
detail::task_result_of<std::result_of_t<F(A...)>> std::future<std::result_of_t<F(A...)>>
{ {
using R = std::result_of_t<F(A...)>; using R = std::result_of_t<F(A...)>;
if constexpr(std::is_same_v<R, void>) { /* TODO: we can ditch the shared_ptr by implementing our own
/* void-returning funcs return void */ * move-only backing representation to replace use of std::function
{ */
std::lock_guard<std::mutex> l{p_lock}; auto t = std::make_shared<std::packaged_task<R()>>(
if (!p_running) { std::bind(std::forward<F>(func), std::forward<A>(args)...)
throw std::runtime_error{"push on stopped thread_pool"}; );
} auto ret = t->get_future();
if constexpr(sizeof...(A) == 0) { {
p_tasks.push(std::forward<F>(func)); std::lock_guard<std::mutex> l{p_lock};
} else { if (!p_running) {
p_tasks.push( throw std::runtime_error{"push on stopped thread_pool"};
std::bind(std::forward<F>(func), std::forward<A>(args)...)
);
}
} }
p_cond.notify_one(); p_tasks.emplace([t = std::move(t)]() mutable {
} else { (*t)();
/* non-void-returning funcs return a future */ });
std::packaged_task<R> t;
if constexpr(sizeof...(A) == 0) {
t = std::packaged_task<R>{std::forward<F>(func)};
} else {
t = std::packaged_task<R>{
std::bind(std::forward<F>(func), std::forward<A>(args)...)
};
}
auto ret = t.get_future();
{
std::lock_guard<std::mutex> l{p_lock};
if (!p_running) {
throw std::runtime_error{"push on stopped thread_pool"};
}
p_tasks.emplace([t = std::move(t)]() {
t();
});
}
p_cond.notify_one();
return ret;
} }
p_cond.notify_one();
return ret;
} }
private: private: