dyn_base.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"
#include <type_traits>

namespace etl {

enum class init_flag_t {
    DUMMY 
};

constexpr init_flag_t init_flag = init_flag_t::DUMMY;

template <typename... V>
struct values_t {
    const std::tuple<V...> values; 

    explicit values_t(V... v) : values(v...){};

    template <typename T>
    std::vector<T> list() const {
        return list_sub<T>(std::make_index_sequence<sizeof...(V)>());
    }

private:
    template <typename T, size_t... I>
    std::vector<T> list_sub(const std::index_sequence<I...>& /*i*/) const {
        return {static_cast<T>(std::get<I>(values))...};
    }
};

template <typename... V>
values_t<V...> values(V... v) {
    return values_t<V...>{v...};
}

namespace dyn_detail {

template <typename... S>
struct is_init_constructor : std::false_type {};

template <typename S1, typename S2, typename S3, typename... S>
struct is_init_constructor<S1, S2, S3, S...> : std::is_same<init_flag_t, typename cpp::nth_type<sizeof...(S), S2, S3, S...>::type> {};

template <typename... S>
struct is_initializer_list_constructor : std::false_type {};

template <typename S1, typename S2, typename... S>
struct is_initializer_list_constructor<S1, S2, S...> : cpp::is_specialization_of<std::initializer_list, typename cpp::last_type<S2, S...>::type> {};

template <size_t... I, typename... T>
inline std::array<size_t, sizeof...(I)> sizes(const std::index_sequence<I...>& /*i*/, const T&... args) {
    return {{static_cast<size_t>(cpp::nth_value<I>(args...))...}};
}

} // end of namespace dyn_detail

template <typename Derived, typename T, size_t D>
requires(D > 0) struct dyn_base {
protected:
    static constexpr size_t n_dimensions = D;                                      
    static constexpr size_t alignment    = default_intrinsic_traits<T>::alignment; 

    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 derived_t              = Derived;                          
    using this_type              = dyn_base<Derived, T, D>;          

    size_t _size;                       
    dimension_storage_impl _dimensions; 

    void check_invariants() {
        cpp_assert(_dimensions.size() == D, "Invalid dimensions");

#ifndef NDEBUG
        auto computed = std::accumulate(_dimensions.begin(), _dimensions.end(), size_t(1), std::multiplies<size_t>());
        cpp_assert(computed == _size, "Incoherency in dimensions");
#endif
    }

    template <typename M = value_type>
    static M* allocate(size_t n) {
        inc_counter("cpu:allocate");

        cpp_assert(n, "Impossible allocate zero elements");

        M* memory = aligned_allocator<alignment>::template allocate<M>(n);

        cpp_assert(memory, "Impossible to allocate memory for dyn_matrix");
        cpp_assert(reinterpret_cast<uintptr_t>(memory) % alignment == 0, "Failed to align memory of matrix");

        //In case of non-trivial type, we need to call the constructors
        if constexpr (!std::is_trivially_default_constructible_v<M>) {
            new (memory) M[n]();
        }

        if constexpr (padding) {
            std::fill_n(memory, n, M());
        }

        return memory;
    }

    template <typename M>
    static void release(M* ptr, size_t n) {
        //In case of non-trivial type, we need to call the destructors
        if constexpr (!std::is_trivially_default_constructible_v<M>) {
            for (size_t i = 0; i < n; ++i) {
                ptr[i].~M();
            }
        }

        aligned_allocator<alignment>::template release<M>(ptr);
    }

    dyn_base() noexcept : _size(0) {
        std::fill(_dimensions.begin(), _dimensions.end(), 0);

        check_invariants();
    }

    dyn_base(const dyn_base& rhs) noexcept = default;

    dyn_base(dyn_base&& rhs) noexcept = default;

    dyn_base(size_t size, dimension_storage_impl dimensions) noexcept : _size(size), _dimensions(dimensions) {
        check_invariants();
    }

    template <etl_expr E>
    explicit dyn_base(E&& rhs) requires(!std::same_as<std::decay<E>, derived_t>) : _size(etl::size(rhs)) {
        for (size_t d = 0; d < etl::dimensions(rhs); ++d) {
            _dimensions[d] = etl::dim(rhs, d);
        }

        check_invariants();
    }

public:
    static constexpr size_t dimensions() noexcept {
        return n_dimensions;
    }

    size_t size() const noexcept {
        return _size;
    }

    size_t rows() const noexcept {
        return _dimensions[0];
    }

    size_t columns() const noexcept requires(n_dimensions > 1) {
        return _dimensions[1];
    }

    size_t dim(size_t d) const noexcept(assert_nothrow) {
        cpp_assert(d < n_dimensions, "Invalid dimension");

        return _dimensions[d];
    }

    template <size_t D2>
    size_t dim() const noexcept(assert_nothrow) {
        cpp_assert(D2 < n_dimensions, "Invalid dimension");

        return _dimensions[D2];
    }
};

template <typename Derived, typename T, order SO, size_t D>
struct dense_dyn_base : dyn_base<Derived, T, D> {
    using value_type        = T;                                 
    using base_type         = dyn_base<Derived, T, D>;           
    using this_type         = dense_dyn_base<Derived, T, SO, D>; 
    using derived_t         = Derived;                           
    using memory_type       = value_type*;                       
    using const_memory_type = const value_type*;                 
    using iterator          = memory_type;                       
    using const_iterator    = const_memory_type;                 

