thread_management.h File Reference

#include <deal.II/base/config.h>
#include <deal.II/base/exceptions.h>
#include <deal.II/base/multithread_info.h>
#include <deal.II/base/mutex.h>
#include <deal.II/base/template_constraints.h>
#include <taskflow/taskflow.hpp>
#include <atomic>
#include <functional>
#include <future>
#include <list>
#include <memory>
#include <thread>
#include <tuple>
#include <utility>
#include <vector>
#include <tbb/task_group.h>

Go to the source code of this file.

Classes
struct	Threads::internal::return_value< RT >
struct	Threads::internal::return_value< RT & >
struct	Threads::internal::return_value< void >
struct	Threads::internal::maybe_make_ref< T >
struct	Threads::internal::maybe_make_ref< T & >
class	Threads::Task< RT >
class	Threads::Task< RT >::TaskData
class	Threads::TaskGroup< RT >

Namespaces
namespace	Threads
namespace	Threads::internal

Functions
template<typename ForwardIterator >
std::vector< std::pair< ForwardIterator, ForwardIterator > >	Threads::split_range (const ForwardIterator &begin, const ForwardIterator &end, const unsigned int n_intervals)
std::vector< std::pair< unsigned int, unsigned int > >	Threads::split_interval (const unsigned int begin, const unsigned int end, const unsigned int n_intervals)
template<typename RT , typename Function >
void	Threads::internal::evaluate_and_set_promise (Function &function, std::promise< RT > &promise)
template<typename Function >
void	Threads::internal::evaluate_and_set_promise (Function &function, std::promise< void > &promise)
template<typename RT >
Task< RT >	Threads::new_task (const std::function< RT()> &function)
template<typename FunctionObjectType >
auto	Threads::new_task (FunctionObjectType function_object) -> Task< decltype(function_object())>
template<typename RT , typename... Args>
Task< RT >	Threads::new_task (RT(*fun_ptr)(Args...), std_cxx20::type_identity_t< Args >... args)
template<typename FunctionObject , typename... Args, typename = std::enable_if_t<std::is_invocable_v<FunctionObject, Args...>>, typename = std::enable_if_t<std::is_function_v<FunctionObject> == false>, typename = std::enable_if_t<std::is_member_pointer_v<FunctionObject> == false>, typename = std::enable_if_t<std::is_pointer_v<FunctionObject> == false>>
Task< std::invoke_result_t< FunctionObject, Args... > >	Threads::new_task (const FunctionObject &fun, Args &&...args)
template<typename RT , typename C , typename... Args>
Task< RT >	Threads::new_task (RT(C::*fun_ptr)(Args...), std_cxx20::type_identity_t< C > &c, std_cxx20::type_identity_t< Args >... args)
template<typename RT , typename C , typename... Args>
Task< RT >	Threads::new_task (RT(C::*fun_ptr)(Args...) const, std_cxx20::type_identity_t< const C > &c, std_cxx20::type_identity_t< Args >... args)