gpu_dyn.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/dyn_base.hpp" //The base class and utilities

namespace etl {

template <typename T, order SO, size_t D>
struct gpu_dyn_matrix_impl final : dense_dyn_base<gpu_dyn_matrix_impl<T, SO, D>, T, SO, D>, dim_testable<gpu_dyn_matrix_impl<T, SO, D>> {
    static constexpr size_t n_dimensions = D;                                      
    static constexpr order storage_order = SO;                                     
    static constexpr size_t alignment    = default_intrinsic_traits<T>::alignment; 

    using this_type              = gpu_dyn_matrix_impl<T, SO, D>;              
    using base_type              = dense_dyn_base<this_type, T, SO, D>;        
    using iterable_base_type     = iterable<this_type, SO == order::RowMajor>; 
    using value_type             = T;                                          
    using dimension_storage_impl = std::array<size_t, n_dimensions>;           
    using memory_type            = value_type*;                                
    using const_memory_type      = const value_type*;                          

    using iterator       = std::conditional_t<SO == order::RowMajor, value_type*, etl::iterator<this_type>>;             
    using const_iterator = std::conditional_t<SO == order::RowMajor, const value_type*, etl::iterator<const this_type>>; 

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

private:
    using base_type::_dimensions;
    using base_type::_memory;
    using base_type::_size;

    using base_type::check_invariants;

public:
    using base_type::_gpu;

    // Construction

    gpu_dyn_matrix_impl() noexcept : base_type() {
        //Nothing else to init
    }

    gpu_dyn_matrix_impl(const gpu_dyn_matrix_impl& rhs) noexcept(assert_nothrow) : base_type(rhs) {
        // The CPU status is discarded!

        cpp_assert(rhs.is_gpu_up_to_date() == this->is_gpu_up_to_date(), "gpu_dyn_matrix_impl(&) must preserve GPU status");
    }

    gpu_dyn_matrix_impl(gpu_dyn_matrix_impl&& rhs) noexcept : base_type(std::move(rhs)) {
        _memory     = rhs._memory;
        rhs._memory = nullptr;
    }

    gpu_dyn_matrix_impl& operator=(const gpu_dyn_matrix_impl& rhs) noexcept(assert_nothrow) {
        if (this != &rhs) {
            if (!_size) {
                _size       = rhs._size;
                _dimensions = rhs._dimensions;
            } else {
                validate_assign(*this, rhs);
            }

            // TODO Find a better solution
            const_cast<gpu_dyn_matrix_impl&>(rhs).assign_to(*this);
        }

        check_invariants();

        cpp_assert(rhs.is_gpu_up_to_date() == this->is_gpu_up_to_date(), "gpu_dyn_matrix_impl::operator= must preserve GPU status");

        return *this;
    }

    gpu_dyn_matrix_impl& operator=(gpu_dyn_matrix_impl&& rhs) noexcept {
        if (this != &rhs) {
            _gpu = std::move(rhs._gpu);

            _size       = rhs._size;
            _dimensions = std::move(rhs._dimensions);

            rhs._size   = 0;
            rhs._memory = nullptr;
        }

        check_invariants();

        return *this;
    }

    template <etl_expr E>
    gpu_dyn_matrix_impl& operator=(E&& e) noexcept requires(!std::same_as<std::decay_t<E>, gpu_dyn_matrix_impl<T, SO, D>> && std::convertible_to<value_t<E>, value_type>) {
        // It is possible that the matrix was not initialized before
        // In the case, get the the dimensions from the expression and
        // initialize the matrix
        if (!_size) {
            inherit(e);
        } else {
            validate_assign(*this, e);
        }

        // Avoid aliasing issues
        if constexpr (!decay_traits<E>::is_linear) {
            if (e.alias(*this)) {
                // Create a temporary to hold the result
                this_type tmp;

                // Assign the expression to the temporary
                tmp = e;

                // Assign the temporary to this matrix
                *this = tmp;
            } else {
                e.assign_to(*this);
            }
        } else {
            // Direct assignment of the expression into this matrix
            e.assign_to(*this);
        }

        check_invariants();

        return *this;
    }

    gpu_dyn_matrix_impl& operator=([[maybe_unused]] value_type v) noexcept {
        cpp_unreachable("Invalid call to operator=(value_type) for GPU dyn matrix");

        return *this;
    }

    ~gpu_dyn_matrix_impl() noexcept {
        // Nothing to do here
    }

    template <typename Y>
    auto& gpu_compute_hint([[maybe_unused]] Y& y) {
        this->ensure_gpu_up_to_date();
        return *this;
    }

    template <typename Y>
    const auto& gpu_compute_hint([[maybe_unused]] Y& y) const {
        this->ensure_gpu_up_to_date();
        return *this;
    }

    // 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([[maybe_unused]] const detail::evaluator_visitor& visitor) const {}

    template <typename E>
    void inherit([[maybe_unused]] const E& e) {
        if constexpr (etl::decay_traits<E>::is_generator) {
            cpp_unreachable("Impossible to inherit dimensions from generators");
        } else {
            cpp_assert(n_dimensions == etl::dimensions(e), "Invalid number of dimensions");

            // Compute the size and new dimensions
            _size = 1;
            for (size_t d = 0; d < n_dimensions; ++d) {
                _dimensions[d] = etl::dim(e, d);
                _size *= _dimensions[d];
            }
        }
    }

    void resize_scalar() {
        _size          = 1;
        _dimensions[0] = 1;
    }

    friend std::ostream& operator<<(std::ostream& os, const gpu_dyn_matrix_impl& mat) {
        if (D == 1) {
            return os << "GV[" << mat.size() << "]";
        }

        os << "GM[" << mat.dim(0);

        for (size_t i = 1; i < D; ++i) {
            os << "," << mat.dim(i);
        }

        return os << "]";
    }
};

#ifndef CPP_UTILS_ASSERT_EXCEPTION
static_assert(std::is_nothrow_default_constructible_v<gpu_dyn_matrix<double>>, "dyn_vector should be nothrow default constructible");
static_assert(std::is_nothrow_copy_constructible_v<gpu_dyn_matrix<double>>, "dyn_vector should be nothrow copy constructible");
static_assert(std::is_nothrow_move_constructible_v<gpu_dyn_matrix<double>>, "dyn_vector should be nothrow move constructible");
static_assert(std::is_nothrow_copy_assignable_v<gpu_dyn_matrix<double>>, "dyn_vector should be nothrow copy assignable");
static_assert(std::is_nothrow_move_assignable_v<gpu_dyn_matrix<double>>, "dyn_vector should be nothrow move assignable");
static_assert(std::is_nothrow_destructible_v<gpu_dyn_matrix<double>>, "dyn_vector should be nothrow destructible");
#endif

} //end of namespace etl