cuda-cccl 0.3.2__cp313-cp313-manylinux_2_24_aarch64.whl → 0.3.4__cp313-cp313-manylinux_2_24_aarch64.whl

cuda/cccl/headers/include/thrust/system/omp/detail/remove.h

@@ -1,18 +1,5 @@
-/*
- *  Copyright 2008-2013 NVIDIA Corporation
- *
- *  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
- *
- *  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.
- */
+// SPDX-FileCopyrightText: Copyright (c) 2008-2013, NVIDIA Corporation. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
 
 #pragma once
 
@@ -25,19 +12,20 @@
 #elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
 #  pragma system_header
 #endif // no system header
+
+#include <thrust/system/detail/generic/remove.h>
 #include <thrust/system/omp/detail/execution_policy.h>
 
 THRUST_NAMESPACE_BEGIN
-namespace system
-{
-namespace omp
-{
-namespace detail
+namespace system::omp::detail
 {
-
 template <typename DerivedPolicy, typename ForwardIterator, typename Predicate>
 ForwardIterator
-remove_if(execution_policy<DerivedPolicy>& exec, ForwardIterator first, ForwardIterator last, Predicate pred);
+remove_if(execution_policy<DerivedPolicy>& exec, ForwardIterator first, ForwardIterator last, Predicate pred)
+{
+  // omp prefers generic::remove_if to cpp::remove_if
+  return thrust::system::detail::generic::remove_if(exec, first, last, pred);
+}
 
 template <typename DerivedPolicy, typename ForwardIterator, typename InputIterator, typename Predicate>
 ForwardIterator remove_if(
@@ -45,11 +33,19 @@ ForwardIterator remove_if(
   ForwardIterator first,
   ForwardIterator last,
   InputIterator stencil,
-  Predicate pred);
+  Predicate pred)
+{
+  // omp prefers generic::remove_if to cpp::remove_if
+  return thrust::system::detail::generic::remove_if(exec, first, last, stencil, pred);
+}
 
 template <typename DerivedPolicy, typename InputIterator, typename OutputIterator, typename Predicate>
 OutputIterator remove_copy_if(
-  execution_policy<DerivedPolicy>& exec, InputIterator first, InputIterator last, OutputIterator result, Predicate pred);
+  execution_policy<DerivedPolicy>& exec, InputIterator first, InputIterator last, OutputIterator result, Predicate pred)
+{
+  // omp prefers generic::remove_copy_if to cpp::remove_copy_if
+  return thrust::system::detail::generic::remove_copy_if(exec, first, last, result, pred);
+}
 
 template <typename DerivedPolicy,
           typename InputIterator1,
@@ -62,11 +58,10 @@ OutputIterator remove_copy_if(
   InputIterator1 last,
   InputIterator2 stencil,
   OutputIterator result,
-  Predicate pred);
-
-} // end namespace detail
-} // end namespace omp
-} // end namespace system
+  Predicate pred)
+{
+  // omp prefers generic::remove_copy_if to cpp::remove_copy_if
+  return thrust::system::detail::generic::remove_copy_if(exec, first, last, stencil, result, pred);
+}
+} // end namespace system::omp::detail
 THRUST_NAMESPACE_END
-
-#include <thrust/system/omp/detail/remove.inl>

cuda/cccl/headers/include/thrust/system/omp/detail/replace.h

@@ -1,18 +1,5 @@
-/*
- *  Copyright 2008-2013 NVIDIA Corporation
- *
- *  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
- *
- *  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.
- */
+// SPDX-FileCopyrightText: Copyright (c) 2008-2013, NVIDIA Corporation. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
 
 #pragma once
 

cuda/cccl/headers/include/thrust/system/omp/detail/reverse.h

@@ -1,18 +1,5 @@
-/*
- *  Copyright 2008-2013 NVIDIA Corporation
- *
- *  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
- *
- *  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.
- */
+// SPDX-FileCopyrightText: Copyright (c) 2008-2013, NVIDIA Corporation. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
 
 #pragma once
 

cuda/cccl/headers/include/thrust/system/omp/detail/scan.h

@@ -1,18 +1,5 @@
-/*
- *  Copyright 2008-2013 NVIDIA Corporation
- *
- *  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
- *
- *  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.
- */
+// SPDX-FileCopyrightText: Copyright (c) 2008-2013, NVIDIA Corporation. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
 
 #pragma once
 
@@ -26,5 +13,177 @@
 #  pragma system_header
 #endif // no system header
 
