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"

#include <ostream>
#include <utility>

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);
        // The same value would be returned using cuDriverGetVersion()
    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);
}

} // namespace version_numbers
} // namespace cuda

#endif // CUDA_API_WRAPPERS_VERSIONS_HPP_