cppuddle::kernel_aggregation::detail Namespace Reference

Classes
class	aggregated_executor
	Executor Class that aggregates function calls for specific kernels. More...
class	aggregated_function_call
	Manages the launch conditions for aggregated function calls type/value-errors. More...
class	aggregation_pool
class	allocator_slice
	Declaration since the actual allocator is only defined after the Executors. More...

Typedefs
using	aggregation_mutex_t = hpx::mutex

Enumerations
enum class	aggregated_executor_modes { EAGER = 1 , STRICT , ENDLESS }

Functions
template<typename aggregation_region_t >
void	init_area_aggregation_pool (const size_t max_slices)
template<typename... Ts>
std::tuple< Ts... >	make_tuple_supporting_references (Ts &&...ts)
	Constructs a tuple with copies (to store temporaries in aggregated function calls) yet also supporting references (on the users own risk...)
template<typename T >
std::string	print_if_possible (T val)
	Print some specific values that we can, but don't bother for most types (such as vector)
template<class TupType , size_t... I>
void	print_tuple (const TupType &_tup, std::index_sequence< I... >)
	Helper class for the helper class that prints tuples – do not use this directly.
template<class... T>
void	print_tuple (const std::tuple< T... > &_tup)
	Helper class for printing tuples (first component should be a function pointer, remaining components the function arguments)
template<typename Executor , typename F , typename... Ts>
void	exec_post_wrapper (Executor &exec, F &&f, Ts &&...ts)
template<typename Executor , typename F , typename... Ts>
hpx::lcos::future< void >	exec_async_wrapper (Executor &exec, F &&f, Ts &&...ts)
template<typename T , typename U , typename Host_Allocator , typename Executor >
constexpr bool	operator== (allocator_slice< T, Host_Allocator, Executor > const &, allocator_slice< U, Host_Allocator, Executor > const &) noexcept
template<typename T , typename U , typename Host_Allocator , typename Executor >
constexpr bool	operator!= (allocator_slice< T, Host_Allocator, Executor > const &, allocator_slice< U, Host_Allocator, Executor > const &) noexcept

Typedef Documentation

aggregation_mutex_t

using cppuddle::kernel_aggregation::detail::aggregation_mutex_t = typedef hpx::mutex

Enumeration Type Documentation

aggregated_executor_modes

enum class cppuddle::kernel_aggregation::detail::aggregated_executor_modes

strong

Enumerator
EAGER
STRICT
ENDLESS

Function Documentation

exec_async_wrapper()

template<typename Executor , typename F , typename... Ts>

hpx::lcos::future< void > cppuddle::kernel_aggregation::detail::exec_async_wrapper	(	Executor &	exec,
		F &&	f,
		Ts &&...	ts
	)

exec_post_wrapper()

template<typename Executor , typename F , typename... Ts>

void cppuddle::kernel_aggregation::detail::exec_post_wrapper	(	Executor &	exec,
		F &&	f,
		Ts &&...	ts
	)

init_area_aggregation_pool()

template<typename aggregation_region_t >

void cppuddle::kernel_aggregation::detail::init_area_aggregation_pool

(

const size_t

max_slices

)

make_tuple_supporting_references()

template<typename... Ts>

std::tuple< Ts... > cppuddle::kernel_aggregation::detail::make_tuple_supporting_references

(

Ts &&...

ts

)

Constructs a tuple with copies (to store temporaries in aggregated function calls) yet also supporting references (on the users own risk...)

operator!=()

template<typename T , typename U , typename Host_Allocator , typename Executor >

constexpr bool cppuddle::kernel_aggregation::detail::operator!= ( allocator_slice< T, Host_Allocator, Executor > const &  , allocator_slice< U, Host_Allocator, Executor > const &    )

constexprnoexcept

operator==()

template<typename T , typename U , typename Host_Allocator , typename Executor >

constexpr bool cppuddle::kernel_aggregation::detail::operator== ( allocator_slice< T, Host_Allocator, Executor > const &  , allocator_slice< U, Host_Allocator, Executor > const &    )

constexprnoexcept

print_if_possible()

template<typename T >

std::string cppuddle::kernel_aggregation::detail::print_if_possible

(

T

val

)

Print some specific values that we can, but don't bother for most types (such as vector)

print_tuple() [1/2]

template<class... T>

void cppuddle::kernel_aggregation::detail::print_tuple

(

const std::tuple< T... > &

_tup

)

Helper class for printing tuples (first component should be a function pointer, remaining components the function arguments)

print_tuple() [2/2]

template<class TupType , size_t... I>

void cppuddle::kernel_aggregation::detail::print_tuple	(	const TupType &	_tup,
		std::index_sequence< I... >
	)

Helper class for the helper class that prints tuples – do not use this directly.