    using dimension_storage_impl = typename base_type::dimension_storage_impl; 

    static constexpr size_t n_dimensions = D;  
    static constexpr order storage_order = SO; 

    using base_type::_size;
    using base_type::dim;

    value_type* ETL_RESTRICT _memory = nullptr; 
    gpu_memory_handler<T> _gpu;                 

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

    dense_dyn_base(const dense_dyn_base& rhs) noexcept : base_type(rhs), _gpu(rhs._gpu) {
        //Nothing else to init
    }

    explicit dense_dyn_base(const derived_t& rhs) noexcept : base_type(rhs), _gpu(rhs._gpu) {
        //Nothing else to init
    }

    dense_dyn_base(dense_dyn_base&& rhs) noexcept : base_type(std::move(rhs)), _gpu(std::move(rhs._gpu)) {
        //Nothing else to init
    }

    explicit dense_dyn_base(derived_t&& rhs) noexcept : base_type(std::move(rhs)), _gpu(std::move(rhs._gpu)) {
        //Nothing else to init
    }

    dense_dyn_base(size_t size, dimension_storage_impl dimensions) noexcept : base_type(size, dimensions) {
        //Nothing else to init
    }

    template <etl_expr E>
    explicit dense_dyn_base(E&& rhs) requires(!std::same_as<std::decay_t<E>, derived_t>) : base_type(std::forward(rhs)) {
        //Nothing else to init
    }

    decltype(auto) operator()(size_t i) noexcept(assert_nothrow) {
        cpp_assert(i < dim(0), "Out of bounds");

        if constexpr (n_dimensions == 1) {
            ensure_cpu_up_to_date();
            invalidate_gpu();

            return _memory[i];
        } else {
            return sub(as_derived(), i);
        }
    }

    decltype(auto) operator()(size_t i) const noexcept(assert_nothrow) {
        cpp_assert(i < dim(0), "Out of bounds");

        if constexpr (n_dimensions == 1) {
            ensure_cpu_up_to_date();

            return _memory[i];
        } else {
            return sub(as_derived(), i);
        }
    }

    template <size_c... S>
    const value_type& operator()(S... sizes) const noexcept(assert_nothrow) requires(sizeof...(S) > 1 && sizeof...(S) == n_dimensions) {
        ensure_cpu_up_to_date();
        return _memory[etl::dyn_index(as_derived(), sizes...)];
    }

    template <size_c... S>
    value_type& operator()(S... sizes) noexcept(assert_nothrow) requires(sizeof...(S) > 1 && sizeof...(S) == n_dimensions){
        ensure_cpu_up_to_date();
        invalidate_gpu();
        return _memory[etl::dyn_index(as_derived(), sizes...)];
    }

    template <size_c... S>
    const value_type& operator[](size_t first, S... sizes) const noexcept(assert_nothrow) requires(sizeof...(S) >= 1 && (1 + sizeof...(S)) == n_dimensions) {
        ensure_cpu_up_to_date();
        return _memory[etl::dyn_index(as_derived(), first, sizes...)];
    }

    template <size_c... S>
    value_type& operator[](size_t first, S... sizes) noexcept(assert_nothrow) requires(sizeof...(S) >= 1 && (1 + sizeof...(S)) == n_dimensions){
        ensure_cpu_up_to_date();
        invalidate_gpu();
        return _memory[etl::dyn_index(as_derived(), first, sizes...)];
    }

    const value_type& operator[](size_t i) const noexcept(assert_nothrow) {
        cpp_assert(i < _size, "Out of bounds");

        ensure_cpu_up_to_date();

        return _memory[i];
    }

    value_type& operator[](size_t i) noexcept(assert_nothrow) {
        cpp_assert(i < _size, "Out of bounds");

        ensure_cpu_up_to_date();
        invalidate_gpu();

        return _memory[i];
    }

    value_type read_flat(size_t i) const noexcept(assert_nothrow) {
        cpp_assert(i < _size, "Out of bounds");

        ensure_cpu_up_to_date();

        return _memory[i];
    }

    template <typename E>
    bool alias(const E& rhs) const noexcept {
        if constexpr (is_dma<E>) {
            return memory_alias(memory_start(), memory_end(), rhs.memory_start(), rhs.memory_end());
        } else {
            return rhs.alias(as_derived());
        }
    }

    inline memory_type memory_start() noexcept {
        return _memory;
    }

    inline const_memory_type memory_start() const noexcept {
        return _memory;
    }

    memory_type memory_end() noexcept {
        return _memory + _size;
    }

    const_memory_type memory_end() const noexcept {
        return _memory + _size;
    }

    auto slice(size_t first, size_t last) noexcept {
        return etl::slice(as_derived(), first, last);
    }

    auto slice(size_t first, size_t last) const noexcept {
        return etl::slice(as_derived(), first, last);
    }

    T* gpu_memory() const noexcept {
        return _gpu.gpu_memory();
    }

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

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

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

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

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

    void ensure_gpu_allocated() const {
        _gpu.ensure_gpu_allocated(_size);
    }

    void ensure_gpu_up_to_date() const {
        _gpu.ensure_gpu_up_to_date(memory_start(), _size);
    }

    void ensure_cpu_up_to_date() const {
        _gpu.ensure_cpu_up_to_date(memory_start(), _size);
    }

    void gpu_copy_from(const T* gpu_memory) const {
        _gpu.gpu_copy_from(gpu_memory, _size);
    }

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

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

private:
    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);
    }
};

} //end of namespace etl