options.hpp

Go to the documentation of this file.

#ifndef TDLS_SOLVERS_OPTIONS_HPP
#define TDLS_SOLVERS_OPTIONS_HPP
 
 
 
 
 
 
#include <type_traits>
 
#include <tdls/core/macros.hpp>
#include <tdls/core/target.hpp>
 
#if defined(TDLS_DETAIL_SIDE_DISPATCH)
#include <nv/target>
#endif
 
 
 
namespace tdls {
 
 
 
enum class Schedule {
    RightLooking, 
    LeftLooking   
};
 
 
 
enum class RowInterchange {
    Logical,  
    Physical, 
    Auto
};
 
namespace detail {
 
template<typename T, bool gpu>
[[nodiscard]] TDLS_HOST_DEVICE constexpr bool physical_rows_fit_on(const int n) noexcept {
    if constexpr (gpu)
        return sizeof(T) <= 4 ? n <= 14 : n <= 10;
    else
        return sizeof(T) <= 4 ? n <= 8 : n <= 12;
}
 
template<typename T>
[[nodiscard]] TDLS_HOST_DEVICE constexpr bool physical_rows_fit(const int n) noexcept {
    return physical_rows_fit_on<T, TDLS_TARGET_GPU != 0>(n);
}
 
template<typename T, bool gpu>
[[nodiscard]] TDLS_HOST_DEVICE constexpr bool physical_rows_on(const RowInterchange r,
                                                               const int n) noexcept {
    return r == RowInterchange::Physical ||
           (r == RowInterchange::Auto && physical_rows_fit_on<T, gpu>(n));
}
 
template<typename T>
[[nodiscard]] TDLS_HOST_DEVICE constexpr bool physical_rows(const RowInterchange r,
                                                            const int n) noexcept {
    return physical_rows_on<T, TDLS_TARGET_GPU != 0>(r, n);
}
 
#if defined(TDLS_DETAIL_SIDE_DISPATCH)
TDLS_HOST_DEVICE inline bool on_device_side() noexcept {
    NV_IF_TARGET(NV_IS_DEVICE, (return true;), (return false;))
}
#endif
 
template<typename T>
[[nodiscard]] TDLS_HOST_DEVICE constexpr bool physical_rows_here(const RowInterchange r,
                                                                 const int n) noexcept {
#if defined(TDLS_DETAIL_SIDE_DISPATCH)
    if (!std::is_constant_evaluated())
        return on_device_side() ? physical_rows_on<T, true>(r, n)
                                : physical_rows_on<T, false>(r, n);
#endif
    return physical_rows<T>(r, n);
}
 
} // namespace detail
 
 
 
inline constexpr int dynamic_stride = -1;
 
namespace detail {
 
template<int s>
[[nodiscard]] TDLS_HOST_DEVICE TDLS_FORCE_INLINE_ALL constexpr int
stride_or(const int runtime) noexcept {
    static_assert(s == dynamic_stride || s >= 1,
                  "tdls: a compile-time stride must be tdls::dynamic_stride or positive");
    if constexpr (s == dynamic_stride)
        return runtime;
    else
        return s;
}
 
template<int... s>
inline constexpr bool any_static_stride = ((s != dynamic_stride) || ...);
 
} // namespace detail
 
 
 
enum class MatrixLayout {
    RowMajor, 
    ColMajor  
};
 
 
 
} // namespace tdls
 
 
 
#endif // TDLS_SOLVERS_OPTIONS_HPP