Homec4science
Diffusion tamaas (archive/legacy_mpi) Browse

tamaas/src/core/loops/apply.hh
7043e94a544aarchive/legacy_mpi

Last Change
Raw File

apply.hh
View Options

/**
* @file
*
* @author Lucas Frérot <lucas.frerot@epfl.ch>
*
* @section LICENSE
*
* Copyright (©) 2017 EPFL (Ecole Polytechnique Fédérale de
* Lausanne) Laboratory (LSMS - Laboratoire de Simulation en Mécanique des
* Solides)
*
* Tamaas is free software: you can redistribute it and/or modify it under the
* terms of the GNU Lesser General Public License as published by the Free
* Software Foundation, either version 3 of the License, or (at your option) any
* later version.
*
* Tamaas is distributed in the hope that it will be useful, but WITHOUT ANY
* WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
* A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
* details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with Tamaas. If not, see <http://www.gnu.org/licenses/>.
*
*/
/* -------------------------------------------------------------------------- */
#ifndef __APPLY_HH__
#define __APPLY_HH__
/* -------------------------------------------------------------------------- */
#include "tamaas.hh"
#include <thrust/tuple.h>
#include <utility>
#include <cstddef>
/* -------------------------------------------------------------------------- */
__BEGIN_TAMAAS__
namespace detail {
/// Helper function for application of a functor on a thrust::tuple
template <size_t nargs>
struct Apply;
template <>
struct Apply<0> {
template <typename Functor, typename Tuple>
__host__ __device__
static auto apply(Functor&& func, Tuple&& t [[gnu::unused]])
-> decltype(func()) {
return func();
}
};
template <>
struct Apply<1> {
template <typename Functor, typename Tuple>
__host__ __device__
static auto apply(Functor&& func, Tuple&& t)
-> decltype(func(thrust::get<0>(std::forward<Tuple>(t)))) {
return func(thrust::get<0>(std::forward<Tuple>(t)));
}
};
template <>
struct Apply<2> {
template <typename Functor, typename Tuple>
__host__ __device__
static auto apply(Functor&& func, Tuple&& t)
-> decltype(func(thrust::get<0>(std::forward<Tuple>(t)),
thrust::get<1>(std::forward<Tuple>(t)))) {
return func(thrust::get<0>(std::forward<Tuple>(t)),
thrust::get<1>(std::forward<Tuple>(t)));
}
};
template <>
struct Apply<3> {
template <typename Functor, typename Tuple>
__host__ __device__
static auto apply(Functor&& func, Tuple&& t)
-> decltype(func(thrust::get<0>(std::forward<Tuple>(t)),
thrust::get<1>(std::forward<Tuple>(t)),
thrust::get<2>(std::forward<Tuple>(t)))) {
return func(thrust::get<0>(std::forward<Tuple>(t)),
thrust::get<1>(std::forward<Tuple>(t)),
thrust::get<2>(std::forward<Tuple>(t)));
}
};
template <>
struct Apply<4> {
template <typename Functor, typename Tuple>
__host__ __device__
static auto apply(Functor&& func, Tuple&& t)
-> decltype(func(thrust::get<0>(std::forward<Tuple>(t)),
thrust::get<1>(std::forward<Tuple>(t)),
thrust::get<2>(std::forward<Tuple>(t)),
thrust::get<3>(std::forward<Tuple>(t)))) {
return func(thrust::get<0>(std::forward<Tuple>(t)),
thrust::get<1>(std::forward<Tuple>(t)),
thrust::get<2>(std::forward<Tuple>(t)),
thrust::get<3>(std::forward<Tuple>(t)));
}
};
template <>
struct Apply<5> {
template <typename Functor, typename Tuple>
__host__ __device__
static auto apply(Functor&& func, Tuple&& t)
-> decltype(func(thrust::get<0>(std::forward<Tuple>(t)),
thrust::get<1>(std::forward<Tuple>(t)),
thrust::get<2>(std::forward<Tuple>(t)),
thrust::get<3>(std::forward<Tuple>(t)),
thrust::get<4>(std::forward<Tuple>(t)))) {
return func(thrust::get<0>(std::forward<Tuple>(t)),
thrust::get<1>(std::forward<Tuple>(t)),
thrust::get<2>(std::forward<Tuple>(t)),
thrust::get<3>(std::forward<Tuple>(t)),
thrust::get<4>(std::forward<Tuple>(t)));
}
};
/// Helper class for functor application in thrust
template <typename Functor, typename ret_type = void>
class ApplyFunctor {
public:
__host__ __device__
ApplyFunctor(const Functor & functor):functor(functor) {}
__host__ __device__
ApplyFunctor(const ApplyFunctor & o):functor(o.functor) {}
template <typename Tuple>
__host__ __device__
ret_type operator()(Tuple&& t) const {
return Apply<thrust::tuple_size<typename std::remove_reference<Tuple>::type>::value>::
apply(functor, std::forward<Tuple>(t));
}
private:
const Functor & functor;
};
} // namespace detail
__END_TAMAAS__
#endif
c4science · Help