Main merge release/26.08 (#2392)

<!--

Thank you for contributing to cuvs :)

Here are some guidelines to help the review process go smoothly.

1. Please write a description in this text box of the changes that are
being
   made.

2. Please ensure that you have written units tests for the changes
made/features
   added.

3. If you are closing an issue please use one of the automatic closing
words as
noted here:
https://help.github.com/articles/closing-issues-using-keywords/

4. If your pull request is not ready for review but you want to make use
of the
continuous integration testing facilities please label it with `[WIP]`.

5. If your pull request is ready to be reviewed without requiring
additional
work on top of it, then remove the `[WIP]` label (if present) and
replace
it with `[REVIEW]`. If assistance is required to complete the
functionality,
for example when the C/C++ code of a feature is complete but Python
bindings
are still required, then add the label `[HELP-REQ]` so that others can
triage
and assist. The additional changes then can be implemented on top of the
same PR. If the assistance is done by members of the rapidsAI team, then
no
additional actions are required by the creator of the original PR for
this,
otherwise the original author of the PR needs to give permission to the
person(s) assisting to commit to their personal fork of the project. If
that
doesn't happen then a new PR based on the code of the original PR can be
opened by the person assisting, which then will be the PR that will be
   merged.

6. Once all work has been done and review has taken place please do not
add
features or make changes out of the scope of those requested by the
reviewer
(doing this just add delays as already reviewed code ends up having to
be
re-reviewed/it is hard to tell what is new etc!). Further, please do not
rebase your branch on master/force push/rewrite history, doing any of
these
   causes the context of any comments made by reviewers to be lost. If
conflicts occur against master they should be resolved by merging master
   into the branch used for making the pull request.

Many thanks in advance for your cooperation!

-->

---------

Co-authored-by: Howard Huang <howardhuangb@gmail.com>
Co-authored-by: aamijar <aamijar230@gmail.com>
Co-authored-by: divyegala <divyegala@gmail.com>
Co-authored-by: Yan Zaretskiy <yzaretskiy@nvidia.com>
Co-authored-by: Artem M. Chirkin <9253178+achirkin@users.noreply.github.com>
Co-authored-by: tarangj <jaintarang2015@gmail.com>
Co-authored-by: Tarang Jain <40517122+tarang-jain@users.noreply.github.com>
Co-authored-by: Igor Motov <igor@motovs.org>

Author: 8 people

README.md

@@ -132,8 +132,12 @@ cuvsResourcesCreate(&res);
 cuvsCagraIndexParamsCreate(&index_params);
 cuvsCagraIndexCreate(&index);
 
-cuvsCagraBuild(res, index_params, dataset, index);
+cuvsDataset_t dataset_view;
+cuvsDatasetMakeStandardView(res, dataset, &dataset_view);
 
+cuvsCagraBuild(res, index_params, dataset_view, index);
+
+cuvsDatasetDestroy(dataset_view);
 cuvsCagraIndexDestroy(index);
 cuvsCagraIndexParamsDestroy(index_params);
 cuvsResourcesDestroy(res);

c/include/cuvs/core/all.h

@@ -11,6 +11,7 @@
 #include <cuvs/core/c_config.h>
 #include <cuvs/core/export.h>
 #include <cuvs/core/c_api.h>
+#include <cuvs/core/dataset.h>
 
 #include <cuvs/cluster/kmeans.h>
 

c/include/cuvs/core/dataset.h

