mindspore 2.4.10__cp310-cp310-manylinux1_x86_64.whl → 2.5.0__cp310-cp310-manylinux1_x86_64.whl

mindspore/lib/plugin/ascend/ms_kernels_internal/internal_kernel/include/acme/src/ops/host_src/paged_attention_op.h

@@ -1,99 +0,0 @@
-/**
- * Copyright 2024 Huawei Technologies Co., Ltd
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef MS_KERNELS_INTERNAL_KERNEL_ACME_SRC_OPS_HOST_SRC_PAGED_ATTENTION_OP_H_
-#define MS_KERNELS_INTERNAL_KERNEL_ACME_SRC_OPS_HOST_SRC_PAGED_ATTENTION_OP_H_
-
-#include "multi_impls_op.h"
-#include "acme/src/ops/device_src/cce/paged_attention/paged_attention_tiling_data.h"
-
-namespace mindspore {
-namespace acme {
-static std::ostringstream &operator<<(std::ostringstream &os, const PagedAttentionParam &dt) {
-  os << "AcmePagedAttention Param: ";
-  os << "\n inner_precise:  " << dt.inner_precise;
-  os << "\n head_num:       " << dt.head_num;
-  os << "\n kv_head_num:    " << dt.kv_head_num;
-  os << "\n tor:            " << dt.tor;
-  os << "\n kv_seq_len:     ";
-  os << "[";
-  for (auto element : dt.kv_seq_len) {
-    os << element << " ";
-  }
-  os << "]";
-  os << "\n q_seq_len:      ";
-  os << "[";
-  for (auto element : dt.kv_seq_len) {
-    os << element << " ";
-  }
-  os << "]";
-  return os;
-}
-
-class PagedAttentionOp : public MultiImplsOp {
- public:
-  PagedAttentionOp(const InputsImmutableInfoList &inputs_ii, const OutputsImmutableInfoList &outputs_ii,
-                   const PagedAttentionParam &param, const std::string &op_name);
-  virtual ~PagedAttentionOp() = default;
-
-  AsdOps::Any BuildAsdParam() override;
-  AcmeStatus UpdateShape(const ShapeInfoList &inputs_shape, const ShapeInfoList &outputs_shape) override;
-  AcmeStatus UpdateParam(const void *) override;
-  const std::string &TargetKernelName() const override { return target_kernel_name_; }
-  ShapeInfoList InferShape(const ShapeInfoList &inputs_shape) const override;
-
- protected:
-  AcmeStatus InitImpl() override;
-  bool UseAsdopImpl() override;
-  AcmeStatus LaunchImpl(const InputsAddrList &input_ptrs, const OutputsAddrList &output_ptrs, const WsAddrList &ws_ptrs,
-                        void *stream);
-  AcmeStatus TilingImplAcme(RawHostAddr host_ptr, HostRunInfoPtr *run_info_ptr) override;
-  AcmeStatus LaunchImplAcme(const InputsAddrList &input_ptrs, const OutputsAddrList &output_ptrs,
-                            const WsAddrList &ws_ptrs, void *stream) override;
-  std::string DumpTilingAcme(const RawHostAddr host_ptr) const override;
-  uint32_t GetLaunchCoreNumAcme() const override;
-  AcmeStatus CreateAsdTensor();
-  AcmeStatus UpdateAsdParam();
-  AcmeStatus UpdateAsdTensor();
-  AcmeStatus CheckAsdopSupport() const;
-
- private:
-  const std::string target_kernel_name_{"MixOperation"};
-  PagedAttentionParam param_;
-  InputsDescList asd_inputs_;
-  OutputsDescList asd_outputs_;
-  InputsImmutableInfoList asd_inputs_ii_;
-  InputsImmutableInfoList asd_outputs_ii_;
-  ShapeInfoList asd_input_shape_;
-  ShapeInfoList asd_output_shape_;
-  uint64_t tiling_key_{0};
-  bool is_custom_quant_{false};
-  bool has_mask_{false};
-  bool has_alibi_mask_{false};
-  bool has_attn_mask_{false};
-  int alibi_mask_index_{-1};
-  int attn_mask_index_{-1};
-  bool is_910_{false};
-  bool is_310p_{false};
-  bool is_asd_quant_{false};
-  int dequant_shape_{0};
-};
-
-using PagedAttentionOpPtr = std::shared_ptr<PagedAttentionOp>;
-}  // namespace acme
-}  // namespace mindspore
-
-#endif  // MS_KERNELS_INTERNAL_KERNEL_ACME_SRC_OPS_HOST_SRC_PAGED_ATTENTION_OP_H_

mindspore/lib/plugin/ascend/ms_kernels_internal/internal_kernel/include/acme/src/ops/host_src/reshape_and_cache_nz_op.h

@@ -1,44 +0,0 @@
-/**
- * Copyright 2024 Huawei Technologies Co., Ltd
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef MS_KERNELS_INTERNAL_KERNEL_ACME_SRC_OPS_HOST_SRC_RESHAPE_AND_CACHE_NZ_OP_H_
-#define MS_KERNELS_INTERNAL_KERNEL_ACME_SRC_OPS_HOST_SRC_RESHAPE_AND_CACHE_NZ_OP_H_
-
-#include "acme/include/op_param.h"
-#include "acme/include/acme_op.h"
-
-namespace mindspore::acme {
-class ReshapeAndCacheNzOp : public AcmeOp {
- public:
-  ReshapeAndCacheNzOp(const InputsImmutableInfoList &inputs_ii, const OutputsImmutableInfoList &outputs_ii,
-                    const std::string &op_name)
-      : AcmeOp(inputs_ii, outputs_ii, op_name) {}
-  ~ReshapeAndCacheNzOp() = default;
-
-  std::string DumpTiling(const RawHostAddr host_ptr) const override;
-
-  bool IsSupported(const InputDataTypes &dtypes) override { return true; }
-
-  ShapeInfoList InferShape(const ShapeInfoList &inputs_shape) const override;
-
- protected:
-  AcmeStatus InitImpl() override;
-  AcmeStatus TilingImpl(RawHostAddr host_ptr, HostRunInfoPtr *run_info_ptr) override;
-  AcmeStatus LaunchImpl(const InputsAddrList &input_ptrs, const OutputsAddrList &output_ptrs, const WsAddrList &ws_ptrs,
-                        void *stream) override;
-};
-}  // namespace mindspore::acme
-#endif

mindspore/lib/plugin/ascend/ms_kernels_internal/internal_kernel/include/acme/src/ops/host_src/reshape_and_cache_op.h

@@ -1,44 +0,0 @@
-/**
- * Copyright 2024 Huawei Technologies Co., Ltd
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef MS_KERNELS_INTERNAL_KERNEL_ACME_SRC_OPS_HOST_SRC_RESHAPE_AND_CACHE_OP_H_
-#define MS_KERNELS_INTERNAL_KERNEL_ACME_SRC_OPS_HOST_SRC_RESHAPE_AND_CACHE_OP_H_
-
-#include "acme/include/op_param.h"
-#include "acme/include/acme_op.h"
-
-namespace mindspore::acme {
-class ReshapeAndCacheOp : public AcmeOp {
- public:
-  ReshapeAndCacheOp(const InputsImmutableInfoList &inputs_ii, const OutputsImmutableInfoList &outputs_ii,
-                    const std::string &op_name)
-      : AcmeOp(inputs_ii, outputs_ii, op_name) {}
-  ~ReshapeAndCacheOp() = default;
-
-  std::string DumpTiling(const RawHostAddr host_ptr) const override;
-
-  bool IsSupported(const InputDataTypes &dtypes) override { return true; }
-
-  ShapeInfoList InferShape(const ShapeInfoList &inputs_shape) const override;
-
- protected:
-  AcmeStatus InitImpl() override;
-  AcmeStatus TilingImpl(RawHostAddr host_ptr, HostRunInfoPtr *run_info_ptr) override;
-  AcmeStatus LaunchImpl(const InputsAddrList &input_ptrs, const OutputsAddrList &output_ptrs, const WsAddrList &ws_ptrs,
-                        void *stream) override;
-};
-}  // namespace mindspore::acme
-#endif

mindspore/lib/plugin/ascend/ms_kernels_internal/internal_kernel/include/acme/src/ops/host_src/rms_norm_op.h

@@ -1,64 +0,0 @@
-/**
- * Copyright 2024 Huawei Technologies Co., Ltd
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef MS_KERNELS_INTERNAL_KERNEL_ACME_SRC_OPS_HOST_SRC_RMSNORM_OP_H_
-#define MS_KERNELS_INTERNAL_KERNEL_ACME_SRC_OPS_HOST_SRC_RMSNORM_OP_H_
-
-#include <algorithm>
-#include "acme/include/acme_op.h"
-#include "acme/include/op_param.h"
-#include "acme/include/base_type.h"
-#include "acme/src/ops/host_src/multi_impls_op.h"
-
-#include "asdops/op_desc.h"
-#include "asdops/operation.h"
-#include "asdops/run_info.h"
-#include "asdops/tactic.h"
-#include "asdops/tensor.h"
-#include "asdops/params/norm.h"
-
-namespace mindspore {
-namespace acme {
-class RmsNormOp : public MultiImplsOp {
- public:
-  RmsNormOp(const InputsImmutableInfoList &inputs_ii, const OutputsImmutableInfoList &outputs_ii,
-            const NormParam &param, const std::string &op_name);
-  ~RmsNormOp() = default;
-
-  AcmeStatus InitImpl() override;
-  AsdOps::Any BuildAsdParam() override;
-  const std::string &TargetKernelName() const override { return target_kernel_name; }
-  ShapeInfoList InferShape(const ShapeInfoList &inputs_shape) const override;
-
- protected:
-  bool UseAsdopImpl() override;
-  AcmeStatus TilingImplAcme(RawHostAddr host_ptr, HostRunInfoPtr *run_info_ptr) override;
-  AcmeStatus LaunchImplAcme(const InputsAddrList &input_ptrs, const OutputsAddrList &output_ptrs,
-                            const WsAddrList &ws_ptrs, void *stream) override;
-  std::string DumpTilingAcme(const RawHostAddr host_ptr) const override;
-  uint32_t GetLaunchCoreNumAcme() const override;
-
- private:
-  NormParam param_;
-  bool is_ascend_310p_{false};
-  const std::string target_kernel_name{"NormOperation"};
-};
-
-using RmsNormOpPtr = std::shared_ptr<RmsNormOp>;
-}  // namespace acme
-}  // namespace mindspore
-
-#endif  // MS_KERNELS_INTERNAL_KERNEL_ACME_SRC_OPS_HOST_SRC_RMSNORM_OP_H

mindspore/lib/plugin/ascend/ms_kernels_internal/internal_kernel/include/acme/src/utils/asd_utils.h

@@ -1,179 +0,0 @@
-/**
- * Copyright 2024 Huawei Technologies Co., Ltd
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef MS_KERNELS_INTERNAL_KERNEL_ACME_SRC_UTILS_ASD_UTILS_H_
-#define MS_KERNELS_INTERNAL_KERNEL_ACME_SRC_UTILS_ASD_UTILS_H_
-
-#include "asdops/types.h"
-#include "utils/log/log.h"
-#include "acme/include/base_type.h"
-#include "acme/src/utils/comm_utils.h"
-
-namespace mindspore {
-namespace acme {
-constexpr size_t kIdx0 = 0;
-constexpr size_t kIdx1 = 1;
-constexpr size_t kIdx2 = 2;
-constexpr size_t kIdx3 = 3;
-constexpr int64_t DEFAULT_ALIGN = 16;
-constexpr int64_t DEFAULT_INT8_ALIGN = 32;
-
-using DIMS = AsdOps::SVector<int64_t>;
-
-inline DIMS NdToNz(const DIMS &inDims, const DataType &dtype) {
-  DIMS auxDims{0, 0, 0, 0};
-  DIMS nzDims{0, 0, 0, 0};
-  DIMS realInDims{0, 0, 0};
-  if (inDims.size() == 1) {
-    realInDims[kIdx0] = 1;
-    realInDims[kIdx1] = 1;
-    realInDims[kIdx2] = inDims[kIdx0];
-  } else if (inDims.size() == 2) {
-    realInDims[kIdx0] = 1;
-    realInDims[kIdx1] = inDims[kIdx0];
-    realInDims[kIdx2] = inDims[kIdx1];
-  } else if (inDims.size() == 3) {
-    realInDims[kIdx0] = inDims[kIdx0];
-    realInDims[kIdx1] = inDims[kIdx1];
-    realInDims[kIdx2] = inDims[kIdx2];
-  } else {
-    realInDims[kIdx0] = inDims[kIdx0];
-    realInDims[kIdx1] = inDims[kIdx1];
-    realInDims[kIdx2] = inDims[kIdx2] * inDims[kIdx3];
-  }
-
-  int64_t nzAlign = DEFAULT_ALIGN;
-  if (dtype == DataType::kTypeInt8) {
-    nzAlign = DEFAULT_INT8_ALIGN;
-  }
-
-  // inference aux dims: [N, H, W] -> [N, H', W'/16, 16]
-  auxDims[kIdx0] = realInDims[kIdx0];
-  auxDims[kIdx1] = UpRound(realInDims[kIdx1], DEFAULT_ALIGN);
-  auxDims[kIdx2] = UpRound(realInDims[kIdx2], nzAlign) / nzAlign;
-  auxDims[kIdx3] = nzAlign;
-
-  // inference output dims: [N, H', W'/16, 16] -> [N, W'/16, H', 16]
-  nzDims[kIdx0] = auxDims[kIdx0];
-  nzDims[kIdx1] = auxDims[kIdx2];
-  nzDims[kIdx2] = auxDims[kIdx1];
-  nzDims[kIdx3] = auxDims[kIdx3];
-  return nzDims;
-}
-
-inline DIMS ConvertStandardNdDims(const DIMS &inDims) {
-  DIMS dims{0, 0, 0};
-  if (inDims.size() == 2) {
-    dims[kIdx0] = 1;
-    dims[kIdx1] = inDims[kIdx0];
-    dims[kIdx2] = inDims[kIdx1];
-  } else {
-    dims[0] = inDims[kIdx0];
-    dims[1] = inDims[kIdx1];
-    dims[2] = inDims[kIdx2];
-    if (inDims.size() == 4) {
-      dims[2] *= inDims[kIdx3];
-    }
-  }
-  return dims;
-}
-
-inline AsdOps::TensorDType ToAsdType(DataType type) {
-  switch (type) {
-    // float data type
-    case DataType::kTypeBF16:
-      return AsdOps::TENSOR_DTYPE_BF16;
-    case DataType::kTypeFloat16:
-      return AsdOps::TENSOR_DTYPE_FLOAT16;
-    case DataType::kTypeFloat32:
-      return AsdOps::TENSOR_DTYPE_FLOAT;
-    case DataType::kTypeFloat64:
-      return AsdOps::TENSOR_DTYPE_DOUBLE;
-    // uint data type
-    case DataType::kTypeUint8:
-      return AsdOps::TENSOR_DTYPE_UINT8;
-    case DataType::kTypeUint16:
-      return AsdOps::TENSOR_DTYPE_UINT16;
-    case DataType::kTypeUint32:
-      return AsdOps::TENSOR_DTYPE_UINT32;
-    case DataType::kTypeUint64:
-      return AsdOps::TENSOR_DTYPE_UINT64;
-    // int data type
-    case DataType::kTypeInt8:
-      return AsdOps::TENSOR_DTYPE_INT8;
-    case DataType::kTypeInt16:
-      return AsdOps::TENSOR_DTYPE_INT16;
-    case DataType::kTypeInt32:
-      return AsdOps::TENSOR_DTYPE_INT32;
-    case DataType::kTypeInt64:
-      return AsdOps::TENSOR_DTYPE_INT64;
-    // complex data type
-    case DataType::kTypeComplex64:
-      return AsdOps::TENSOR_DTYPE_COMPLEX64;
-    case DataType::kTypeComplex128:
-      return AsdOps::TENSOR_DTYPE_COMPLEX128;
-    // other data type
-    case DataType::kTypeString:
-      return AsdOps::TENSOR_DTYPE_STRING;
-    case DataType::kTypeBool:
-      return AsdOps::TENSOR_DTYPE_BOOL;
-    case DataType::kTypeNone:
-      return AsdOps::TENSOR_DTYPE_UNDEFINED;
-    default:
-      MSOP_LOG(EXCEPTION) << "Unsupported type: " << type;
-      return AsdOps::TENSOR_DTYPE_UNDEFINED;
-  }
-}
-
-inline AsdOps::TensorFormat ToAsdFormat(TensorFormat format) {
-  switch (format) {
-    case TensorFormat::kFormatUnknown:
-      return AsdOps::TENSOR_FORMAT_UNDEFINED;
-    case TensorFormat::kFormatNCHW:
-      return AsdOps::TENSOR_FORMAT_NCHW;
-    case TensorFormat::kFormatND:
-      return AsdOps::TENSOR_FORMAT_ND;
-    case TensorFormat::kFormatNHWC:
-      return AsdOps::TENSOR_FORMAT_NHWC;
-    case TensorFormat::kFormatFRACTAL_NZ:
-      return AsdOps::TENSOR_FORMAT_FRACTAL_NZ;
-    default:
-      MSOP_LOG(EXCEPTION) << "Unsupported format: " << format;
-      return AsdOps::TENSOR_FORMAT_UNDEFINED;
-  }
-}
-
-inline void ToAsdDimsInplace(const ShapeInfo &shape, const DataType &dtype, const TensorFormat &format, DIMS *dims) {
-  dims->resize(shape.size());
-  for (auto i = 0; i < shape.size(); i++) {
-    dims->at(i) = shape[i];
-  }
-
-  if (format == TensorFormat::kFormatFRACTAL_NZ) {
-    *dims = NdToNz(*dims, dtype);
-    MSOP_LOG(DEBUG) << " nd_shape = " << shape << ", nz_shape = " << *dims;
-  }
-}
-
-inline DIMS ToAsdDims(const ShapeInfo &shape, const DataType &dtype, const TensorFormat &format) {
-  DIMS asd_dims;
-  ToAsdDimsInplace(shape, dtype, format, &asd_dims);
-  return asd_dims;
-}
-}  // namespace acme
-}  // namespace mindspore
-
-#endif  // MS_KERNELS_INTERNAL_KERNEL_ACME_SRC_UTILS_ASD_UTILS_H_

mindspore/lib/plugin/ascend/ms_kernels_internal/internal_kernel/include/acme/src/utils/comm_utils.h

@@ -1,69 +0,0 @@
-/**
- * Copyright 2024 Huawei Technologies Co., Ltd
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef MS_KERNELS_INTERNAL_KERNEL_ACME_SRC_UTILS_COMM_UTILS_H_
-#define MS_KERNELS_INTERNAL_KERNEL_ACME_SRC_UTILS_COMM_UTILS_H_
-
-#include <unordered_map>
-#include "acme/include/base_type.h"
-#include "utils/log/log.h"
-
-template <typename T>
-inline T CeilDiv(T x, T y) {
-  return y == 0 ? x : (x + y - 1) / y;
-}
-
-template <typename T>
-inline T UpRound(T x, T y) {
-  return ((x + y - 1) / y) * y;
-}
-
-namespace mindspore {
-namespace acme {
-inline size_t GetTypeSize(DataType type) {
-  static const std::unordered_map<DataType, size_t> kTypeSize = {
-    {DataType::kTypeFloat16, sizeof(float) / 2},
-    {DataType::kTypeFloat32, sizeof(float)},
-    {DataType::kTypeFloat64, sizeof(double)},
-    {DataType::kTypeInt8, sizeof(int8_t)},
-    {DataType::kTypeInt16, sizeof(int16_t)},
-    {DataType::kTypeInt32, sizeof(int32_t)},
-    {DataType::kTypeInt64, sizeof(int64_t)},
-    {DataType::kTypeUint8, sizeof(uint8_t)},
-    {DataType::kTypeUint16, sizeof(uint16_t)},
-    {DataType::kTypeUint32, sizeof(uint32_t)},
-    {DataType::kTypeUint64, sizeof(uint64_t)},
-    {DataType::kTypeBF16, sizeof(float) / 2},
-    {DataType::kTypeBool, sizeof(bool)},
-    {DataType::kTypeComplex64, 64},
-    {DataType::kTypeComplex128, 128},
-    {DataType::kTypeNone, 0},
-  };
-
-  auto it = kTypeSize.find(type);
-  if (it == kTypeSize.end()) {
-    MSOP_LOG(EXCEPTION) << "Unsupported type: " << static_cast<int>(type);
-    return 0;
-  }
-
-  return it->second;
-}
-
-bool IsOpEnabled(const std::string &op_name);
-}  // namespace acme
-}  // namespace mindspore
-
-#endif  // MS_KERNELS_INTERNAL_KERNEL_ACME_SRC_UTILS_COMM_UTILS_H_