[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/codegen/generators/definitions.h

@@ -0,0 +1,192 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of libcu++, the C++ Standard Library for your entire system,
+// 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) 2024 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef DEFINITIONS_H
+#define DEFINITIONS_H
+
+#include <format>
+#include <map>
+#include <string>
+#include <type_traits>
+#include <vector>
+
+enum class Mmio
+{
+  Disabled,
+  Enabled,
+};
+
+inline std::string mmio(Mmio m)
+{
+  static const char* mmio_map[]{
+    "",
+    ".mmio",
+  };
+  return mmio_map[std::underlying_type_t<Mmio>(m)];
+}
+
+inline std::string mmio_tag(Mmio m)
+{
+  static const char* mmio_map[]{
+    "__atomic_cuda_mmio_disable",
+    "__atomic_cuda_mmio_enable",
+  };
+  return mmio_map[std::underlying_type_t<Mmio>(m)];
+}
+
+enum class Operand
+{
+  Floating,
+  Unsigned,
+  Signed,
+  Bit,
+};
+
+inline std::string operand(Operand op)
+{
+  static std::map op_map = {
+    std::pair{Operand::Floating, "f"},
+    std::pair{Operand::Unsigned, "u"},
+    std::pair{Operand::Signed, "s"},
+    std::pair{Operand::Bit, "b"},
+  };
+  return op_map[op];
+}
+
+inline std::string operand_proxy_type(Operand op, size_t sz)
+{
+  if (op == Operand::Floating)
+  {
+    if (sz == 32)
+    {
+      return {"float"};
+    }
+    else
+    {
+      return {"double"};
+    }
+  }
+  else if (op == Operand::Signed)
+  {
+    return std::format("int{}_t", sz);
+  }
+  // Binary and unsigned can be the same proxy_type
+  return std::format("uint{}_t", sz);
+}
+
+inline std::string constraints(Operand op, size_t sz)
+{
+  static std::map constraint_map = {
+    std::pair{32,
+              std::map{
+                std::pair{Operand::Bit, "r"},
+                std::pair{Operand::Unsigned, "r"},
+                std::pair{Operand::Signed, "r"},
+                std::pair{Operand::Floating, "f"},
+              }},
+    std::pair{64,
+              std::map{
+                std::pair{Operand::Bit, "l"},
+                std::pair{Operand::Unsigned, "l"},
+                std::pair{Operand::Signed, "l"},
+                std::pair{Operand::Floating, "d"},
+              }},
+    std::pair{128,
+              std::map{
+                std::pair{Operand::Bit, "l"},
+                std::pair{Operand::Unsigned, "l"},
+                std::pair{Operand::Signed, "l"},
+                std::pair{Operand::Floating, "d"},
+              }},
+  };
+
+  if (sz == 16)
+  {
+    return {"h"};
+  }
+  else
+  {
+    return constraint_map[sz][op];
+  }
+}
+
+enum class Semantic
+{
+  Relaxed,
+  Release,
+  Acquire,
+  Acq_Rel,
+  Seq_Cst,
+  Volatile,
+};
+
+inline std::string semantic(Semantic sem)
+{
+  static std::map sem_map = {
+    std::pair{Semantic::Relaxed, ".relaxed"},
+    std::pair{Semantic::Release, ".release"},
+    std::pair{Semantic::Acquire, ".acquire"},
+    std::pair{Semantic::Acq_Rel, ".acq_rel"},
+    std::pair{Semantic::Seq_Cst, ".sc"},
+    std::pair{Semantic::Volatile, ""},
+  };
+  return sem_map[sem];
+}
+
+inline std::string semantic_tag(Semantic sem)
+{
+  static std::map sem_map = {
+    std::pair{Semantic::Relaxed, "__atomic_cuda_relaxed"},
+    std::pair{Semantic::Release, "__atomic_cuda_release"},
+    std::pair{Semantic::Acquire, "__atomic_cuda_acquire"},
+    std::pair{Semantic::Acq_Rel, "__atomic_cuda_acq_rel"},
+    std::pair{Semantic::Seq_Cst, "__atomic_cuda_seq_cst"},
+    std::pair{Semantic::Volatile, "__atomic_cuda_volatile"},
+  };
+  return sem_map[sem];
+}
+
+enum class Scope
+{
+  Thread,
+  Warp,
+  CTA,
+  Cluster,
+  GPU,
+  System,
+};
+
+inline std::string scope(Scope sco)
+{
+  static std::map sco_map = {
+    std::pair{Scope::Thread, ""},
+    std::pair{Scope::Warp, ""},
+    std::pair{Scope::CTA, ".cta"},
+    std::pair{Scope::Cluster, ".cluster"},
+    std::pair{Scope::GPU, ".gpu"},
+    std::pair{Scope::System, ".sys"},
+  };
+  return sco_map[sco];
+}
+
+inline std::string scope_tag(Scope sco)
+{
+  static std::map sco_map = {
+    std::pair{Scope::Thread, "__thread_scope_thread_tag"},
+    std::pair{Scope::Warp, ""},
+    std::pair{Scope::CTA, "__thread_scope_block_tag"},
+    std::pair{Scope::Cluster, "__thread_scope_cluster_tag"},
+    std::pair{Scope::GPU, "__thread_scope_device_tag"},
+    std::pair{Scope::System, "__thread_scope_system_tag"},
+  };
+  return sco_map[sco];
+}
+
+#endif // DEFINITIONS_H