Add static_assert check for std::range::ref_view in SYCL-kernel code

include/oneapi/dpl/pstl/hetero/dpcpp/utils_ranges_sycl.h

@@ -309,10 +309,60 @@ __require_access_range(sycl::handler& __cgh, oneapi::dpl::__internal::tuple<_Ran
                                   ::std::make_index_sequence<__num_ranges>());
 }
 
+template <typename...>
+constexpr auto
+__contains_host_pointer_probe(...) -> std::false_type;
+
+// for std::ranges::ref_view
+#if _ONEDPL_CPP20_RANGES_PRESENT
+template <std::ranges::range Rng>
+constexpr auto
+__contains_host_pointer_probe(std::ranges::ref_view<Rng>*) -> std::true_type;
+#endif // _ONEDPL_CPP20_RANGES_PRESENT
+
+template <typename T>
+using __remove_cv_ref_t = typename std::remove_cv<typename std::remove_reference<T>::type>::type;
+
+template <typename T>
+struct __contains_host_pointer : decltype(__contains_host_pointer_probe(static_cast<T*>(nullptr))){};
+
+template <typename...>
+struct __contains_host_pointer_on_any_layers;
+
+// 1. Checking the top-level view
+// 2. Searching view with host pointer in internal views(layers)
+template <typename _View>
+struct __contains_host_pointer_on_any_layers<_View>
+    : std::disjunction<
+          __contains_host_pointer<__remove_cv_ref_t<_View>>,
+          std::conditional_t<oneapi::dpl::__ranges::pipeline_base_range<_View>::has_next_layer_t::value,
+                             __contains_host_pointer_on_any_layers<
+                                 typename oneapi::dpl::__ranges::pipeline_base_range<_View>::next_layer_view_t>,
+                             std::false_type>>
+{
+};
+
+// 1.1. Checking the top-level view
+// 1.2. Searching view with host pointer in internal views(layers)
+// 2.1. Searching view with host pointer in the rest of views
+template <typename _View, typename... _Views>
+struct __contains_host_pointer_on_any_layers<_View, _Views...>
+    : std::disjunction<__contains_host_pointer_on_any_layers<_View>, __contains_host_pointer_on_any_layers<_Views...>>
+{
+};
+
+template <typename _Range, typename... _Ranges>
+struct __contains_host_pointer_on_any_layers<oneapi::dpl::__ranges::zip_view<_Range, _Ranges...>>
+    : std::disjunction<__contains_host_pointer_on_any_layers<_Range>, __contains_host_pointer_on_any_layers<_Ranges...>>
+{
+};
+
 template <typename _BaseRange>
 void
 __require_access_range(sycl::handler&, _BaseRange&)
 {
+    static_assert(!__contains_host_pointer_on_any_layers<_BaseRange>::value,
+                  "oneDPL does not support std::ranges::ref_view in SYCL-kernel code");
 }
 
 template <typename _Range, typename... _Ranges>

include/oneapi/dpl/pstl/utils_ranges.h

