user unique ptr

Author: hipudding

ggml/src/ggml-cann/acl_tensor.cpp

@@ -50,7 +50,7 @@ aclDataType ggml_cann_type_mapping(ggml_type type) {
     }
 }
 
-aclTensor * ggml_cann_create_tensor(const ggml_tensor * tensor,
+acl_tensor_ptr ggml_cann_create_tensor(const ggml_tensor * tensor,
                                     int64_t *           ne,
                                     size_t *            nb,
                                     int64_t             dims,
@@ -86,10 +86,20 @@ aclTensor * ggml_cann_create_tensor(const ggml_tensor * tensor,
     std::reverse(acl_ne, acl_ne + final_dims);
     std::reverse(acl_stride, acl_stride + final_dims);
 
-    aclTensor * acl_tensor = aclCreateTensor(acl_ne, final_dims, ggml_cann_type_mapping(tensor->type), acl_stride,
+    aclTensor * raw = aclCreateTensor(acl_ne, final_dims, ggml_cann_type_mapping(tensor->type), acl_stride,
                                              elem_offset, format, &acl_storage_len, 1, tensor->data);
 
-    return acl_tensor;
+    return acl_tensor_ptr(raw);
+}
+
+acl_int_array_ptr ggml_cann_create_int_array(const int64_t *value, uint64_t size) {
+    aclIntArray * raw = aclCreateIntArray(value, size);
+    return acl_int_array_ptr(raw);
+}
+
+acl_scalar_ptr ggml_cann_create_scalar(void *value, aclDataType dataType) {
+    aclScalar * raw = aclCreateScalar(value, dataType);
+    return acl_scalar_ptr(raw);
 }
 
 bool ggml_cann_need_bcast(const ggml_tensor * t0, const ggml_tensor * t1) {

ggml/src/ggml-cann/acl_tensor.h

@@ -43,6 +43,46 @@
  */
 aclDataType ggml_cann_type_mapping(ggml_type type);
 
+struct acl_tensor_deleter {
+    void operator()(aclTensor* ptr) const noexcept {
+        if (ptr != nullptr) {
+            ACL_CHECK(aclDestroyTensor(ptr));
+        }
+    }
+};
+
+using acl_tensor_ptr = std::unique_ptr<aclTensor, acl_tensor_deleter>;
+
+struct acl_int_array_deleter {
+    void operator()(aclIntArray* ptr) const noexcept {
+        if (ptr != nullptr) {
+            ACL_CHECK(aclDestroyIntArray(ptr));
+        }
+    }
+};
+
+using acl_int_array_ptr = std::unique_ptr<aclIntArray, acl_int_array_deleter>;
+
+struct acl_scalar_deleter {
+    void operator()(aclScalar* ptr) const noexcept {
+        if (ptr != nullptr) {
+            ACL_CHECK(aclDestroyScalar(ptr));
+        }
+    }
+};
+
+using acl_scalar_ptr = std::unique_ptr<aclScalar, acl_scalar_deleter>;
+
+struct acl_tensor_list_deleter {
+    void operator()(aclTensorList* ptr) const noexcept {
+        if (ptr != nullptr) {
+            ACL_CHECK(aclDestroyTensorList(ptr));
+        }
+    }
+};
+
+using acl_tensor_list_ptr = std::unique_ptr<aclTensorList, acl_tensor_list_deleter>;
+
 /**
  * @brief   Creates an ACL tensor from a ggml_tensor with optional shape.
  *
@@ -62,7 +102,7 @@ aclDataType ggml_cann_type_mapping(ggml_type type);
  * @param   offset      Offset in bytes for the ACL tensor data. Defaults to 0.
  * @return  Pointer to the created ACL tensor.
  */
-aclTensor * ggml_cann_create_tensor(const ggml_tensor * tensor,
+acl_tensor_ptr ggml_cann_create_tensor(const ggml_tensor * tensor,
                                     int64_t *           ne     = nullptr,
                                     size_t *            nb     = nullptr,
                                     int64_t             dims   = 0,
@@ -90,7 +130,7 @@ aclTensor * ggml_cann_create_tensor(const ggml_tensor * tensor,
  * @return  Pointer to the created ACL tensor.
  */
 template <typename TYPE>
-aclTensor * ggml_cann_create_tensor(void *      data_ptr,
+acl_tensor_ptr ggml_cann_create_tensor(void *      data_ptr,
                                     aclDataType dtype,
                                     TYPE        type_size,
                                     int64_t *   ne,
@@ -114,12 +154,27 @@ aclTensor * ggml_cann_create_tensor(void *      data_ptr,
     std::reverse(tmp_ne, tmp_ne + dims);
     std::reverse(tmp_stride, tmp_stride + dims);
 
-    aclTensor * acl_tensor =
+    aclTensor * raw =
         aclCreateTensor(tmp_ne, dims, dtype, tmp_stride, offset / type_size, format, &acl_storage_len, 1, data_ptr);
 
-    return acl_tensor;
+    return acl_tensor_ptr(raw);
 }
 
+acl_int_array_ptr ggml_cann_create_int_array(const int64_t *value, uint64_t size);
+acl_scalar_ptr ggml_cann_create_scalar(void *value, aclDataType dataType);
+
+template <typename... acl_tensor_ptr>
+acl_tensor_list_ptr ggml_cann_create_tensor_list(acl_tensor_ptr&&... tensors) {
+    aclTensor* raw_tensors[] = { tensors.get()... };
+    aclTensorList * raw = aclCreateTensorList(raw_tensors, sizeof...(tensors));
+    // aclTensor will release by aclTensorList, so release ownership without
+    // destroying the tensor
+    int dummy[] = { (tensors.release(), 0)... };
+    GGML_UNUSED(dummy);
+    return acl_tensor_list_ptr(raw);
+}
+
+
 /**
  * @brief   Checks if tensors require broadcasting based on their shapes.
  *