version.hpp

// SPDX-FileCopyrightText: 2017 - 2024 The Ginkgo authors
//
// SPDX-License-Identifier: BSD-3-Clause
 
#ifndef GKO_PUBLIC_CORE_BASE_VERSION_HPP_
#define GKO_PUBLIC_CORE_BASE_VERSION_HPP_
 
 
#include <ostream>
 
 
#include <ginkgo/config.hpp>
#include <ginkgo/core/base/types.hpp>
 
 
namespace gko {
 
 
struct version {
    constexpr version(const uint64 major, const uint64 minor,
                      const uint64 patch, const char* tag)
        : major{major}, minor{minor}, patch{patch}, tag{tag}
    {}
 
    const uint64 major;
 
    const uint64 minor;
 
    const uint64 patch;
 
    const char* const tag;
};
 
inline bool operator==(const version& first, const version& second)
{
    return first.major == second.major && first.minor == second.minor &&
           first.patch == second.patch;
}
 
inline bool operator!=(const version& first, const version& second)
{
    return !(first == second);
}
 
inline bool operator<(const version& first, const version& second)
{
    if (first.major < second.major) return true;
    if (first.major == second.major && first.minor < second.minor) return true;
    if (first.major == second.major && first.minor == second.minor &&
        first.patch < second.patch)
        return true;
    return false;
}
 
inline bool operator<=(const version& first, const version& second)
{
    return !(second < first);
}
 
inline bool operator>(const version& first, const version& second)
{
    return second < first;
}
 
inline bool operator>=(const version& first, const version& second)
{
    return !(first < second);
}
 
#undef GKO_ENABLE_VERSION_COMPARISON
 
 
inline std::ostream& operator<<(std::ostream& os, const version& ver)
{
    os << ver.major << "." << ver.minor << "." << ver.patch;
    if (ver.tag) {
        os << " (" << ver.tag << ")";
    }
    return os;
}
 
 
class version_info {
public:
    static const version_info& get()
    {
        static version_info info{};
        return info;
    }
 
    version header_version;
 
    version core_version;
 
    version reference_version;
 
    version omp_version;
 
    version cuda_version;
 
    version hip_version;
 
    version dpcpp_version;
 
private:
    static constexpr version get_header_version() noexcept
    {
        return version{GKO_VERSION_MAJOR, GKO_VERSION_MINOR, GKO_VERSION_PATCH,
                       GKO_VERSION_TAG};
    }
 
    static version get_core_version() noexcept;
 
    static version get_reference_version() noexcept;
 
    static version get_omp_version() noexcept;
 
    static version get_cuda_version() noexcept;
 
    static version get_hip_version() noexcept;
 
    static version get_dpcpp_version() noexcept;
 
    version_info()
        : header_version{get_header_version()},
          core_version{get_core_version()},
          reference_version{get_reference_version()},
          omp_version{get_omp_version()},
          cuda_version{get_cuda_version()},
          hip_version{get_hip_version()},
          dpcpp_version{get_dpcpp_version()}
    {}
};
 
 
std::ostream& operator<<(std::ostream& os, const version_info& ver_info);
 
 
}  // namespace gko
 
 
#endif  // GKO_PUBLIC_CORE_BASE_VERSION_HPP_