@@ -304,6 +304,8 @@ template <typename Range, typename = void>
 struct pipeline_base_range
 {
     Range rng;
+    using has_next_layer_t = std::false_type;
+    using next_layer_view_t = Range;
 
     pipeline_base_range(Range r) : rng(r) {}
     constexpr Range
@@ -318,6 +320,8 @@ template <typename Range>
 struct pipeline_base_range<Range, ::std::enable_if_t<is_pipeline_object<Range>::value>>
 {
     Range rng;
+    using has_next_layer_t = std::true_type;
+    using next_layer_view_t = decltype(std::declval<Range>().base());
 
     pipeline_base_range(Range r) : rng(r) {}
     constexpr auto

test/general/implementation_details/contains_host_pointers.pass.cpp

@@ -0,0 +1,177 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Copyright (C) Intel Corporation
+//
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// This file incorporates work covered by the following copyright and permission
+// notice:
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+//
+//===----------------------------------------------------------------------===//
+
+#include "support/test_config.h"
+
+#include "support/utils.h"
+
+#if _ENABLE_STD_RANGES_TESTING && TEST_DPCPP_BACKEND_PRESENT
+#include <oneapi/dpl/pstl/hetero/dpcpp/utils_ranges_sycl.h>
+
+using IntVector = std::vector<int>;
+using IteratorOfIntVector = typename IntVector::iterator;
+
+using MinimalisticRangeForIntVec     = TestUtils::MinimalisticRange<IteratorOfIntVector>;
+using MinimalisticRangeViewForIntVec = TestUtils::MinimalisticView <IteratorOfIntVector>;
+
+template <typename RandomIt>
+struct MinimalisticViewWithSubscription : TestUtils::MinimalisticView<RandomIt>
+{
+    MinimalisticViewWithSubscription(RandomIt it_begin, RandomIt it_end)
+        : TestUtils::MinimalisticView<RandomIt>(it_begin, it_end)
+    {
+    }
+
+    auto operator[](std::size_t index) const
+    {
+        return *(oneapi::dpl::__ranges::__begin(*this) + index);
+    }
+};
+
+template <typename _Rng>
+inline constexpr bool contains_host_pointer_v = oneapi::dpl::__ranges::__contains_host_pointer<_Rng>::value;
+
+template <typename... _Rng>
+inline constexpr bool contains_host_pointer_on_any_layers_v = oneapi::dpl::__ranges::__contains_host_pointer_on_any_layers<_Rng...>::value;
+
+// oneapi::dpl::__ranges::__contains_host_pointer functional
+void
+check_contains_host_pointer()
+{
+    {
+        IntVector vec;
+        auto all_view = std::ranges::views::all(MinimalisticRangeForIntVec(vec.begin(), vec.end()));
+        static_assert(contains_host_pointer_v<decltype(all_view)> == false);
+        static_assert(contains_host_pointer_on_any_layers_v<decltype(all_view)> == false);
+    }
+
+    {
+        IntVector vec;
+        MinimalisticViewWithSubscription mr_view(vec.begin(), vec.end());
+        auto all_view = std::ranges::views::all(mr_view);
+        static_assert(contains_host_pointer_v<decltype(all_view)> == false);
+        static_assert(contains_host_pointer_on_any_layers_v<decltype(all_view)> == false);
+    }
+
+    {
+        IntVector vec;
+
+        MinimalisticViewWithSubscription mr_view(vec.begin(), vec.end());
+        auto all_view1 = std::ranges::views::all(mr_view);
+
+        MinimalisticRangeForIntVec mr(vec.begin(), vec.end());
+        auto all_view2 = std::ranges::views::all(mr);
+
+        static_assert(contains_host_pointer_on_any_layers_v<decltype(all_view1)> == false);
+        static_assert(contains_host_pointer_on_any_layers_v<decltype(all_view2)> == true);
+        static_assert(contains_host_pointer_on_any_layers_v<decltype(all_view1), decltype(all_view2)> == true);
+    }
+}
+
+// oneapi::dpl::__ranges::__contains_host_pointer functional with oneapi::dpl::__ranges::zip_view
+void
+check_contains_host_pointer_in_zip_view()
+{
+    {
+        IntVector vec;
+
+        MinimalisticRangeForIntVec mr(vec.begin(), vec.end());
+        auto all_view = std::ranges::views::all(mr);
+
+        auto zip_view = oneapi::dpl::__ranges::make_zip_view(all_view, all_view);
+
+        static_assert(contains_host_pointer_v<decltype(all_view)> == true);
+        static_assert(contains_host_pointer_v<decltype(zip_view)> == false);
+        static_assert(contains_host_pointer_on_any_layers_v<decltype(zip_view)> == true);
+    }
+
+    {
+        IntVector vec;
+
+        MinimalisticViewWithSubscription mrv(vec.begin(), vec.end());
+        auto all_view1 = std::ranges::views::all(mrv);
+
+        MinimalisticRangeForIntVec mr(vec.begin(), vec.end());
+        auto all_view2 = std::ranges::views::all(mr);
+
+        auto zip_view = oneapi::dpl::__ranges::make_zip_view(all_view1, all_view2);
+
+        static_assert(contains_host_pointer_v<decltype(all_view1)> == false);
+        static_assert(contains_host_pointer_v<decltype(all_view2)> == true);
+        static_assert(contains_host_pointer_v<decltype(zip_view)> == false);
+        static_assert(contains_host_pointer_on_any_layers_v<decltype(zip_view)> == true);
+    }
+
+    {
+        IntVector vec;
+
+        MinimalisticViewWithSubscription mrv(vec.begin(), vec.end());
+        auto all_view = std::ranges::views::all(mrv);
+
+        auto zip_view = oneapi::dpl::__ranges::make_zip_view(all_view, all_view);
+
+        static_assert(contains_host_pointer_v<decltype(all_view)> == false);
+        static_assert(contains_host_pointer_v<decltype(zip_view)> == false);
+        static_assert(contains_host_pointer_on_any_layers_v<decltype(zip_view)> == false);
+    }
+}
+
+// oneapi::dpl::__ranges::__contains_host_pointer functional with std::ranges::take_view
+void
+check_contains_host_pointer_in_take_view()
+{
+    IntVector vec;
+    MinimalisticRangeForIntVec mr(vec.begin(), vec.end());
+    auto all_view = std::ranges::views::all(mr);
+    auto taken_view = std::ranges::take_view(all_view, all_view.size());
+
+    static_assert(contains_host_pointer_v<decltype(all_view)> == true);
+    static_assert(contains_host_pointer_v<decltype(taken_view)> == false);
+    static_assert(contains_host_pointer_on_any_layers_v<decltype(taken_view)> == true);
+}
+
+// oneapi::dpl::__ranges::__contains_host_pointer functional with std::ranges::drop_view
+void
+check_contains_host_pointer_in_drop_view()
+{
+    IntVector vec;
+    MinimalisticRangeForIntVec mr(vec.begin(), vec.end());
+    auto all_view = std::ranges::views::all(mr);
+    auto dropped_view = std::ranges::drop_view(all_view, 0);
+
+    static_assert(contains_host_pointer_v<decltype(all_view)> == true);
+    static_assert(contains_host_pointer_v<decltype(dropped_view)> == false);
+    static_assert(contains_host_pointer_on_any_layers_v<decltype(dropped_view)> == true);
+}
+#endif // _ENABLE_STD_RANGES_TESTING && TEST_DPCPP_BACKEND_PRESENT
+
+int
+main()
+{
+    bool bProcessed = false;
+
+#if _ENABLE_STD_RANGES_TESTING && TEST_DPCPP_BACKEND_PRESENT
+
+    check_contains_host_pointer();
+    check_contains_host_pointer_in_zip_view();
+    check_contains_host_pointer_in_take_view();
+    check_contains_host_pointer_in_drop_view();
+
+    bProcessed = true;
+
+#endif // _ENABLE_STD_RANGES_TESTING && TEST_DPCPP_BACKEND_PRESENT
+
+    return TestUtils::done(bProcessed);
+}

test/support/utils.h

@@ -1342,21 +1342,46 @@ struct NoDefaultCtorWrapper {
 
 #if _ENABLE_STD_RANGES_TESTING
 
-// A minimalistic view to detect an accidental use of methods such as begin(), end(), empty(), operator[] and etc,
-// which are not required for a class to be considered a range.
+// A minimalistic range: it can't be applied directly to hetero range-based algorithms,
+// but can be used for internal checks
 // Note, begin() and end() functions are still required, but they can be provided as ADL-discoverable free functions.
 template <typename RandomIt>
-struct MinimalisticView : std::ranges::view_base
+struct MinimalisticRange
 {
     RandomIt it_begin;
     RandomIt it_end;
 
-    MinimalisticView(RandomIt it_begin, RandomIt it_end) 
+    MinimalisticRange(RandomIt it_begin, RandomIt it_end)
         : it_begin(it_begin), it_end(it_end)
     {
     }
 };
 
+template <typename RandomIt>
+RandomIt
+begin(MinimalisticRange<RandomIt> range)
+{
+    return range.it_begin;
+}
+
+template <typename RandomIt>
+RandomIt
+end(MinimalisticRange<RandomIt> range)
+{
+    return range.it_end;
+}
+
+// A minimalistic view to detect an accidental use of methods such as begin(), end(), empty(), operator[] and etc,
+// which are not required for a class to be considered a range.
+template <typename RandomIt>
+struct MinimalisticView : MinimalisticRange<RandomIt>, std::ranges::view_base
+{
+    MinimalisticView(RandomIt it_begin, RandomIt it_end)
+        : MinimalisticRange<RandomIt>(it_begin, it_end)
+    {
+    }
+};
+
 template <typename RandomIt>
 RandomIt
 begin(MinimalisticView<RandomIt> view)