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

mindspore/lib/plugin/ascend/ms_kernels_internal/internal_kernel/include/utils/log/log_entity.h

@@ -1,38 +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_OP_LOG_LOGENTITY_H
-#define MS_OP_LOG_LOGENTITY_H
-#include <chrono>
-#include <string>
-#include <vector>
-
-namespace mindspore {
-namespace internal {
-enum class LogLevel { DEBUG = 0, INFO, WARN, ERROR, EXCEPTION };
-
-const char *LogLevelToString(LogLevel level);
-
-struct LogEntity {
-  std::chrono::system_clock::time_point time;
-  long threadId = 0;
-  LogLevel level = LogLevel::WARN;
-  const char *fileName = nullptr;
-  int line = 0;
-  const char *funcName = nullptr;
-};
-}  // namespace internal
-}  // namespace mindspore
-#endif

mindspore/lib/plugin/ascend/ms_kernels_internal/internal_kernel/include/utils/log/log_sink.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_OP_LOG_LOGSINK_H
-#define MS_OP_LOG_LOGSINK_H
-
-#include <fstream>
-#include <mutex>
-#include "utils/log/log_entity.h"
-
-namespace mindspore {
-namespace internal {
-class LogSink {
- public:
-  LogSink() = default;
-  virtual ~LogSink() = default;
-  virtual void Log(const char *log, uint64_t logLen) = 0;
-};
-
-class LogSinkStdout : public LogSink {
- public:
-  LogSinkStdout() = default;
-  ~LogSinkStdout() override = default;
-  void Log(const char *log, uint64_t logLen) override;
-
- private:
-  std::mutex mtx_;
-};
-
-class LogSinkFile : public LogSink {
- public:
-  LogSinkFile();
-  ~LogSinkFile() override;
-  void Log(const char *log, uint64_t logLen) override;
-
- private:
-  LogSinkFile(const LogSinkFile &) = delete;
-  const LogSinkFile &operator=(const LogSinkFile &) = delete;
-  void Init();
-  void OpenFile();
-  void DeleteOldestFile();
-  std::string GetNewLogFilePath();
-  bool IsDiskAvailable();
-  void MakeLogDir();
-  void CloseFile();
-  std::string GetHomeDir();
-
- private:
-  std::string boostType_;
-  std::string logDir_;
-  int currentFd_ = -1;
-  uint64_t currentFileSize_ = 0;
-  std::mutex mutex_;
-};
-}  // namespace internal
-}  // namespace mindspore
-#endif

mindspore/lib/plugin/ascend/ms_kernels_internal/internal_kernel/include/utils/log/log_stream.h

@@ -1,41 +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_OP_LOG_LOGSTREAM_H
-#define MS_OP_LOG_LOGSTREAM_H
-#include <sstream>
-#include "utils/log/log_entity.h"
-
-namespace mindspore {
-namespace internal {
-class LogStream {
- public:
-  LogStream(const char *filePath, int line, const char *funcName, LogLevel level);
-  ~LogStream();
-  template <typename T>
-  LogStream &operator<<(const T &value) {
-    stream_ << value;
-    return *this;
-  }
-  void Format(const char *format, ...);
-
- private:
-  LogEntity logEntity_;
-  bool useStream_ = true;
-  std::ostringstream &stream_;
-};
-}  // namespace internal
-}  // namespace mindspore
-#endif

mindspore/lib/plugin/ascend/ms_kernels_internal/internal_kernel/include/utils/log/log_tiling.h