-// this system inherits scan
-#include <thrust/system/cpp/detail/scan.h>
+// OMP parallel scan implementation
+#include <thrust/advance.h>
+#include <thrust/detail/function.h>
+#include <thrust/detail/temporary_array.h>
+#include <thrust/distance.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/system/omp/detail/execution_policy.h>
+#include <thrust/system/omp/detail/pragma_omp.h>
+
+#include <cuda/std/__functional/invoke.h>
+#include <cuda/std/__numeric/exclusive_scan.h>
+#include <cuda/std/__numeric/inclusive_scan.h>
+#include <cuda/std/__numeric/reduce.h>
+#include <cuda/std/cmath>
+
+#include <omp.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace system::omp::detail
+{
+struct __no_init_tag
+{};
+
+// Threshold below which serial scan is faster than parallel
+// Benchmarking shows parallel overhead dominates for small arrays
+inline constexpr size_t parallel_scan_threshold = 1024;
+
+template <bool IsInclusive,
+          typename DerivedPolicy,
+          typename InputIterator,
+          typename OutputIterator,
+          typename InitialValueType,
+          typename BinaryFunction>
+OutputIterator scan_impl(
+  execution_policy<DerivedPolicy>& exec,
+  InputIterator first,
+  InputIterator last,
+  OutputIterator result,
+  [[maybe_unused]] InitialValueType init,
+  BinaryFunction binary_op)
+{
+  using namespace thrust::detail;
+
+  static constexpr bool has_init = !::cuda::std::is_same_v<InitialValueType, __no_init_tag>;
+  // Use logic from https://wg21.link/P0571
+  using accum_t = ::cuda::std::conditional_t<has_init, InitialValueType, it_value_t<InputIterator>>;
+  using Size    = it_difference_t<InputIterator>;
+
+  const Size n = ::cuda::std::distance(first, last);
+
+  if (n == 0)
+  {
+    return result;
+  }
+
+  auto wrapped_binary_op = wrapped_function<BinaryFunction, accum_t>{binary_op};
+
+  const int num_threads = omp_get_max_threads();
+
+  // Use serial scan for small arrays where parallel overhead dominates
+  if (static_cast<size_t>(n) < parallel_scan_threshold || num_threads <= 1)
+  {
+    if constexpr (IsInclusive)
+    {
+      if constexpr (has_init)
+      {
+        return ::cuda::std::inclusive_scan(first, last, result, wrapped_binary_op, init);
+      }
+      else
+      {
+        return ::cuda::std::inclusive_scan(first, last, result, wrapped_binary_op);
+      }
+    }
+    else
+    {
+      return ::cuda::std::exclusive_scan(first, last, result, init, wrapped_binary_op);
+    }
+  }
+
+  temporary_array<accum_t, DerivedPolicy> block_sums(exec, num_threads);
+
+  // Step 1: Reduce each block (N reads)
+  THRUST_PRAGMA_OMP(parallel num_threads(num_threads))
+  {
+    const int tid         = omp_get_thread_num();
+    const Size block_size = ::cuda::ceil_div(n, num_threads);
+    const Size start      = tid * block_size;
+    const Size end        = ::cuda::std::min(start + block_size, n);
+
+    if (start < n)
+    {
+      block_sums[tid] = ::cuda::std::reduce(first + start, first + end, accum_t{}, wrapped_binary_op);
+    }
+  }
+
+  // Step 2: Scan block sums
+  if constexpr (has_init)
+  {
+    ::cuda::std::exclusive_scan(block_sums.begin(), block_sums.end(), block_sums.begin(), init, wrapped_binary_op);
+  }
+  else
+  {
+    ::cuda::std::exclusive_scan(block_sums.begin(), block_sums.end(), block_sums.begin(), accum_t{}, wrapped_binary_op);
+  }
+
+  // Step 3: Scan each block with offset (N reads/writes)
+  THRUST_PRAGMA_OMP(parallel num_threads(num_threads))
+  {
+    const int tid         = omp_get_thread_num();
+    const Size block_size = ::cuda::ceil_div(n, num_threads);
+    const Size start      = tid * block_size;
+    const Size end        = ::cuda::std::min(start + block_size, n);
+
+    if (start < n)
+    {
+      const accum_t prefix = block_sums[tid];
+      if constexpr (IsInclusive)
+      {
+        ::cuda::std::inclusive_scan(first + start, first + end, result + start, wrapped_binary_op, prefix);
+      }
+      else
+      {
+        ::cuda::std::exclusive_scan(first + start, first + end, result + start, prefix, wrapped_binary_op);
+      }
+    }
+  }
+
+  return result + n;
+}
+
+template <typename DerivedPolicy, typename InputIterator, typename OutputIterator, typename BinaryFunction>
+OutputIterator inclusive_scan(
+  execution_policy<DerivedPolicy>& exec,
+  InputIterator first,
+  InputIterator last,
+  OutputIterator result,
+  BinaryFunction binary_op)
+{
+  return inclusive_scan(exec, first, last, result, __no_init_tag{}, binary_op);
+}
+
+template <typename DerivedPolicy,
+          typename InputIterator,
+          typename OutputIterator,
+          typename InitialValueType,
+          typename BinaryFunction>
+OutputIterator inclusive_scan(
+  execution_policy<DerivedPolicy>& exec,
+  InputIterator first,
+  InputIterator last,
+  OutputIterator result,
+  InitialValueType init,
+  BinaryFunction binary_op)
+{
+  return scan_impl<true>(exec, first, last, result, init, binary_op);
+}
+
+template <typename DerivedPolicy,
+          typename InputIterator,
+          typename OutputIterator,
+          typename InitialValueType,
+          typename BinaryFunction>
+OutputIterator exclusive_scan(
+  execution_policy<DerivedPolicy>& exec,
+  InputIterator first,
+  InputIterator last,
+  OutputIterator result,
+  InitialValueType init,
+  BinaryFunction binary_op)
+{
+  return scan_impl<false>(exec, first, last, result, init, binary_op);
+}
+} // namespace system::omp::detail
+THRUST_NAMESPACE_END

