mindspore 2.3.0__cp39-none-any.whl → 2.3.0rc2__cp39-none-any.whl

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

@@ -1,37 +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_
-
-namespace mindspore {
-namespace acme {
-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_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_ADD_OP_H_
-#define MS_KERNELS_INTERNAL_KERNEL_ACME_SRC_OPS_HOST_SRC_ADD_OP_H_
-
-#include "acme/src/ops/host_src/asd_elewise_op.h"
-
-namespace mindspore {
-namespace acme {
-class AddOp : public AsdElewiseOp {
- public:
-  AddOp(const InputsImmutableInfoList &inputs_ii, const OutputsImmutableInfoList &outputs_ii);
-  ~AddOp() = default;
-};
-
-using AddOpPtr = std::shared_ptr<AddOp>;
-}  // namespace acme
-}  // namespace mindspore
-
-#endif  // MS_KERNELS_INTERNAL_KERNEL_ACME_SRC_OPS_HOST_SRC_ADD_OP_H_

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

@@ -1,62 +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_BACKOFF_H_
-#define MS_KERNELS_INTERNAL_KERNEL_ACME_SRC_OPS_HOST_SRC_ASD_BACKOFF_H_
-
-#include <any>
-#include "acme/src/ops/host_src/asd_ops.h"
-
-namespace mindspore {
-namespace acme {
-class AsdBackOffKernel : public AcmeOp {
- public:
-  AsdBackOffKernel(const InputsImmutableInfoList &inputs_ii, const OutputsImmutableInfoList &outputs_ii);
-  ~AsdBackOffKernel() = default;
-
-  AcmeStatus UpdateShape(const ShapeInfoList &inputs_shape, const ShapeInfoList &outputs_shape) override;
-  void SetTilingInfo(const TilingInfoPtr &tiling_info) override;
-
-  virtual AsdOps::Any BuildAsdParam() = 0;
-  virtual bool CanAsdSupport();
-  virtual bool NeedBackOff();
-  virtual const std::string &TargetKernelName() const;
-  virtual AsdOpPtr CreateBackOffKernel(const InputsImmutableInfoList &inputs_ii,
-                                       const OutputsImmutableInfoList &outputs_ii, const AsdOps::Any &param,
-                                       const std::string &kernel_name);
-  
-  std::string DumpTiling(const RawHostAddr host_ptr) const override;
-
- protected:
-  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;
-
-  virtual bool NeedBackOffImpl();
-  virtual AcmeStatus TilingNoBackOff(RawHostAddr host_ptr, HostRunInfoPtr *run_info_ptr) = 0;
-  virtual AcmeStatus LaunchNoBackOff(const InputsAddrList &input_ptrs, const OutputsAddrList &output_ptrs,
-                                     const WsAddrList &ws_ptrs, void *stream) = 0;
-  virtual std::string DumpTilingNoBackOff(const RawHostAddr host_ptr) const = 0;
-
- private:
-  bool backoff_{false};
-  AsdOpPtr asd_op_{nullptr};
-};
-
-}  // namespace acme
-}  // namespace mindspore
-
-#endif  // MS_KERNELS_INTERNAL_KERNEL_ACME_SRC_OPS_HOST_SRC_ASD_BACKOFF_H_

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

@@ -1,33 +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_ops.h"
-#include "asdops/params/elewise.h"
-
-namespace mindspore {
-namespace acme {
-class AsdElewiseOp : public AsdOp {
- public:
-  AsdElewiseOp(const InputsImmutableInfoList &inputs_ii, const OutputsImmutableInfoList &outputs_ii, 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_ops.h

@@ -1,88 +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_OPS_H_
-#define MS_KERNELS_INTERNAL_KERNEL_ACME_SRC_OPS_HOST_SRC_ASD_OPS_H_
-
-#include <any>
-#include "acme/include/acme_op.h"
-
-#include "asdops/op_desc.h"
-#include "asdops/operation.h"
-#include "asdops/run_info.h"
-#include "asdops/tactic.h"
-#include "asdops/tensor.h"
-
-namespace mindspore {
-namespace acme {
-class HostRunInfoAsd : public HostRunInfo {
- public:
-  HostRunInfoAsd() = default;
-  ~HostRunInfoAsd() = default;
-
-  HostRunInfoAsd(const HostRunInfoAsd &other);
-  HostRunInfoAsd(HostRunInfoAsd &other);
-
-  const HostRunInfoAsd &operator=(const HostRunInfoAsd &other);
-  const HostRunInfoAsd &operator=(HostRunInfoAsd &other);
-  AsdOps::RunInfo run_info_;
-};
-using HostRunInfoAsdPtr = std::shared_ptr<HostRunInfoAsd>;
-
-class AsdOp : public AcmeOp {
- public:
-  AsdOp(const InputsImmutableInfoList &inputs_ii, const OutputsImmutableInfoList &outputs_ii,
-            const AsdOps::Any &param, const std::string &asd_op_name);
-  AsdOp(const InputsImmutableInfoList &inputs_ii, const OutputsImmutableInfoList &outputs_ii,
-            const std::string &asd_op_name);
-  virtual ~AsdOp() = default;
-  AcmeStatus UpdateShape(const ShapeInfoList &inputs_shape, const ShapeInfoList &outputs_shape) override;
-  void SetTilingInfo(const TilingInfoPtr &tiling_info) 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;
-
-  std::string DumpTiling(const RawHostAddr host_ptr) const override;
-  ShapeInfoList InferShape(const ShapeInfoList &inputs_shape) const override;
-
- protected:
-  virtual void UpdateLaunchParam();
-  AcmeStatus InitImpl() override;
-  void SetParam(const AsdOps::Any &param);
-  AsdOps::LaunchParam launch_param_;
-
- private:
-  void UpdateRunInfo(const InputsAddrList &input_ptrs, const OutputsAddrList &output_ptrs, const WsAddrList &ws_ptrs,
-                     void *stream);
-
-  uint32_t dim_axis_{0};
-  bool is_same_shape_{true};
-  ShapeInfo input_shape1_;
-  ShapeInfo input_shape2_;
-  AsdOps::Any asd_param_;
-  std::string asd_op_name_;
-  AsdOps::OpDesc op_desc_;
-  AsdOps::Tactic *tactic_{nullptr};
-  AsdOps::Operation *op_{nullptr};
-  HostRunInfoAsdPtr host_run_info_asd_ptr_{nullptr};
-};
-
-using AsdOpPtr = std::shared_ptr<AsdOp>;
-}  // namespace acme
-}  // namespace mindspore
-
-#endif  // MS_KERNELS_INTERNAL_KERNEL_ACME_SRC_OPS_HOST_SRC_ASD_OPS_H_

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

@@ -1,45 +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_PA_OP_H_
-#define MS_KERNELS_INTERNAL_KERNEL_ACME_SRC_OPS_HOST_SRC_ASD_PA_OP_H_
-
-#include <any>
-#include "acme/src/ops/host_src/asd_ops.h"
-
-#include "asdops/op_desc.h"
-#include "asdops/operation.h"
-#include "asdops/run_info.h"
-#include "asdops/tactic.h"
-#include "asdops/tensor.h"
-
-namespace mindspore {
-namespace acme {
-class AsdPAOp : public AsdOp {
- public:
-  AsdPAOp(const InputsImmutableInfoList &inputs_ii, const OutputsImmutableInfoList &outputs_ii,
-              const AsdOps::Any &param, const std::string &kenrel_name);
-  ~AsdPAOp() = default;
-
- protected:
-  void UpdateLaunchParam() override;
-};
-
-using AsdPAOpPtr = std::shared_ptr<AsdPAOp>;
-}  // namespace acme
-}  // namespace mindspore
-
-#endif  // MS_KERNELS_INTERNAL_KERNEL_ACME_SRC_OPS_HOST_SRC_ASD_PA_OP_H_

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

@@ -1,52 +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_CAST_OP_H_
-#define MS_KERNELS_INTERNAL_KERNEL_ACME_SRC_OPS_HOST_SRC_CAST_OP_H_
-
-#include "acme/include/acme_op.h"
-#include "acme/src/ops/device_src/ascendc/cast/cast_tiling.h"
-
-namespace mindspore {
-namespace acme {
-class CastOp : public AcmeOp {
- public:
-  CastOp(const InputsImmutableInfoList &inputs_ii, const OutputsImmutableInfoList &outputs_ii)
-      : AcmeOp(inputs_ii, outputs_ii) {}
-  ~CastOp() = 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:
-  void DoUbTiling(uint32_t factor, uint32_t total_num, uint32_t &ub_num, uint32_t &ub_loop, uint32_t &ub_tail);
-  int32_t GetCastDType();
-  uint32_t GetMaxUbCount(uint32_t cast_type);
-
-  int32_t cast_type_{UNSUPPORTED_DTYPE};
-};
-
-using CastOpPtr = std::shared_ptr<CastOp>;
-}  // namespace acme
-}  // namespace mindspore
-
-#endif  // MS_KERNELS_INTERNAL_KERNEL_ACME_SRC_OPS_HOST_SRC_CAST_OP_H_

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

@@ -1,95 +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_MATMUL_OP_H_
-#define MS_KERNELS_INTERNAL_KERNEL_ACME_SRC_OPS_HOST_SRC_MATMUL_OP_H_
-
-#include <algorithm>
-#include "acme/include/acme_op.h"
-#include "acme/include/op_param.h"
-#include "matmul/kernel/matmul.h"
-#include "tune_repo/matmul_table.h"
-#include "matmul_common/pp_matmul_info.h"
-#include "matmul_common/tiling_data.h"
-#include "matmul_common/pp_matmul_common_tiling.h"
-
-#include "asdops/op_desc.h"
-#include "asdops/operation.h"
-#include "asdops/run_info.h"
-#include "asdops/tactic.h"
-#include "asdops/tensor.h"
-
-#include "backend_param.h"
-
-using namespace mindspore::internal;
-using namespace mindspore::internal::tiling;
-
-namespace mindspore {
-namespace acme {
-enum class MatMulAlgo { PP = 0, LLM_CUSTOM = 1 };
-enum class MatMulFusionLevel { NONE = 0, CUBE = 1, MIX= 2 };
-
-class MatmulOp : public AcmeOp {
- public:
-  MatmulOp(const InputsImmutableInfoList &inputs_ii, const OutputsImmutableInfoList &outputs_ii,
-           const MatmulParam &param);
-  ~MatmulOp() = 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 SetFusionLevel();
-  bool UseCustomMatMul();
-  bool GenTilingId(uint32_t &tiling_id);
-  void GetTunedKey();
-  void SetTunedValueCustom(const std::vector<int> &tuned_config);
-  bool GetPpMatmulTiling(const MatMulInfo &, uint32_t &,
-                         PpTilingData &, const REPO &, const std::vector<int> &);
-  void TilingBasicFromPp(uint32_t &, PpTilingData &);
-  AcmeStatus TilingLLMCustom(RawHostAddr, uint64_t, uint32_t &,
-                             const PpTilingData &);
-  AcmeStatus TilingPp(RawHostAddr &tiling_addr, uint32_t tiling_id, const uint32_t &block_dim,
-                         const PpTilingData &tilingdata);
-  AcmeStatus LaunchMix(const InputsAddrList &input_ptrs, const OutputsAddrList &output_ptrs, void *stream);
-
-  MatmulParam param_;
-  REPO tuning_table_;
-  REPO tuning_table_custom_;
-  MatMulFusionLevel fusion_level_ = MatMulFusionLevel::NONE;
-  std::vector<int> tune_key_;
-  CustomMatmulTilingData t_;
-  uint32_t m_;
-  uint32_t n_;
-  uint32_t k_;
-  MatMulAlgo algo_ = MatMulAlgo::PP;
-  HardwareInfo hw_info_;
-};
-
-using MatmulOpPtr = std::shared_ptr<MatmulOp>;
-}  // namespace acme
-}  // namespace mindspore
-
-#endif  // MS_KERNELS_INTERNAL_KERNEL_ACME_SRC_OPS_HOST_SRC_MATMUL_OP_H_