Make cuBLASLt descriptor wrappers move-safe (#3078)

## Summary
- make the cuBLASLt matrix layout and matmul descriptor wrappers move-safe
- transfer descriptor ownership explicitly on move construction and move assignment
- make moved-from wrappers null-safe on destruction
- add focused tests that verify each wrapper transfers its raw handle and nulls the source on move

## Why
These wrappers own raw `cublasLt*` descriptors and destroy them in their destructors, but their move constructor and move assignment operator were defaulted. That meant moving a wrapper copied the raw handle into the destination without clearing the source, so both objects believed they owned the same descriptor.

## Impact
This closes a double-destroy hazard in any path that moves or move-assigns these wrappers, including code that caches or returns compound matmul descriptor objects.

## Root cause
The wrapper types were acting like RAII owners while still using raw-pointer default move semantics.

## Validation
- `git diff --check`
- attempted `PARALLEL_LEVEL=8 ./build.sh tests -n --limit-tests=LINALG_TEST`
- local build is blocked here because `nvcc` is not installed and CMake cannot resolve `CUDAToolkit_ROOT`

Authors:
  - Minh Vu (https://github.com/fallintoplace)
  - Divye Gala (https://github.com/divyegala)

Approvers:
  - Divye Gala (https://github.com/divyegala)

URL: #3078

Author: fallintoplace

cpp/include/raft/linalg/detail/cublaslt_wrappers.hpp

@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: Copyright (c) 2024-2026, NVIDIA CORPORATION.
+ * SPDX-FileCopyrightText: Copyright (c) 2024-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
 #pragma once
@@ -19,6 +19,7 @@
 #include <cublasLt.h>
 
 #include <type_traits>
+#include <utility>
 
 namespace raft {
 namespace linalg::detail {
@@ -108,12 +109,19 @@ struct cublastlt_matrix_layout {
   }
   inline cublastlt_matrix_layout(const cublastlt_matrix_layout&)                    = delete;
   inline auto operator=(const cublastlt_matrix_layout&) -> cublastlt_matrix_layout& = delete;
-  inline cublastlt_matrix_layout(cublastlt_matrix_layout&&)                         = default;
-  inline auto operator=(cublastlt_matrix_layout&&) -> cublastlt_matrix_layout&      = default;
+  inline cublastlt_matrix_layout(cublastlt_matrix_layout&& other) noexcept
+    : res(std::exchange(other.res, nullptr))
+  {
+  }
+  inline auto operator=(cublastlt_matrix_layout&& other) noexcept -> cublastlt_matrix_layout&
+  {
+    std::swap(res, other.res);
+    return *this;
+  }
 
   inline ~cublastlt_matrix_layout() noexcept
   {
-    RAFT_CUBLAS_TRY_NO_THROW(cublasLtMatrixLayoutDestroy(res));
+    if (res != nullptr) { RAFT_CUBLAS_TRY_NO_THROW(cublasLtMatrixLayoutDestroy(res)); }
   }
 
   // NOLINTNEXTLINE
@@ -137,12 +145,19 @@ struct cublastlt_matmul_desc {
   }
   inline cublastlt_matmul_desc(const cublastlt_matmul_desc&)                    = delete;
   inline auto operator=(const cublastlt_matmul_desc&) -> cublastlt_matmul_desc& = delete;
-  inline cublastlt_matmul_desc(cublastlt_matmul_desc&&)                         = default;
-  inline auto operator=(cublastlt_matmul_desc&&) -> cublastlt_matmul_desc&      = default;
+  inline cublastlt_matmul_desc(cublastlt_matmul_desc&& other) noexcept
+    : res(std::exchange(other.res, nullptr))
+  {
+  }
+  inline auto operator=(cublastlt_matmul_desc&& other) noexcept -> cublastlt_matmul_desc&
+  {
+    std::swap(res, other.res);
+    return *this;
+  }
 
   inline ~cublastlt_matmul_desc() noexcept
   {
-    RAFT_CUBLAS_TRY_NO_THROW(cublasLtMatmulDescDestroy(res));
+    if (res != nullptr) { RAFT_CUBLAS_TRY_NO_THROW(cublasLtMatmulDescDestroy(res)); }
   }
 
   // NOLINTNEXTLINE

cpp/tests/CMakeLists.txt

@@ -1,6 +1,6 @@
 # =============================================================================
 # cmake-format: off
-# SPDX-FileCopyrightText: Copyright (c) 2021-2026, NVIDIA CORPORATION.
+# SPDX-FileCopyrightText: Copyright (c) 2021-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 # SPDX-License-Identifier: Apache-2.0
 # cmake-format: on
 # =============================================================================
@@ -149,6 +149,7 @@ if(BUILD_TESTS)
     linalg/binary_op.cu
     linalg/cholesky_r1.cu
     linalg/coalesced_reduction.cu
+    linalg/cublaslt_wrappers.cpp
     linalg/divide.cu
     linalg/dot.cu
     linalg/eig.cu

cpp/tests/linalg/cublaslt_wrappers.cpp

@@ -0,0 +1,72 @@
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include <raft/linalg/detail/cublaslt_wrappers.hpp>
+
+#include <gtest/gtest.h>
+
+#include <utility>
+
+namespace raft::linalg::detail {
+
+TEST(Raft, CublasLtMatrixLayoutMoveConstructorTransfersOwnership)
+{
+  auto layout = cublastlt_matrix_layout{CUDA_R_32F, 2, 3, 2};
+  auto raw    = static_cast<cublasLtMatrixLayout_t>(layout);
+
+  ASSERT_NE(raw, nullptr);
+
+  auto moved = std::move(layout);
+
+  EXPECT_EQ(static_cast<cublasLtMatrixLayout_t>(layout), nullptr);
+  EXPECT_EQ(static_cast<cublasLtMatrixLayout_t>(moved), raw);
+}
+
+TEST(Raft, CublasLtMatrixLayoutMoveAssignmentTransfersOwnership)
+{
+  auto src     = cublastlt_matrix_layout{CUDA_R_32F, 2, 3, 2};
+  auto src_raw = static_cast<cublasLtMatrixLayout_t>(src);
+  auto dst     = cublastlt_matrix_layout{CUDA_R_16F, 4, 5, 4};
+  auto dst_raw = static_cast<cublasLtMatrixLayout_t>(dst);
+
+  ASSERT_NE(src_raw, nullptr);
+  ASSERT_NE(dst_raw, nullptr);
+
+  dst = std::move(src);
+
+  EXPECT_EQ(static_cast<cublasLtMatrixLayout_t>(src), dst_raw);
+  EXPECT_EQ(static_cast<cublasLtMatrixLayout_t>(dst), src_raw);
+}
+
+TEST(Raft, CublasLtMatmulDescMoveConstructorTransfersOwnership)
+{
+  auto desc = cublastlt_matmul_desc{CUBLAS_COMPUTE_32F, CUDA_R_32F};
+  auto raw  = static_cast<cublasLtMatmulDesc_t>(desc);
+
+  ASSERT_NE(raw, nullptr);
+
+  auto moved = std::move(desc);
+
+  EXPECT_EQ(static_cast<cublasLtMatmulDesc_t>(desc), nullptr);
+  EXPECT_EQ(static_cast<cublasLtMatmulDesc_t>(moved), raw);
+}
+
+TEST(Raft, CublasLtMatmulDescMoveAssignmentTransfersOwnership)
+{
+  auto src     = cublastlt_matmul_desc{CUBLAS_COMPUTE_32F, CUDA_R_32F};
+  auto src_raw = static_cast<cublasLtMatmulDesc_t>(src);
+  auto dst     = cublastlt_matmul_desc{CUBLAS_COMPUTE_16F, CUDA_R_16F};
+  auto dst_raw = static_cast<cublasLtMatmulDesc_t>(dst);
+
+  ASSERT_NE(src_raw, nullptr);
+  ASSERT_NE(dst_raw, nullptr);
+
+  dst = std::move(src);
+
+  EXPECT_EQ(static_cast<cublasLtMatmulDesc_t>(src), dst_raw);
+  EXPECT_EQ(static_cast<cublasLtMatmulDesc_t>(dst), src_raw);
+}
+
+}  // namespace raft::linalg::detail