vector_cache.hpp

// SPDX-FileCopyrightText: 2017 - 2025 The Ginkgo authors
//
// SPDX-License-Identifier: BSD-3-Clause
 
#ifndef GKO_PUBLIC_CORE_DISTRIBUTED_VECTOR_CACHE_HPP_
#define GKO_PUBLIC_CORE_DISTRIBUTED_VECTOR_CACHE_HPP_
 
 
#include <memory>
 
#include <ginkgo/config.hpp>
#include <ginkgo/core/base/executor.hpp>
#include <ginkgo/core/base/mpi.hpp>
#include <ginkgo/core/distributed/vector.hpp>
 
 
#if GINKGO_BUILD_MPI
 
 
namespace gko {
namespace experimental {
namespace distributed {
namespace detail {
 
 
template <typename ValueType>
class VectorCache {
public:
    VectorCache() = default;
    ~VectorCache() = default;
    VectorCache(const VectorCache&) {}
    VectorCache(VectorCache&&) noexcept {}
    VectorCache& operator=(const VectorCache&) { return *this; }
    VectorCache& operator=(VectorCache&&) noexcept { return *this; }
    mutable std::unique_ptr<Vector<ValueType>> vec{};
 
 
    void init_from(const Vector<ValueType>* template_vec) const;
 
    void init(std::shared_ptr<const Executor> exec,
              gko::experimental::mpi::communicator comm, dim<2> global_size,
              dim<2> local_size) const;
 
    Vector<ValueType>& operator*() const { return *vec; }
 
    Vector<ValueType>* operator->() const { return vec.get(); }
 
    Vector<ValueType>* get() const { return vec.get(); }
};
 
 
// helper to access private member for testing
class GenericVectorCacheAccessor;
 
 
class GenericVectorCache {
public:
    friend class GenericVectorCacheAccessor;
 
    GenericVectorCache() = default;
    ~GenericVectorCache() = default;
    GenericVectorCache(const GenericVectorCache&);
    GenericVectorCache(GenericVectorCache&&) noexcept;
    GenericVectorCache& operator=(const GenericVectorCache&);
    GenericVectorCache& operator=(GenericVectorCache&&) noexcept;
 
    template <typename ValueType>
    std::shared_ptr<Vector<ValueType>> get(
        std::shared_ptr<const Executor> exec,
        gko::experimental::mpi::communicator comm, dim<2> global_size,
        dim<2> local_size) const;
 
private:
    mutable array<char> workspace;
};
 
 
}  // namespace detail
}  // namespace distributed
}  // namespace experimental
}  // namespace gko
 
 
#endif  // GINKGO_BUILD_MPI
#endif  // GKO_PUBLIC_CORE_DISTRIBUTED_VECTOR_CACHE_HPP_