Add distributed ranges as experimental feature.

.clang-format

@@ -1,6 +1,6 @@
 BasedOnStyle: LLVM
 
-Standard: c++17
+Standard: c++20
 
 IndentWidth: 4
 ColumnLimit: 120

.github/workflows/ci.yml

@@ -8,6 +8,7 @@ on:
       - release_oneDPL
       - main
       - 'release/**'
+      - distributed-ranges
 
 permissions: read-all
 
@@ -170,6 +171,12 @@ jobs:
             build_type: release
             backend: serial
             device_type: HOST
+          - os: ubuntu-24.04
+            cxx_compiler: icpx
+            std: 23
+            build_type: release
+            backend: dpcpp
+            device_type: CPU
     steps:
       - uses: actions/checkout@v3
       - name: Set up Intel APT repository
@@ -194,6 +201,11 @@ jobs:
         if: (matrix.device_type == 'FPGA_EMU')
         run: |
           sudo apt-get install intel-oneapi-compiler-fpga -y
+      - name: Install libfmt and gtest needed by Distributed Ranges tests
+        if: (matrix.std == '23')
+        run: |
+          sudo apt-get install libgtest-dev libfmt-dev -y
+          sudo apt-get remove libgcc-14-dev cpp-14-x86-64-linux-gnu -y  # gcc14 toolkit not supported yet by DR
       - name: Run testing
         shell: bash
         run: |
@@ -208,6 +220,13 @@ jobs:
             make_targets="build-onedpl-sycl_iterator-tests"
             ctest_flags="-R sycl_iterator_.*\.pass"
             echo "::warning::dpcpp backend is set. Compile and run only sycl_iterator tests"
+
+            if [[ "${{ matrix.std }}" == "23" ]]; then
+              make_targets="$make_targets shp-all-tests"
+              ctest_flags="$ctest_flags|shp-tests"
+              echo "::warning::23 standard is set. Compile and run distributed ranges tests"
+            fi
+
           else
             make_targets="build-onedpl-tests"
           fi

CMakeLists.txt

@@ -311,6 +311,14 @@ if (ONEDPL_BACKEND MATCHES "^(tbb|dpcpp|dpcpp_only)$")
             $<$<AND:$<BOOL:${ONEDPL_USE_DEVICE_FPGA_HW}>,$<BOOL:${ONEDPL_FPGA_STATIC_REPORT}>>:-fsycl-link>
             ${ONEDPL_AOT_OPTIONS}
             )
+
+        # if C++23 or newer, include Distributed Ranges (experimental)
+        if (CMAKE_CXX_STANDARD GREATER_EQUAL 23)
+            set(ONEDPL_USE_DR TRUE)
+            message(STATUS "Adding Distributed Ranges to the project")
+        else()
+            message(STATUS "C++23 required to use Distributed Ranges in oneDPL")
+        endif()
     endif()
 
 elseif(ONEDPL_BACKEND MATCHES "^(serial)$")

cmake/oneDPLWindowsIntelLLVMApply.cmake

@@ -21,6 +21,8 @@ if (INTELLLVM_MSVC_WIN_STDOPTION_FIX)
     set(CMAKE_CXX17_EXTENSION_COMPILE_OPTION "-Qstd:c++17")
     set(CMAKE_CXX20_STANDARD_COMPILE_OPTION  "-Qstd:c++20")
     set(CMAKE_CXX20_EXTENSION_COMPILE_OPTION "-Qstd:c++20")
+    set(CMAKE_CXX23_STANDARD_COMPILE_OPTION  "-Qstd:c++23")
+    set(CMAKE_CXX23_EXTENSION_COMPILE_OPTION "-Qstd:c++23")
 endif()
 
 if (INTELLLVM_MSVC_WIN_LINKORDER_FIX)
@@ -37,5 +39,5 @@ endif()
 if (INTELLLVM_WIN_STD_IGNORE_FIX)
     include(Compiler/CMakeCommonCompilerMacros)
     # Setting c++ standard default to 14, and enabling usage of CMAKE_CXX_STANDARD
-    __compiler_check_default_language_standard(CXX 2020 14)
+    __compiler_check_default_language_standard(CXX 2023 14)
 endif()

cmake/oneDPLWindowsIntelLLVMConfig.cmake

@@ -59,13 +59,15 @@ else()
             set(CMAKE_CXX_COMPILER_ID "IntelLLVM GNU-Like Workaround" CACHE STRING "Switch compiler identification" FORCE)
             set(CMAKE_CXX_COMPILER_VERSION "${INTEL_LLVM_COMPILER_VERSION}" CACHE STRING "Switch compiler version" FORCE)
             # Explicitly setting the c++17 standard compile option so that "target_compile_features()" check functions properly for this workaround
-            set(CMAKE_CXX_COMPILE_FEATURES cxx_std_14 cxx_std_17 cxx_std_20)
+            set(CMAKE_CXX_COMPILE_FEATURES cxx_std_14 cxx_std_17 cxx_std_20 cxx_std_23)
             set(CMAKE_CXX14_COMPILE_FEATURES cxx_std_14)
             set(CMAKE_CXX17_COMPILE_FEATURES cxx_std_17)
             set(CMAKE_CXX20_COMPILE_FEATURES cxx_std_20)
+            set(CMAKE_CXX23_COMPILE_FEATURES cxx_std_23)
             set(CMAKE_CXX14_STANDARD_COMPILE_OPTION "-std=c++14")
             set(CMAKE_CXX17_STANDARD_COMPILE_OPTION "-std=c++17")
             set(CMAKE_CXX20_STANDARD_COMPILE_OPTION "-std=c++20")
