base_temporary_expr.hpp

//=======================================================================
// Copyright (c) 2014-2023 Baptiste Wicht
// Distributed under the terms of the MIT License.
// (See accompanying file LICENSE or copy at
//  http://opensource.org/licenses/MIT)
//=======================================================================

#pragma once

#include <memory> //For shared_ptr

#include "etl/concepts.hpp"
#include "etl/iterator.hpp"

namespace etl {

namespace temporary_detail {

template <typename E, bool Fast>
struct expr_result;

template <typename E>
struct expr_result<E, false> {
    using type = dyn_matrix_impl<typename decay_traits<E>::value_type, decay_traits<E>::storage_order, decay_traits<E>::dimensions()>;
};

template <typename E>
struct expr_result<E, true> {
    using type = typename detail::build_fast_dyn_matrix_type<E, std::make_index_sequence<decay_traits<E>::dimensions()>>::type;
};

template <bool Fast, typename E>
using expr_result_t = typename expr_result<E, Fast && is_fast<E>>::type;

} // namespace temporary_detail

template <typename D, bool Fast>
struct base_temporary_expr : value_testable<D>, dim_testable<D>, iterable<const D, true> {
    using derived_t         = D;                                        
    using value_type        = typename decay_traits<D>::value_type;     
    using result_type       = temporary_detail::expr_result_t<Fast, D>; 
    using memory_type       = value_type*;                              
    using const_memory_type = const value_type*;                        

protected:
    mutable std::shared_ptr<bool> evaluated; 
    mutable std::shared_ptr<result_type> _c; 

public:
    base_temporary_expr() : evaluated(std::make_shared<bool>(false)) {
        // Nothing else to init
    }

    base_temporary_expr(const base_temporary_expr& expr) = default;

    base_temporary_expr(base_temporary_expr&& rhs) : evaluated(std::move(rhs.evaluated)), _c(std::move(rhs._c)) {
        //Nothing else to change
    }

    //Expressions are invariant
    base_temporary_expr& operator=(const base_temporary_expr& /*e*/) = delete;
    base_temporary_expr& operator=(base_temporary_expr&& /*e*/) = delete;

    template <typename VV = default_vec>
    using vec_type = typename VV::template vec_type<value_type>;

protected:
    derived_t& as_derived() noexcept {
        return *static_cast<derived_t*>(this);
    }

    const derived_t& as_derived() const noexcept {
        return *static_cast<const derived_t*>(this);
    }

    bool is_allocated() const noexcept {
        return _c.get();
    }

    bool is_evaluated() const noexcept {
        return *evaluated;
    }

protected:
    void evaluate() const {
        if (!*evaluated) {
            cpp_assert(is_allocated(), "The result has not been allocated");
            as_derived().assign_to(*_c);
            *evaluated = true;
        }
    }

    void allocate_temporary() const {
        if (!_c) {
            _c.reset(allocate());
        }
    }

    template <size_t... I>
    result_type* dyn_allocate(std::index_sequence<I...> /*seq*/) const {
        return new result_type(decay_traits<derived_t>::dim(as_derived(), I)...);
    }

    result_type* allocate() const {
        if constexpr (is_fast<derived_t>) {
            return new result_type;
        } else {
            return dyn_allocate(std::make_index_sequence<decay_traits<derived_t>::dimensions()>());
        }
    }

public:
    //Apply the expression

    value_type operator[](size_t i) const {
        return result()[i];
    }

    value_type read_flat(size_t i) const {
        return result().read_flat(i);
    }

    template <size_c... S>
    value_type operator()(S... args) const requires(sizeof...(S) == safe_dimensions<derived_t>) {
        return result()(args...);
    }

    auto operator()(size_t i) const requires sub_capable<derived_t> {
        return sub(as_derived(), i);
    }

    auto slice(size_t first, size_t last) noexcept {
        return slice(*this, first, last);
    }

    auto slice(size_t first, size_t last) const noexcept {
        return slice(*this, first, last);
    }

    template <typename VV = default_vec>
    vec_type<VV> load(size_t i) const noexcept {
        return VV::loadu(memory_start() + i);
    }

    template <typename VV = default_vec>
    vec_type<VV> loadu(size_t i) const noexcept {
        return VV::loadu(memory_start() + i);
    }

    template <typename Y>
    auto& gpu_compute_hint(Y& y) {
        cpu_unused(y);
        this->ensure_gpu_up_to_date();
        return as_derived();
    }

    template <typename Y>
    const auto& gpu_compute_hint(Y& y) const {
        cpu_unused(y);
        this->ensure_gpu_up_to_date();
        return as_derived();
    }

    // Direct memory access

    memory_type memory_start() noexcept {
        return result().memory_start();
    }

    const_memory_type memory_start() const noexcept {
        return result().memory_start();
    }

    memory_type memory_end() noexcept {
        return result().memory_end();
    }

    const_memory_type memory_end() const noexcept {
        return result().memory_end();
    }

    value_type* gpu_memory() const noexcept {
        return result().gpu_memory();
    }

    void gpu_evict() const noexcept {
        result().gpu_evict();
    }

    void invalidate_cpu() const noexcept {
        result().invalidate_cpu();
    }

    void invalidate_gpu() const noexcept {
        result().invalidate_gpu();
    }

    void validate_cpu() const noexcept {
        result().validate_cpu();
    }

    void validate_gpu() const noexcept {
        result().validate_gpu();
    }

    void ensure_gpu_allocated() const {
        result().ensure_gpu_allocated();
    }

    void ensure_gpu_up_to_date() const {
        result().ensure_gpu_up_to_date();
    }

