add op acc

Author: hipudding

ggml-cann.cpp

@@ -347,7 +347,8 @@ static bool ggml_cann_compute_forward(ggml_backend_cann_context& ctx,
             ggml_cann_add(ctx, dst);
             break;
         case GGML_OP_ACC:
-            return false;
+            ggml_cann_acc(ctx, dst);
+            break;
         case GGML_OP_MUL:
             ggml_cann_mul_div<aclnnMulGetWorkspaceSize, aclnnMul>(ctx, dst);
             break;
@@ -686,7 +687,7 @@ GGML_CALL static bool ggml_backend_cann_supports_op(ggml_backend_t backend,
         case GGML_OP_ARGSORT:
             return true;
         case GGML_OP_ACC:
-            return false;
+            return true;
         case GGML_OP_GROUP_NORM:
             return true;
         case GGML_OP_UPSCALE:

ggml-cann/acl_tensor.cpp

@@ -34,7 +34,7 @@ aclDataType type_mapping(ggml_type type) {
  */
 aclTensor* create_acl_tensor(const ggml_tensor* tensor, int64_t* bcast_ne,
                              size_t* bcast_nb, int64_t bcast_dims,
-                             aclFormat format) {
+                             aclFormat format, size_t offset) {
     size_t size = ggml_nbytes(tensor);
     void* deviceAddr = nullptr;
 
@@ -55,23 +55,23 @@ aclTensor* create_acl_tensor(const ggml_tensor* tensor, int64_t* bcast_ne,
         for (int i = 0; i < GGML_MAX_DIMS; i++) {
             acl_ne[i] = tensor->ne[i];
             // The step size of acl is in elements.
-            acl_stride[i] = tensor->nb[i] / ggml_type_size(tensor->type);
+            acl_stride[i] = tensor->nb[i] / ggml_element_size(tensor);
         }
     } else {
         // With bcast
         for (int i = 0; i < bcast_dims; i++) {
             acl_ne[i] = bcast_ne[i];
-            acl_stride[i] = bcast_nb[i] / ggml_type_size(tensor->type);
+            acl_stride[i] = bcast_nb[i] / ggml_element_size(tensor);
         }
     }
 
     int64_t dims = (bcast_dims == 0 ? GGML_MAX_DIMS : bcast_dims);
     std::reverse(acl_ne, acl_ne + dims);
     std::reverse(acl_stride, acl_stride + dims);
 
-    aclTensor* acl_tensor =
-        aclCreateTensor(acl_ne, dims, type_mapping(tensor->type), acl_stride, 0,
-                        format, acl_ne, dims, deviceAddr);
+    aclTensor* acl_tensor = aclCreateTensor(
+        acl_ne, dims, type_mapping(tensor->type), acl_stride,
+        offset / ggml_element_size(tensor), format, acl_ne, dims, deviceAddr);
 
     return acl_tensor;
 }

ggml-cann/acl_tensor.h

@@ -11,7 +11,7 @@ aclDataType type_mapping(ggml_type type);
 aclTensor* create_acl_tensor(const ggml_tensor* tensor,
                              int64_t* bcast_ne = nullptr,
                              size_t* bcast_nb = nullptr, int64_t bcast_dims = 0,
-                             aclFormat format = ACL_FORMAT_ND);
+                             aclFormat format = ACL_FORMAT_ND, size_t offset = 0);
 
 aclTensor* create_acl_tensor(void* data_ptr, aclDataType dtype,
                              size_t type_size, int64_t* ne, size_t* nb,

ggml-cann/aclnn_ops.cpp

@@ -424,4 +424,55 @@ void ggml_cann_softmax(ggml_backend_cann_context& ctx, ggml_tensor* dst) {
     ACL_CHECK(aclDestroyTensor(acl_dst));
 }
 
-void ggml_cann_acc(ggml_backend_cann_context& ctx, ggml_tensor* dst) {}
+void ggml_cann_acc(ggml_backend_cann_context& ctx, ggml_tensor* dst) {
+    ggml_tensor* src0 = dst->src[0];
+    ggml_tensor* src1 = dst->src[1];
+
+    size_t nb1 = ((int32_t*)dst->op_params)[0];
+    size_t nb2 = ((int32_t*)dst->op_params)[1];
+    size_t nb3 = ((int32_t*)dst->op_params)[2];
+    size_t offset = ((int32_t*)dst->op_params)[3];
+    bool inplace = (bool)((int32_t*)dst->op_params)[4];
+
+    size_t param_nb[] = {ggml_element_size(src0), nb1, nb2, nb3};
+
+    aclTensor* acl_dst = create_acl_tensor(
+        dst, src1->ne, param_nb, GGML_MAX_DIMS, ACL_FORMAT_ND, offset);
+    aclTensor* acl_src1 = create_acl_tensor(src1);
+
+    aclScalar* alpha = nullptr;
+    float alphaValue = 1.0f;
+    alpha = aclCreateScalar(&alphaValue, aclDataType::ACL_FLOAT);
+
+    uint64_t workspaceSize = 0;
+    aclOpExecutor* executor;
+    void* workspaceAddr = nullptr;
+
+    aclrtStream stream = ctx.stream();
+
+    if (!inplace) {
+        size_t cpy_size = ggml_nbytes(dst);
+        ACL_CHECK(aclrtMemcpyAsync(dst->data, cpy_size, src0->data, cpy_size,
+                                   ACL_MEMCPY_DEVICE_TO_DEVICE, stream));
+        aclTensor* acl_src0 = create_acl_tensor(
+            src0, src1->ne, src0->nb, GGML_MAX_DIMS, ACL_FORMAT_ND, offset);
+        ACL_CHECK(aclnnAddGetWorkspaceSize(acl_src0, acl_src1, alpha, acl_dst,
+                                           &workspaceSize, &executor));
+        if (workspaceSize > 0) {
+            workspaceAddr = ctx.alloc_buffer(workspaceSize);
+        }
+        ACL_CHECK(aclnnAdd(workspaceAddr, workspaceSize, executor, stream));
+        ACL_CHECK(aclDestroyTensor(acl_src0));
+    } else {
+        ACL_CHECK(aclnnInplaceAddGetWorkspaceSize(acl_dst, acl_src1, alpha,
+                                                  &workspaceSize, &executor));
+        if (workspaceSize > 0) {
+            workspaceAddr = ctx.alloc_buffer(workspaceSize);
+        }
+        ACL_CHECK(
+            aclnnInplaceAdd(workspaceAddr, workspaceSize, executor, stream));
+    }
+
+    ACL_CHECK(aclDestroyTensor(acl_src1));
+    ACL_CHECK(aclDestroyTensor(acl_dst));
+}

ggml-cann/aclnn_ops.h

@@ -43,6 +43,8 @@ void ggml_cann_group_norm(ggml_backend_cann_context& ctx, ggml_tensor* dst);
 
 void ggml_cann_softmax(ggml_backend_cann_context& ctx, ggml_tensor* dst);
 
+void ggml_cann_acc(ggml_backend_cann_context& ctx, ggml_tensor* dst);
+
 template <aclnnStatus getWorkspaceSize(const aclTensor*, const aclTensor*,
                                        aclTensor*, uint64_t*, aclOpExecutor**),
           aclnnStatus execute(void*, uint64_t, aclOpExecutor*, aclrtStream)>