misc.hpp

 
#pragma once
 
#include <algorithm>
#include <chrono>
#include <cmath>
#include <concepts>
#include <cstdlib>
#include <functional>
#include <memory>
#include <ranges>
#include <source_location>
#include <stdexcept>
#include <type_traits>
#include <utility>
#include <vector>
 
#include <cuda_runtime_api.h>
 
namespace rapidsmpf {
 
#define RAPIDSMPF_CUDA_VERSION_AT_LEAST(version) (CUDART_VERSION >= version)
 
using Clock = std::chrono::high_resolution_clock;
using Duration = std::chrono::duration<double>;
using TimePoint = std::chrono::time_point<Clock, Duration>;
 
template <typename MapType>
std::pair<typename MapType::key_type, typename MapType::mapped_type> extract_item(
    MapType& map, typename MapType::const_iterator position
) {
    auto node = map.extract(position);
    if (!node) {
        throw std::out_of_range("Invalid iterator passed to extract");
    }
    return {std::move(node.key()), std::move(node.mapped())};
}
 
template <typename MapType>
std::pair<typename MapType::key_type, typename MapType::mapped_type> extract_item(
    MapType& map, typename MapType::key_type const& key
) {
    auto node = map.extract(key);
    if (!node) {
        throw std::out_of_range("Invalid key passed to extract");
    }
    return {std::move(node.key()), std::move(node.mapped())};
}
 
template <typename MapType>
typename MapType::mapped_type extract_value(
    MapType& map, typename MapType::key_type const& key
) {
    return std::move(extract_item(map, key).second);
}
 
template <typename MapType>
typename MapType::mapped_type extract_value(
    MapType& map, typename MapType::const_iterator position
) {
    return std::move(extract_item(map, position).second);
}
 
template <typename MapType>
typename MapType::key_type extract_key(
    MapType& map, typename MapType::key_type const& key
) {
    return std::move(extract_item(map, key).first);
}
 
template <typename MapType>
typename MapType::key_type extract_key(
    MapType& map, typename MapType::const_iterator position
) {
    return std::move(extract_item(map, position).first);
}
 
template <typename MapType>
auto to_vector(MapType&& map) {
    using ValueType = typename std::remove_reference_t<MapType>::mapped_type;
    std::vector<ValueType> vec;
    vec.reserve(map.size());
    for (auto&& [key, value] : map) {
        vec.push_back(std::move(value));
    }
    return vec;
}
 
bool is_running_under_valgrind();
 
template <typename T>
constexpr T safe_div(T x, T y) {
    return (y == 0) ? 0 : x / y;
}
 
template <std::integral T>
constexpr T ceil_div(T x, T y) {
    return x / y + (x % y != 0 ? T{1} : T{0});
}
 
[[nodiscard]] inline auto chunk_indices(std::size_t count, std::size_t num_chunks) {
    std::size_t const chunk_size = ceil_div(count, num_chunks);
    return std::views::iota(std::size_t{0}, num_chunks)
           | std::views::transform([count, chunk_size](std::size_t k) {
                 return std::pair<std::size_t, std::size_t>{
                     std::min(k * chunk_size, count),
                     std::min((k + 1) * chunk_size, count)
                 };
             });
}
 
// Macro to concatenate two tokens x and y.
#define RAPIDSMPF_CONCAT_DETAIL_(x, y) x##y
#define RAPIDSMPF_CONCAT(x, y) RAPIDSMPF_CONCAT_DETAIL_(x, y)
 
// Stringify a macro argument.
#define RAPIDSMPF_STRINGIFY_DETAIL_(x) #x
#define RAPIDSMPF_STRINGIFY(x) RAPIDSMPF_STRINGIFY_DETAIL_(x)
 
#define RAPIDSMPF_OVERLOAD_BY_ARG_COUNT(_1, _2, NAME, ...) NAME
 
namespace detail {
 
template <typename T>
constexpr T* to_pointer(T* ptr) noexcept {
    return ptr;
}
 
template <typename T>
constexpr T* to_pointer(T& ptr) noexcept {
    return std::addressof(ptr);
}
 
template <typename T>
constexpr T* to_pointer(std::unique_ptr<T>& ptr) noexcept {
    return ptr.get();
}
 
template <typename T>
constexpr T* to_pointer(std::shared_ptr<T>& ptr) noexcept {
    return ptr.get();
}
 
}  // namespace detail
 
template <class... Ts>
struct overloaded : Ts... {
    using Ts::operator()...;
};
 
template <std::ranges::input_range R, typename T, typename Proj = std::identity>
[[nodiscard]] constexpr bool contains(R&& range, T const& value, Proj proj = {}) {
    for (auto const& elem : range) {
        if (std::invoke(proj, elem) == value) {
            return true;
        }
    }
    return false;
}
 
template <typename T>
concept SharedOrWeakPtr = requires {
    typename T::element_type;
    requires std::same_as<T, std::shared_ptr<typename T::element_type>>
                 || std::same_as<T, std::weak_ptr<typename T::element_type>>;
};
 
template <SharedOrWeakPtr A, SharedOrWeakPtr B>
    requires std::same_as<typename A::element_type, typename B::element_type>
[[nodiscard]] constexpr bool owner_equal(A const& a, B const& b) noexcept {
    return !a.owner_before(b) && !b.owner_before(a);
}
 
template <typename To, typename From>
    requires std::is_arithmetic_v<To> && std::is_arithmetic_v<From>
constexpr To safe_cast(
    From value, std::source_location const& loc = std::source_location::current()
) {
    if constexpr (std::is_same_v<From, To>) {
        // Same type, no-op.
        return value;
    } else if constexpr (std::is_integral_v<From> && std::is_integral_v<To>) {
        // Integer to integer.
        if (!std::in_range<To>(value)) {
            throw std::overflow_error(
                "RapidsMPF cast error at: " + std::string(loc.file_name()) + ":"
                + std::to_string(loc.line())
                + ", value out of range (value=" + std::to_string(value) + ")"
            );
        }
        return static_cast<To>(value);
    } else {
        // Floating point conversions: direct cast (well-defined overflow behavior).
        return static_cast<To>(value);
    }
}
 
}  // namespace rapidsmpf