cuda/cccl/headers/include/thrust/system/omp/detail/scan_by_key.h

@@ -1,18 +1,5 @@
-/*
- *  Copyright 2008-2013 NVIDIA Corporation
- *
- *  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
- *
- *  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.
- */
+// SPDX-FileCopyrightText: Copyright (c) 2008-2013, NVIDIA Corporation. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
 
 #pragma once
 
@@ -28,3 +15,9 @@
 
 // this system inherits this algorithm
 #include <thrust/system/cpp/detail/scan_by_key.h>
+
+// Ensure OMP scan is available before using generic scan_by_key
+#include <thrust/system/omp/detail/scan.h>
+
+// use generic parallel implementation
+#include <thrust/system/detail/generic/scan_by_key.h>

cuda/cccl/headers/include/thrust/system/omp/detail/scatter.h

@@ -1,18 +1,5 @@
-/*
- *  Copyright 2008-2013 NVIDIA Corporation
- *
- *  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
- *
- *  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.
- */
+// SPDX-FileCopyrightText: Copyright (c) 2008-2013, NVIDIA Corporation. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
 
 #pragma once
 

cuda/cccl/headers/include/thrust/system/omp/detail/sequence.h

@@ -1,18 +1,5 @@
-/*
- *  Copyright 2008-2013 NVIDIA Corporation
- *
- *  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
- *
- *  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.
- */
+// SPDX-FileCopyrightText: Copyright (c) 2008-2013, NVIDIA Corporation. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
 
 #pragma once
 

cuda/cccl/headers/include/thrust/system/omp/detail/set_operations.h

@@ -1,18 +1,5 @@
-/*
- *  Copyright 2008-2013 NVIDIA Corporation
- *
- *  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
- *
- *  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.
- */
+// SPDX-FileCopyrightText: Copyright (c) 2008-2013, NVIDIA Corporation. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
 
 #pragma once
 

cuda/cccl/headers/include/thrust/system/omp/detail/sort.h

@@ -1,18 +1,5 @@
-/*
- *  Copyright 2008-2013 NVIDIA Corporation
- *
- *  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
- *
- *  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.
- */
+// SPDX-FileCopyrightText: Copyright (c) 2008-2013, NVIDIA Corporation. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
 
 #pragma once
 
@@ -25,21 +12,143 @@
 #elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
 #  pragma system_header
 #endif // no system header
+
 #include <thrust/system/omp/detail/execution_policy.h>
 
+// don't attempt to #include this file without omp support
+#if (THRUST_DEVICE_COMPILER_IS_OMP_CAPABLE == THRUST_TRUE)
+#  include <omp.h>
+#endif // omp support
+
+#include <thrust/detail/seq.h>
+#include <thrust/detail/temporary_array.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/merge.h>
+#include <thrust/sort.h>
+#include <thrust/system/detail/generic/select_system.h>
+#include <thrust/system/omp/detail/default_decomposition.h>
+
 THRUST_NAMESPACE_BEGIN
