declarations.hpp

Go to the documentation of this file.

// Copyright (c) 2019-2024 Simons Foundation
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0.txt
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// Authors: Thomas Hahn, Olivier Parcollet, Nils Wentzell
 
#pragma once
 
#include "./accessors.hpp"
#include "./concepts.hpp"
#include "./layout/idx_map.hpp"
#include "./layout/permutation.hpp"
#include "./layout/policies.hpp"
#include "./mem/address_space.hpp"
#include "./mem/policies.hpp"
#include "./traits.hpp"
 
#include <array>
#include <cstddef>
#include <cstdint>
#include <stdexcept>
#include <type_traits>
 
namespace nda {
 
  // Forward declarations.
  template <int Rank, uint64_t StaticExtents, uint64_t StrideOrder, layout_prop_e LayoutProp>
  class idx_map;
 
  template <typename ValueType, int Rank, typename Layout, char Algebra, typename ContainerPolicy>
  class basic_array;
 
  template <typename ValueType, int Rank, typename Layout, char Algebra = 'A',
            typename AccessorPolicy = nda::default_accessor, //, nda::no_alias_accessor, //,
            typename OwningPolicy   = nda::borrowed<>>
  class basic_array_view;
 
  template <char OP, Array A>
  struct expr_unary;
 
  template <char OP, ArrayOrScalar L, ArrayOrScalar R>
  struct expr;
 
  template <typename ValueType, int Rank, typename Layout = C_layout, typename ContainerPolicy = heap<>>
  using array = basic_array<ValueType, Rank, Layout, 'A', ContainerPolicy>;
 
  template <typename ValueType, int Rank, typename Layout = C_stride_layout>
  using array_view = basic_array_view<ValueType, Rank, Layout, 'A', default_accessor, borrowed<>>;
 
  template <typename ValueType, int Rank, typename Layout = C_stride_layout>
  using array_const_view = basic_array_view<ValueType const, Rank, Layout, 'A', default_accessor, borrowed<>>;
 
  template <typename ValueType, int Rank, typename Layout = C_layout>
    requires(has_contiguous(Layout::template mapping<Rank>::layout_prop))
  using array_contiguous_view = basic_array_view<ValueType, Rank, Layout, 'A', default_accessor, borrowed<>>;
 
  template <typename ValueType, int Rank, typename Layout = C_layout>
    requires(has_contiguous(Layout::template mapping<Rank>::layout_prop))
  using array_contiguous_const_view = basic_array_view<ValueType const, Rank, Layout, 'A', default_accessor, borrowed<>>;
 
  template <typename ValueType, typename Layout = C_layout, typename ContainerPolicy = heap<>>
  using matrix = basic_array<ValueType, 2, Layout, 'M', ContainerPolicy>;
 
  template <typename ValueType, typename Layout = C_stride_layout>
  using matrix_view = basic_array_view<ValueType, 2, Layout, 'M', default_accessor, borrowed<>>;
 
  template <typename ValueType, typename Layout = C_stride_layout>
  using matrix_const_view = basic_array_view<ValueType const, 2, Layout, 'M', default_accessor, borrowed<>>;
 
  template <typename ValueType, typename ContainerPolicy = heap<>>
  using vector = basic_array<ValueType, 1, C_layout, 'V', ContainerPolicy>;
 
  template <typename ValueType, typename Layout = C_stride_layout>
  using vector_view = basic_array_view<ValueType, 1, Layout, 'V', default_accessor, borrowed<>>;
 
  template <typename ValueType, typename Layout = C_stride_layout>
  using vector_const_view = basic_array_view<ValueType const, 1, Layout, 'V', default_accessor, borrowed<>>;
 
  template <typename... Is>
  constexpr uint64_t static_extents(int i0, Is... is) {
    if (i0 > 15) throw std::runtime_error("Error in nda::static_extents: Only 16 dimensions are supported!");
    return encode(std::array<int, sizeof...(Is) + 1>{i0, static_cast<int>(is)...});
  }
 
  template <typename ValueType, int N0, int... Ns>
  using stack_array =
     nda::basic_array<ValueType, 1 + sizeof...(Ns),
                      nda::basic_layout<nda::static_extents(N0, Ns...), nda::C_stride_order<1 + sizeof...(Ns)>, nda::layout_prop_e::contiguous>, 'A',
                      nda::stack<N0 *(Ns *... * 1)>>;
 
  template <typename ValueType, int N, int M>
  using stack_matrix =
     nda::basic_array<ValueType, 2, nda::basic_layout<nda::static_extents(N, M), nda::C_stride_order<2>, nda::layout_prop_e::contiguous>, 'M',
                      nda::stack<static_cast<size_t>(N *M)>>;
 
  template <typename ValueType, int N>
  using stack_vector =
     nda::basic_array<ValueType, 1, nda::basic_layout<nda::static_extents(N), nda::C_stride_order<1>, nda::layout_prop_e::contiguous>, 'V',
                      nda::stack<N>>;
 
  template <typename ValueType, int Rank, typename Layout = C_layout>
  using cuarray = basic_array<ValueType, Rank, Layout, 'A', heap<mem::Device>>;
 
  template <typename ValueType, int Rank, typename Layout = C_stride_layout>
  using cuarray_view = basic_array_view<ValueType, Rank, Layout, 'A', default_accessor, borrowed<mem::Device>>;
 
