[INFRA] Import NVIDIA/CCCL upstream as optimization reference library

CCCL (CUDA C++ Core Libraries) provides:
- CUB: device/block/warp-level GPU primitives (reduce, scan, sort, topk)
- Thrust: high-level parallel algorithms (transform_reduce, sort, scan)
- libcudacxx: CUDA C++ standard library (atomics, barriers, memory)
- cudax: experimental features (memory resources, allocators)
- Tuning policies: per-SM hardware-specific algorithm parameters

Competition optimization vectors mapped to CCCL:
- Output TPS (83% weight): warp_reduce, block_reduce, device_topk
- Input TPS (14% weight): device_scan, block_load, prefetch
- Cache TPS (3% weight): prefix caching strategy patterns
- Memory (0.9 util): pooled/cached/buddy allocators

Source: https://github.com/NVIDIA/cccl (shallow clone, HEAD only)
License: Apache-2.0

cccl_upstream/libcudacxx/test/support/counting_predicates.h

@@ -0,0 +1,111 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef TEST_SUPPORT_COUNTING_PREDICATES_H
+#define TEST_SUPPORT_COUNTING_PREDICATES_H
+
+#include <cuda/std/cstddef>
+#include <cuda/std/utility>
+
+#include "test_macros.h"
+
+template <typename Predicate, typename Arg>
+struct unary_counting_predicate
+{
+public:
+  using argument_type = Arg;
+  using result_type   = bool;
+
+  TEST_FUNC constexpr unary_counting_predicate(Predicate p)
+      : p_(p)
+      , count_(0)
+  {}
+
+  TEST_FUNC constexpr bool operator()(const Arg& a)
+  {
+    ++count_;
+    return p_(a);
+  }
+  TEST_FUNC constexpr size_t count() const
+  {
+    return count_;
+  }
+  TEST_FUNC constexpr void reset()
+  {
+    count_ = 0;
+  }
+
+private:
+  Predicate p_;
+  size_t count_;
+};
+
+template <typename Predicate, typename Arg1, typename Arg2 = Arg1>
+struct binary_counting_predicate
+{
+public:
+  using first_argument_type  = Arg1;
+  using second_argument_type = Arg2;
+  using result_type          = bool;
+
+  TEST_FUNC constexpr binary_counting_predicate(Predicate p)
+      : p_(p)
+      , count_(0)
+  {}
+
+  TEST_FUNC constexpr bool operator()(const Arg1& a1, const Arg2& a2)
+  {
+    ++count_;
+    return p_(a1, a2);
+  }
+  TEST_FUNC constexpr size_t count() const
+  {
+    return count_;
+  }
+  TEST_FUNC constexpr void reset()
+  {
+    count_ = 0;
+  }
+
+private:
+  Predicate p_;
+  size_t count_;
+};
+
+template <class Predicate>
+class counting_predicate
+{
+  Predicate pred_;
+  int* count_ = nullptr;
+
+public:
+  constexpr counting_predicate() = default;
+  TEST_FUNC constexpr counting_predicate(Predicate pred, int& count)
+      : pred_(cuda::std::move(pred))
+      , count_(&count)
+  {}
+
+  template <class... Args>
+  TEST_FUNC constexpr auto operator()(Args&&... args) -> decltype(pred_(cuda::std::forward<Args>(args)...))
+  {
+    ++(*count_);
+    return pred_(cuda::std::forward<Args>(args)...);
+  }
+
+  template <class... Args>
+  TEST_FUNC constexpr auto operator()(Args&&... args) const -> decltype(pred_(cuda::std::forward<Args>(args)...))
+  {
+    ++(*count_);
+    return pred_(cuda::std::forward<Args>(args)...);
+  }
+};
+
+template <class Predicate>
+counting_predicate(Predicate pred, int& count) -> counting_predicate<Predicate>;
+
+#endif // TEST_SUPPORT_COUNTING_PREDICATES_H