Merge dense device_view type

This is a simpler representation of Dense that provides a simple ABI-stable representation to be passed between libraries.

Author: upsj

core/matrix/dense.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: 2017 - 2025 The Ginkgo authors
+// SPDX-FileCopyrightText: 2017 - 2026 The Ginkgo authors
 //
 // SPDX-License-Identifier: BSD-3-Clause
 
@@ -1956,6 +1956,22 @@ void Dense<ValueType>::get_imag(ptr_param<real_type> result) const
 }
 
 
+template <typename ValueType>
+auto Dense<ValueType>::get_device_view() -> device_view
+{
+    return device_view{this->get_size(), this->get_stride(),
+                       this->get_values()};
+};
+
+
+template <typename ValueType>
+auto Dense<ValueType>::get_const_device_view() const -> const_device_view
+{
+    return const_device_view{this->get_size(), this->get_stride(),
+                             this->get_const_values()};
+};
+
+
 template <typename ValueType>
 void Dense<ValueType>::add_scaled_identity_impl(const LinOp* a, const LinOp* b)
 {

core/test/matrix/CMakeLists.txt

@@ -7,6 +7,7 @@ ginkgo_create_test(coo_builder)
 ginkgo_create_test(csr)
 ginkgo_create_test(csr_builder)
 ginkgo_create_test(dense)
+ginkgo_create_test(device_views)
 ginkgo_create_test(diagonal)
 ginkgo_create_test(ell)
 ginkgo_create_test(fbcsr)

core/test/matrix/dense.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: 2017 - 2025 The Ginkgo authors
+// SPDX-FileCopyrightText: 2017 - 2026 The Ginkgo authors
 //
 // SPDX-License-Identifier: BSD-3-Clause
 
@@ -306,6 +306,26 @@ TYPED_TEST(Dense, CanBeReadFromMatrixAssemblyData)
 }
 
 
+TYPED_TEST(Dense, CanCreateDeviceView)
+{
+    auto view = this->mtx->get_device_view();
+
+    EXPECT_EQ(view.size, this->mtx->get_size());
+    EXPECT_EQ(view.stride, this->mtx->get_stride());
+    EXPECT_EQ(view.data, this->mtx->get_values());
+}
+
+
+TYPED_TEST(Dense, CanCreateConstDeviceView)
+{
+    auto view = this->mtx->get_const_device_view();
+
+    EXPECT_EQ(view.size, this->mtx->get_size());
+    EXPECT_EQ(view.stride, this->mtx->get_stride());
+    EXPECT_EQ(view.data, this->mtx->get_values());
+}
+
+
 TYPED_TEST(Dense, CanCreateSubmatrix)
 {
     using value_type = typename TestFixture::value_type;

core/test/matrix/device_views.cpp

@@ -0,0 +1,34 @@
+// SPDX-FileCopyrightText: 2026 The Ginkgo authors
+//
+// SPDX-License-Identifier: BSD-3-Clause
+
+#include <gtest/gtest.h>
+
+#include <ginkgo/core/matrix/device_views.hpp>
+
+#include "core/test/utils.hpp"
+
+
+template <typename T>
+class DenseView : public ::testing::Test {};
+
+TYPED_TEST_SUITE(DenseView, gko::test::ValueTypes, TypenameNameGenerator);
+
+
+TYPED_TEST(DenseView, AccessWorks)
+{
+    std::vector<TypeParam> values(10);
+    gko::matrix::view::dense<TypeParam> view{gko::dim<2>{1, 2}, 3,
+                                             values.data()};
+    auto const_view = view.as_const();
+
+    ASSERT_EQ(view.size, gko::dim<2>(1, 2));
+    ASSERT_EQ(view.stride, 3);
+    ASSERT_EQ(view.data, values.data());
+    ASSERT_EQ(&view(0, 0), &values[0]);
+    ASSERT_EQ(&view(1, 0), &values[3]);
+    ASSERT_EQ(&view(1, 1), &values[4]);
+    ASSERT_EQ(const_view.size, view.size);
+    ASSERT_EQ(const_view.stride, view.stride);
+    ASSERT_EQ(const_view.data, view.data);
+}

include/ginkgo/core/matrix/dense.hpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: 2017 - 2025 The Ginkgo authors
+// SPDX-FileCopyrightText: 2017 - 2026 The Ginkgo authors
 //
 // SPDX-License-Identifier: BSD-3-Clause
 
@@ -16,6 +16,7 @@
 #include <ginkgo/core/base/range_accessors.hpp>
 #include <ginkgo/core/base/types.hpp>
 #include <ginkgo/core/base/utils.hpp>
+#include <ginkgo/core/matrix/device_views.hpp>
 #include <ginkgo/core/matrix/permutation.hpp>
 #include <ginkgo/core/matrix/scaled_permutation.hpp>
 
@@ -177,14 +178,16 @@ class Dense
 
     using value_type = ValueType;
     using index_type = int64;
-    using transposed_type = Dense<ValueType>;
-    using mat_data = matrix_data<ValueType, int64>;
-    using mat_data32 = matrix_data<ValueType, int32>;
-    using device_mat_data = device_matrix_data<ValueType, int64>;
-    using device_mat_data32 = device_matrix_data<ValueType, int32>;
+    using transposed_type = Dense<value_type>;
+    using mat_data = matrix_data<value_type, int64>;
+    using mat_data32 = matrix_data<value_type, int32>;
+    using device_mat_data = device_matrix_data<value_type, int64>;
+    using device_mat_data32 = device_matrix_data<value_type, int32>;
     using absolute_type = remove_complex<Dense>;
     using real_type = absolute_type;
     using complex_type = to_complex<Dense>;
+    using device_view = matrix::view::dense<value_type>;
+    using const_device_view = matrix::view::dense<const value_type>;
 
     using row_major_range = gko::range<gko::accessor::row_major<ValueType, 2>>;
 
@@ -889,6 +892,10 @@ class Dense
         return values_.get_size();
     }
 