-namespace system
+namespace system::omp::detail
 {
-namespace omp
+namespace sort_detail
 {
-namespace detail
+template <typename DerivedPolicy, typename RandomAccessIterator, typename StrictWeakOrdering>
+void inplace_merge(execution_policy<DerivedPolicy>& exec,
+                   RandomAccessIterator first,
+                   RandomAccessIterator middle,
+                   RandomAccessIterator last,
+                   StrictWeakOrdering comp)
+{
+  using value_type = thrust::detail::it_value_t<RandomAccessIterator>;
+
+  thrust::detail::temporary_array<value_type, DerivedPolicy> a(exec, first, middle);
+  thrust::detail::temporary_array<value_type, DerivedPolicy> b(exec, middle, last);
+
+  thrust::merge(thrust::seq, a.begin(), a.end(), b.begin(), b.end(), first, comp);
+}
+
+template <typename DerivedPolicy,
+          typename RandomAccessIterator1,
+          typename RandomAccessIterator2,
+          typename StrictWeakOrdering>
+void inplace_merge_by_key(
+  execution_policy<DerivedPolicy>& exec,
+  RandomAccessIterator1 first1,
+  RandomAccessIterator1 middle1,
+  RandomAccessIterator1 last1,
+  RandomAccessIterator2 first2,
+  StrictWeakOrdering comp)
 {
+  using value_type1 = thrust::detail::it_value_t<RandomAccessIterator1>;
+  using value_type2 = thrust::detail::it_value_t<RandomAccessIterator2>;
+
+  RandomAccessIterator2 middle2 = first2 + (middle1 - first1);
+  RandomAccessIterator2 last2   = first2 + (last1 - first1);
+
+  thrust::detail::temporary_array<value_type1, DerivedPolicy> lhs1(exec, first1, middle1);
+  thrust::detail::temporary_array<value_type1, DerivedPolicy> rhs1(exec, middle1, last1);
+  thrust::detail::temporary_array<value_type2, DerivedPolicy> lhs2(exec, first2, middle2);
+  thrust::detail::temporary_array<value_type2, DerivedPolicy> rhs2(exec, middle2, last2);
+
+  thrust::merge_by_key(
+    thrust::seq, lhs1.begin(), lhs1.end(), rhs1.begin(), rhs1.end(), lhs2.begin(), rhs2.begin(), first1, first2, comp);
+}
+} // namespace sort_detail
 
 template <typename DerivedPolicy, typename RandomAccessIterator, typename StrictWeakOrdering>
-void stable_sort(execution_policy<DerivedPolicy>& exec,
-                 RandomAccessIterator first,
-                 RandomAccessIterator last,
-                 StrictWeakOrdering comp);
+void stable_sort(
+  execution_policy<DerivedPolicy>& exec, RandomAccessIterator first, RandomAccessIterator last, StrictWeakOrdering comp)
+{
+  // we're attempting to launch an omp kernel, assert we're compiling with omp support
+  // ========================================================================
+  // X Note to the user: If you've found this line due to a compiler error, X
+  // X you need to enable OpenMP support in your compiler.                  X
+  // ========================================================================
+  static_assert(thrust::detail::depend_on_instantiation<RandomAccessIterator,
+                                                        (THRUST_DEVICE_COMPILER_IS_OMP_CAPABLE == THRUST_TRUE)>::value,
+                "OpenMP compiler support is not enabled");
+
+  // Avoid issues on compilers that don't provide `omp_get_num_threads()`.
+#if (THRUST_DEVICE_COMPILER_IS_OMP_CAPABLE == THRUST_TRUE)
+  using IndexType = thrust::detail::it_difference_t<RandomAccessIterator>;
+
+  if (first == last)
+  {
+    return;
+  }
+
+  THRUST_PRAGMA_OMP(parallel)
+  {
+    thrust::system::detail::internal::uniform_decomposition<IndexType> decomp(last - first, 1, omp_get_num_threads());
+
+    // process id
+    IndexType p_i = omp_get_thread_num();
+
+    // every thread sorts its own tile
+    if (p_i < decomp.size())
+    {
+      thrust::stable_sort(thrust::seq, first + decomp[p_i].begin(), first + decomp[p_i].end(), comp);
+    }
+
+    THRUST_PRAGMA_OMP(barrier)
+
+    // #5020: For some reason, MSVC may yield an error unless we include this meaningless semicolon here
+    ;
+
+    IndexType nseg = decomp.size();
+    IndexType h    = 2;
+
+    // keep track of which sub-range we're processing
+    IndexType a = p_i, b = p_i, c = p_i + 1;
+
+    while (nseg > 1)
+    {
+      if (c >= decomp.size())
+      {
+        c = decomp.size() - 1;
+      }
+
+      if ((p_i % h) == 0 && c > b)
+      {
+        sort_detail::inplace_merge(
+          exec, first + decomp[a].begin(), first + decomp[b].end(), first + decomp[c].end(), comp);
+
+        b = c;
+        c += h;
+      }
+
+      nseg = (nseg + 1) / 2;
+      h *= 2;
+
+      THRUST_PRAGMA_OMP(barrier)
+
+      // #5020: For some reason, MSVC may yield an error unless we include this meaningless semicolon here
+      ;
+    }
+  }
+#endif // THRUST_DEVICE_COMPILER_IS_OMP_CAPABLE
+}
 
 template <typename DerivedPolicy,
           typename RandomAccessIterator1,
@@ -50,11 +159,87 @@ void stable_sort_by_key(
   RandomAccessIterator1 keys_first,
   RandomAccessIterator1 keys_last,
   RandomAccessIterator2 values_first,
-  StrictWeakOrdering comp);
+  StrictWeakOrdering comp)
+{
+  // we're attempting to launch an omp kernel, assert we're compiling with omp support
+  // ========================================================================
+  // X Note to the user: If you've found this line due to a compiler error, X
+  // X you need to enable OpenMP support in your compiler.                  X
+  // ========================================================================
+  static_assert(thrust::detail::depend_on_instantiation<RandomAccessIterator1,
+                                                        (THRUST_DEVICE_COMPILER_IS_OMP_CAPABLE == THRUST_TRUE)>::value,
+                "OpenMP compiler support is not enabled");
 
-} // end namespace detail
-} // end namespace omp
-} // end namespace system
-THRUST_NAMESPACE_END
+  // Avoid issues on compilers that don't provide `omp_get_num_threads()`.
+#if (THRUST_DEVICE_COMPILER_IS_OMP_CAPABLE == THRUST_TRUE)
+  using IndexType = thrust::detail::it_difference_t<RandomAccessIterator1>;
+
+  if (keys_first == keys_last)
+  {
+    return;
+  }
+
+  THRUST_PRAGMA_OMP(parallel)
+  {
+    thrust::system::detail::internal::uniform_decomposition<IndexType> decomp(
+      keys_last - keys_first, 1, omp_get_num_threads());
 
-#include <thrust/system/omp/detail/sort.inl>
+    // process id
+    IndexType p_i = omp_get_thread_num();
+
+    // every thread sorts its own tile
+    if (p_i < decomp.size())
+    {
+      thrust::stable_sort_by_key(
+        thrust::seq,
+        keys_first + decomp[p_i].begin(),
+        keys_first + decomp[p_i].end(),
+        values_first + decomp[p_i].begin(),
+        comp);
+    }
+
+    THRUST_PRAGMA_OMP(barrier)
+
+    // #5020: For some reason, MSVC may yield an error unless we include this meaningless semicolon here
+    ;
+
+    IndexType nseg = decomp.size();
+    IndexType h    = 2;
+
+    // keep track of which sub-range we're processing
+    IndexType a = p_i, b = p_i, c = p_i + 1;
+
+    while (nseg > 1)
+    {
+      if (c >= decomp.size())
+      {
+        c = decomp.size() - 1;
+      }
+
+      if ((p_i % h) == 0 && c > b)
+      {
+        sort_detail::inplace_merge_by_key(
+          exec,
+          keys_first + decomp[a].begin(),
+          keys_first + decomp[b].end(),
+          keys_first + decomp[c].end(),
+          values_first + decomp[a].begin(),
+          comp);
+
+        b = c;
+        c += h;
+      }
+
+      nseg = (nseg + 1) / 2;
+      h *= 2;
+
+      THRUST_PRAGMA_OMP(barrier)
+
+      // #5020: For some reason, MSVC may yield an error unless we include this meaningless semicolon here
+      ;
+    }
+  }
+#endif // THRUST_DEVICE_COMPILER_IS_OMP_CAPABLE
+}
+} // end namespace system::omp::detail
+THRUST_NAMESPACE_END