fast_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"

namespace etl {

namespace matrix_detail {

template <typename N>
struct is_vector_impl : std::false_type {};

template <typename... Args>
struct is_vector_impl<std::vector<Args...>> : std::true_type {};

template <typename... Args>
struct is_vector_impl<etl::simple_vector<Args...>> : std::true_type {};

template <typename N>
constexpr bool is_vector = is_vector_impl<N>::value;

template <typename T>
struct iterator_type {
    using iterator       = typename T::iterator;       
    using const_iterator = typename T::const_iterator; 
};

template <typename T>
struct iterator_type<T*> {
    using iterator       = T*;       
    using const_iterator = const T*; 
};

template <typename T>
struct iterator_type<const T*> {
    using iterator       = const T*; 
    using const_iterator = const T*; 
};

template <typename T>
using iterator_t = typename iterator_type<T>::iterator;

template <typename T>
using const_iterator_t = typename iterator_type<T>::const_iterator;

} //end of namespace matrix_detail

template <typename D, typename T, typename ST, order SO, size_t... Dims>
struct fast_matrix_base {
    static constexpr size_t n_dimensions = sizeof...(Dims); 
    static constexpr size_t etl_size     = (Dims * ...);    

    using value_type        = T;                 
    using derived_t         = D;                 
    using storage_impl      = ST;                
    using memory_type       = value_type*;       
    using const_memory_type = const value_type*; 

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

protected:
    storage_impl _data;         
    gpu_memory_handler<T> _gpu; 

    void init() {
        if constexpr (matrix_detail::is_vector<ST>) {
            _data.resize(alloc_size_mat<value_type>(size(), dim<n_dimensions - 1>()));
        }
    }

    template <typename... S>
    static constexpr size_t index(S... args) {
        return etl::fast_index<derived_t>(args...);
    }

    template <typename... S>
    value_type& access(S... args) {
        ensure_cpu_up_to_date();
        invalidate_gpu();
        return _data[index(args...)];
    }

    template <typename... S>
    const value_type& access(S... args) const {
        ensure_cpu_up_to_date();
        return _data[index(args...)];
    }

public:
    fast_matrix_base() : _data() {
        init();
    }

    fast_matrix_base(storage_impl data) : _data(data) {
        // Nothing else to init
    }

    fast_matrix_base(const fast_matrix_base& rhs) : _data(), _gpu(rhs._gpu) {
        // Only perform the copy if the CPU is up to date
        if (rhs._gpu.is_cpu_up_to_date()) {
            _data = rhs._data;
        } else {
            init();
        }

        // The GPU updates are handled by gpu_handler
    }

    fast_matrix_base(fast_matrix_base&& rhs) noexcept : _data(), _gpu(std::move(rhs._gpu)) {
        // Only perform the copy if the CPU is up to date
        if (_gpu.is_cpu_up_to_date()) {
            _data = std::move(rhs._data);
        } else {
            init();
        }

        // The GPU updates are handled by gpu_handler
    }

    // Assignment must be handled by the derived class!

    fast_matrix_base& operator=(const fast_matrix_base& rhs) = delete;
    fast_matrix_base& operator=(fast_matrix_base&& rhs) = delete;

    memory_type memory_start() noexcept {
        return _data.data();
    }

    const_memory_type memory_start() const noexcept {
        return _data.data();
    }

    memory_type memory_end() noexcept {
        return _data.data() +size();
    }

    const_memory_type memory_end() const noexcept {
        return _data.data() + size();
    }

    static constexpr size_t size() noexcept {
        return etl_size;
    }

    static constexpr size_t rows() noexcept {
        return dim<0>();
    }

    static constexpr size_t columns() noexcept requires(n_dimensions > 1) {
        return dim<1>();
    }

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

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

    size_t dim(size_t d) const noexcept {
        return dyn_nth_size<Dims...>(d);
    }

    auto operator()(size_t i) noexcept requires(n_dimensions > 1) {
        return sub(as_derived(), i);
    }

    auto operator()(size_t i) const noexcept requires(n_dimensions > 1) {
        return sub(as_derived(), i);
    }

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

    template <size_c... S>
    value_type& operator()(S... args) noexcept(assert_nothrow) requires (sizeof...(S) == sizeof...(Dims)) {
        return access(static_cast<size_t>(args)...);
    }

    template <size_c... S>
    const value_type& operator()(S... args) const noexcept(assert_nothrow) requires (sizeof...(S) == sizeof...(Dims)) {
        return access(static_cast<size_t>(args)...);
    }

    template <size_c... S>
    value_type& operator[](size_t first, S... args) noexcept(assert_nothrow) requires (sizeof...(S) >= 1 && (1 + sizeof...(S)) == sizeof...(Dims)) {
        return access(first, static_cast<size_t>(args)...);
    }

    template <size_c... S>
    const value_type& operator[](size_t first, S... args) const noexcept(assert_nothrow) requires (sizeof...(S) >= 1 && (1 + sizeof...(S)) == sizeof...(Dims)) {
        return access(first, static_cast<size_t>(args)...);
    }

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

        ensure_cpu_up_to_date();

        return _data[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 _data[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 _data[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());
        }
    }

    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(etl_size);
    }

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

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

    void gpu_copy_from(const T* gpu_memory) const {
        _gpu.gpu_copy_from(gpu_memory, etl_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