dense_cache.hpp

// SPDX-FileCopyrightText: 2017 - 2025 The Ginkgo authors
//
// SPDX-License-Identifier: BSD-3-Clause
 
#ifndef GKO_PUBLIC_CORE_BASE_DENSE_CACHE_HPP_
#define GKO_PUBLIC_CORE_BASE_DENSE_CACHE_HPP_
 
 
#include <map>
#include <memory>
#include <string>
 
#include <ginkgo/core/base/array.hpp>
#include <ginkgo/core/base/dim.hpp>
#include <ginkgo/core/base/executor.hpp>
 
 
namespace gko {
 
 
class LinOp;
 
 
namespace matrix {
 
 
template <typename ValueType>
class Dense;
 
 
}
 
 
namespace detail {
 
 
template <typename ValueType>
struct DenseCache {
    DenseCache() = default;
    ~DenseCache() = default;
    DenseCache(const DenseCache&) {}
    DenseCache(DenseCache&&) noexcept {}
    DenseCache& operator=(const DenseCache&) { return *this; }
    DenseCache& operator=(DenseCache&&) noexcept { return *this; }
    mutable std::unique_ptr<matrix::Dense<ValueType>> vec{};
 
 
    void init_from(const matrix::Dense<ValueType>* template_vec) const;
 
    void init(std::shared_ptr<const Executor> exec, dim<2> size) const;
 
    matrix::Dense<ValueType>& operator*() const { return *vec; }
 
    matrix::Dense<ValueType>* operator->() const { return vec.get(); }
 
    matrix::Dense<ValueType>* get() const { return vec.get(); }
};
 
 
// helper to access private member for testing
class GenericDenseCacheAccessor;
 
 
struct GenericDenseCache {
    friend class GenericDenseCacheAccessor;
 
    GenericDenseCache() = default;
    ~GenericDenseCache() = default;
    GenericDenseCache(const GenericDenseCache&);
    GenericDenseCache(GenericDenseCache&&) noexcept;
    GenericDenseCache& operator=(const GenericDenseCache&);
    GenericDenseCache& operator=(GenericDenseCache&&) noexcept;
 
    template <typename ValueType>
    std::shared_ptr<matrix::Dense<ValueType>> get(
        std::shared_ptr<const Executor> exec, dim<2> size) const;
 
private:
    mutable array<char> workspace;
};
 
 
// helper to access private member for testing.
class ScalarCacheAccessor;
 
 
struct ScalarCache {
    friend class ScalarCacheAccessor;
 
    ScalarCache(std::shared_ptr<const Executor> executor, double scalar_value);
    ~ScalarCache() = default;
    ScalarCache(const ScalarCache& other);
    ScalarCache(ScalarCache&& other) noexcept;
    ScalarCache& operator=(const ScalarCache& other);
    ScalarCache& operator=(ScalarCache&& other) noexcept;
 
    template <typename ValueType>
    std::shared_ptr<const matrix::Dense<ValueType>> get() const;
 
private:
    std::shared_ptr<const Executor> exec;
    double value;
    mutable std::map<std::string, std::shared_ptr<const gko::LinOp>> scalars;
};
 
 
}  // namespace detail
}  // namespace gko
 
 
#endif  // GKO_PUBLIC_CORE_BASE_DENSE_CACHE_HPP_