  template <typename ValueType, int Rank, typename Layout = C_stride_layout>
  using cuarray_const_view = basic_array_view<ValueType const, Rank, Layout, 'A', default_accessor, borrowed<mem::Device>>;
 
  template <typename ValueType, typename Layout = C_layout, typename ContainerPolicy = heap<mem::Device>>
  using cumatrix = basic_array<ValueType, 2, Layout, 'M', ContainerPolicy>;
 
  template <typename ValueType, typename Layout = C_stride_layout>
  using cumatrix_view = basic_array_view<ValueType, 2, Layout, 'M', default_accessor, borrowed<mem::Device>>;
 
  template <typename ValueType, typename Layout = C_stride_layout>
  using cumatrix_const_view = basic_array_view<ValueType const, 2, Layout, 'M', default_accessor, borrowed<mem::Device>>;
 
  template <typename ValueType>
  using cuvector = basic_array<ValueType, 1, C_layout, 'V', heap<mem::Device>>;
 
  template <typename ValueType, typename Layout = C_stride_layout>
  using cuvector_view = basic_array_view<ValueType, 1, Layout, 'V', default_accessor, borrowed<mem::Device>>;
 
  template <typename ValueType, typename Layout = C_stride_layout>
  using cuvector_const_view = basic_array_view<ValueType const, 1, Layout, 'V', default_accessor, borrowed<mem::Device>>;
 
  template <typename ValueType, int Rank, typename Layout, char Algebra, typename ContainerPolicy>
  inline constexpr bool is_regular_v<basic_array<ValueType, Rank, Layout, Algebra, ContainerPolicy>> = true;
 
  template <typename ValueType, int Rank, typename Layout, char Algebra, typename AccessorPolicy, typename OwningPolicy>
  inline constexpr bool is_view_v<basic_array_view<ValueType, Rank, Layout, Algebra, AccessorPolicy, OwningPolicy>> = true;
 
  template <typename ValueType, int Rank, typename Layout, char Algebra, typename ContainerPolicy>
  inline constexpr char get_algebra<basic_array<ValueType, Rank, Layout, Algebra, ContainerPolicy>> = Algebra;
 
  template <typename ValueType, int Rank, typename Layout, char Algebra, typename AccessorPolicy, typename OwningPolicy>
  inline constexpr char get_algebra<basic_array_view<ValueType, Rank, Layout, Algebra, AccessorPolicy, OwningPolicy>> = Algebra;
 
  template <typename ValueType, int Rank, typename Layout, char Algebra, typename ContainerPolicy>
  inline constexpr layout_info_t get_layout_info<basic_array<ValueType, Rank, Layout, Algebra, ContainerPolicy>> =
     basic_array<ValueType, Rank, Layout, Algebra, ContainerPolicy>::layout_t::layout_info;
 
  template <typename ValueType, int Rank, typename Layout, char Algebra, typename AccessorPolicy, typename OwningPolicy>
  inline constexpr layout_info_t get_layout_info<basic_array_view<ValueType, Rank, Layout, Algebra, AccessorPolicy, OwningPolicy>> =
     basic_array_view<ValueType, Rank, Layout, Algebra, AccessorPolicy, OwningPolicy>::layout_t::layout_info;
 
  template <typename T, typename T2 = std::remove_reference_t<T> /* Keep this: Fix for gcc11 bug */>
  using get_view_t = std::remove_reference_t<decltype(basic_array_view{std::declval<T>()})>;
 
  template <typename T, typename T2 = std::remove_reference_t<T> /* Keep this: Fix for gcc11 bug */>
  using get_regular_t = decltype(basic_array{std::declval<T>()});
 
  template <typename T, typename RT = get_regular_t<T>>
  using get_regular_host_t =
     std::conditional_t<mem::on_host<RT>, RT,
                        basic_array<get_value_t<RT>, get_rank<RT>, get_contiguous_layout_policy<get_rank<RT>, get_layout_info<RT>.stride_order>,
                                    get_algebra<RT>, heap<mem::Host>>>;
 
  template <typename T, typename RT = get_regular_t<T>>
  using get_regular_device_t =
     std::conditional_t<mem::on_device<RT>, RT,
                        basic_array<get_value_t<RT>, get_rank<RT>, get_contiguous_layout_policy<get_rank<RT>, get_layout_info<RT>.stride_order>,
                                    get_algebra<RT>, heap<mem::Device>>>;
 
  template <typename T, typename RT = get_regular_t<T>>
  using get_regular_unified_t =
     std::conditional_t<mem::on_unified<RT>, RT,
                        basic_array<get_value_t<RT>, get_rank<RT>, get_contiguous_layout_policy<get_rank<RT>, get_layout_info<RT>.stride_order>,
                                    get_algebra<RT>, heap<mem::Unified>>>;
 
  template <char OP, Array A>
  inline constexpr char get_algebra<expr_unary<OP, A>> = get_algebra<A>;
 
  template <char OP, Array A>
  inline constexpr layout_info_t get_layout_info<expr_unary<OP, A>> = get_layout_info<A>;
 
  template <char OP, typename L, typename R>
  inline constexpr char get_algebra<expr<OP, L, R>> = expr<OP, L, R>::algebra;
 
  template <char OP, typename L, typename R>
  inline constexpr layout_info_t get_layout_info<expr<OP, L, R>> = expr<OP, L, R>::compute_layout_info();
 
} // namespace nda