transpose_front_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 "etl/expr/base_temporary_expr.hpp"

//Get the implementations
#include "etl/impl/egblas/transpose_front.hpp"

namespace etl {

template <etl_expr A>
struct transpose_front_expr : base_temporary_expr_un<transpose_front_expr<A>, A> {
    using value_type = value_t<A>;                           
    using this_type  = transpose_front_expr<A>;                    
    using base_type  = base_temporary_expr_un<this_type, A>; 
    using sub_traits = decay_traits<A>;                      

    static constexpr auto storage_order = sub_traits::storage_order; 

    static constexpr bool gpu_computable = all_row_major<A> && all_floating<A> && impl::egblas::has_stranspose_front;

    explicit transpose_front_expr(A a) : base_type(a) {
        //Nothing else to init
    }

    template <etl_expr C>
    static void check([[maybe_unused]] const A& a, [[maybe_unused]] const C& c) {
        if constexpr (all_fast<A, C>) {
            static_assert(etl::dim<0, A>() == etl::dim<1, C>(), "Invalid dimensions for front transposition");
            static_assert(etl::dim<1, A>() == etl::dim<0, C>(), "Invalid dimensions for front transposition");
            static_assert(etl::dim<2, A>() == etl::dim<2, C>(), "Invalid dimensions for front transposition");
        } else {
            cpp_assert(etl::dim<0>(a) == etl::dim<1>(c), "Invalid dimensions for front transposition");
            cpp_assert(etl::dim<1>(a) == etl::dim<0>(c), "Invalid dimensions for front transposition");
            cpp_assert(etl::dim<2>(a) == etl::dim<2>(c), "Invalid dimensions for front transposition");
        }
    }

    // Assignment functions

    template <etl_expr C>
    void assign_to(C&& lhs) const {
        auto& a = this->a();

        check(a, lhs);

        const auto B = etl::dim<0>(a);
        const auto K = etl::dim<1>(a);

        if constexpr (all_row_major<A, C> && all_floating<A, C> && impl::egblas::has_stranspose_front) {
            decltype(auto) t1 = smart_forward_gpu(a);
            t1.ensure_gpu_up_to_date();

            lhs.ensure_gpu_allocated();

            impl::egblas::transpose_front(B, K, etl::size(a) / (B * K), t1.gpu_memory(), lhs.gpu_memory());

            lhs.validate_gpu();
            lhs.invalidate_cpu();
        } else {
            auto batch_fun_b = [&](const size_t first, const size_t last) {
                for (size_t b = first; b < last; ++b) {
                    for (size_t k = 0; k < K; ++k) {
                        lhs(k)(b) = a(b)(k);
                    }
                }
            };

            // Ideally, this should be optimized to not use hyper thread
            // for large containers, but the threshold is tricky to define
            engine_dispatch_1d_serial(batch_fun_b, 0, B, 8UL);

            a.ensure_cpu_up_to_date();

            lhs.validate_cpu();
            lhs.invalidate_gpu();
        }
    }

    template <etl_expr L>
    void assign_add_to(L&& lhs) const {
        std_add_evaluate(*this, lhs);
    }

    template <etl_expr L>
    void assign_sub_to(L&& lhs) const {
        std_sub_evaluate(*this, lhs);
    }

    template <etl_expr L>
    void assign_mul_to(L&& lhs) const {
        std_mul_evaluate(*this, lhs);
    }

    template <etl_expr L>
    void assign_div_to(L&& lhs) const {
        std_div_evaluate(*this, lhs);
    }

    template <etl_expr L>
    void assign_mod_to(L&& lhs) const {
        std_mod_evaluate(*this, lhs);
    }

    friend std::ostream& operator<<(std::ostream& os, const transpose_front_expr& expr) {
        return os << "trans_front(" << expr._a << ")";
    }
};

template <typename A>
struct etl_traits<etl::transpose_front_expr<A>> {
    using expr_t     = etl::transpose_front_expr<A>; 
    using sub_expr_t = std::decay_t<A>;        
    using sub_traits = etl_traits<sub_expr_t>; 
    using value_type = value_t<A>;             

    static constexpr bool is_etl         = true;                                 
    static constexpr bool is_transformer = false;                                
    static constexpr bool is_view        = false;                                
    static constexpr bool is_magic_view  = false;                                
    static constexpr bool is_fast        = sub_traits::is_fast;                  
    static constexpr bool is_linear      = true;                                 
    static constexpr bool is_thread_safe = true;                                 
    static constexpr bool is_value       = false;                                
    static constexpr bool is_direct      = true;                                 
    static constexpr bool is_generator   = false;                                
    static constexpr bool is_padded      = false;                                
    static constexpr bool is_aligned     = true;                                 
    static constexpr bool is_temporary   = true;                                 
    static constexpr bool gpu_computable = is_gpu_t<value_type> && cuda_enabled; 
    static constexpr order storage_order = sub_traits::storage_order;            

    template <vector_mode_t V>
    static constexpr bool vectorizable = true;

    template <size_t DD>
    static constexpr size_t dim() {
        if (DD == 0) {
            return sub_traits::template dim<1>();
        } else if (DD == 1) {
            return sub_traits::template dim<0>();
        } else {
            return sub_traits::template dim<DD>();
        }
    }

    static size_t dim(const expr_t& e, size_t d) {
        if (d == 0) {
            return etl::dim<1>(e._a);
        } else if (d == 1) {
            return etl::dim<0>(e._a);
        } else {
            return etl::dim(e._a, d);
        }
    }

    static size_t size(const expr_t& e) {
        return etl::size(e._a);
    }

    static constexpr size_t size() {
        return sub_traits::size();
    }

    static constexpr size_t dimensions() {
        return sub_traits::dimensions();
    }

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

} //end of namespace etl