+    device_view get_device_view();
+
+    const_device_view get_const_device_view() const;
+
     /**
      * Returns a single element of the matrix.
      *

include/ginkgo/core/matrix/device_views.hpp

@@ -0,0 +1,53 @@
+// SPDX-FileCopyrightText: 2026 The Ginkgo authors
+//
+// SPDX-License-Identifier: BSD-3-Clause
+
+#ifndef GKO_PUBLIC_CORE_MATRIX_DEVICE_DENSE_HPP_
+#define GKO_PUBLIC_CORE_MATRIX_DEVICE_DENSE_HPP_
+
+#include <ginkgo/core/base/dim.hpp>
+
+
+namespace gko {
+namespace matrix {
+namespace view {
+
+
+/**
+ * Non-owning view of a matrix::Dense to be used inside device kernels.
+ * This type is used to provide a simple and stable ABI for passing data between
+ * libraries.
+ *
+ * @tparam ValueType  the value type used to store matrix entries.
+ */
+template <typename ValueType>
+struct dense {
+    dim<2> size;
+    size_type stride;
+    ValueType* data;
+
+    /** Constructs a dense view from size, stride and data. */
+    constexpr dense(dim<2> size, size_type stride, ValueType* data)
+        : size{size}, stride{stride}, data{data}
+    {}
+
+    /** Returns a const view of the same data */
+    constexpr dense<const ValueType> as_const() const
+    {
+        return dense<const ValueType>{size, stride, data};
+    }
+
+    /** Subscript operator accessing the given row and column */
+    constexpr ValueType& operator()(size_type row, size_type col) const
+    {
+        return data[row * stride + col];
+    }
+};
+
+
+}  // namespace view
+}  // namespace matrix
+}  // namespace gko
+
+
+#endif  // GKO_PUBLIC_CORE_MATRIX_DEVICE_DENSE_HPP_

test/matrix/CMakeLists.txt

@@ -5,6 +5,7 @@ ginkgo_create_common_device_test(csr_kernels)
 ginkgo_create_common_test(csr_kernels2)
 ginkgo_create_common_test(coo_kernels)
 ginkgo_create_common_test(dense_kernels)
+ginkgo_create_common_device_test(device_views)
 ginkgo_create_common_test(diagonal_kernels)
 ginkgo_create_common_test(ell_kernels)
 ginkgo_create_common_test(fbcsr_kernels DISABLE_EXECUTORS dpcpp)

test/matrix/device_views.cpp

@@ -0,0 +1,53 @@
+// SPDX-FileCopyrightText: 2017 - 2026 The Ginkgo authors
+//
+// SPDX-License-Identifier: BSD-3-Clause
+
+/*@GKO_PREPROCESSOR_FILENAME_HELPER@*/
+
+#include <type_traits>
+
+#include <gtest/gtest.h>
+
+#include "common/unified/base/kernel_launch.hpp"
+#include "core/base/array_access.hpp"
+#include "core/test/utils.hpp"
+#include "test/utils/common_fixture.hpp"
+
+
+template <typename ValueType>
+class DenseView : public CommonTestFixture {
+public:
+    using value_type = ValueType;
+    using view_type = gko::matrix::view::dense<value_type>;
+};
+
+TYPED_TEST_SUITE(DenseView, gko::test::ValueTypes, TypenameNameGenerator);
+
+
+template <typename ValueType>
+void assert_dense_view(std::shared_ptr<const gko::EXEC_TYPE> exec)
+{
+    gko::array<bool> correct{exec, {false}};
+    gko::array<ValueType> values{exec, 5};
+    values.fill(gko::one<ValueType>());
+    gko::kernels::GKO_DEVICE_NAMESPACE::run_kernel(
+        exec,
+        [] GKO_KERNEL(auto i, auto values, auto correct) {
+            using device_type = std::decay_t<decltype(values[0])>;
+            gko::matrix::view::dense<device_type> view{gko::dim<2>{1, 2}, 3,
+                                                       values};
+            if (view.size == gko::dim<2>(1, 2) && view.stride == 3 &&
+                view.data == values && &view(0, 0) == &values[0] &&
+                &view(1, 0) == &values[3] && &view(1, 1) == &values[4] &&
+                view(1, 1) == gko::one(view(1, 1))) {
+                *correct = true;
+            }
+        },
+        1, values, correct);
+    ASSERT_TRUE(get_element(correct, 0));
+}
+
+TYPED_TEST(DenseView, WorksOnDevice)
+{
+    assert_dense_view<TypeParam>(this->exec);
+}