[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/cub/examples/device/example_device_reduce.cu

@@ -0,0 +1,164 @@
+// SPDX-FileCopyrightText: Copyright (c) 2011, Duane Merrill. All rights reserved.
+// SPDX-FileCopyrightText: Copyright (c) 2011-2018, NVIDIA CORPORATION. All rights reserved.
+// SPDX-License-Identifier: BSD-3
+
+/******************************************************************************
+ * Simple example of DeviceReduce::Sum().
+ *
+ * Sums an array of int keys.
+ *
+ * To compile using the command line:
+ *   nvcc -arch=sm_XX example_device_reduce.cu -I../.. -lcudart -O3
+ *
+ ******************************************************************************/
+
+// Ensure printing of CUDA runtime errors to console
+#define CUB_STDERR
+
+#include <cub/device/device_reduce.cuh>
+#include <cub/util_allocator.cuh>
+
+#include <cstdio>
+
+#include "../../test/test_util.h"
+
+using namespace cub;
+
+//---------------------------------------------------------------------
+// Globals, constants and aliases
+//---------------------------------------------------------------------
+
+bool g_verbose = false; // Whether to display input/output to console
+CachingDeviceAllocator g_allocator(true); // Caching allocator for device memory
+
+//---------------------------------------------------------------------
+// Test generation
+//---------------------------------------------------------------------
+
+/**
+ * Initialize problem
+ */
+void Initialize(int* h_in, int num_items)
+{
+  for (int i = 0; i < num_items; ++i)
+  {
+    h_in[i] = i;
+  }
+
+  if (g_verbose)
+  {
+    printf("Input:\n");
+    DisplayResults(h_in, num_items);
+    printf("\n\n");
+  }
+}
+
+/**
+ * Compute solution
+ */
+void Solve(int* h_in, int& h_reference, int num_items)
+{
+  for (int i = 0; i < num_items; ++i)
+  {
+    if (i == 0)
+    {
+      h_reference = h_in[0];
+    }
+    else
+    {
+      h_reference += h_in[i];
+    }
+  }
+}
+
+//---------------------------------------------------------------------
+// Main
+//---------------------------------------------------------------------
+
+/**
+ * Main
+ */
+int main(int argc, char** argv)
+{
+  int num_items = 150;
+
+  // Initialize command line
+  CommandLineArgs args(argc, argv);
+  g_verbose = args.CheckCmdLineFlag("v");
+  args.GetCmdLineArgument("n", num_items);
+
+  // Print usage
+  if (args.CheckCmdLineFlag("help"))
+  {
+    printf("%s "
+           "[--n=<input items> "
+           "[--device=<device-id>] "
+           "[--v] "
+           "\n",
+           argv[0]);
+    exit(0);
+  }
+
+  // Initialize device
+  CubDebugExit(args.DeviceInit());
+
+  printf("cub::DeviceReduce::Sum() %d items (%d-byte elements)\n", num_items, (int) sizeof(int));
+  fflush(stdout);
+
+  // Allocate host arrays
+  int* h_in = new int[num_items];
+  int h_reference{};
+
+  // Initialize problem and solution
+  Initialize(h_in, num_items);
+  Solve(h_in, h_reference, num_items);
+
+  // Allocate problem device arrays
+  int* d_in = nullptr;
+  CubDebugExit(g_allocator.DeviceAllocate((void**) &d_in, sizeof(int) * num_items));
+
+  // Initialize device input
+  CubDebugExit(cudaMemcpy(d_in, h_in, sizeof(int) * num_items, cudaMemcpyHostToDevice));
+
+  // Allocate device output array
+  int* d_out = nullptr;
+  CubDebugExit(g_allocator.DeviceAllocate((void**) &d_out, sizeof(int) * 1));
+
+  // example-begin temp-storage-query
+  // Request and allocate temporary storage
+  void* d_temp_storage      = nullptr;
+  size_t temp_storage_bytes = 0;
+  CubDebugExit(DeviceReduce::Sum(d_temp_storage, temp_storage_bytes, d_in, d_out, num_items));
+  CubDebugExit(g_allocator.DeviceAllocate(&d_temp_storage, temp_storage_bytes));
+
+  // Run
+  CubDebugExit(DeviceReduce::Sum(d_temp_storage, temp_storage_bytes, d_in, d_out, num_items));
+  // example-end temp-storage-query
+
+  // Check for correctness (and display results, if specified)
+  int compare = CompareDeviceResults(&h_reference, d_out, 1, g_verbose, g_verbose);
+  printf("\t%s", compare ? "FAIL" : "PASS");
+  AssertEquals(0, compare);
+
+  // Cleanup
+  if (h_in)
+  {
+    delete[] h_in;
+  }
+  if (d_in)
+  {
+    CubDebugExit(g_allocator.DeviceFree(d_in));
+  }
+  if (d_out)
+  {
+    CubDebugExit(g_allocator.DeviceFree(d_out));
+  }
+  if (d_temp_storage)
+  {
+    CubDebugExit(g_allocator.DeviceFree(d_temp_storage));
+  }
+
+  printf("\n\n");
+
+  return 0;
+}