mindspore 2.4.10__cp39-none-any.whl → 2.5.0__cp39-none-any.whl

mindspore/lib/plugin/ascend/ms_kernels_internal/internal_kernel/include/acme/src/core/kernel_register.h

@@ -1,46 +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_CORE_KERNEL_REGISTER_H_
-#define MS_KERNELS_INTERNAL_KERNEL_ACME_SRC_CORE_KERNEL_REGISTER_H_
-
-#include <vector>
-
-namespace mindspore {
-namespace acme {
-
-extern const char *kMatmulKernelName;
-extern const char *kMultiWeightMatmulKernelName;
-extern const size_t kFlashAttentionScoreRegisterIndex;
-extern const size_t kPagedAttentionRegisterIndex;
-extern const std::vector<std::vector<const char *>> kKernelMaps;
-
-class KernelRegister {
- public:
-  KernelRegister();
-  ~KernelRegister() = default;
-
-  static const KernelRegister &GetInstance() {
-    static const KernelRegister kKernelRegister;
-    return kKernelRegister;
-  }
-
-  void Register();
-};
-}  // namespace acme
-}  // namespace mindspore
-
-#endif  // MS_KERNELS_INTERNAL_KERNEL_ACME_SRC_CORE_KERNEL_REGISTER_H_

mindspore/lib/plugin/ascend/ms_kernels_internal/internal_kernel/include/acme/src/core/platform/platform_configs.h

@@ -1,89 +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_CORE_PLATFORM_CONFIGS_H_
-#define MS_KERNELS_INTERNAL_KERNEL_ACME_SRC_CORE_PLATFORM_CONFIGS_H_
-
-#include <string>
-#include <cstdint>
-
-namespace mindspore {
-namespace acme {
-class HardwareConfig {
- public:
-  HardwareConfig() = default;
-  ~HardwareConfig() = default;
-  HardwareConfig(uint32_t core_num, uint32_t l2_size, uint32_t l1_size, uint32_t l0a_size, uint32_t l0b_size,
-                 uint32_t l0c_size, uint32_t ub_size)
-      : core_num_(core_num),
-        l2_size_(l2_size),
-        l1_size_(l1_size),
-        l0a_size_(l0a_size),
-        l0b_size_(l0b_size),
-        l0c_size_(l0c_size),
-        ub_size_(ub_size) {}
-
-  uint32_t core_num_{0};
-  uint32_t l2_size_{0};
-  uint32_t l1_size_{0};
-  uint32_t l0a_size_{0};
-  uint32_t l0b_size_{0};
-  uint32_t l0c_size_{0};
-  uint32_t hbm_bandwidth_{1};
-  uint32_t l2_bandwidth_{5};
-  uint32_t ub_size_{0};
-};
-
-class PlatformConfigs {
- public:
-  PlatformConfigs();
-  ~PlatformConfigs() = default;
-
-  static const PlatformConfigs &GetInstance() {
-    static PlatformConfigs kPlatformConfigs;
-    return kPlatformConfigs;
-  }
-
-  inline uint32_t GetCoreNum() const { return hw_config_.core_num_; }
-
-  inline uint32_t GetL2Size() const { return hw_config_.l2_size_; }
-
-  inline uint32_t GetL1Size() const { return hw_config_.l1_size_; }
-
-  inline uint32_t GetL0aSize() const { return hw_config_.l0a_size_; }
-
-  inline uint32_t GetL0bSize() const { return hw_config_.l0b_size_; }
-
-  inline uint32_t GetL0cSize() const { return hw_config_.l0c_size_; }
-
-  inline uint32_t GetHbmBandwidth() const { return hw_config_.hbm_bandwidth_; }
-
-  inline uint32_t GetL2BandwidthSize() const { return hw_config_.l2_bandwidth_; }
-
-  inline uint32_t GetUbSize() const { return hw_config_.ub_size_; }
-
-  const HardwareConfig &GetConfigByVersion(const std::string &soc_version) const;
-
- private:
-  void Init();
-
-  HardwareConfig hw_config_;
-  std::string soc_version_;
-};
-}  // namespace acme
-}  // namespace mindspore
-
-#endif  // MS_KERNELS_INTERNAL_KERNEL_ACME_SRC_CORE_PLATFORM_CONFIGS_H_