@@ -0,0 +1,111 @@
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#pragma once
+
+#include <cuvs/core/c_api.h>
+
+#include <dlpack/dlpack.h>
+#include <stdbool.h>
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @brief Generic dataset layout kind for C API dataset handles.
+ */
+typedef enum {
+  CUVS_DATASET_LAYOUT_STANDARD = 0,
+  CUVS_DATASET_LAYOUT_PADDED   = 1
+} cuvsDatasetLayout_t;
+
+/**
+ * @brief Memory space holding a C API dataset handle's data.
+ */
+typedef enum {
+  CUVS_DATASET_MEM_TYPE_HOST   = 0,
+  CUVS_DATASET_MEM_TYPE_DEVICE = 1
+} cuvsDatasetMemType_t;
+
+/**
+ * @brief Dataset handle representing owning storage or a non-owning view.
+ *
+ * `addr` points to C++ dataset storage or view metadata managed by the C API. `mem_type`
+ * identifies the memory space, `layout` identifies the data layout, and `is_owning` indicates
+ * whether the handle owns its backing data.
+ */
+typedef struct {
+  uintptr_t addr;
+  void (*destroy_addr)(void*);
+  DLDataType dtype;
+  cuvsDatasetMemType_t mem_type;
+  cuvsDatasetLayout_t layout;
+  bool is_owning;
+} cuvsDataset;
+typedef cuvsDataset* cuvsDataset_t;
+
+/**
+ * @brief Create an empty owning dataset handle.
+ *
+ * The dataset storage, memory type, layout, and dtype are populated by the operation that fills
+ * this handle.
+ */
+CUVS_EXPORT cuvsError_t cuvsDatasetCreate(cuvsDataset_t* dataset);
+
+/**
+ * @brief Create an owning padded dataset in the requested memory space.
+ *
+ * The source tensor may reside in host- or device-accessible memory. Its contents are copied into
+ * newly allocated padded storage in `target_mem_type`.
+ *
+ * @param[in] res cuVS resources
+ * @param[in] dataset source tensor
+ * @param[in] target_mem_type memory space in which to allocate the padded dataset
+ * @param[out] padded_dataset newly allocated owning padded dataset
+ */
+CUVS_EXPORT cuvsError_t cuvsDatasetMakePadded(cuvsResources_t res,
+                                              DLManagedTensor* dataset,
+                                              cuvsDatasetMemType_t target_mem_type,
+                                              cuvsDataset_t* padded_dataset);
+
+/**
+ * @brief Create a non-owning padded dataset view from a host- or device-resident tensor.
+ *
+ * Memory residency is inferred from the tensor.
+ */
+CUVS_EXPORT cuvsError_t cuvsDatasetMakePaddedView(cuvsResources_t res,
+                                                  DLManagedTensor* dataset,
+                                                  cuvsDataset_t* padded_dataset);
+
+/**
+ * @brief Create a non-owning standard dataset view from a host- or device-resident tensor.
+ *
+ * Memory residency is inferred from the tensor.
+ */
+CUVS_EXPORT cuvsError_t cuvsDatasetMakeStandardView(cuvsResources_t res,
+                                                    DLManagedTensor* dataset,
+                                                    cuvsDataset_t* standard_dataset);
+
+/** @brief Destroy a dataset handle created by a `cuvsDatasetMake*` function. */
+CUVS_EXPORT cuvsError_t cuvsDatasetDestroy(cuvsDataset_t dataset);
+
+/** @brief Get the memory residency of a dataset handle. */
+CUVS_EXPORT cuvsError_t cuvsDatasetGetMemType(cuvsDataset_t dataset,
+                                              cuvsDatasetMemType_t* mem_type);
+
+/** @brief Get the layout of a dataset handle. */
+CUVS_EXPORT cuvsError_t cuvsDatasetGetLayout(cuvsDataset_t dataset, cuvsDatasetLayout_t* layout);
+
+/** @brief Get whether a dataset handle owns its backing storage. */
+CUVS_EXPORT cuvsError_t cuvsDatasetGetIsOwning(cuvsDataset_t dataset, bool* is_owning);
+
+/** @brief Get the element dtype of a dataset handle. */
+CUVS_EXPORT cuvsError_t cuvsDatasetGetDtype(cuvsDataset_t dataset, DLDataType* dtype);
+
+#ifdef __cplusplus
+}
+#endif