versions.hpp

Go to the documentation of this file.

#pragma once
#ifndef CUDA_API_WRAPPERS_VERSIONS_HPP_
#define CUDA_API_WRAPPERS_VERSIONS_HPP_

#include "error.hpp"

#if CUDA_VERSION >= 12040
#include <nvFatbin.h>
#endif

#include <ostream>
#include <utility>
#include <limits>


namespace cuda {

using combined_version_t = int;

struct version_t {
    int major;
    int minor;

    static version_t from_single_number(combined_version_t combined_version) noexcept
    {
        return { combined_version / 1000, (combined_version % 100) / 10 };
    }

    operator ::std::pair<int, int>() const noexcept { return { major, minor }; }
};

inline ::std::ostream& operator<<(::std::ostream& os, version_t v)
{
    return os << v.major << '.' << v.minor;
}

// Note: All of comparison operators in this can be made constexpr in C++14

inline bool operator==(const version_t& lhs, const version_t& rhs) noexcept
{
    return lhs.operator ::std::pair<int, int>() == rhs.operator ::std::pair<int, int>();
}

inline bool operator!=(const version_t& lhs, const version_t& rhs) noexcept
{
    return lhs.operator ::std::pair<int, int>() != rhs.operator ::std::pair<int, int>();
}

inline bool operator<(const version_t& lhs, const version_t& rhs) noexcept
{
    return lhs.operator ::std::pair<int, int>() < rhs.operator ::std::pair<int, int>();
}

inline bool operator<=(const version_t& lhs, const version_t& rhs) noexcept
{
    return lhs.operator ::std::pair<int, int>() <= rhs.operator ::std::pair<int, int>();
}

inline bool operator>(const version_t& lhs, const version_t& rhs) noexcept
{
    return lhs.operator ::std::pair<int, int>() > rhs.operator ::std::pair<int, int>();
}

inline bool operator>=(const version_t& lhs, const version_t& rhs) noexcept
{
    return lhs.operator ::std::pair<int, int>() >= rhs.operator ::std::pair<int, int>();
}

// comparison with single integers - as major versions

inline bool operator==(const version_t& lhs, int rhs)  noexcept { return lhs == version_t::from_single_number(rhs); }
inline bool operator!=(const version_t& lhs, int rhs)  noexcept { return lhs != version_t::from_single_number(rhs); }
inline bool operator< (const version_t& lhs, int rhs)  noexcept { return lhs  < version_t::from_single_number(rhs); }
inline bool operator> (const version_t& lhs, int rhs)  noexcept { return lhs  > version_t::from_single_number(rhs); }
inline bool operator<=(const version_t& lhs, int rhs)  noexcept { return lhs <= version_t::from_single_number(rhs); }
inline bool operator>=(const version_t& lhs, int rhs)  noexcept { return lhs >= version_t::from_single_number(rhs); }



namespace version_numbers {

constexpr version_t none() noexcept
{
    return { 0, 0 };
}

inline version_t make(combined_version_t combined_version) noexcept
{
    return version_t::from_single_number(combined_version);
}

inline version_t make(int major, int minor) noexcept
{
    return { major, minor };
}

inline version_t driver() {
    combined_version_t version;
    auto status = cuDriverGetVersion(&version);
    throw_if_error_lazy(status, "Failed obtaining the CUDA driver version");
    return version_t::from_single_number(version);
}

inline version_t runtime() {
    combined_version_t version;
    auto status = cudaRuntimeGetVersion(&version);
    throw_if_error_lazy(status, "Failed obtaining the CUDA runtime version");
    return version_t::from_single_number(version);
}

#if CUDA_VERSION >= 12040

inline version_t fatbin() {
    unsigned int major { 0 }, minor { 0 };

    auto status = nvFatbinVersion(&major, &minor);
    throw_if_error_lazy(status, "Failed obtaining the nvfatbin library version");
#ifndef NDEBUG
    if ((major == 0) or (major > ::std::numeric_limits<int>::max())
        or (minor == 0) or (minor > ::std::numeric_limits<int>::max())) {
        throw ::std::logic_error("Invalid version encountered: ("
            + ::std::to_string(major) + ", " + ::std::to_string(minor) + ')' );
    }
#endif
    return version_t{ static_cast<int>(major), static_cast<int>(minor) };
}
#endif // CUDA_VERSION >= 12040

} // namespace version_numbers
} // namespace cuda

#endif // CUDA_API_WRAPPERS_VERSIONS_HPP_