mindspore/lib/plugin/ascend/ms_kernels_internal/internal_kernel/include/acme/src/core/platform/rt_funcs.h

@@ -1,135 +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_CORE_PLATFORM_RT_FUNCS_H_
-#define MS_KERNELS_INTERNAL_KERNEL_ACME_SRC_CORE_PLATFORM_RT_FUNCS_H_
-
-#include "acme/include/base_type.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#define RT_DEV_BINARY_MAGIC_ELF 0x43554245U
-#define RT_DEV_BINARY_MAGIC_ELF_AIVEC 0x41415246U
-#define RT_DEV_BINARY_MAGIC_ELF_AICUBE 0x41494343U
-
-typedef void *rtStream_t;
-
-typedef enum {
-  INTERNAL_RTSUCCESS = 0,
-  INTERNAL_RTERROR_NOT_INITIALIZED = -1,
-  INTERNAL_RTERROR_NOT_IMPLMENT = -2,
-  INTERNAL_RTERROR_ASCEND_ENV_NOT_EXIST = -3,
-  INTERNAL_RTERROR_LOAD_RUNTIME_FAIL = -4,
-  INTERNAL_RTERROR_FUNC_NOT_EXIST = -5,
-  INTERNAL_RTERROR_OPEN_BIN_FILE_FAIL = -6,
-  INTERNAL_RTERROR_PARA_CHECK_FAIL = -7,
-} RtError;
-
-typedef enum tagRtError {
-  RT_ERROR_NONE = 0x0,                      // success
-  RT_ERROR_INVALID_VALUE = 0x1,             // invalid value
-  RT_ERROR_MEMORY_ALLOCATION = 0x2,         // memory allocation fail
-  RT_ERROR_INVALID_RESOURCE_HANDLE = 0x3,   // invalid handle
-  RT_ERROR_INVALID_DEVICE_POINTER = 0x4,    // invalid device point
-  RT_ERROR_INVALID_MEMCPY_DIRECTION = 0x5,  // invalid memory copy dirction
-  RT_ERROR_INVALID_DEVICE = 0x6,            // invalid device
-  RT_ERROR_NO_DEVICE = 0x7,                 // no valid device
-  RT_ERROR_CMD_OCCUPY_FAILURE = 0x8,        // command occpuy failure
-  RT_ERROR_SET_SIGNAL_FAILURE = 0x9,        // set signal failure
-  RT_ERROR_UNSET_SIGNAL_FAILURE = 0xA,      // unset signal failure
-  RT_ERROR_OPEN_FILE_FAILURE = 0xB,         // unset signal failure
-  RT_ERROR_WRITE_FILE_FAILURE = 0xC,
-  RT_ERROR_MEMORY_ADDRESS_UNALIGNED = 0xD,
-  RT_ERROR_DRV_ERR = 0xE,
-  RT_ERROR_LOST_HEARTBEAT = 0xF,
-  RT_ERROR_REPORT_TIMEOUT = 0x10,
-  RT_ERROR_NOT_READY = 0x11,
-  RT_ERROR_DATA_OPERATION_FAIL = 0x12,
-  RT_ERROR_INVALID_L2_INSTR_SIZE = 0x13,
-  RT_ERROR_DEVICE_PROC_HANG_OUT = 0x14,
-  RT_ERROR_DEVICE_POWER_UP_FAIL = 0x15,
-  RT_ERROR_DEVICE_POWER_DOWN_FAIL = 0x16,
-  RT_ERROR_FEATURE_NOT_SUPPROT = 0x17,
-  RT_ERROR_KERNEL_DUPLICATE = 0x18,             // register same kernel repeatly
-  RT_ERROR_MODEL_STREAM_EXE_FAILED = 0x91,      // the model stream failed
-  RT_ERROR_MODEL_LOAD_FAILED = 0x94,            // the model stream failed
-  RT_ERROR_END_OF_SEQUENCE = 0x95,              // end of sequence
-  RT_ERROR_NO_STREAM_CB_REG = 0x96,             // no callback register info for stream
-  RT_ERROR_DATA_DUMP_LOAD_FAILED = 0x97,        // data dump load info fail
-  RT_ERROR_CALLBACK_THREAD_UNSUBSTRIBE = 0x98,  // callback thread unsubstribe
-  RT_ERROR_RESERVED
-} rtError_t;
-
-// rt kernel
-typedef struct {
-  uint32_t magic{0};
-  uint32_t version{0};
-  const void *data{nullptr};
-  uint64_t length{0};
-} RtDevBinary_T;
-
-typedef void *rtStream_t;
-
-using RtDevBinaryRegisterFunc = rtError_t (*)(const RtDevBinary_T *bin, void **hdl);
-using RtFunctionRegisterFunc = rtError_t (*)(void *binHandle, const void *subFunc, const char *stubName,
-                                             const void *kernelInfoExt, uint32_t funcMode);
-using RtKernelLaunchFunc = rtError_t (*)(const void *stubFunc, uint32_t blockDim, void *args, uint32_t argsSize,
-                                         void *smDesc, rtStream_t sm);
-using RtGetC2cCtrlAddrFunc = rtError_t (*)(uint64_t *addr, uint32_t *len);
-
-using RtGetSocVersionFunc = int (*)(char *version, uint32_t maxLen);
-
-#ifdef __cplusplus
-}
-#endif
-
-namespace mindspore {
-namespace acme {
-class RtFuncs {
- public:
-  RtFuncs();
-  ~RtFuncs() = default;
-
-  static const RtFuncs &GetInstance() {
-    static RtFuncs kRtFuncs;
-    return kRtFuncs;
-  }
-
-  inline RtDevBinaryRegisterFunc GetRtDevBinaryRegisterFunc() const { return rt_dev_bin_reg_func_; }
-
-  inline RtFunctionRegisterFunc GetRtFunctionRegisterFunc() const { return rt_func_reg_func_; }
-
-  inline RtKernelLaunchFunc GetRtKernelLaunchFunc() const { return rt_kernel_launch_func_; }
-
-  inline RtGetC2cCtrlAddrFunc GetRtGetC2cCtrlAddrFunc() const { return rt_get_c2c_ctrl_addr_func_; }
-
-  std::string GetSocVersion() const;
-
- private:
-  void Init();
-
-  RtDevBinaryRegisterFunc rt_dev_bin_reg_func_{nullptr};
-  RtFunctionRegisterFunc rt_func_reg_func_{nullptr};
-  RtKernelLaunchFunc rt_kernel_launch_func_{nullptr};
-  RtGetC2cCtrlAddrFunc rt_get_c2c_ctrl_addr_func_{nullptr};
-  RtGetSocVersionFunc rt_get_soc_version_func_{nullptr};
-};
-}  // namespace acme
-}  // namespace mindspore
-
-#endif  // MS_KERNELS_INTERNAL_KERNEL_ACME_SRC_CORE_PLATFORM_RT_FUNCS_H_

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

