fast_matrix_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

#include "etl/index.hpp"

namespace etl {

template <typename T, bool DMA, size_t... Dims>
struct fast_matrix_view;

template <typename T, size_t... Dims>
struct fast_matrix_view<T, false, Dims...> final : iterable<fast_matrix_view<T, false, Dims...>, false>,
                                                   value_testable<fast_matrix_view<T, false, Dims...>>,
                                                   assignable<fast_matrix_view<T, false, Dims...>, value_t<T>> {
    using sub_type             = T;                                                                    
    using this_type            = fast_matrix<T, false, Dims...>;                                       
    using value_type           = value_t<sub_type>;                                                    
    using iterable_base_type   = iterable<this_type, false>;                                           
    using assignable_base_type = assignable<this_type, value_type>;                                    
    using memory_type          = memory_t<sub_type>;                                                   
    using const_memory_type    = const_memory_t<sub_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])>; 

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

    using assignable_base_type::operator=;
    using iterable_base_type::begin;
    using iterable_base_type::end;

private:
    sub_type sub; 

    static constexpr size_t n_dimensions = sizeof...(Dims); 

    friend struct etl_traits<fast_matrix_view>;

public:
    explicit fast_matrix_view(sub_type sub) : sub(sub) {}

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

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

    value_type read_flat(size_t j) const noexcept {
        return sub.read_flat(j);
    }

    template <size_c... S>
    return_type operator()(S... args) requires (sizeof...(S) == sizeof...(Dims)) {
        return sub[etl::fast_index<this_type>(static_cast<size_t>(args)...)];
    }

    template <size_c... S>
    const_return_type operator()(S... args) const noexcept requires (sizeof...(S) == sizeof...(Dims)) {
        return sub[etl::fast_index<this_type>(static_cast<size_t>(args)...)];
    }

    auto operator()(size_t i) noexcept requires sub_capable<this_type> {
        return etl::sub(*this, i);
    }

    auto operator()(size_t i) const noexcept requires sub_capable<this_type> {
        return etl::sub(*this, i);
    }

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

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

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

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

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

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

    // 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 {
        // Need to ensure sub value
        sub.ensure_cpu_up_to_date();
    }

    void ensure_gpu_up_to_date() const {
        // Need to ensure both LHS and RHS
        sub.ensure_gpu_up_to_date();
    }

    friend std::ostream& operator<<(std::ostream& os, const fast_matrix_view& v) {
        return os << "reshape(" << v.sub << ")";
    }
};

template <typename T, size_t... Dims>
struct fast_matrix_view<T, true, Dims...> final : iterable<fast_matrix_view<T, true, Dims...>, true>,
                                                  value_testable<fast_matrix_view<T, true, Dims...>>,
                                                  assignable<fast_matrix_view<T, true, Dims...>, value_t<T>> {
    using this_type            = fast_matrix_view<T, true, Dims...>;                                   
    using sub_type             = T;                                                                    
    using value_type           = value_t<sub_type>;                                                    
    using iterable_base_type   = iterable<this_type, true>;                                            
    using assignable_base_type = assignable<this_type, value_type>;                                    
    using memory_type          = memory_t<sub_type>;                                                   
    using const_memory_type    = const_memory_t<sub_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])>; 

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

    using assignable_base_type::operator=;
    using iterable_base_type::begin;
    using iterable_base_type::end;

private:
    sub_type sub; 

    mutable memory_type memory; 

    static constexpr size_t n_dimensions = sizeof...(Dims); 

    friend struct etl_traits<fast_matrix_view>;

public:
    explicit fast_matrix_view(sub_type sub) : sub(sub) {
        // Accessing the memory through fast sub views means evaluation
        if constexpr (decay_traits<sub_type>::is_temporary) {
            standard_evaluator::pre_assign_rhs(*this);
        }

        this->memory = this->sub.memory_start();

        cpp_assert(this->memory, "Invalid memory");
    }

    const_return_type operator[](size_t j) const {
        cpp_assert(memory, "Memory has not been initialized");
        ensure_cpu_up_to_date();
        return memory[j];
    }

    return_type operator[](size_t j) {
        cpp_assert(memory, "Memory has not been initialized");
        ensure_cpu_up_to_date();
        invalidate_gpu();
        return memory[j];
    }

    value_type read_flat(size_t j) const noexcept(assert_nothrow) {
        cpp_assert(memory, "Memory has not been initialized");
        ensure_cpu_up_to_date();
        return memory[j];
    }

    template <size_c... S>
    return_type operator()(S... args) noexcept(assert_nothrow) requires(sizeof...(S) == sizeof...(Dims)) {
        cpp_assert(memory, "Memory has not been initialized");
        ensure_cpu_up_to_date();
        invalidate_gpu();
        return memory[etl::fast_index<this_type>(static_cast<size_t>(args)...)];
    }

    template <size_c... S>
    const_return_type operator()(S... args) const noexcept(assert_nothrow) requires(sizeof...(S) == sizeof...(Dims)) {
        cpp_assert(memory, "Memory has not been initialized");
        ensure_cpu_up_to_date();
        return memory[etl::fast_index<this_type>(static_cast<size_t>(args)...)];
    }

    auto operator()(size_t i) noexcept requires sub_capable<this_type> {
        return etl::sub(*this, i);
    }

    auto operator()(size_t i) const noexcept requires sub_capable<this_type> {
        return etl::sub(*this, i);
    }

    template <typename V = default_vec>
    auto load(size_t x) const noexcept {
        return V::loadu(memory + x);
    }

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

    template <typename V = default_vec>
    void stream(vec_type<V> in, size_t i) noexcept {
        return V::stream(memory + i, in);
    }

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

    template <typename V = default_vec>
    void storeu(vec_type<V> in, size_t i) noexcept {
        return V::storeu(memory + i, in);
    }

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

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

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

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

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

    // 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);
    }

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

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

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

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

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

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

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

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

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

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

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

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

    friend std::ostream& operator<<(std::ostream& os, const fast_matrix_view& v) {
        return os << "reshape(" << v.sub << ")";
    }
};

template <typename T, bool DMA, size_t... Dims>
struct etl_traits<etl::fast_matrix_view<T, DMA, Dims...>> {
    using expr_t     = etl::fast_matrix_view<T, DMA, Dims...>; 
    using sub_expr_t = std::decay_t<T>;                        
    using sub_traits = etl_traits<sub_expr_t>;                 
    using value_type = typename sub_traits::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_linear      = sub_traits::is_linear;      
    static constexpr bool is_thread_safe = sub_traits::is_thread_safe; 
    static constexpr bool is_fast        = true;                       
    static constexpr bool is_value       = false;                      
    static constexpr bool is_direct      = sub_traits::is_direct;      
    static constexpr bool is_generator   = false;                      
    static constexpr bool is_padded      = false;                      
    static constexpr bool is_aligned     = false;                      
    static constexpr bool is_temporary   = sub_traits::is_temporary;   
    static constexpr bool gpu_computable = false;                      
    static constexpr order storage_order = sub_traits::storage_order;  

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

    static constexpr size_t size([[maybe_unused]] const expr_t& v) {
        return (Dims * ...);
    }

    static size_t dim([[maybe_unused]] const expr_t& v, size_t d) {
        return dyn_nth_size<Dims...>(d);
    }

    static constexpr size_t size() {
        return (Dims * ...);
    }

    template <size_t D>
    static constexpr size_t dim() {
        return nth_size<D, 0, Dims...>();
    }

    static constexpr size_t dimensions() {
        return sizeof...(Dims);
    }

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

} //end of namespace etl