Sid: dimension to tuple like

include/gridtools/common/tuple_util.hpp

@@ -182,7 +182,7 @@
  * ```
  * Also tuple algorithms works with `foo` as expected:
  * ```
- *    auto x = tuple_util::trasnform([](auto x) { return x * 2; }, foo{1, 2.5});
+ *    auto x = tuple_util::transform([](auto x) { return x * 2; }, foo{1, 2.5});
  *    assert(x.a == 2);
  *    assert(x.b == 5.);
  * ```

include/gridtools/sid/composite.hpp

@@ -137,7 +137,7 @@ namespace gridtools {
 
                 struct sum {
                     template <class Lhs, class Rhs>
-                    GT_FUNCTION constexpr auto operator()(Lhs &&lhs, Rhs &&rhs) const {
+                    GT_FORCE_INLINE constexpr auto operator()(Lhs &&lhs, Rhs &&rhs) const {
                         return std::forward<Lhs>(lhs) + std::forward<Rhs>(rhs);
                     }
                 };

include/gridtools/sid/dimension_to_tuple_like.hpp

@@ -0,0 +1,71 @@
+/*
+ * GridTools
+ *
+ * Copyright (c) 2014-2021, ETH Zurich
+ * All rights reserved.
+ *
+ * Please, refer to the LICENSE file in the root directory.
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+#pragma once
+
+#include <type_traits>
+#include <utility>
+
+#include "../common/host_device.hpp"
+#include "../common/hymap.hpp"
+#include "../meta.hpp"
+#include "composite.hpp"
+#include "concept.hpp"
+#include "delegate.hpp"
+#include "sid_shift_origin.hpp"
+
+namespace gridtools {
+    namespace sid {
+        namespace dimension_to_tuple_like_impl_ {
+            template <class Dim, class Sid>
+            struct remove_dimension_sid : sid::delegate<Sid> {
+                friend decltype(hymap::canonicalize_and_remove_key<Dim>(std::declval<sid::strides_type<Sid>>()))
+                sid_get_strides(remove_dimension_sid const &obj) {
+                    return hymap::canonicalize_and_remove_key<Dim>(sid::get_strides(obj.m_impl));
+                }
+                friend decltype(hymap::canonicalize_and_remove_key<Dim>(std::declval<sid::lower_bounds_type<Sid>>()))
+                sid_get_lower_bounds(remove_dimension_sid const &obj) {
+                    return hymap::canonicalize_and_remove_key<Dim>(sid::get_lower_bounds(obj.m_impl));
+                }
+                friend decltype(hymap::canonicalize_and_remove_key<Dim>(std::declval<sid::upper_bounds_type<Sid>>()))
+                sid_get_upper_bounds(remove_dimension_sid const &obj) {
+                    return hymap::canonicalize_and_remove_key<Dim>(sid::get_upper_bounds(obj.m_impl));
+                }
+
+                using sid::delegate<Sid>::delegate;
+            };
+
+            template <class Dim, class Sid>
+            remove_dimension_sid<Dim, Sid> remove_dimension(Sid &&sid) {
+                return {std::forward<Sid>(sid)};
+            }
+
+            template <class Dim, class Sid, size_t... Is>
+            constexpr auto as_tuple_like_helper(Sid &&sid, std::index_sequence<Is...>) {
+                using keys = sid::composite::keys<integral_constant<int, Is>...>;
+                return keys::make_values(remove_dimension<Dim>(
+                    sid::shift_sid_origin(std::forward<Sid>(sid), hymap::keys<Dim>::make_values(Is)))...);
+            }
+        } // namespace dimension_to_tuple_like_impl_
+
+        /**
+         * Returns a SID, where `Dim` of `sid` is mapped to a tuple-like of size `N`.
+         *
+         * TODO(havogt):
+         * - Currently, no bounds check is implemented.
+         * - In case bounds are compile-time known we could infer `N`.
+         */
+        template <class Dim, size_t N, class Sid>
+        auto dimension_to_tuple_like(Sid &&sid) {
+            return dimension_to_tuple_like_impl_::as_tuple_like_helper<Dim>(
+                std::forward<Sid>(sid), std::make_index_sequence<N>{});
+        }
+    } // namespace sid
+} // namespace gridtools

include/gridtools/stencil/common/intent.hpp

@@ -21,6 +21,11 @@ namespace gridtools {
         template <intent Intent, class T>
         struct apply_intent_type;
 
+        template <class T>
+        struct apply_intent_type<intent::inout, T> {
+            using type = T; // in case T is wrapping a reference (e.g. sid::composite)
+        };
+
         template <class T>
         struct apply_intent_type<intent::inout, T &> {
             using type = T &;

tests/include/fn_mesh.hpp

@@ -90,16 +90,21 @@ namespace gridtools {
         }
         constexpr int nlevels() const { return m_nz; }
 
-        template <class T = FloatType, class Init, class... Dims, std::enable_if_t<!std::is_integral_v<Init>, int> = 0>
+        template <class T = FloatType,
+            class Init,
+            class... Dims,
+            std::enable_if_t<!(std::is_integral_v<Init> || is_integral_constant<Init>::value), int> = 0>
         auto make_storage(Init const &init, Dims... dims) const {
             return storage::builder<StorageTraits>.dimensions(dims...).template type<T>().initializer(init).unknown_id().build();
         }
 
         template <class T = FloatType,
             class... Dims,
-            std::enable_if_t<std::conjunction_v<std::is_integral<Dims>...>, int> = 0>
+            std::enable_if_t<std::conjunction_v<std::bool_constant<std::is_integral<Dims>::value ||
+                                                                   is_integral_constant<Dims>::value>...>,
+                int> = 0>
         auto make_storage(Dims... dims) const {
-            return make_storage<T>([](int, int) { return T(); }, dims...);
+            return make_storage<T>([](int...) { return T(); }, dims...);
         }
 
         template <class T = FloatType, class... Args>

tests/include/test_environment.hpp

@@ -208,11 +208,11 @@ namespace gridtools {
                     EXPECT_TRUE(verify_data_store(expected, actual, halos, equal_to));
                 }
 
-                template <class T = FloatType>
-                static auto builder() {
-                    return storage::builder<storage_traits_t> //
-                        .dimensions(d(0), d(1), k_size())     //
-                        .halos(Halo, Halo, 0)                 //
+                template <class T = FloatType, class... ExtraDims>
+                static auto builder(ExtraDims... extra_dims) {
+                    return storage::builder<storage_traits_t>                        //
+                        .dimensions(d(0), d(1), k_size(), extra_dims...)             //
+                        .halos(Halo, Halo, 0, [](auto) { return 0; }(extra_dims)...) //
                         .template type<T>();
                 }
 

tests/include/verifier.hpp

@@ -108,23 +108,15 @@ namespace gridtools {
             return out;
         }
 
-        template <class Expected, class DataStore, class Halos, class EqualTo = default_equal_to>
-        std::enable_if_t<storage::is_data_store<DataStore>::value &&
-                             is_view_compatible<Expected, DataStore::ndims>::value,
-            bool>
-        verify_data_store(Expected const &expected,
-            std::shared_ptr<DataStore> const &actual,
-            Halos const &halos,
+        template <class Expected, class Actual, size_t NDims, class EqualTo = default_equal_to>
+        bool verify_generic(Expected const &expected,
+            Actual const &actual,
+            array<array<size_t, 2>, NDims> const &bounds,
             EqualTo equal_to = {}) {
-            array<array<size_t, 2>, DataStore::ndims> bounds;
-            auto &&lengths = actual->lengths();
-            for (size_t i = 0; i < bounds.size(); ++i)
-                bounds[i] = {halos[i][0], lengths[i] - halos[i][1]};
-            auto view = actual->const_host_view();
             static constexpr size_t err_lim = 20;
             size_t err_count = 0;
             for (auto &&pos : make_hypercube_view(bounds)) {
-                auto a = verify_impl_::apply(view, pos);
+                auto a = verify_impl_::apply(actual, pos);
                 decltype(a) e = verify_impl_::apply(expected, pos);
                 if (equal_to(e, a))
                     continue;
@@ -138,6 +130,22 @@ namespace gridtools {
             return err_count == 0;
         }
 
+        template <class Expected, class DataStore, class Halos, class EqualTo = default_equal_to>
+        std::enable_if_t<storage::is_data_store<DataStore>::value &&
+                             is_view_compatible<Expected, DataStore::ndims>::value,
+            bool>
+        verify_data_store(Expected const &expected,
+            std::shared_ptr<DataStore> const &actual,
+            Halos const &halos,
+            EqualTo equal_to = {}) {
+            array<array<size_t, 2>, DataStore::ndims> bounds;
+            auto &&lengths = actual->lengths();
+            for (size_t i = 0; i < bounds.size(); ++i)
+                bounds[i] = {halos[i][0], lengths[i] - halos[i][1]};
+            auto view = actual->const_host_view();
+            return verify_generic(expected, view, bounds, equal_to);
+        }
+
         template <class DataStore, class Halos, class EqualTo = default_equal_to>
         std::enable_if_t<storage::is_data_store_ptr<DataStore>::value, bool> verify_data_store(
             DataStore const &expected, DataStore const &actual, Halos const &halos, EqualTo equal_to = {}) {

tests/regression/CMakeLists.txt

@@ -145,6 +145,7 @@ gridtools_add_cartesian_regression_test(horizontal_diffusion SOURCES horizontal_
 gridtools_add_cartesian_regression_test(horizontal_diffusion_fused SOURCES horizontal_diffusion_fused.cpp PERFTEST)
 gridtools_add_cartesian_regression_test(simple_hori_diff SOURCES simple_hori_diff.cpp PERFTEST)
 gridtools_add_cartesian_regression_test(copy_stencil SOURCES copy_stencil.cpp PERFTEST)
+gridtools_add_cartesian_regression_test(copy_stencil_tuple SOURCES copy_stencil_tuple.cpp PERFTEST)
 gridtools_add_cartesian_regression_test(vertical_advection_dycore SOURCES vertical_advection_dycore.cpp PERFTEST)
 gridtools_add_cartesian_regression_test(advection_pdbott_prepare_tracers SOURCES advection_pdbott_prepare_tracers.cpp PERFTEST)
 gridtools_add_cartesian_regression_test(parallel_multistage_fusion SOURCES parallel_multistage_fusion.cpp)