@@ -1,60 +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_ADDLAYERNORM_OP_H_
-#define MS_KERNELS_INTERNAL_KERNEL_ACME_SRC_OPS_HOST_SRC_ADDLAYERNORM_OP_H_
-
-#include "acme/include/acme_op.h"
-#include "acme/include/op_param.h"
-#include "acme/src/ops/device_src/ascendc/add_layer_norm/add_layer_norm_tiling.h"
-
-namespace mindspore {
-namespace acme {
-static constexpr int RESERVED_WORKSPACE_SIZE_910B = 16 * 1024 * 1024;
-static constexpr int RESERVED_WORKSPACE_SIZE_310P = 2 * 1024 * 1024;
-
-class AddLayerNormOp : public AcmeOp {
- public:
-  AddLayerNormOp(const InputsImmutableInfoList &inputs_ii, const OutputsImmutableInfoList &outputs_ii,
-                 const NormParam &param, const std::string &op_name)
-      : AcmeOp(inputs_ii, outputs_ii, op_name), param_(param){};
-  ~AddLayerNormOp() = default;
-
-  std::string DumpTiling(const RawHostAddr host_ptr) const override;
-  ShapeInfoList InferShape(const ShapeInfoList &inputs_shape) const override;
-  std::vector<size_t> GetWorkspaceSize() const override {
-    size_t sysWorkspaceSize = RESERVED_WORKSPACE_SIZE_910B;
-    if ((soc_.find("Ascend310P") != std::string::npos)) {
-      sysWorkspaceSize = RESERVED_WORKSPACE_SIZE_310P;
-    }
-    return {1 + sysWorkspaceSize};
-  };
-
- 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;
-
- private:
-  NormParam param_;
-};
-
-using AddLayerNormOpPtr = std::shared_ptr<AddLayerNormOp>;
-}  // namespace acme
-}  // namespace mindspore
-
-#endif  // MS_KERNELS_INTERNAL_KERNEL_ACME_SRC_OPS_HOST_SRC_ADDLAYERNORM_OP_H_

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

