temporary_clone.hpp

// SPDX-FileCopyrightText: 2017 - 2024 The Ginkgo authors
//
// SPDX-License-Identifier: BSD-3-Clause
 
#ifndef GKO_PUBLIC_CORE_BASE_TEMPORARY_CLONE_HPP_
#define GKO_PUBLIC_CORE_BASE_TEMPORARY_CLONE_HPP_
 
 
#include <functional>
#include <memory>
#include <type_traits>
 
#include <ginkgo/core/base/exception_helpers.hpp>
#include <ginkgo/core/base/executor.hpp>
#include <ginkgo/core/base/utils_helper.hpp>
 
 
namespace gko {
namespace detail {
 
 
template <typename T>
class copy_back_deleter {
public:
    using pointer = T*;
 
    copy_back_deleter(pointer original) : original_{original} {}
 
    void operator()(pointer ptr) const
    {
        original_->copy_from(ptr);
        delete ptr;
    }
 
private:
    pointer original_;
};
 
// specialization for constant objects, no need to copy back something that
// cannot change
template <typename T>
class copy_back_deleter<const T> {
public:
    using pointer = const T*;
    copy_back_deleter(pointer original) : original_{original} {}
 
    void operator()(pointer ptr) const { delete ptr; }
 
private:
    pointer original_;
};
 
 
// specialization for copy back via assignment
template <typename T>
class copy_back_deleter_from_assignment {
public:
    using pointer = T*;
 
    copy_back_deleter_from_assignment(pointer original) : original_{original} {}
 
    void operator()(pointer ptr) const
    {
        *original_ = *ptr;
        delete ptr;
    }
 
private:
    pointer original_;
};
 
 
template <typename T>
struct temporary_clone_helper {
    static std::unique_ptr<T> create(std::shared_ptr<const Executor> exec,
                                     T* ptr, bool)
    {
        return gko::clone(std::move(exec), ptr);
    }
};
 
 
template <typename T>
class temporary_clone {
public:
    using value_type = T;
    using pointer = T*;
 
    explicit temporary_clone(std::shared_ptr<const Executor> exec,
                             ptr_param<T> ptr, bool copy_data = true)
    {
        if (ptr->get_executor()->memory_accessible(exec)) {
            // just use the object we already have
            handle_ = handle_type(ptr.get(), null_deleter<T>());
        } else {
            // clone the object to the new executor and make sure it's copied
            // back before we delete it
            handle_ = handle_type(temporary_clone_helper<T>::create(
                                      std::move(exec), ptr.get(), copy_data)
                                      .release(),
                                  copy_back_deleter<T>(ptr.get()));
        }
    }
 
    T* get() const { return handle_.get(); }
 
    T* operator->() const { return handle_.get(); }
 
    T& operator*() const { return *handle_; }
 
private:
    // std::function deleter allows to decide the (type of) deleter at runtime
    using handle_type = std::unique_ptr<T, std::function<void(T*)>>;
 
    handle_type handle_;
};
 
 
}  // namespace detail
 
 
template <typename T>
struct err {};
 
template <typename Ptr>
detail::temporary_clone<detail::pointee<Ptr>> make_temporary_clone(
    std::shared_ptr<const Executor> exec, Ptr&& ptr)
{
    using T = detail::pointee<Ptr>;
    return detail::temporary_clone<T>(std::move(exec), std::forward<Ptr>(ptr));
}
 
 
template <typename Ptr>
detail::temporary_clone<detail::pointee<Ptr>> make_temporary_output_clone(
    std::shared_ptr<const Executor> exec, Ptr&& ptr)
{
    using T = detail::pointee<Ptr>;
    static_assert(
        !std::is_const<T>::value,
        "make_temporary_output_clone should only be used on non-const objects");
    return detail::temporary_clone<T>(std::move(exec), std::forward<Ptr>(ptr),
                                      false);
}
 
 
}  // namespace gko
 
 
#endif  // GKO_PUBLIC_CORE_BASE_TEMPORARY_CLONE_HPP_