16 #ifndef dealii_thread_management_h
17 #define dealii_thread_management_h
37 #ifdef DEAL_II_HAVE_CXX20
42 #ifdef DEAL_II_WITH_TBB
43 # include <tbb/task_group.h>
76 template <
typename ForwardIterator>
77 std::vector<std::pair<ForwardIterator, ForwardIterator>>
79 const ForwardIterator &
end,
80 const unsigned int n_intervals);
90 std::vector<std::pair<unsigned int, unsigned int>>
92 const unsigned int end,
93 const unsigned int n_intervals);
145 template <
typename ForwardIterator>
146 std::vector<std::pair<ForwardIterator, ForwardIterator>>
148 const ForwardIterator &
end,
149 const unsigned int n_intervals)
151 using IteratorPair = std::pair<ForwardIterator, ForwardIterator>;
157 if (n_intervals == 1)
158 return (std::vector<IteratorPair>(1, IteratorPair(
begin,
end)));
161 const unsigned int n_elements = std::distance(
begin,
end);
162 const unsigned int n_elements_per_interval = n_elements / n_intervals;
163 const unsigned int residual = n_elements % n_intervals;
165 std::vector<IteratorPair> return_values(n_intervals);
167 return_values[0].first =
begin;
168 for (
unsigned int i = 0; i < n_intervals; ++i)
170 if (i != n_intervals - 1)
172 return_values[i].second = return_values[i].first;
178 static_cast<signed int>(n_elements_per_interval));
182 ++return_values[i].second;
184 return_values[i + 1].first = return_values[i].second;
187 return_values[i].second =
end;
189 return return_values;
217 template <
typename RT>
239 value = std::move(v);
245 value = std::move(v.get());
269 template <
typename RT>
282 inline reference_type
340 template <
typename RT>
342 call(
const std::function<RT()> &
function,
345 ret_val.
set(
function());
370 template <
typename RT>
450 start(
const std::function<RT()> &
function)
453 ret_val = std::make_shared<return_value<RT>>();
496 catch (
const std::exception &exc)
535 template <
typename RT =
void>
543 Thread(
const std::function<RT()> &
function)
669 template <
typename T>
688 template <
typename T>
691 static std::reference_wrapper<T>
713 template <
typename RT>
794 template <
typename FunctionObjectType>
797 ->
Thread<decltype(function_object())>
801 using return_type = decltype(function_object());
816 template <
typename RT,
typename... Args>
837 template <
typename RT,
typename C,
typename... Args>
844 return new_thread(std::function<RT()>(std::bind(
855 template <
typename RT,
typename C,
typename... Args>
864 return new_thread(std::function<RT()>(std::bind(
880 template <
typename RT =
void>
890 threads.push_back(t);
903 for (
auto &t : threads)
920 template <
typename RT,
typename Function>
922 (std::invocable<Function> &&
923 std::convertible_to<std::invoke_result_t<Function>, RT>))
926 promise.set_value(
function());
937 template <
typename Function>
940 std::promise<
void> &promise)
975 template <
typename RT =
void>
990 Task(
const std::function<RT()> &function_object)
994 #ifdef DEAL_II_WITH_TBB
999 std::unique_ptr<std::promise<RT>> promise =
1000 std::make_unique<std::promise<RT>>();
1002 std::make_shared<TaskData>(std::move(promise->get_future()));
1042 std::shared_ptr<std::promise<RT>>(std::move(promise))]() {
1052 promise->set_exception(std::current_exception());
1081 std::async(std::launch::async | std::launch::deferred,
1097 std::promise<RT> promise;
1098 task_data = std::make_shared<TaskData>(promise.get_future());
1108 promise.set_exception(std::current_exception());
1258 "The current object is not associated with a task that "
1259 "can be joined. It may have been detached, or you "
1260 "may have already joined it in the past.");
1365 std::lock_guard<std::mutex> lock(
mutex);
1370 #ifdef DEAL_II_WITH_TBB
1448 #ifdef DEAL_II_WITH_TBB
1454 friend class Task<RT>;
1486 template <
typename RT>
1570 template <
typename FunctionObjectType>
1572 inline auto
new_task(FunctionObjectType function_object)
1573 ->
Task<decltype(function_object())>
1575 using return_type = decltype(function_object());
1577 return new_task(std::function<return_type()>(function_object));
1588 template <
typename RT,
typename... Args>
1605 template <
typename RT,
typename C,
typename... Args>
1612 return new_task(std::function<RT()>(std::bind(
1622 template <
typename RT,
typename C,
typename... Args>
1629 return new_task(std::function<RT()>(std::bind(
1648 template <
typename RT =
void>
1673 return tasks.size();
1693 std::vector<RT> results;
1694 results.reserve(
size());
1695 for (
auto &t :
tasks)
1696 results.emplace_back(std::move(t.return_value()));
1710 for (
auto &t :
tasks)
static void initialize_multithreading()
static unsigned int n_threads()
std::list< Task< RT > > tasks
std::vector< RT > return_values()
TaskGroup & operator+=(const Task< RT > &t)
TaskData(std::future< RT > &&future) noexcept
TaskData(const TaskData &)=delete
std::atomic< bool > task_has_finished
internal::return_value< RT > returned_object
TaskData & operator=(const TaskData &)=delete
TaskData(TaskData &&)=delete
TaskData & operator=(TaskData &&)=delete
internal::return_value< RT >::reference_type get()
tbb::task_group task_group
std::shared_ptr< TaskData > task_data
internal::return_value< RT >::reference_type return_value()
Task(const std::function< RT()> &function_object)
std::list< Thread< RT > > threads
ThreadGroup & operator+=(const Thread< RT > &t)
internal::return_value< RT >::reference_type return_value()
Thread(const std::function< RT()> &function)
std::shared_ptr< internal::ThreadDescriptor< RT > > thread_descriptor
bool operator==(const Thread &t) const
Thread(const Thread< RT > &t)
#define DEAL_II_DEPRECATED
#define DEAL_II_NAMESPACE_OPEN
#define DEAL_II_DISABLE_EXTRA_DIAGNOSTICS
#define DEAL_II_CXX20_REQUIRES(condition)
#define DEAL_II_NAMESPACE_CLOSE
#define DEAL_II_ENABLE_EXTRA_DIAGNOSTICS
static ::ExceptionBase & ExcNoTask()
static ::ExceptionBase & ExcInternalError()
#define Assert(cond, exc)
#define DeclExceptionMsg(Exception, defaulttext)
#define AssertThrow(cond, exc)
Thread< RT > new_thread(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)
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)
SymmetricTensor< 2, dim, Number > C(const Tensor< 2, dim, Number > &F)
void handle_unknown_exception()
void evaluate_and_set_promise(Function &function, std::promise< RT > &promise)
void call(const std::function< RT()> &function, internal::return_value< RT > &ret_val)
void handle_std_exception(const std::exception &exc)
VectorType::value_type * begin(VectorType &V)
VectorType::value_type * end(VectorType &V)
auto apply(F &&fn, Tuple &&t) -> decltype(apply_impl(std::forward< F >(fn), std::forward< Tuple >(t), std::make_index_sequence< std::tuple_size< typename std::remove_reference< Tuple >::type >::value >()))
typename type_identity< T >::type type_identity_t
Mutex thread_is_active_mutex
std::shared_ptr< return_value< RT > > ret_val
static void thread_entry_point(const std::function< RT()> &function, std::shared_ptr< return_value< RT >> ret_val)
std::atomic< bool > thread_is_active
void start(const std::function< RT()> &function)
static std::reference_wrapper< T > act(T &t)
reference_type get() const
void set_from(std::future< RT & > &v)
void set_from(std::future< void > &)
void set_from(std::future< RT > &v)
void advance(std::tuple< I1, I2 > &t, const unsigned int n)