@@ -1,50 +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_ADD_RMS_NORM_OP_H_
-#define MS_KERNELS_INTERNAL_KERNEL_ACME_SRC_OPS_HOST_SRC_ADD_RMS_NORM_OP_H_
-
-#include <vector>
-#include "acme/include/acme_op.h"
-#include "acme/include/op_param.h"
-
-namespace mindspore {
-namespace acme {
-class AddRmsNormOp : public AcmeOp {
- public:
-  AddRmsNormOp(const InputsImmutableInfoList &inputs_ii, const OutputsImmutableInfoList &outputs_ii,
-               const NormParam &param, const std::string &op_name)
-      : AcmeOp(inputs_ii, outputs_ii, op_name), param_(param) {}
-  ~AddRmsNormOp() = default;
-
-  std::string DumpTiling(const RawHostAddr host_ptr) const override;
-  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;
-
- private:
-  NormParam param_;
-};
-
-using AddRmsNormOpPtr = std::shared_ptr<AddRmsNormOp>;
-}  // namespace acme
-}  // namespace mindspore
-
-#endif  // MS_KERNELS_INTERNAL_KERNEL_ACME_SRC_OPS_HOST_SRC_ADD_RMS_NORM_OP_H_

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

@@ -1,50 +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_ADD_RMS_NORM_QUANT_OP_H_
-#define MS_KERNELS_INTERNAL_KERNEL_ACME_SRC_OPS_HOST_SRC_ADD_RMS_NORM_QUANT_OP_H_
-
-#include "acme/include/acme_op.h"
-#include "acme/include/op_param.h"
-
-namespace mindspore {
-namespace acme {
-class AddRmsNormQuantOp : public AcmeOp {
- public:
-  AddRmsNormQuantOp(const InputsImmutableInfoList &inputs_ii, const OutputsImmutableInfoList &outputs_ii,
-                    const NormParam &param, const std::string &op_name)
-      : AcmeOp(inputs_ii, outputs_ii, op_name), param_(param){};
-  ~AddRmsNormQuantOp() = default;
-
-  std::string DumpTiling(const RawHostAddr host_ptr) const override;
-  ShapeInfoList InferShape(const ShapeInfoList &inputs_shape) const override;
-  std::vector<size_t> GetWorkspaceSize() const override { return {16 * 1024 * 1024 + 256}; };
-
- 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;
-
- private:
-  NormParam param_;
-};
-
-using AddRmsNormQuantOpPtr = std::shared_ptr<AddRmsNormQuantOp>;
-}  // namespace acme
-}  // namespace mindspore
-
-#endif  // MS_KERNELS_INTERNAL_KERNEL_ACME_SRC_OPS_HOST_SRC_ADD_RMS_NORM_QUANT_OP_H_

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

