CPPuddle
Loading...
Searching...
No Matches
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

namespace  cppuddle
namespace  cppuddle::kernel_aggregation
 CPPuddle namespace containing the kernel aggregation functionality.
namespace  cppuddle::kernel_aggregation::detail
namespace  CPPUDDLE_HPX_EXECUTOR_SPECIALIZATION_NS

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...).
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).
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.
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).
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::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