@@ -1,71 +0,0 @@
-#ifndef MS_KERNELS_INTERNAL_KERNEL_UTILS_LOG_LOG_TILING_H_
-#define MS_KERNELS_INTERNAL_KERNEL_UTILS_LOG_LOG_TILING_H_
-
-#include <iostream>
-#include "src/utils/elewise_tiling.h"
-#include "src/compare/compare_tiling.h"
-#include "src/cast/cast_tiling.h"
-#include "src/elewise_binary/elewise_binary_tiling.h"
-#include "src/elewise_unary/elewise_unary_tiling.h"
-#include "src/sub/sub_tiling.h"
-
-namespace mindspore::internal {
-static std::ostream &operator<<(std::ostream &os, const CastTilingData &dt) {
-  os << ", buffer_num:" << dt.buffer_num;
-  os << ", cast_dtype:" << dt.cast_dtype;
-  os << ", core_num:" << dt.core_num;
-  os << ", avg_block_count:" << dt.avg_block_count;
-  os << ", avg_block_ub_num:" << dt.avg_block_ub_num;
-  os << ", avg_block_ub_tail:" << dt.avg_block_ub_tail;
-  os << ", avg_block_ub_loop:" << dt.avg_block_ub_loop;
-  os << ", tail_block_count:" << dt.tail_block_count;
-  os << ", tail_block_ub_num:" << dt.tail_block_ub_num;
-  os << ", tail_block_ub_tail:" << dt.tail_block_ub_tail;
-  os << ", tail_block_ub_loop:" << dt.tail_block_ub_loop;
-  return os;
-}
-static std::ostream &operator<<(std::ostream &os, const ElewiseTailTilingData &dt) {
-  os << ", avg_block_count:" << dt.avg_block_count;
-  os << ", avg_block_ub_num:" << dt.avg_block_ub_num;
-  os << ", avg_block_ub_tail:" << dt.avg_block_ub_tail;
-  os << ", avg_block_ub_loop:" << dt.avg_block_ub_loop;
-  os << ", tail_block_count:" << dt.tail_block_count;
-  os << ", tail_block_ub_num:" << dt.tail_block_ub_num;
-  os << ", tail_block_ub_tail:" << dt.tail_block_ub_tail;
-  os << ", tail_block_ub_loop:" << dt.tail_block_ub_loop;
-  os << ", buffer_num:" << dt.buffer_num;
-  os << ", block_dim:" << dt.block_dim;
-  return os;
-}
-static std::ostream &operator<<(std::ostream &os, const CompareTilingData &dt) {
-  os << ", input_dtype:" << dt.input_dtype;
-  os << ", broadcast_mode:" << dt.broadcast_mode;
-  os << ", compare_mode:" << dt.compare_mode;
-  ElewiseTailTilingData *ele_tiling = (ElewiseTailTilingData *)&dt;
-  os << *ele_tiling;
-  return os;
-}
-
-static std::ostream &operator<<(std::ostream &os, const ElewiseBinaryTilingData &dt) {
-  os << "broadcast_mode:" << dt.broadcast_mode_;
-  os << ", op_dtype:" << dt.op_dtype_;
-  ElewiseTailTilingData *ele_tiling = (ElewiseTailTilingData *)&dt;
-  os << *ele_tiling;
-  return os;
-}
-
-static std::ostream &operator<<(std::ostream &os, const ElewiseUnaryTilingData &dt) {
-  os << "op_dtype:" << dt.op_dtype_;
-  ElewiseTailTilingData *ele_tiling = (ElewiseTailTilingData *)&dt;
-  os << *ele_tiling;
-  return os;
-}
-static std::ostream &operator<<(std::ostream &os, const SubTilingData &dt) {
-  os << ", broadcast_mode_:" << dt.broadcast_mode_;
-  os << ", input_dtype_:" << dt.input_dtype_;
-  ElewiseTailTilingData *ele_tiling = (ElewiseTailTilingData *)&dt;
-  os << *ele_tiling;
-  return os;
-}
-}  // namespace mindspore::internal
-#endif  // MS_KERNELS_INTERNAL_KERNEL_UTILS_LOG_LOG_TILING_H_

mindspore/lib/plugin/ascend/ms_kernels_internal/internal_kernel/include/utils/log/log_utils.h

