memory_slice_view.hpp

Go to the documentation of this file.

//=======================================================================
// 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

namespace etl {

template <typename T, bool Aligned>
struct memory_slice_view {
    using sub_type          = T;                                                                    
    using value_type        = value_t<sub_type>;                                                    
    using memory_type       = value_type*;                                                          
    using const_memory_type = const value_type*;                                                    
    using return_type       = return_helper<sub_type, decltype(std::declval<sub_type>()[0])>;       
    using const_return_type = const_return_helper<sub_type, decltype(std::declval<sub_type>()[0])>; 

private:
    T sub;              
    const size_t first; 
    const size_t last;  

    friend struct etl_traits<memory_slice_view>;

public:
    template <typename V = default_vec>
    using vec_type = typename V::template vec_type<value_type>;

    memory_slice_view(sub_type sub, size_t first, size_t last) : sub(sub), first(first), last(last) {}

    const_return_type operator[](size_t j) const {
        return sub[first + j];
    }

    return_type operator[](size_t j) {
        return sub[first + j];
    }

    value_type read_flat(size_t j) const noexcept {
        return sub[first + j];
    }

    template <typename V = default_vec>
    auto load(size_t x) const noexcept {
        if constexpr (Aligned) {
            return sub.template load<V>(x + first);
        } else {
            return sub.template loadu<V>(x + first);
        }
    }

    template <typename V = default_vec>
    auto loadu(size_t x) const noexcept {
        return sub.template loadu<V>(x + first);
    }

    template <typename V = default_vec>
    void store(vec_type<V> in, size_t i) noexcept {
        if constexpr (Aligned) {
            sub.template store<V>(in, first + i);
        } else {
            sub.template storeu<V>(in, first + i);
        }
    }

    template <typename V = default_vec>
    void storeu(vec_type<V> in, size_t i) noexcept {
        sub.template storeu<V>(in, first + i);
    }

    template <typename V = default_vec>
    void stream(vec_type<V> in, size_t i) noexcept {
        if constexpr (Aligned) {
            sub.template stream<V>(in, first + i);
        } else {
            sub.template storeu<V>(in, first + i);
        }
    }

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

    memory_type memory_start() noexcept {
        return sub.memory_start() + first;
    }

    const_memory_type memory_start() const noexcept {
        return sub.memory_start() + first;
    }

    memory_type memory_end() noexcept {
        return sub.memory_start() + last;
    }

    const_memory_type memory_end() const noexcept {
        return sub.memory_start() + last;
    }

    // Assignment functions

    template <typename L>
    void assign_to(L&& lhs) const {
        std_assign_evaluate(*this, std::forward<L>(lhs));
    }

    template <typename L>
    void assign_add_to(L&& lhs) const {
        std_add_evaluate(*this, std::forward<L>(lhs));
    }

    template <typename L>
    void assign_sub_to(L&& lhs) const {
        std_sub_evaluate(*this, std::forward<L>(lhs));
    }

    template <typename L>
    void assign_mul_to(L&& lhs) const {
        std_mul_evaluate(*this, std::forward<L>(lhs));
    }

    template <typename L>
    void assign_div_to(L&& lhs) const {
        std_div_evaluate(*this, std::forward<L>(lhs));
    }

    template <typename L>
    void assign_mod_to(L&& lhs) const {
        std_mod_evaluate(*this, std::forward<L>(lhs));
    }

    // Internals

    void visit(detail::evaluator_visitor& visitor) const {
        sub.visit(visitor);
    }

    void ensure_cpu_up_to_date() const {
        // The sub value must be ensured
        sub.ensure_cpu_up_to_date();
    }

    void ensure_gpu_up_to_date() const {
        // The sub value must be ensured
        sub.ensure_gpu_up_to_date();
    }
};

template <typename T, bool Aligned>
struct etl_traits<etl::memory_slice_view<T, Aligned>> {
    using expr_t     = etl::memory_slice_view<T, Aligned>;          
    using sub_expr_t = std::decay_t<T>;                             
    using value_type = typename etl_traits<sub_expr_t>::value_type; 

    static constexpr bool is_etl         = true;                                   
    static constexpr bool is_transformer = false;                                  
    static constexpr bool is_view        = true;                                   
    static constexpr bool is_magic_view  = false;                                  
    static constexpr bool is_fast        = false;                                  
    static constexpr bool is_linear      = etl_traits<sub_expr_t>::is_linear;      
    static constexpr bool is_thread_safe = etl_traits<sub_expr_t>::is_thread_safe; 
    static constexpr bool is_value       = false;                                  
    static constexpr bool is_direct      = etl_traits<sub_expr_t>::is_direct;      
    static constexpr bool is_generator   = false;                                  
    static constexpr bool is_padded      = false;                                  
    static constexpr bool is_aligned     = Aligned;                                
    static constexpr bool is_temporary   = etl_traits<sub_expr_t>::is_temporary;   
    static constexpr bool gpu_computable = false;                                  
    static constexpr order storage_order = etl_traits<sub_expr_t>::storage_order;  

    template <vector_mode_t V>
    static constexpr bool vectorizable = etl_traits<sub_expr_t>::template vectorizable<V>;

    static size_t size(const expr_t& v) {
        return v.last - v.first;
    }

    static size_t dim(const expr_t& v, [[maybe_unused]] size_t d) {
        return v.last - v.first;
    }

    static constexpr size_t dimensions() {
        return 1;
    }

    static constexpr int complexity() noexcept {
        return -1;
    }
};

template <bool Aligned = false, etl_expr E>
auto memory_slice(E&& value, size_t first, size_t last) -> detail::identity_helper<E, memory_slice_view<detail::build_identity_type<E>, Aligned>> {
    return detail::identity_helper<E, memory_slice_view<detail::build_identity_type<E>, Aligned>>{{value, first, last}};
}

} //end of namespace etl