/__w/rapidsmpf/rapidsmpf/cpp/include/rapidsmpf/utils.hpp

Parses a string into a value of type T.This function attempts to parse the given string into a value of the specified type T using a std::stringstream. If the parsing fails, an exception is thrown.

Template Parameters

T	The type to parse the string into. Must support extraction from std::istream via operator>>.

Parameters

value

The input string to parse.

Returns

T The parsed value of type T.

Exceptions

std::invalid_argument

If the string cannot be parsed into the requested type.

Note

This function assumes that the input string contains a valid representation of type T, and that T has a suitable operator>> overload.

int i = parse_string<int>("42"); // i == 42 double d = parse_string<double>("3.14"); // d == 3.14

 
#pragma once
 
#include <array>
#include <chrono>
#include <cmath>
#include <cstdlib>
#include <memory>
#include <sstream>
#include <string>
#include <type_traits>
#include <utility>
#include <vector>
 
#include <cuda.h>
#include <cuda_runtime_api.h>
 
namespace rapidsmpf {
 
using Clock = std::chrono::high_resolution_clock;
using Duration = std::chrono::duration<double>;
 
template <typename T>
std::string to_precision(T value, int precision = 2) {
    std::stringstream ss;
    ss.precision(precision);
    ss << std::fixed;
    ss << value;
    return ss.str();
}
 
std::string inline format_nbytes(double nbytes, int precision = 2) {
    constexpr std::array<const char*, 6> units = {" B", " KiB", " MiB", " GiB", " TiB"};
    double n = nbytes;
    for (auto const& unit : units) {
        if (std::abs(n) < 1024.0) {
            return to_precision(n, precision) + unit;
        }
        n /= 1024.0;
    }
    return to_precision(n, precision) + " PiB";
}
 
std::string inline format_duration(double seconds, int precision = 2) {
    double sec = std::abs(seconds);
    if (sec < 1e-6) {
        return to_precision(seconds * 1e9, precision) + " ns";
    } else if (sec < 1e-3) {
        return to_precision(seconds * 1e6, precision) + " us";
    } else if (sec < 1) {
        return to_precision(seconds * 1e3, precision) + " ms";
    } else {
        return to_precision(seconds, precision) + " s";
    }
}
 
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;
}
 
std::string trim(std::string const& str);
 
std::string to_lower(std::string str);
 
std::string to_upper(std::string str);
 
template <typename T>
T parse_string(std::string const& value) {
    std::stringstream sstream(value);
    T ret;
    sstream >> ret;
    if (sstream.fail()) {
        throw std::invalid_argument("cannot parse \"" + std::string{value} + "\"");
    }
    return ret;
}
 
template <>
bool parse_string(std::string const& value);
 
// 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()...;
};
 
#define RAPIDSMPF_CUDA_VERSION_AT_LEAST(version) (CUDART_VERSION >= version)
 
 
int get_current_numa_node_id();
 
}  // namespace rapidsmpf