    void ensure_cpu_up_to_date() const {
        result().ensure_cpu_up_to_date();
    }

    void gpu_copy_from(const value_type* gpu_memory) const {
        result().gpu_copy_from(gpu_memory);
    }

    bool is_cpu_up_to_date() const noexcept {
        return result().is_cpu_up_to_date();
    }

    bool is_gpu_up_to_date() const noexcept {
        return result().is_gpu_up_to_date();
    }

protected:
    result_type& result() {
        cpp_assert(is_allocated(), "The result has not been allocated");
        cpp_assert(*evaluated, "The result has not been evaluated");
        return *_c;
    }

    const result_type& result() const {
        cpp_assert(is_allocated(), "The result has not been allocated");
        cpp_assert(*evaluated, "The result has not been evaluated");
        return *_c;
    }
};

template <typename D, etl_expr A, bool Fast = true>
struct base_temporary_expr_un : base_temporary_expr<D, Fast> {
    using this_type = base_temporary_expr_un<D, A>; 
    using base_type = base_temporary_expr<D, Fast>; 

    A _a; 

    using base_type::evaluated;

    explicit base_temporary_expr_un(A a) : _a(a) {
        //Nothing else to init
    }

    base_temporary_expr_un(const base_temporary_expr_un& e) : base_type(e), _a(e._a) {
        //Nothing else to init
    }

    base_temporary_expr_un(base_temporary_expr_un&& e) noexcept : base_type(std::move(e)), _a(e._a) {
        //Nothing else to init
    }

    template <typename E>
    bool alias(const E& rhs) const {
        return _a.alias(rhs);
    }

    std::add_lvalue_reference_t<A> a() {
        return _a;
    }

    cpp::add_const_lvalue_t<A> a() const {
        return _a;
    }

    // Internals

    void visit(detail::evaluator_visitor& visitor) const {
        // If the expression is already evaluated, no need to
        // recurse through the tree
        if (*evaluated) {
            return;
        }

        this->allocate_temporary();

        _a.visit(visitor);

        this->evaluate();
    }
};

template <typename D, etl_expr A, etl_expr B, bool Fast = true>
struct base_temporary_expr_bin : base_temporary_expr<D, Fast> {
    using this_type = base_temporary_expr_bin<D, A, B>; 
    using base_type = base_temporary_expr<D, Fast>;     

    A _a; 
    B _b; 

    using base_type::evaluated;

    explicit base_temporary_expr_bin(A a, B b) : _a(a), _b(b) {
        //Nothing else to init
    }

    base_temporary_expr_bin(const base_temporary_expr_bin& e) : base_type(e), _a(e._a), _b(e._b) {
        //Nothing else to init
    }

    base_temporary_expr_bin(base_temporary_expr_bin&& e) noexcept : base_type(std::move(e)), _a(e._a), _b(e._b) {
        //Nothing else to init
    }

    template <typename E>
    bool alias(const E& rhs) const {
        return _a.alias(rhs) || _b.alias(rhs);
    }

    std::add_lvalue_reference_t<A> a() {
        return _a;
    }

    cpp::add_const_lvalue_t<A> a() const {
        return _a;
    }

    std::add_lvalue_reference_t<B> b() {
        return _b;
    }

    cpp::add_const_lvalue_t<B> b() const {
        return _b;
    }

    // Internals

    void visit(detail::evaluator_visitor& visitor) const {
        // If the expression is already evaluated, no need to
        // recurse through the tree
        if (*evaluated) {
            return;
        }

        this->allocate_temporary();

        _a.visit(visitor);
        _b.visit(visitor);

        this->evaluate();
    }
};

template <typename D, etl_expr A, etl_expr B, etl_expr C, bool Fast = true>
struct base_temporary_expr_tern : base_temporary_expr<D, Fast> {
    using this_type = base_temporary_expr_tern<D, A, B, C>; 
    using base_type = base_temporary_expr<D, Fast>;         

    A _a; 
    B _b; 
    C _c; 

    using base_type::evaluated;

public:
    base_temporary_expr_tern(A a, B b, C c) : _a(a), _b(b), _c(c) {
        //Nothing else to init
    }

    base_temporary_expr_tern(const base_temporary_expr_tern& e) : base_type(e), _a(e._a), _b(e._b), _c(e._c) {
        //Nothing else to init
    }

    base_temporary_expr_tern(base_temporary_expr_tern&& e) noexcept : base_type(std::move(e)), _a(e._a), _b(e._b), _c(e._c) {
        //Nothing else to init
    }

    template <typename E>
    bool alias(const E& rhs) const {
        return _a.alias(rhs) || _b.alias(rhs) || _c.alias(rhs);
    }

protected:
    std::add_lvalue_reference_t<A> a() {
        return _a;
    }

    cpp::add_const_lvalue_t<A> a() const {
        return _a;
    }

    std::add_lvalue_reference_t<B> b() {
        return _b;
    }

    cpp::add_const_lvalue_t<B> b() const {
        return _b;
    }

    std::add_lvalue_reference_t<C> c() {
        return _c;
    }

    cpp::add_const_lvalue_t<C> c() const {
        return _c;
    }

public:
    // Internals

    void visit(detail::evaluator_visitor& visitor) const {
        // If the expression is already evaluated, no need to
        // recurse through the tree
        if (*evaluated) {
            return;
        }

        this->allocate_temporary();

        _a.visit(visitor);
        _b.visit(visitor);
        _c.visit(visitor);

        this->evaluate();
    }
};

} //end of namespace etl