From 84386f652468a11ee7f576ef7c76a7daf3d5d0bc Mon Sep 17 00:00:00 2001
From: Patrick Stotko <stotko@cs.uni-bonn.de>
Date: Mon, 9 Sep 2024 08:51:44 +0200
Subject: [PATCH] algorithm,memory,numeric: Improve thrust compatibility via
 ADL barriers

---
 src/stdgpu/algorithm.h             | 43 +++++++++++++++++++++++
 src/stdgpu/impl/algorithm_detail.h |  6 ++++
 src/stdgpu/impl/memory_detail.h    |  3 ++
 src/stdgpu/impl/numeric_detail.h   |  3 ++
 src/stdgpu/memory.h                | 56 ++++++++++++++++++++++++++++++
 src/stdgpu/numeric.h               | 20 +++++++++++
 6 files changed, 131 insertions(+)

diff --git a/src/stdgpu/algorithm.h b/src/stdgpu/algorithm.h
index bde5e07e9..be73a65d7 100644
--- a/src/stdgpu/algorithm.h
+++ b/src/stdgpu/algorithm.h
@@ -86,6 +86,8 @@ template <typename IndexType,
 void
 for_each_index(ExecutionPolicy&& policy, IndexType size, UnaryFunction f);
 
+#ifdef STDGPU_RUN_DOXYGEN
+
 /**
  * \ingroup algorithm
  * \brief Writes the given value into the given range using the copy assignment operator
@@ -165,6 +167,47 @@ template <typename ExecutionPolicy,
 OutputIt
 copy_n(ExecutionPolicy&& policy, InputIt begin, Size n, OutputIt output_begin);
 
+#endif
+
+//! @cond Doxygen_Suppress
+namespace adl_barrier
+{
+
+template <typename ExecutionPolicy,
+          typename Iterator,
+          typename T,
+          STDGPU_DETAIL_OVERLOAD_IF(is_execution_policy_v<remove_cvref_t<ExecutionPolicy>>)>
+void
+fill(ExecutionPolicy&& policy, Iterator begin, Iterator end, const T& value);
+
+template <typename ExecutionPolicy,
+          typename Iterator,
+          typename Size,
+          typename T,
+          STDGPU_DETAIL_OVERLOAD_IF(is_execution_policy_v<remove_cvref_t<ExecutionPolicy>>)>
+Iterator
+fill_n(ExecutionPolicy&& policy, Iterator begin, Size n, const T& value);
+
+template <typename ExecutionPolicy,
+          typename InputIt,
+          typename OutputIt,
+          STDGPU_DETAIL_OVERLOAD_IF(is_execution_policy_v<remove_cvref_t<ExecutionPolicy>>)>
+OutputIt
+copy(ExecutionPolicy&& policy, InputIt begin, InputIt end, OutputIt output_begin);
+
+template <typename ExecutionPolicy,
+          typename InputIt,
+          typename Size,
+          typename OutputIt,
+          STDGPU_DETAIL_OVERLOAD_IF(is_execution_policy_v<remove_cvref_t<ExecutionPolicy>>)>
+OutputIt
+copy_n(ExecutionPolicy&& policy, InputIt begin, Size n, OutputIt output_begin);
+
+} // namespace adl_barrier
+
+using namespace adl_barrier;
+//! @endcond
+
 } // namespace stdgpu
 
 #include <stdgpu/impl/algorithm_detail.h>
diff --git a/src/stdgpu/impl/algorithm_detail.h b/src/stdgpu/impl/algorithm_detail.h
index 1507c7a9f..fd816d328 100644
--- a/src/stdgpu/impl/algorithm_detail.h
+++ b/src/stdgpu/impl/algorithm_detail.h
@@ -85,6 +85,8 @@ class fill_functor
 };
 } // namespace detail
 
+namespace adl_barrier
+{
 template <typename ExecutionPolicy,
           typename Iterator,
           typename T,
@@ -106,6 +108,7 @@ fill_n(ExecutionPolicy&& policy, Iterator begin, Size n, const T& value)
     for_each_index(std::forward<ExecutionPolicy>(policy), n, detail::fill_functor<Iterator, T>(begin, value));
     return begin + n;
 }
+} // namespace adl_barrier
 
 namespace detail
 {
@@ -131,6 +134,8 @@ class copy_functor
 };
 } // namespace detail
 
+namespace adl_barrier
+{
 template <typename ExecutionPolicy,
           typename InputIt,
           typename OutputIt,
@@ -154,6 +159,7 @@ copy_n(ExecutionPolicy&& policy, InputIt begin, Size n, OutputIt output_begin)
                    detail::copy_functor<InputIt, OutputIt>(begin, output_begin));
     return output_begin + n;
 }
+} // namespace adl_barrier
 
 } // namespace stdgpu
 
diff --git a/src/stdgpu/impl/memory_detail.h b/src/stdgpu/impl/memory_detail.h
index 3ad2f1d9d..e2cc86911 100644
--- a/src/stdgpu/impl/memory_detail.h
+++ b/src/stdgpu/impl/memory_detail.h
@@ -705,6 +705,8 @@ destroy_at(T* p)
     p->~T();
 }
 
+namespace adl_barrier
+{
 template <typename ExecutionPolicy,
           typename Iterator,
           typename T,
@@ -781,6 +783,7 @@ destroy_n(ExecutionPolicy&& policy, Iterator first, Size n)
 
     return last;
 }
+} // namespace adl_barrier
 
 template <>
 dynamic_memory_type
diff --git a/src/stdgpu/impl/numeric_detail.h b/src/stdgpu/impl/numeric_detail.h
index 2b04832b5..c99117444 100644
--- a/src/stdgpu/impl/numeric_detail.h
+++ b/src/stdgpu/impl/numeric_detail.h
@@ -49,6 +49,8 @@ class iota_functor
 };
 } // namespace detail
 
+namespace adl_barrier
+{
 template <typename ExecutionPolicy,
           typename Iterator,
           typename T,
@@ -60,6 +62,7 @@ iota(ExecutionPolicy&& policy, Iterator begin, Iterator end, T value)
                    static_cast<index_t>(end - begin),
                    detail::iota_functor<Iterator, T>(begin, value));
 }
+} // namespace adl_barrier
 
 template <typename IndexType,
           typename ExecutionPolicy,
diff --git a/src/stdgpu/memory.h b/src/stdgpu/memory.h
index 80b8946d1..7a5f0d81b 100644
--- a/src/stdgpu/memory.h
+++ b/src/stdgpu/memory.h
@@ -770,6 +770,8 @@ template <typename T>
 STDGPU_HOST_DEVICE void
 destroy_at(T* p);
 
+#ifdef STDGPU_RUN_DOXYGEN
+
 /**
  * \ingroup memory
  * \brief Writes the given value to into the given range using the copy constructor
@@ -882,6 +884,60 @@ template <typename ExecutionPolicy,
 Iterator
 destroy_n(ExecutionPolicy&& policy, Iterator first, Size n);
 
+#endif
+
+//! @cond Doxygen_Suppress
+namespace adl_barrier
+{
+
+template <typename ExecutionPolicy,
+          typename Iterator,
+          typename T,
+          STDGPU_DETAIL_OVERLOAD_IF(is_execution_policy_v<remove_cvref_t<ExecutionPolicy>>)>
+void
+uninitialized_fill(ExecutionPolicy&& policy, Iterator begin, Iterator end, const T& value);
+
+template <typename ExecutionPolicy,
+          typename Iterator,
+          typename Size,
+          typename T,
+          STDGPU_DETAIL_OVERLOAD_IF(is_execution_policy_v<remove_cvref_t<ExecutionPolicy>>)>
+Iterator
+uninitialized_fill_n(ExecutionPolicy&& policy, Iterator begin, Size n, const T& value);
+
+template <typename ExecutionPolicy,
+          typename InputIt,
+          typename OutputIt,
+          STDGPU_DETAIL_OVERLOAD_IF(is_execution_policy_v<remove_cvref_t<ExecutionPolicy>>)>
+OutputIt
+uninitialized_copy(ExecutionPolicy&& policy, InputIt begin, InputIt end, OutputIt output_begin);
+
+template <typename ExecutionPolicy,
+          typename InputIt,
+          typename Size,
+          typename OutputIt,
+          STDGPU_DETAIL_OVERLOAD_IF(is_execution_policy_v<remove_cvref_t<ExecutionPolicy>>)>
+OutputIt
+uninitialized_copy_n(ExecutionPolicy&& policy, InputIt begin, Size n, OutputIt output_begin);
+
+template <typename ExecutionPolicy,
+          typename Iterator,
+          STDGPU_DETAIL_OVERLOAD_IF(is_execution_policy_v<remove_cvref_t<ExecutionPolicy>>)>
+void
+destroy(ExecutionPolicy&& policy, Iterator first, Iterator last);
+
+template <typename ExecutionPolicy,
+          typename Iterator,
+          typename Size,
+          STDGPU_DETAIL_OVERLOAD_IF(is_execution_policy_v<remove_cvref_t<ExecutionPolicy>>)>
+Iterator
+destroy_n(ExecutionPolicy&& policy, Iterator first, Size n);
+
+} // namespace adl_barrier
+
+using namespace adl_barrier;
+//! @endcond
+
 /**
  * \ingroup memory
  * \brief Registers the given memory block into the internal memory size manger
diff --git a/src/stdgpu/numeric.h b/src/stdgpu/numeric.h
index 3df1f341d..ba1dd0187 100644
--- a/src/stdgpu/numeric.h
+++ b/src/stdgpu/numeric.h
@@ -30,6 +30,8 @@
 namespace stdgpu
 {
 
+#ifdef STDGPU_RUN_DOXYGEN
+
 /**
  * \ingroup numeric
  * \brief Writes ascending values {values + i} to the i-th position of the given range
@@ -48,6 +50,24 @@ template <typename ExecutionPolicy,
 void
 iota(ExecutionPolicy&& policy, Iterator begin, Iterator end, T value);
 
+#endif
+
+//! @cond Doxygen_Suppress
+namespace adl_barrier
+{
+
+template <typename ExecutionPolicy,
+          typename Iterator,
+          typename T,
+          STDGPU_DETAIL_OVERLOAD_IF(is_execution_policy_v<remove_cvref_t<ExecutionPolicy>>)>
+void
+iota(ExecutionPolicy&& policy, Iterator begin, Iterator end, T value);
+
+} // namespace adl_barrier
+
+using namespace adl_barrier;
+//! @endcond
+
 /**
  * \ingroup numeric
  * \brief Calls the given unary function with an index from the range [0, size) and performs a reduction afterwards