[STF] Move unstable_unique from STF to generic cudax utility

cudax/include/cuda/experimental/__stf/stream/internal/event_types.cuh

@@ -25,7 +25,7 @@
 #include <cuda/experimental/__stf/internal/backend_ctx.cuh>
 #include <cuda/experimental/__stf/utility/getenv_cache.cuh>
 #include <cuda/experimental/__stf/utility/memory.cuh>
-#include <cuda/experimental/__stf/utility/unstable_unique.cuh>
+#include <cuda/experimental/__utility/unstable_unique.cuh>
 
 #include <mutex>
 
@@ -196,11 +196,12 @@ public:
 
     // Remove duplicates. Two events are duplicates if they have the same stream.
     // Will keep the first element of each duplicate run, which is the one with the largest id.
-    proxy.erase(unstable_unique(proxy.begin(),
-                                proxy.end(),
-                                [](const auto& a, const auto& b) {
-                                  return a->dstream.stream == b->dstream.stream;
-                                }),
+    proxy.erase(::cuda::experimental::unstable_unique(
+                  proxy.begin(),
+                  proxy.end(),
+                  [](const auto& a, const auto& b) {
+                    return a->dstream.stream == b->dstream.stream;
+                  }),
                 proxy.end());
 
     return true;

cudax/include/cuda/experimental/__utility/unstable_unique.cuh

@@ -0,0 +1,105 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of CUDA Experimental in CUDA C++ Core Libraries,
+// under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2022-2025 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _CUDAX__UTILITY_UNSTABLE_UNIQUE
+#define _CUDAX__UTILITY_UNSTABLE_UNIQUE
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/__cccl/assert.h>
+#include <cuda/std/__iterator/next.h>
+#include <cuda/std/__iterator/prev.h>
+#include <cuda/std/__utility/move.h>
+
+namespace cuda::experimental
+{
+//! @brief Removes duplicates from a sorted range using a custom predicate.
+//!
+//! Operates from both sides of the range, moving elements from the right-hand
+//! side to the left to eliminate duplicates. The relative order of elements is
+//! not preserved.
+//!
+//! @tparam _Iterator The type of the iterator.
+//! @tparam _BinaryPredicate The type of the predicate.
+//!
+//! @param[in] __first Iterator to the beginning of the range.
+//! @param[in] __last Iterator past the end of the range.
+//! @param[in] __pred The predicate used to compare adjacent elements.
+//!
+//! @return Iterator to the new end of the range after duplicates have been removed.
+template <class _Iterator, class _BinaryPredicate>
+_CCCL_HOST_API _Iterator unstable_unique(_Iterator __first, _Iterator __last, _BinaryPredicate __pred)
+{
+  if (__first == __last || ::cuda::std::next(__first) == __last)
+  {
+    return __last;
+  }
+
+  ++__first;
+  bool __first_is_known_duplicate = false;
+
+  for (; __first < __last; ++__first)
+  {
+    if (!__first_is_known_duplicate)
+    {
+      if (!__pred(*__first, *::cuda::std::prev(__first)))
+      {
+        continue;
+      }
+    }
+    _CCCL_ASSERT(__first < __last, "unstable_unique: iterator out of range");
+    for (--__last;; --__last)
+    {
+      if (__first == __last)
+      {
+        return __first;
+      }
+      _CCCL_ASSERT(__first < __last, "unstable_unique: iterator out of range");
+      if (!__pred(*__last, *::cuda::std::prev(__last)))
+      {
+        break;
+      }
+    }
+    _CCCL_ASSERT(!__pred(*__first, *__last), "unstable_unique: unexpected duplicate");
+    __first_is_known_duplicate = __pred(*__first, *::cuda::std::next(__first));
+    *__first                   = ::cuda::std::move(*__last);
+  }
+
+  return __first;
+}
+
+//! @brief Removes duplicates from a sorted range using `operator==`.
+//!
+//! Equivalent to calling the predicate overload with `operator==`.
+//!
+//! @tparam _Iterator The type of the iterator.
+//!
+//! @param[in] __first Iterator to the beginning of the range.
+//! @param[in] __last Iterator past the end of the range.
+//!
+//! @return Iterator to the new end of the range after duplicates have been removed.
+template <class _Iterator>
+_CCCL_HOST_API _Iterator unstable_unique(_Iterator __first, _Iterator __last)
+{
+  return ::cuda::experimental::unstable_unique(__first, __last, [](const auto& __a, const auto& __b) {
+    return __a == __b;
+  });
+}
+} // namespace cuda::experimental
+
+#endif // _CUDAX__UTILITY_UNSTABLE_UNIQUE

cudax/test/CMakeLists.txt

@@ -75,6 +75,7 @@ cudax_add_catch2_test(test_target stream
 
 cudax_add_catch2_test(test_target misc
     utility/ensure_current_device.cu
+    utility/unstable_unique.cu
     utility/optionally_static.cu
 )
 

cudax/test/stf/CMakeLists.txt

@@ -234,7 +234,6 @@ set(
   cuda/experimental/__stf/utility/scope_guard.cuh
   cuda/experimental/__stf/stackable/stackable_ctx.cuh
   cuda/experimental/__stf/utility/unittest.cuh
-  cuda/experimental/__stf/utility/unstable_unique.cuh
 )
 
 cccl_get_cudatoolkit()

cudax/test/utility/unstable_unique.cu

@@ -0,0 +1,74 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of CUDA Experimental in CUDA C++ Core Libraries,
+// under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2022-2025 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#include <cuda/experimental/__utility/unstable_unique.cuh>
+
+#include <vector>
+
+#include <catch2/catch_test_macros.hpp>
+
+namespace cudax = cuda::experimental;
+
+TEST_CASE("unstable_unique empty range", "[utility]")
+{
+  std::vector<int> v;
+  auto new_end = cudax::unstable_unique(v.begin(), v.end());
+  REQUIRE(v.end() == new_end);
+}
+
+TEST_CASE("unstable_unique no duplicates", "[utility]")
+{
+  std::vector<int> v = {1, 2, 3, 4, 5};
+  auto new_end       = cudax::unstable_unique(v.begin(), v.end());
+  REQUIRE(v.end() == new_end);
+  REQUIRE(std::vector<int>({1, 2, 3, 4, 5}) == v);
+}
+
+TEST_CASE("unstable_unique leading duplicates", "[utility]")
+{
+  std::vector<int> v = {1, 1, 2, 3, 4, 5};
+  auto new_end       = cudax::unstable_unique(v.begin(), v.end());
+  REQUIRE(v.begin() + 5 == new_end);
+  REQUIRE(std::vector<int>({1, 5, 2, 3, 4, 5}) == v);
+}
+
+TEST_CASE("unstable_unique interleaved duplicates", "[utility]")
+{
+  std::vector<int> v = {1, 1, 2, 2, 3, 3, 4, 4, 5, 5};
+  auto new_end       = cudax::unstable_unique(v.begin(), v.end());
+  REQUIRE(v.begin() + 5 == new_end);
+  REQUIRE(std::vector<int>({1, 5, 2, 4, 3, 3, 4, 4, 5, 5}) == v);
+}
+
+TEST_CASE("unstable_unique all same", "[utility]")
+{
+  std::vector<int> v = {1, 1, 1, 1, 1};
+  auto new_end       = cudax::unstable_unique(v.begin(), v.end());
+  REQUIRE(1 + v.begin() == new_end);
+  REQUIRE(std::vector<int>({1, 1, 1, 1, 1}) == v);
+}
+
+TEST_CASE("unstable_unique trailing unique", "[utility]")
+{
+  std::vector<int> v = {1, 1, 1, 1, 1, 2};
+  auto new_end       = cudax::unstable_unique(v.begin(), v.end());
+  REQUIRE(v.begin() + 2 == new_end);
+  REQUIRE(std::vector<int>({1, 2, 1, 1, 1, 2}) == v);
+}
+
+TEST_CASE("unstable_unique with custom predicate", "[utility]")
+{
+  std::vector<int> v = {1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 3, 4, 5};
+  auto new_end       = cudax::unstable_unique(v.begin(), v.end(), [](int a, int b) {
+    return a == b;
+  });
+  REQUIRE(v.begin() + 5 == new_end);
+  REQUIRE(std::vector<int>{1, 5, 4, 3, 2, 1, 1, 1, 1, 2, 2, 2, 3, 4, 5} == v);
+}