aggregation_executors_and_allocators.hpp File Reference

#include <stdexcept>
#include <stdio.h>
#include <any>
#include <atomic>
#include <chrono>
#include <cstdio>
#include <iostream>
#include <memory>
#include <mutex>
#include <optional>
#include <ostream>
#include <string>
#include <tuple>
#include <type_traits>
#include <typeinfo>
#include <utility>
#include <unordered_map>
#include <hpx/futures/future.hpp>
#include <hpx/hpx_init.hpp>
#include <hpx/include/async.hpp>
#include <hpx/include/iostreams.hpp>
#include <hpx/include/lcos.hpp>
#include <hpx/lcos/promise.hpp>
#include <hpx/mutex.hpp>
#include <boost/core/demangle.hpp>
#include <boost/format.hpp>
#include "cppuddle/common/config.hpp"
#include "cppuddle/memory_recycling/detail/buffer_management.hpp"
#include "cppuddle/executor_recycling/executor_pools_interface.hpp"

Include dependency graph for aggregation_executors_and_allocators.hpp:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
class	cppuddle::kernel_aggregation::detail::aggregated_function_call< Executor >
	Manages the launch conditions for aggregated function calls type/value-errors. More...
class	cppuddle::kernel_aggregation::detail::aggregated_executor< Executor >
	Executor Class that aggregates function calls for specific kernels. More...
class	cppuddle::kernel_aggregation::detail::aggregated_executor< Executor >::executor_slice
	Slice class - meant as a scope interface to the aggregated executor. More...
class	cppuddle::kernel_aggregation::detail::allocator_slice< T, Host_Allocator, Executor >
	Declaration since the actual allocator is only defined after the Executors. More...

Namespaces
	cppuddle
	cppuddle::kernel_aggregation
	CPPuddle namespace containing the kernel aggregation functionality.
	cppuddle::kernel_aggregation::detail
	hpx
	hpx::parallel
	hpx::parallel::execution

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

Enumerations
enum class	cppuddle::kernel_aggregation::detail::aggregated_executor_modes { cppuddle::kernel_aggregation::detail::EAGER = 1 , cppuddle::kernel_aggregation::detail::STRICT , cppuddle::kernel_aggregation::detail::ENDLESS }

Functions
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...) More...
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) More...
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. More...
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) More...
template<typename Executor , typename F , typename... Ts>
void	cppuddle::kernel_aggregation::detail::exec_post_wrapper (Executor &exec, F &&f, Ts &&...ts)
template<typename Executor , typename F , typename... Ts>
hpx::lcos::future< void >	cppuddle::kernel_aggregation::detail::exec_async_wrapper (Executor &exec, F &&f, Ts &&...ts)
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 &) noexcept
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 &) noexcept