adapter.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

namespace etl {

template <typename Matrix>
struct adapter {
    using matrix_t = Matrix;   
    using expr_t   = matrix_t; 

    using value_type        = value_t<matrix_t>; 
    using memory_type       = value_type*;       
    using const_memory_type = const value_type*; 

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

protected:
    matrix_t value; 

public:
    adapter() noexcept : value(value_type()) {
        //Nothing else to init
    }

    explicit adapter(value_type value) noexcept : value(value) {
        //Nothing else to init
    }

    explicit adapter(size_t dim) noexcept : value(dim, dim, value_type()) {
        //Nothing else to init
    }

    adapter(size_t dim, value_type value) noexcept : value(dim, dim, value) {
        //Nothing else to init
    }

    adapter(const adapter& rhs) = default;

    adapter& operator=(const adapter& rhs) = default;

    adapter(adapter&& rhs) noexcept = default;

    adapter& operator=(adapter&& rhs) noexcept = default;

    const value_type& operator()(size_t i, size_t j) const noexcept {
        return value(i, j);
    }

    const value_type& operator[](size_t i) const noexcept {
        return value[i];
    }

    value_type& operator[](size_t i) noexcept {
        return value[i];
    }

    value_type read_flat(size_t i) const noexcept {
        return value.read_flat(i);
    }

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

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

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

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

    template <typename V = default_vec>
    vec_type<V> load(size_t i) const noexcept {
        return value.template load<V>(i);
    }

    template <typename V = default_vec>
    vec_type<V> loadu(size_t i) const noexcept {
        return value.template loadu<V>(i);
    }

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

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

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

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

    template <typename Y>
    auto& gpu_compute_hint([[maybe_unused]] Y& y) {
        value.ensure_gpu_up_to_date();
        return value;
    }

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

    // Assignment functions

    template <typename L>
    void assign_to(L&& lhs) const {
        std_assign_evaluate(value, std::forward<L>(lhs));
    }

    template <typename L>
    void assign_add_to(L&& lhs) const {
        std_add_evaluate(value, std::forward<L>(lhs));
    }

    template <typename L>
    void assign_sub_to(L&& lhs) const {
        std_sub_evaluate(value, std::forward<L>(lhs));
    }

    template <typename L>
    void assign_mul_to(L&& lhs) const {
        std_mul_evaluate(value, std::forward<L>(lhs));
    }

    template <typename L>
    void assign_div_to(L&& lhs) const {
        std_div_evaluate(value, std::forward<L>(lhs));
    }

    template <typename L>
    void assign_mod_to(L&& lhs) const {
        std_mod_evaluate(value, std::forward<L>(lhs));
    }

    // Internals

    void visit([[maybe_unused]] const detail::evaluator_visitor& visitor) const {}

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

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

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

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

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

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

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

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

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

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

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

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

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

} //end of namespace etl