15#ifndef dealii_thread_management_h
16#define dealii_thread_management_h
27#ifdef DEAL_II_WITH_TASKFLOW
28# include <taskflow/taskflow.hpp>
41#ifdef DEAL_II_HAVE_CXX20
46#ifdef DEAL_II_WITH_TBB
47# include <tbb/task_group.h>
80 template <
typename ForwardIterator>
81 std::vector<std::pair<ForwardIterator, ForwardIterator>>
83 const ForwardIterator &end,
84 const unsigned int n_intervals);
94 std::vector<std::pair<unsigned int, unsigned int>>
96 const unsigned int end,
97 const unsigned int n_intervals);
149 template <
typename ForwardIterator>
150 std::vector<std::pair<ForwardIterator, ForwardIterator>>
152 const ForwardIterator &end,
153 const unsigned int n_intervals)
155 using IteratorPair = std::pair<ForwardIterator, ForwardIterator>;
161 if (n_intervals == 1)
162 return (std::vector<IteratorPair>(1, IteratorPair(begin, end)));
165 const unsigned int n_elements = std::distance(begin, end);
166 const unsigned int n_elements_per_interval = n_elements / n_intervals;
167 const unsigned int residual = n_elements % n_intervals;
169 std::vector<IteratorPair> return_values(n_intervals);
171 return_values[0].first =
begin;
172 for (
unsigned int i = 0; i < n_intervals; ++i)
174 if (i != n_intervals - 1)
176 return_values[i].second = return_values[i].first;
181 std::advance(return_values[i].
second,
182 static_cast<signed int>(n_elements_per_interval));
186 ++return_values[i].second;
188 return_values[i + 1].first = return_values[i].second;
191 return_values[i].second =
end;
193 return return_values;
221 template <
typename RT>
242 "You cannot read the return value of a thread or task "
243 "if that value has not been set. This happens, for example, if "
244 "a task or thread threw an exception."));
251 value = std::move(v);
266 value = std::move(v.get());
291 template <
typename RT>
303 , value_is_initialized(false)
306 inline reference_type
310 value_is_initialized,
312 "You cannot read the return value of a thread or task "
313 "if that value has not been set. This happens, for example, if "
314 "a task or thread threw an exception."));
337 value_is_initialized =
true;
393 template <
typename T>
412 template <
typename T>
415 static std::reference_wrapper<T>
430 template <
typename RT,
typename Function>
432 (std::invocable<Function> &&
433 std::convertible_to<std::invoke_result_t<Function>, RT>))
436 promise.set_value(function());
449 template <
typename Function>
452 std::promise<
void> &promise)
488 template <
typename RT =
void>
503 Task(
const std::function<RT()> &function_object)
507#ifdef DEAL_II_WITH_TASKFLOW
516#elif defined(DEAL_II_WITH_TBB)
521 std::unique_ptr<std::promise<RT>> promise =
522 std::make_unique<std::promise<RT>>();
524 std::make_shared<TaskData>(std::move(promise->get_future()));
564 std::shared_ptr<std::promise<RT>>(std::move(promise))]() {
574 promise->set_exception(std::current_exception());
604 std::async(std::launch::async | std::launch::deferred,
620 std::promise<RT> promise;
621 task_data = std::make_shared<TaskData>(promise.get_future());
631 promise.set_exception(std::current_exception());
503 Task(
const std::function<RT()> &function_object) {
…}
843 "The current object is not associated with a task that "
844 "can be joined. It may have been detached, or you "
845 "may have already joined it in the past.");
866#ifdef DEAL_II_WITH_TBB
867 ,
task_group(std::make_unique<tbb::task_group>())
953 std::lock_guard<std::mutex> lock(
mutex);
958#ifdef DEAL_II_WITH_TASKFLOW
970 return (
future.wait_for(std::chrono::seconds(0)) ==
971 std::future_status::ready);
993#elif defined(DEAL_II_WITH_TBB)
1117#ifdef DEAL_II_WITH_TBB
1127 friend class Task<RT>;
1159 template <
typename RT>
1245 template <
typename FunctionObjectType>
1247 inline auto
new_task(FunctionObjectType function_object)
1248 ->
Task<decltype(function_object())>
1250 using return_type =
decltype(function_object());
1252 return new_task(std::function<return_type()>(function_object));
1247 inline auto
new_task(FunctionObjectType function_object) {
…}
1263 template <
typename RT,
typename... Args>
1269 [dummy, fun_ptr]() -> RT {
return std::apply(fun_ptr, dummy); });
1315 typename FunctionObject,
1317 typename = std::enable_if_t<std::is_invocable_v<FunctionObject, Args...>>,
1318 typename = std::enable_if_t<std::is_function_v<FunctionObject> ==
false>,
1320 std::enable_if_t<std::is_member_pointer_v<FunctionObject> ==
false>,
1321 typename = std::enable_if_t<std::is_pointer_v<FunctionObject> ==
false>>
1322 inline Task<std::invoke_result_t<FunctionObject, Args...>>
1325 using RT = std::invoke_result_t<FunctionObject, Args...>;
1326 auto dummy = std::make_tuple(std::forward<Args>(args)...);
1327 return new_task([dummy, fun]() -> RT {
return std::apply(fun, dummy); });
1338 template <
typename RT,
typename C,
typename... Args>
1342 std_cxx20::type_identity_t<Args>... args)
1345 return new_task(std::function<RT()>(std::bind(
1355 template <
typename RT,
typename C,
typename... Args>
1359 std_cxx20::type_identity_t<Args>... args)
1362 return new_task(std::function<RT()>(std::bind(
1379 template <
typename RT =
void>
1404 return tasks.size();
1424 std::vector<RT> results;
1425 results.reserve(
size());
1426 for (
auto &t :
tasks)
1427 results.emplace_back(std::move(t.return_value()));
1441 for (
const auto &t :
tasks)
static void initialize_multithreading()
static unsigned int n_threads()
static tf::Executor & get_taskflow_executor()
TaskGroup & operator+=(const Task< RT > &t)
std::vector< RT > return_values()
std::list< Task< RT > > tasks
TaskData(std::future< RT > &&future) noexcept
TaskData(const TaskData &)=delete
TaskData & operator=(const TaskData &)=delete
std::atomic< bool > task_has_finished
internal::return_value< RT > returned_object
std::unique_ptr< tbb::task_group > task_group
TaskData & operator=(TaskData &&)=delete
TaskData(TaskData &&)=delete
internal::return_value< RT >::reference_type get()
Task(Task &&other) noexcept=default
std::shared_ptr< TaskData > task_data
internal::return_value< RT >::reference_type return_value()
Task & operator=(Task &&other) noexcept=default
Task(const Task &other)=default
Task(const std::function< RT()> &function_object)
Task & operator=(const Task &other)=default
#define DEAL_II_NAMESPACE_OPEN
#define DEAL_II_CXX20_REQUIRES(condition)
#define DEAL_II_NAMESPACE_CLOSE
static ::ExceptionBase & ExcNoTask()
#define Assert(cond, exc)
#define DeclExceptionMsg(Exception, defaulttext)
static ::ExceptionBase & ExcMessage(std::string arg1)
#define AssertThrow(cond, exc)
std::vector< std::pair< ForwardIterator, ForwardIterator > > split_range(const ForwardIterator &begin, const ForwardIterator &end, const unsigned int n_intervals)
Task< RT > new_task(const std::function< RT()> &function)
std::vector< std::pair< unsigned int, unsigned int > > split_interval(const unsigned int begin, const unsigned int end, const unsigned int n_intervals)
void handle_unknown_exception()
void evaluate_and_set_promise(Function &function, std::promise< RT > &promise)
void handle_std_exception(const std::exception &exc)
VectorType::value_type * end(VectorType &V)
VectorType::value_type * begin(VectorType &V)
typename type_identity< T >::type type_identity_t
static std::reference_wrapper< T > act(T &t)
reference_type get() const
bool value_is_initialized
void set_from(std::future< RT & > &v)
void set_from(std::future< void > &)
bool value_is_initialized
void set_from(std::future< RT > &v)