Cuda good first issues

A performance regression has been observed in mixed-join operations within cuDF, attributed to register spilling in the new cuco hash table implementation. While the new design generally offers advantages, specific scenarios, like CG-based insertions and 100% occupancy checks, combined with longer live ranges for temporary data, lead to significant slowdowns.

This issue proposes a new 'edge-based' capacity concept for electric vehicle (EV) charging in the cuOpt VRP solver. Instead of capacity being tied to tasks (nodes), it should be linked to the travel distance between tasks (edges) to accurately track EV battery depletion. The system should allow vehicles to recharge at depots or charging stations, with recharge time dependent on the current charge level.

This enhancement request aims to add new overloads for the `insert` function in cuCollections. These overloads would accept `value_type` directly, similar to how STL containers handle insertions, to restore the convenience of inserting key-value pairs without explicitly specifying the pair type.

This enhancement aims to remove custom test utilities within the cuco library. The rationale is that these utilities were implemented to mitigate long build times related to Thrust algorithms, but with the new CI setup utilizing sccache, this problem is no longer present. The proposed solution is to replace these custom utilities with their direct Thrust equivalents.

This enhancement aims to enable Programmatic Dependent Launch (PDL) for all cuco kernels. PDL allows secondary kernels to launch before their primary kernel completes, potentially improving performance by overlapping execution, especially on devices with compute capability 9.0 and higher.

This issue proposes relaxing type constraints for keys, payloads, and slots to allow for 1-byte and 2-byte data types. The goal is to align with `cuda::atomic_ref`'s support for these smaller data sizes, enabling broader compatibility and potentially improved performance in certain scenarios.

This issue requests the addition of Java API support for cuOpt, a library likely related to optimization or computational tasks. It also specifies the need for documentation detailing the implementation approach. This is a feature request to expand the library's accessibility to Java developers.

This issue requires investigating the feasibility of integrating ThriftAttention into vLLM v1 without forking the codebase. The core challenge lies in supporting a dual FP16 plus FP4 KV cache, which impacts memory profiling, block allocation, and prefix caching. The investigation will involve analyzing vLLM's backend registration, KV cache abstraction, and CUDA graph capture mechanisms, with a focus on understanding maintenance risks and the potential need for code modifications.

This issue requests the extension of existing CUDA kernels for head dimensions greater than 128, specifically to support a head dimension of 256. The task involves modifying or reimplementing both causal and non-causal kernels within the `csrc/cuda/sm120` directory to accommodate this larger dimension.

This issue proposes adding support for ThriftAttention as a custom attention backend within the Hugging Face Transformers library. The goal is to allow users to load models using ThriftAttention by specifying a new `attn_implementation` string, similar to existing community backends like FlashAttention2. This involves registering ThriftAttention with the Hugging Face Kernel Hub and verifying its correct integration within the Transformers library.

This issue proposes adding support for a new heuristic called SpargeAttention. The goal is to integrate this heuristic into the existing system, likely for performance or efficiency improvements in attention mechanisms.

This issue proposes adding support for the bfloat16 data type to ThriftAttention kernels for compute capability sm_120. Currently, only FP16 is supported, and the goal is to enhance utility by incorporating bfloat16. This will involve defining traits for bfloat16 and templating existing kernels and related components.

This issue proposes adding support for the MXFP4 data type to the SM120 kernels within ThriftAttention. Currently, only NVFP4 is supported for lower precision. The implementation involves defining trait structs, modifying existing CUDA kernels and quantization/block selection files, and updating bindings to route based on torch.dtype, followed by testing and profiling.

This issue proposes adding support for the QUEST min-max heuristic to ThriftAttention, which currently only supports the topk heuristic for selecting blocks to promote to FP16. The work involves implementing the QUEST heuristic in CUDA kernels, adding corresponding tests, and integrating it into the selection policy and attention configuration.

This issue aims to implement and integrate FP4 attention kernels for data center Blackwell GPUs, leveraging specific hardware features like `tcgen05` to achieve theoretical speedups. The goal is to establish a baseline for ThriftAttention and address the current lack of widely available FP4 attention implementations on B200 GPUs.

This enhancement proposes to optimize insertions into multiset and multimap containers by bypassing the default key equality check. This check is unnecessary for these container types as elements are always inserted, regardless of key existence, leading to potential performance gains.

The task is to resolve a naming inconsistency between the cuOpt thin client and the SDK for solver settings related to Mixed Integer Programming (MIP) and Linear Programming (LP). Specifically, parameter names like `relative_mip_gap` in the thin client need to be updated to match the SDK's naming convention (`mip_relative_gap`). This involves modifying the `thin_client_solver_settings.py` file to align the parameter names.

Implement unrestricted coupled-cluster singles and doubles with perturbative triples [UCCSD(T)] calculations within the ByteQC quantum chemistry package. This requires extending ByteQC to handle unrestricted Hartree-Fock (UHF) reference wavefunctions and implementing the spin-unrestricted CCSD and (T) equations, leveraging its existing GPU acceleration capabilities.