+            set(CMAKE_CXX23_STANDARD_COMPILE_OPTION "-std=c++23")
             set(CMAKE_CXX_STANDARD_COMPUTED_DEFAULT 14)
             set(INTELLLVM_WIN_STD_IGNORE_FIX TRUE)
             message(WARNING "On Windows, ${CMAKE_CXX_COMPILER} is not supported by CMake (https://gitlab.kitware.com/cmake/cmake/-/issues/24314) at this time and may encounter issues. We recommend using CMAKE_CXX_COMPILER=icx on Windows.")

include/oneapi/dpl/distributed-ranges

@@ -0,0 +1,28 @@
+// -*- 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.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _ONEDPL_DISTRIBUTED_RANGES
+#define _ONEDPL_DISTRIBUTED_RANGES
+
+#include "oneapi/dpl/internal/common_config.h"
+#include "oneapi/dpl/pstl/onedpl_config.h"
+
+#if __cplusplus > 202002L
+#include "oneapi/dpl/internal/distributed_ranges_impl/shp.hpp"
+#else
+#error "C++23 required to use Distributed Ranges"
+#endif
+
+#endif // _ONEDPL_DISTRIBUTED_RANGES

include/oneapi/dpl/internal/distributed_ranges_impl/concepts/concepts.hpp

@@ -0,0 +1,81 @@
+// -*- 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.
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include <oneapi/dpl/internal/distributed_ranges_impl/detail/ranges.hpp>
+
+namespace oneapi::dpl::experimental::dr
+{
+
+template <typename I>
+concept remote_iterator = std::forward_iterator<I> && requires(I& iter)
+{
+    ranges::rank(iter);
+};
+
+template <typename R>
+concept remote_range = rng::forward_range<R> && requires(R& r)
+{
+    ranges::rank(r);
+};
+
+template <typename R>
+concept distributed_range = rng::forward_range<R> && requires(R& r)
+{
+    ranges::segments(r);
+};
+
+template <typename I>
+concept remote_contiguous_iterator = std::random_access_iterator<I> && requires(I& iter)
+{
+    ranges::rank(iter);
+    {
+        ranges::local(iter)
+        } -> std::contiguous_iterator;
+};
+
+template <typename I>
+concept distributed_iterator = std::forward_iterator<I> && requires(I& iter)
+{
+    ranges::segments(iter);
+};
+
+template <typename R>
+concept remote_contiguous_range = remote_range<R> && rng::random_access_range<R> && requires(R& r)
+{
+    {
+        ranges::local(r)
+        } -> rng::contiguous_range;
+};
+
+template <typename R>
+concept distributed_contiguous_range = distributed_range<R> && rng::random_access_range<R> && requires(R& r)
+{
+    {
+        ranges::segments(r)
+        } -> rng::random_access_range;
+} && remote_contiguous_range<rng::range_value_t<decltype(ranges::segments(std::declval<R>()))>>;
+
+template <typename Iter>
+concept distributed_contiguous_iterator = distributed_iterator<Iter> && std::random_access_iterator<Iter> &&
+    requires(Iter& iter)
+{
+    {
+        ranges::segments(iter)
+        } -> rng::random_access_range;
+} && remote_contiguous_range<rng::range_value_t<decltype(ranges::segments(std::declval<Iter>()))>>;
+
+} // namespace oneapi::dpl::experimental::dr

include/oneapi/dpl/internal/distributed_ranges_impl/detail/enumerate.hpp

@@ -0,0 +1,97 @@
+// -*- 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.
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include <oneapi/dpl/internal/distributed_ranges_impl/detail/ranges_shim.hpp>
+
+namespace oneapi::dpl::experimental::dr
+{
+
+namespace __detail
+{
+
+namespace
+{
+
+template <rng::range R>
+struct range_size
+{
+    using type = std::size_t;
+};
+
+template <rng::sized_range R>
+struct range_size<R>
+{
+    using type = rng::range_size_t<R>;
+};
+
+template <rng::range R>
+using range_size_t = typename range_size<R>::type;
+
+} // namespace
+
+class enumerate_adapter_closure
+{
+  public:
+    template <rng::viewable_range R>
+    auto
+    operator()(R&& r) const
+    {
+        using S = range_size_t<R>;
+        // NOTE: This line only necessary due to bug in range-v3 where views
+        //       have non-weakly-incrementable size types. (Standard mandates
+        //       size type must be weakly incrementable.)
+        using W = std::conditional_t<std::weakly_incrementable<S>, S, std::size_t>;
+        if constexpr (rng::sized_range<R>)
+        {
+            return rng::views::zip(rng::views::iota(W{0}, W{rng::size(r)}), std::forward<R>(r));
+        }
+        else
+        {
+            return rng::views::zip(rng::views::iota(W{0}), std::forward<R>(r));
+        }
+    }
+
+    template <rng::viewable_range R>
+    friend auto
+    operator|(R&& r, const enumerate_adapter_closure& closure)
+    {
+        return closure(std::forward<R>(r));
+    }
+};
+
+class enumerate_fn_
+{
+  public:
+    template <rng::viewable_range R>
+    constexpr auto
+    operator()(R&& r) const
+    {
+        return enumerate_adapter_closure{}(std::forward<R>(r));
+    }
+
+    inline auto
+    enumerate() const
+    {
+        return enumerate_adapter_closure{};
+    }
+};
+
+inline constexpr auto enumerate = enumerate_fn_{};
+
+} // namespace __detail
+
+} // namespace oneapi::dpl::experimental::dr