@@ -1,165 +0,0 @@
-/**
- * Copyright 2023-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_UTILS_LOG_LOG_UTILS_H_
-#define MS_KERNELS_INTERNAL_KERNEL_UTILS_LOG_LOG_UTILS_H_
-#include <iostream>
-#include <map>
-#include "include/op_param.h"
-#include "utils/utils.h"
-#include "acme/include/base_type.h"
-
-namespace mindspore::internal {
-static std::ostream &operator<<(std::ostream &os, const OpParam &param) {
-  os << "[" << OpIdToString(param.opId) << "]";
-  os << ", in dtypes: ";
-  for (size_t i = 0; i < param.in_dtypes_.size(); i++) {
-    os << " " << param.in_dtypes_[i];
-  }
-  os << "; out dtypes: ";
-  for (size_t i = 0; i < param.out_dtypes_.size(); i++) {
-    os << " " << param.out_dtypes_[i];
-  }
-  return os;
-}
-
-static std::ostream &operator<<(std::ostream &os, const DtypesParam &param) {
-  os << "[" << OpIdToString(param.op_id_) << "]";
-  os << ", in dtypes: ";
-  for (size_t i = 0; i < param.in_dtypes_.size(); i++) {
-    os << " " << param.in_dtypes_[i];
-  }
-  os << "; out dtypes: ";
-  for (size_t i = 0; i < param.out_dtypes_.size(); i++) {
-    os << " " << param.out_dtypes_[i];
-  }
-  return os;
-}
-
-static std::ostream &operator<<(
-  std::ostream &os,
-  const std::vector<std::pair<std::vector<TensorDType>, std::vector<TensorDType>>> &support_dtype_list) {
-  for (auto dtyp : support_dtype_list) {
-    auto ins = dtyp.first;
-    auto outs = dtyp.second;
-    os << "(";
-    for (size_t i = 0; i < ins.size(); i++) {
-      os << ins[i] << " ";
-    }
-    os << ",";
-    for (size_t i = 0; i < outs.size(); i++) {
-      os << outs[i] << " ";
-    }
-    os << ")";
-  }
-  return os;
-}
-
-static std::ostream &operator<<(std::ostream &os, const acme::DataType data_type) {
-  switch (data_type) {
-    case acme::DataType::kTypeUnknown:
-      os << "Unknown";
-      break;
-    case acme::DataType::kTypeFloat16:
-      os << "Float16";
-      break;
-    case acme::DataType::kTypeFloat32:
-      os << "Float32";
-      break;
-    case acme::DataType::kTypeFloat64:
-      os << "Float64";
-      break;
-    case acme::DataType::kTypeInt8:
-      os << "Int8";
-      break;
-    case acme::DataType::kTypeInt16:
-      os << "Int16";
-      break;
-    case acme::DataType::kTypeInt32:
-      os << "Int32";
-      break;
-    case acme::DataType::kTypeInt64:
-      os << "Int64";
-      break;
-    case acme::DataType::kTypeUint8:
-      os << "Uint8";
-      break;
-    case acme::DataType::kTypeUint16:
-      os << "Uint16";
-      break;
-    case acme::DataType::kTypeUint32:
-      os << "Uint32";
-      break;
-    case acme::DataType::kTypeUint64:
-      os << "Uint64";
-      break;
-    case acme::DataType::kTypeBF16:
-      os << "BF16";
-      break;
-    case acme::DataType::kTypeBool:
-      os << "Bool";
-      break;
-    case acme::DataType::kTypeComplex64:
-      os << "Complex64";
-      break;
-    case acme::DataType::kTypeComplex128:
-      os << "Complex128";
-      break;
-    case acme::DataType::kTypeString:
-      os << "String";
-      break;
-    case acme::DataType::kTypeNone:
-      os << "None";
-      break;
-    default:
-      os << "UnknownDataType";
-      break;
-  }
-  return os;
-}
-
-static std::ostream &operator<<(std::ostream &os, const acme::InOutDtypesList &support_dtype_list) {
-  for (auto dtype_vec : support_dtype_list) {
-    auto in_dtypes = dtype_vec[0];
-    auto out_dtypes = dtype_vec[1];
-    os << "\n[in_(";
-    for (size_t i = 0; i < in_dtypes.size(); i++) {
-      os << in_dtypes[i];
-      if (i != in_dtypes.size() - 1) {
-        os << " ";
-      }
-    }
-    os << ")_out_(";
-    for (size_t i = 0; i < out_dtypes.size(); i++) {
-      os << out_dtypes[i];
-      if (i != out_dtypes.size() - 1) {
-        os << " ";
-      }
-    }
-    os << ")], ";
-  }
-  return os;
-}
-
-static std::ostream &operator<<(std::ostream &os, const acme::ShapeInfo &shape) {
-  os << "[";
-  for (auto dim : shape) {
-    os << dim << " ";
-  }
-  os << "]";
-  return os;
-}
-}  // namespace mindspore::internal
-#endif  //    MS_KERNELS_INTERNAL_KERNEL_UTILS_LOG_LOG_UTILS_H_

mindspore/lib/plugin/ascend/ms_kernels_internal/internal_kernel/include/utils/math.h

@@ -1,20 +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_SRC_UTILS_MATH_H_
-#define MS_KERNELS_INTERNAL_SRC_UTILS_MATH_H_
-
-#include "src/acme/src/utils/comm_utils.h"
-#endif  // MS_KERNELS_INTERNAL_SRC_UTILS_MATH_H_

mindspore/lib/plugin/ascend/ms_kernels_internal/internal_kernel/include/utils/register/kernel_creator.h

@@ -1,39 +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_UTILS_KERNEL_CREATOR_H_
-#define MS_KERNELS_INTERNAL_KERNEL_UTILS_KERNEL_CREATOR_H_
-#include "internal_kernel.h"
-#include "utils/log/log.h"
-namespace mindspore {
-namespace internal {
-template <class T>
-InternalKernelImplPtr InternalKernelCreator(const OpParamPtr &param) {
-  if (param == nullptr) {
-    MSOP_LOG(ERROR) << "Op param nullptr in kernel creator!";
-    return nullptr;
-  }
-  MSOP_LOG(DEBUG) << "Create " << *param;
-  auto kernel = std::make_shared<T>(param);
-  if (kernel != nullptr && kernel->IsSupported()) {
-    return kernel;
-  }
-  MSOP_LOG(INFO) << "Internal kernel unsupport: id:" << *param;
-  return nullptr;
-}
-}  // namespace internal
-}  // namespace mindspore
-#endif  // MS_KERNELS_INTERNAL_KERNEL_UTILS_KERNEL_CREATOR_H_

mindspore/lib/plugin/ascend/ms_kernels_internal/internal_kernel/include/utils/register/kernel_registry.h

@@ -1,121 +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_UTILS_KERNEL_REGISTER_H_
-#define MS_KERNELS_INTERNAL_KERNEL_UTILS_KERNEL_REGISTER_H_
-#include <stdio.h>
-#include <stdlib.h>
-#include <stdarg.h>
-#include <map>
-#include <atomic>
-#include "utils/register/kernel_creator.h"
-#include "asdops/types.h"
-namespace mindspore {
-namespace internal {
-using AsdOps::TensorDType::TENSOR_DTYPE_BF16;
-using AsdOps::TensorDType::TENSOR_DTYPE_BOOL;
-using AsdOps::TensorDType::TENSOR_DTYPE_DOUBLE;
-using AsdOps::TensorDType::TENSOR_DTYPE_FLOAT;
-using AsdOps::TensorDType::TENSOR_DTYPE_FLOAT16;
-using AsdOps::TensorDType::TENSOR_DTYPE_INT16;
-using AsdOps::TensorDType::TENSOR_DTYPE_INT32;
-using AsdOps::TensorDType::TENSOR_DTYPE_INT64;
-using AsdOps::TensorDType::TENSOR_DTYPE_INT8;
-using AsdOps::TensorDType::TENSOR_DTYPE_UINT16;
-using AsdOps::TensorDType::TENSOR_DTYPE_UINT32;
-using AsdOps::TensorDType::TENSOR_DTYPE_UINT64;
-using AsdOps::TensorDType::TENSOR_DTYPE_UINT8;
-using AsdOps::TensorDType::TENSOR_DTYPE_UNDEFINED;
-typedef InternalKernelImplPtr (*KernelCreator)(const OpParamPtr &param);
-class InternalKernelRegistry {
- public:
-  InternalKernelRegistry() = default;
-  virtual ~InternalKernelRegistry() = default;
-
-  static InternalKernelRegistry *GetInstance();
-  void RegKernel(int op_id, KernelCreator creator);
-  InternalKernelImplPtr GetKernel(const OpParamPtr &param);
-  void SetDtypes(int op_id, std::vector<TensorDType> in_types, std::vector<TensorDType> out_types);
-  void SetMutable(int op_id, bool input, bool output);
-  void SetAsdDtypes(int op_id, std::vector<TensorDType> in_types, std::vector<TensorDType> out_types);
-  bool IsDtypeSupported(const DtypesParamPtr &param);
-
- private:
-  void PrintOpRegistryInfo(int op_id);
-  bool IsAsdSupported(int op_id, std::vector<int64_t> &in_dtypes, std::vector<int64_t> &out_types);
-  bool IsInternalSupported(int op_id, std::vector<int64_t> &in_dtypes, std::vector<int64_t> &out_types);
-  std::vector<int> mutable_input_list_;
-  std::vector<int> mutable_output_list_;
-  std::map<int, KernelCreator> creator_list_;
-  std::map<int, std::vector<std::pair<std::vector<TensorDType>, std::vector<TensorDType>>>> op_dtypes_;
-  std::map<int, std::vector<std::pair<std::vector<TensorDType>, std::vector<TensorDType>>>> asd_op_dtypes_;
-};
-
-#define MUTABLE_NUM 13579
-void CheckMutable(bool &input_mutable, bool &output_mutable, int remain_in, int remain_total);
-
-class InternalKernelRegister {
- public:
-  InternalKernelRegister(const int op_id, KernelCreator creator) {
-    InternalKernelRegistry::GetInstance()->RegKernel(op_id, creator);
-  }
-  InternalKernelRegister(int op_id, int outcnt, TensorDType dt1, TensorDType dt2, TensorDType dt3);
-  InternalKernelRegister(int op_id, TensorDType dt1, TensorDType dt2, TensorDType dt3, TensorDType dt4);
-  InternalKernelRegister(int op_id, TensorDType main_dtype, int remain_in, int remain_total, ...);
-  InternalKernelRegister(int op_id, TensorDType dtype1, TensorDType dtype2);
-  InternalKernelRegister(int op_id, TensorDType dtype1, TensorDType dtype2, TensorDType dtype3);
-  ~InternalKernelRegister() = default;
-};
-#define REG_KERNEL(op_id, creator) static InternalKernelRegister g_##op_id##kernel_reg(op_id, creator);
-#define REG_KERNEL_DTYPES(op_id, incnt, outcnt, dtype, ...)                                         \
-  static InternalKernelRegister g_##op_id##_##incnt##_##outcnt##_##dtype(op_id, dtype, (incnt - 1), \
-                                                                         (incnt + outcnt - 1), ##__VA_ARGS__);
-#define REG_KERNEL_DTYPES_WITH_NAME(name, op_id, incnt, outcnt, dtype, ...) \
-  static InternalKernelRegister g_##name(op_id, dtype, (incnt - 1), (incnt + outcnt - 1), ##__VA_ARGS__);
-#define REG_ROPE_DTYPES(op_id, incnt, outcnt, in_dt1, in_dt2, in_dt3, in_dt4)                                    \
-  static InternalKernelRegister g_##op_id##_##incnt##_##outcnt##_##in_dt1##in_dt2(op_id, in_dt1, in_dt2, in_dt3, \
-                                                                                  in_dt4);
-#define REG_KERNE_BINARY_DTYPES(op_id, dt1, dt2) \
-  static InternalKernelRegister g_##op_id##_##dt1##_##dt2(op_id, dt1, dt2);
-#define REG_RMS_NORM_DTYPES(op_id, incnt, outcnt, in_dt1, in_dt2, out_dt1, out_dt2) \
-  static InternalKernelRegister g_##op_id##_##incnt##_##outcnt##_##in_dt1##out_dt2(op_id, in_dt1, out_dt2);
-#define REG_ADD_RMS_NORM_DTYPES(op_id, incnt, outcnt, in_dt1, in_dt2, in_dt3, out_dt1, out_dt2, out_dt3) \
-  static InternalKernelRegister g_##op_id##_##incnt##_##outcnt##_##in_dt1##in_dt3(op_id, in_dt1, in_dt3);
-#define REG_MATMUL_BIASADD_DTYPES(op_id, incnt, outcnt, in_dt1, in_dt2, in_dt3, out_dt1, ...)                     \
-  static InternalKernelRegister g_##op_id##_##incnt##_##outcnt##_##in_dt1##in_dt3##out_dt1(op_id, outcnt, in_dt1, \
-                                                                                           in_dt3, out_dt1);
-
-class AsdOpInternalKernelRegister {
- public:
-  AsdOpInternalKernelRegister(int op_id, TensorDType main_dtype, int remain_in, int remain_total, ...);
-  AsdOpInternalKernelRegister(int op_id, TensorDType dtype1);
-  AsdOpInternalKernelRegister(int op_id, TensorDType dtype1, TensorDType dtype2, TensorDType dtype3);
-  AsdOpInternalKernelRegister(int op_id, TensorDType dtype1, TensorDType dtype2, TensorDType dtype3, TensorDType dtype4, TensorDType dtype5);
-  AsdOpInternalKernelRegister(int op_id, TensorDType dtype1, TensorDType dtype2, TensorDType dtype3, TensorDType dtype4,
-                              TensorDType dtype5, TensorDType dtype6, TensorDType dtype7, TensorDType dtype8);
-  ~AsdOpInternalKernelRegister() = default;
-};
-#define REG_ASD_KERNEL_DTYPES(op_id, incnt, outcnt, dtype, ...)                    \
-  static AsdOpInternalKernelRegister g_asd_##op_id##_##incnt##_##outcnt##_##dtype( \
-    op_id, dtype, (incnt - 1), (incnt + outcnt - 1), ##__VA_ARGS__);
-#define REG_ASD_NORM_KERNEL_DTYPES(op_id, incnt, outcnt, dt1) \
-  static AsdOpInternalKernelRegister g_asd_##op_id##_##dt1(op_id, dt1);
-#define REG_ASD_GATHER_KERNEL_DTYPES(op_id, incnt, outcnt, dt1, dt2, dt3) \
-  static AsdOpInternalKernelRegister g_asd_##op_id##incnt##outcnt##dt1##dt2##dt3(op_id, dt1, dt2, dt3);
-
-bool InternalKernelEnableByEnv(const int op_id);
-}  // namespace internal
-}  // namespace mindspore
-#endif  // MS_KERNELS_INTERNAL_KERNEL_UTILS_KERNEL_REGISTER_H_

mindspore/lib/plugin/ascend/ms_kernels_internal/internal_kernel/include/utils/utils.h

@@ -1,106 +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_SRC_UTILS_UTILS_H_
-#define MS_KERNELS_INTERNAL_SRC_UTILS_UTILS_H_
-
-#include <iostream>
-#include <map>
-#include <set>
-#include "include/op_param.h"
-
-namespace mindspore::internal {
-inline void SplitString(const std::string &str, char delim, std::set<std::string> &output_list) {
-  std::stringstream ss(str);
-  std::string item;
-  std::vector<std::string> elems;
-  while (std::getline(ss, item, delim)) {
-    if (!item.empty()) {
-      output_list.emplace(item);
-    }
-  }
-}
-
-template <typename T>
-static std::ostream &operator<<(std::ostream &os, const std::vector<T> &v) {
-  os << "[size " << v.size() << "]";
-  os << "[data";
-  for (size_t i = 0; i < v.size(); i++) {
-    os << " " << v[i];
-  }
-  os << "]";
-  return os;
-}
-
-inline std::string OpIdToString(int id) {
-  std::map<int, std::string> op_id_string = {
-    {OpId::MatMul, "MatMul"},
-    {OpId::ReshapeAndCache, "ReshapeAndCache"},
-    {OpId::Slice, "Slice"},
-    {OpId::Gather, "Gather"},
-    {OpId::ApplyRotaryPosEmb, "ApplyRotaryPosEmb"},
-    {OpId::Add, "Add"},
-    {OpId::Sub, "Sub"},
-    {OpId::Exp, "Exp"},
-    {OpId::FlashAttentionScore, "FlashAttentionScore"},
-    {OpId::PagedAttention, "PagedAttention"},
-    {OpId::Cast, "Cast"},
-    {OpId::Gelu, "Gelu"},
-    {OpId::Transpose, "Transpose"},
-    {OpId::Equal, "Equal"},
-    {OpId::NotEqual, "NotEqual"},
-    {OpId::LogicalNot, "LogicalNot"},
-    {OpId::Less, "Less"},
-    {OpId::LessEqual, "LessEqual"},
-    {OpId::Greater, "Greater"},
-    {OpId::GreaterEqual, "GreaterEqual"},
-    {OpId::Mul, "Mul"},
-    {OpId::RealDiv, "RealDiv"},
-    {OpId::LayerNorm, "LayerNorm"},
-    {OpId::AddLayerNorm, "AddLayerNorm"},
-    {OpId::RmsNorm, "RmsNorm"},
-    {OpId::AddRmsNorm, "AddRmsNorm"},
-    {OpId::RmsNormQuant, "RmsNormQuant"},
-    {OpId::AddRmsNormQuant, "AddRmsNormQuantV2"},
-    {OpId::Softmax, "Softmax"},
-    {OpId::Split, "Split"},
-    {OpId::Swish, "Swish"},
-    {OpId::SwiGLU, "SwiGLU"},
-    {OpId::Concat, "Concat"},
-    {OpId::MatmulQkv, "MatmulQkv"},
-    {OpId::MaskedFill, "MaskedFill"},
-    {OpId::BroadcastTo, "BroadcastTo"},
-    {OpId::ReduceSum, "ReduceSum"},
-    {OpId::TopK, "TopK"},
-    {OpId::Tile, "Tile"},
-    {OpId::FastGeLU, "FastGeLU"},
-    {OpId::TransData, "TransData"},
-    {OpId::ReshapeAndCacheNz, "ReshapeAndCache"},
-    {OpId::ApplyRotaryPosEmbNz, "ApplyRotaryPosEmb"},
-    {OpId::QuantPerChannel, "QuantV2"},
-    {OpId::QuantLinearSparse, "QuantLinearSparse"},
-  };
-
-  auto iter = op_id_string.find(id);
-  if (iter != op_id_string.end()) {
-    return iter->second;
-  }
-
-  std::string err_info = "Op not defined! index: " + std::to_string(id);
-  return err_info;
-}
-}  // namespace mindspore::internal
-#endif  //    MS_KERNELS_INTERNAL_SRC_UTILS_UTILS_H_