@@ -1,42 +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_HOST_ACME_ROPE_NZ_H_
-#define MS_KERNELS_INTERNAL_HOST_ACME_ROPE_NZ_H_
-
-#include "acme/include/acme_op.h"
-#include "acme/include/op_param.h"
-#include "apply_rotary_pos_emb_op.h"
-#include "utils/log/log.h"
-
-namespace mindspore {
-namespace acme {
-class ApplyRotaryPosEmbNzOp : public ApplyRotaryPosEmbOp {
- public:
-  ApplyRotaryPosEmbNzOp(const InputsImmutableInfoList &inputs_ii, const OutputsImmutableInfoList &outputs_ii,
-                        const ApplyRotaryPosEmbParam &param, const std::string &op_name)
-      : ApplyRotaryPosEmbOp(inputs_ii, outputs_ii, param, op_name) {}
-  ~ApplyRotaryPosEmbNzOp() = default;
-
-  AcmeStatus LaunchImpl(const InputsAddrList &input_ptrs, const OutputsAddrList &output_ptrs, const WsAddrList &ws_ptrs,
-                        void *stream) override;
-};
-
-using ApplyRotaryPosEmbNzOpPtr = std::shared_ptr<ApplyRotaryPosEmbNzOp>;
-}  // namespace acme
-}  // namespace mindspore
-
-#endif  // MS_KERNELS_INTERNAL_HOST_ACME_ROPE_NZ_H_

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

@@ -1,55 +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_HOST_ACME_ROPE_H_
-#define MS_KERNELS_INTERNAL_HOST_ACME_ROPE_H_
-
-#include "acme/include/acme_op.h"
-#include "acme/include/op_param.h"
-#include "utils/log/log.h"
-#include "acme/src/ops/device_src/ascendc/apply_rotary_pos_emb/apply_rotary_pos_emb_tiling.h"
-
-namespace mindspore {
-namespace acme {
-class ApplyRotaryPosEmbOp : public AcmeOp {
- public:
-  ApplyRotaryPosEmbOp(const InputsImmutableInfoList &inputs_ii, const OutputsImmutableInfoList &outputs_ii,
-                      const ApplyRotaryPosEmbParam &param, const std::string &op_name)
-      : AcmeOp(inputs_ii, outputs_ii, op_name), param_(param) {}
-  ~ApplyRotaryPosEmbOp() = 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;
-
- private:
-  void SetTilingID(RopeTilingData *tiling, int typeKey);
-  int GetTilingType(DataType dataType);
-  bool is_ascend_310p_;
-  ApplyRotaryPosEmbParam param_;
-};
-
-using ApplyRotaryPosEmbOpPtr = std::shared_ptr<ApplyRotaryPosEmbOp>;
-}  // namespace acme
-}  // namespace mindspore
-
-#endif  // MS_KERNELS_INTERNAL_HOST_ACME_ROPE_H_

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

@@ -1,34 +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_ELEWISE_OP_H_
-#define MS_KERNELS_INTERNAL_KERNEL_ACME_SRC_OPS_HOST_SRC_ELEWISE_OP_H_
-
-#include "acme/src/ops/host_src/asd_op_base.h"
-#include "asdops/params/elewise.h"
-
-namespace mindspore {
-namespace acme {
-class AsdElewiseOp : public AsdOp {
- public:
-  AsdElewiseOp(const InputsImmutableInfoList &inputs_ii, const OutputsImmutableInfoList &outputs_ii,
-               const std::string &op_name, AsdOps::OpParam::Elewise::ElewiseType type);
-  ~AsdElewiseOp() = default;
-};
-}  // namespace acme
-}  // namespace mindspore
-
-#endif  // MS_KERNELS_INTERNAL_KERNEL_ACME_SRC_OPS_HOST_SRC_ELEWISE_OP_H_

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

