[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/bounding_box.cu

@@ -0,0 +1,101 @@
+#include <thrust/device_vector.h>
+#include <thrust/extrema.h>
+#include <thrust/random.h>
+#include <thrust/transform_reduce.h>
+
+#include <cuda/std/utility>
+
+#include <iostream>
+
+// This example shows how to compute a bounding box
+// for a set of points in two dimensions.
+
+struct point2d
+{
+  float x, y;
+
+  __host__ __device__ point2d()
+      : x(0)
+      , y(0)
+  {}
+
+  __host__ __device__ point2d(float _x, float _y)
+      : x(_x)
+      , y(_y)
+  {}
+};
+
+// bounding box type
+struct bbox
+{
+  // construct an empty box
+  bbox() = default;
+
+  // construct a box from a single point
+  __host__ __device__ bbox(const point2d& point)
+      : lower_left(point)
+      , upper_right(point)
+  {}
+
+  // construct a box from a single point
+  __host__ __device__ bbox& operator=(const point2d& point)
+  {
+    lower_left  = point;
+    upper_right = point;
+    return *this;
+  }
+
+  // construct a box from a pair of points
+  __host__ __device__ bbox(const point2d& ll, const point2d& ur)
+      : lower_left(ll)
+      , upper_right(ur)
+  {}
+
+  point2d lower_left, upper_right;
+};
+
+// reduce a pair of bounding boxes (a,b) to a bounding box containing a and b
+struct bbox_union
+{
+  __host__ __device__ bbox operator()(bbox a, bbox b)
+  {
+    // lower left corner
+    point2d ll(thrust::min(a.lower_left.x, b.lower_left.x), thrust::min(a.lower_left.y, b.lower_left.y));
+
+    // upper right corner
+    point2d ur(thrust::max(a.upper_right.x, b.upper_right.x), thrust::max(a.upper_right.y, b.upper_right.y));
+
+    return bbox(ll, ur);
+  }
+};
+
+int main()
+{
+  const size_t N = 40;
+
+  // allocate storage for points
+  thrust::device_vector<point2d> points(N);
+
+  // generate some random points in the unit square
+  thrust::default_random_engine rng;
+  thrust::uniform_real_distribution<float> u01(0.0f, 1.0f);
+  for (size_t i = 0; i < N; i++)
+  {
+    float x   = u01(rng);
+    float y   = u01(rng);
+    points[i] = point2d(x, y);
+  }
+
+  // initial bounding box contains first point
+  bbox init(points[0], points[0]);
+
+  // compute the bounding box for the point set
+  bbox result = thrust::reduce(points.begin(), points.end(), init, bbox_union{});
+
+  // print output
+  std::cout << "bounding box " << std::fixed;
+  std::cout << "(" << result.lower_left.x << "," << result.lower_left.y << ") ";
+  std::cout << "(" << result.upper_right.x << "," << result.upper_right.y << ")" << '\n';
+
+  return 0;
+}