cudss.hpp

// SPDX-FileCopyrightText: 2017 - 2026 The Ginkgo authors
//
// SPDX-License-Identifier: BSD-3-Clause
 
#ifndef GKO_PUBLIC_EXTENSIONS_CUDA_SOLVER_CUDSS_HPP_
#define GKO_PUBLIC_EXTENSIONS_CUDA_SOLVER_CUDSS_HPP_
 
 
#include <complex>
#include <memory>
#include <type_traits>
 
#include <ginkgo/core/base/lin_op.hpp>
#include <ginkgo/core/base/types.hpp>
#include <ginkgo/core/config/config.hpp>
#include <ginkgo/core/config/registry.hpp>
 
 
namespace gko {
namespace ext {
namespace cuda {
namespace solver {
 
 
namespace detail {
 
 
template <typename T>
struct is_cudss_supported_value_type : std::false_type {};
 
template <>
struct is_cudss_supported_value_type<float> : std::true_type {};
template <>
struct is_cudss_supported_value_type<double> : std::true_type {};
template <>
struct is_cudss_supported_value_type<std::complex<float>> : std::true_type {};
template <>
struct is_cudss_supported_value_type<std::complex<double>> : std::true_type {};
 
 
}  // namespace detail
 
 
#define GKO_EXT_CUDSS_ASSERT_SUPPORTED_VALUE_TYPE                        \
    static_assert(                                                       \
        ::gko::ext::cuda::solver::detail::is_cudss_supported_value_type< \
            ValueType>::value,                                           \
        "cuDSS only supports float, double, std::complex<float>, and "   \
        "std::complex<double> value types")
 
 
template <typename ValueType, typename IndexType = int32>
class Cudss : public LinOp {
    GKO_EXT_CUDSS_ASSERT_SUPPORTED_VALUE_TYPE;
    GKO_ASSERT_SUPPORTED_INDEX_TYPE;
 
public:
    using value_type = ValueType;
    using index_type = IndexType;
 
    class Factory;
 
    struct parameters_type : enable_parameters_type<parameters_type, Factory> {
        int GKO_FACTORY_PARAMETER_SCALAR(matrix_type, 0);
 
        int GKO_FACTORY_PARAMETER_SCALAR(matrix_view, 0);
 
        int GKO_FACTORY_PARAMETER_SCALAR(reordering_alg, 0);
 
        bool GKO_FACTORY_PARAMETER_SCALAR(hybrid_execute, false);
 
        bool GKO_FACTORY_PARAMETER_SCALAR(hybrid_memory, false);
    };
    GKO_ENABLE_LIN_OP_FACTORY(Cudss, parameters, Factory);
    GKO_ENABLE_BUILD_METHOD(Factory);
 
    static parameters_type parse(
        const config::pnode& config, const config::registry& context,
        const config::type_descriptor& td_for_child =
            config::make_type_descriptor<ValueType, IndexType>());
 
    static config::configuration_map get_config_map();
 
    Cudss(const Cudss&);
 
    Cudss(Cudss&&) noexcept;
 
    Cudss& operator=(const Cudss&);
 
    Cudss& operator=(Cudss&&) noexcept;
 
    void refactorize(std::shared_ptr<const LinOp> new_matrix);
 
protected:
    explicit Cudss(std::shared_ptr<const Executor> exec);
 
    Cudss(const Factory* factory, std::shared_ptr<const LinOp> system_matrix);
 
    void apply_impl(const LinOp* b, LinOp* x) const override;
 
    void apply_impl(const LinOp* alpha, const LinOp* b, const LinOp* beta,
                    LinOp* x) const override;
 
private:
    struct state;
    // system_matrix_ must be declared before state_ so that the CSR data
    // is destroyed after the cuDSS handles that reference it via zero-copy.
    std::shared_ptr<const LinOp> system_matrix_;
    std::shared_ptr<state> state_;
};
 
 
}  // namespace solver
}  // namespace cuda
}  // namespace ext
}  // namespace gko
 
 
#endif  // GKO_PUBLIC_EXTENSIONS_CUDA_SOLVER_CUDSS_HPP_