@@ -1,94 +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_ASD_ONLY_OPS_H_
-#define MS_KERNELS_INTERNAL_KERNEL_ACME_SRC_OPS_HOST_SRC_ASD_ONLY_OPS_H_
-
-#include "acme/include/op_param.h"
-#include "acme/src/ops/host_src/asd_op_base.h"
-#include "acme/src/ops/host_src/asd_elewise_op.h"
-#include "acme/src/utils/asd_utils.h"
-
-#define DECLARE_ASD_OPS_WITH_PARAM(op_name, PARAM_NAME, PARENT)                                        \
-  class op_name##Op : public PARENT {                                                                  \
-   public:                                                                                             \
-    op_name##Op(const InputsImmutableInfoList &, const OutputsImmutableInfoList &, const PARAM_NAME &, \
-                const std::string &);                                                                  \
-    ~op_name##Op() = default;                                                                          \
-  };                                                                                                   \
-  using op_name##OpPtr = std::shared_ptr<op_name##Op>;
-
-#define DECLARE_ASD_OPS_NO_PARAM(op_name, PARENT)                                                        \
-  class op_name##Op : public PARENT {                                                                    \
-   public:                                                                                               \
-    op_name##Op(const InputsImmutableInfoList &, const OutputsImmutableInfoList &, const std::string &); \
-    ~op_name##Op() = default;                                                                            \
-  };                                                                                                     \
-  using op_name##OpPtr = std::shared_ptr<op_name##Op>;
-
-namespace mindspore {
-namespace acme {
-DECLARE_ASD_OPS_WITH_PARAM(Transpose, TransposeParam, AsdOp)
-
-DECLARE_ASD_OPS_NO_PARAM(Swish, AsdOp)
-DECLARE_ASD_OPS_WITH_PARAM(SwiGLU, SwiGLUParam, AsdOp)
-DECLARE_ASD_OPS_NO_PARAM(LogicalNot, AsdElewiseOp)
-DECLARE_ASD_OPS_NO_PARAM(Add, AsdElewiseOp)
-DECLARE_ASD_OPS_NO_PARAM(Mul, AsdElewiseOp)
-DECLARE_ASD_OPS_NO_PARAM(RealDiv, AsdElewiseOp)
-DECLARE_ASD_OPS_NO_PARAM(Sub, AsdElewiseOp)
-DECLARE_ASD_OPS_NO_PARAM(QuantPerChannel, AsdElewiseOp)
-DECLARE_ASD_OPS_NO_PARAM(FastGeLU, AsdOp)
-
-DECLARE_ASD_OPS_WITH_PARAM(Softmax, SoftmaxParam, AsdOp)
-DECLARE_ASD_OPS_WITH_PARAM(ReduceSum, ReduceSumParam, AsdOp)
-DECLARE_ASD_OPS_WITH_PARAM(Gather, GatherParam, AsdOp)
-
-class QuantLinearSparseOp : public AsdOp {
- public:
-  QuantLinearSparseOp(const InputsImmutableInfoList &, const OutputsImmutableInfoList &, const std::string &);
-  ~QuantLinearSparseOp() = default;
-
- protected:
-  AcmeStatus UpdateShape(const ShapeInfoList &inputs_shape, const ShapeInfoList &outputs_shape) override;
-  ShapeInfoList InferShape(const ShapeInfoList &inputs_shape) const override;
-  void UpdateDeqScale(const ShapeInfoList &inputs_shape);
-
- private:
-  bool is_310p_{false};
-};
-using QuantLinearSparseOpPtr = std::shared_ptr<QuantLinearSparseOp>;
-
-class TransDataOp : public AsdOp {
- public:
-  TransDataOp(const InputsImmutableInfoList &, const OutputsImmutableInfoList &, const TransDataParam &,
-              const std::string &);
-  ~TransDataOp() = default;
-
- protected:
-  void UpdateLaunchParam() override;
-  void Process310TensorDims(AsdOps::Tensor &tensor, const DIMS &dims, const DataType &dtype,
-                            const TensorFormat &format);
-
- private:
-  TransDataParam param_;
-  bool is_310p_{false};
-};
-using TransDataOpPtr = std::shared_ptr<TransDataOp>;
-}  // namespace acme
-}  // namespace mindspore
-
-#endif  // MS_KERNELS_INTERNAL_KERNEL_ACME_SRC_OPS_HOST_SRC_ASD_ONLY_OPS_H_