[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/thrust/examples/uninitialized_vector.cu

@@ -0,0 +1,73 @@
+// Occasionally, it is advantageous to avoid initializing the individual
+// elements of a device_vector. For example, the default behavior of
+// zero-initializing numeric data may introduce undesirable overhead.
+// This example demonstrates how to avoid default construction of a
+// device_vector's data by using a custom allocator.
+
+#include <thrust/device_allocator.h>
+#include <thrust/device_vector.h>
+#include <thrust/functional.h>
+#include <thrust/logical.h>
+
+#include <cassert>
+
+// uninitialized_allocator is an allocator which
+// derives from device_allocator and which has a
+// no-op construct member function
+template <typename T>
+struct uninitialized_allocator : thrust::device_allocator<T>
+{
+  // the default generated constructors and destructors are implicitly
+  // marked __host__ __device__, but the current Thrust device_allocator
+  // can only be constructed and destroyed on the host; therefore, we
+  // define these as host only
+  __host__ uninitialized_allocator() {} // NOLINT(modernize-use-equals-default)
+  __host__ uninitialized_allocator(const uninitialized_allocator& other)
+      : thrust::device_allocator<T>(other)
+  {}
+  __host__ ~uninitialized_allocator() {} // NOLINT(modernize-use-equals-default)
+
+  uninitialized_allocator& operator=(const uninitialized_allocator&) = default;
+
+  // for correctness, you should also redefine rebind when you inherit
+  // from an allocator type; this way, if the allocator is rebound somewhere,
+  // it's going to be rebound to the correct type - and not to its base
+  // type for U
+  template <typename U>
+  struct rebind
+  {
+    using other = uninitialized_allocator<U>;
+  };
+
+  // note that construct is annotated as
+  // a __host__ __device__ function
+  __host__ __device__ void construct(T*)
+  {
+    // no-op
+  }
+};
+
+// to make a device_vector which does not initialize its elements,
+// use uninitialized_allocator as the 2nd template parameter
+using uninitialized_vector = thrust::device_vector<float, uninitialized_allocator<float>>;
+
+int main()
+{
+  uninitialized_vector vec(10);
+
+  // the initial value of vec's 10 elements is undefined
+
+  // resize without default value does not initialize elements
+  vec.resize(20);
+
+  // resize with default value does initialize elements
+  vec.resize(30, 13);
+
+  // the value of elements [0,20) is still undefined
+  // but the value of elements [20,30) is 13:
+
+  using namespace thrust::placeholders;
+  assert(thrust::all_of(vec.begin() + 20, vec.end(), _1 == 13));
+
+  return 0;
+}