mindspore 2.4.1__cp311-cp311-manylinux1_x86_64.whl → 2.5.0__cp311-cp311-manylinux1_x86_64.whl

mindspore/lib/plugin/ascend/ms_kernels_internal/internal_kernel/include/elewise_binary/kernel/mul_kernel.h

@@ -1,66 +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_ASCENDC_ELEWISE_BINARY_MUL_KERNEL_H_
-#define MS_KERNELS_INTERNAL_KERNEL_ASCENDC_ELEWISE_BINARY_MUL_KERNEL_H_
-
-#include "elewise_binary_base.h"
-
-template <typename T = int16_t>
-class MulI16 : public ElewiseBaseWide<T> {
- public:
-  __aicore__ inline MulI16() { ElewiseBaseWide<T>::SetBinaryFunc(AscendC::Mul); }
-};
-
-template <typename T = int32_t>
-class MulInt : public ElewiseBaseWide<T> {
- public:
-  __aicore__ inline MulInt() { ElewiseBaseWide<T>::SetBinaryFunc(AscendC::Mul); }
-};
-
-template <typename T = half>
-class MulFp16 : public ElewiseBaseWide<T> {
- public:
-  __aicore__ inline MulFp16() { ElewiseBaseWide<T>::SetBinaryFunc(AscendC::Mul); }
-};
-
-template <typename T = float>
-class MulFp32 : public ElewiseBaseWide<T> {
- public:
-  __aicore__ inline MulFp32() { ElewiseBaseWide<T>::SetBinaryFunc(AscendC::Mul); }
-};
-
-extern "C" __global__ __aicore__ void mul_device_legacy(GM_ADDR x1, GM_ADDR x2, GM_ADDR y, GM_ADDR tiling, int32_t dtype) {
-  if (dtype == 3) {  // int32
-    MulInt<int32_t> op;
-    op.InitBinary(x1, x2, y, tiling);
-    op.ProcessBinary();
-  } else if (dtype == 1) {  // fp16
-    MulFp16<half> op;
-    op.InitBinary(x1, x2, y, tiling);
-    op.ProcessBinary();
-  } else if (dtype == 0) {  // fp32
-    MulFp32<float> op;
-    op.InitBinary(x1, x2, y, tiling);
-    op.ProcessBinary();
-  } else if (dtype == 6) {  // int16
-    MulI16<int16_t> op;
-    op.InitBinary(x1, x2, y, tiling);
-    op.ProcessBinary();
-  }
-}
-
-#endif  // MS_KERNELS_INTERNAL_KERNEL_ASCENDC_ELEWISE_BINARY_MUL_KERNEL_H_

mindspore/lib/plugin/ascend/ms_kernels_internal/internal_kernel/include/elewise_binary/kernel/or_kernel.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_ASCENDC_ELEWISE_BINARY_OR_KERNEL_H_
-#define MS_KERNELS_INTERNAL_KERNEL_ASCENDC_ELEWISE_BINARY_OR_KERNEL_H_
-
-#include "elewise_binary_base.h"
-
-template <typename T = int16_t>
-class OrI16 : public ElewiseBaseWide<T> {
- public:
-  __aicore__ inline OrI16() { ElewiseBaseWide<T>::SetBinaryFunc(AscendC::Or); }
-};
-
-template <typename T = uint16_t>
-class OrU16 : public ElewiseBaseWide<T> {
- public:
-  __aicore__ inline OrU16() { ElewiseBaseWide<T>::SetBinaryFunc(AscendC::Or); }
-};
-
-extern "C" __global__ __aicore__ void or_device_legacy(GM_ADDR x1, GM_ADDR x2, GM_ADDR y, GM_ADDR tiling, int32_t dtype) {
-  if (dtype == 6) {  // int16
-    OrI16<int16_t> op;
-    op.InitBinary(x1, x2, y, tiling);
-    op.ProcessBinary();
-  } else if (dtype == 7) {  // uint16
-    OrU16<uint16_t> op;
-    op.InitBinary(x1, x2, y, tiling);
-    op.ProcessBinary();
-  }
-}
-
-#endif  // MS_KERNELS_INTERNAL_KERNEL_ASCENDC_ELEWISE_BINARY_OR_KERNEL_H_

mindspore/lib/plugin/ascend/ms_kernels_internal/internal_kernel/include/elewise_binary/max_impl.h

@@ -1,29 +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_MAX_IMPL_H_
-#define MS_KERNELS_INTERNAL_KERNEL_MAX_IMPL_H_
-#include "elewise_binary_impl.h"
-namespace mindspore {
-namespace internal {
-class MaxImpl : public ElewiseBinaryImpl {
- public:
-  MaxImpl(const OpParamPtr &param) : ElewiseBinaryImpl(param) {}
-  virtual ~MaxImpl() {}
-  int Launch() override;
-};
-}  // namespace internal
-}  // namespace mindspore
-#endif  // MS_KERNELS_INTERNAL_KERNEL_MAX_IMPL_H_

mindspore/lib/plugin/ascend/ms_kernels_internal/internal_kernel/include/elewise_binary/min_impl.h

@@ -1,29 +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_MIN_IMPL_H_
-#define MS_KERNELS_INTERNAL_KERNEL_MIN_IMPL_H_
-#include "elewise_binary_impl.h"
-namespace mindspore {
-namespace internal {
-class MinImpl : public ElewiseBinaryImpl {
- public:
-  MinImpl(const OpParamPtr &param) : ElewiseBinaryImpl(param) {}
-  virtual ~MinImpl() {}
-  int Launch() override;
-};
-}  // namespace internal
-}  // namespace mindspore
-#endif  // MS_KERNELS_INTERNAL_KERNEL_MIN_IMPL_H_

mindspore/lib/plugin/ascend/ms_kernels_internal/internal_kernel/include/elewise_binary/mul_impl.h

@@ -1,29 +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_MUL_IMPL_H_
-#define MS_KERNELS_INTERNAL_KERNEL_MUL_IMPL_H_
-#include "elewise_binary_impl.h"
-namespace mindspore {
-namespace internal {
-class MulImpl : public ElewiseBinaryImpl {
- public:
-  MulImpl(const OpParamPtr &param) : ElewiseBinaryImpl(param) {}
-  virtual ~MulImpl() {}
-  int Launch() override;
-};
-}  // namespace internal
-}  // namespace mindspore
-#endif  // MS_KERNELS_INTERNAL_KERNEL_MUL_IMPL_H_

mindspore/lib/plugin/ascend/ms_kernels_internal/internal_kernel/include/elewise_binary/or_impl.h

@@ -1,29 +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_OR_IMPL_H_
-#define MS_KERNELS_INTERNAL_KERNEL_OR_IMPL_H_
-#include "elewise_binary_impl.h"
-namespace mindspore {
-namespace internal {
-class OrImpl : public ElewiseBinaryImpl {
- public:
-  OrImpl(const OpParamPtr &param) : ElewiseBinaryImpl(param) {}
-  virtual ~OrImpl() {}
-  int Launch() override;
-};
-}  // namespace internal
-}  // namespace mindspore
-#endif  // MS_KERNELS_INTERNAL_KERNEL_OR_IMPL_H_

mindspore/lib/plugin/ascend/ms_kernels_internal/internal_kernel/include/elewise_unary/abs_impl.h

@@ -1,29 +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_ABS_IMPL_H_
-#define MS_KERNELS_INTERNAL_KERNEL_ABS_IMPL_H_
-#include "elewise_unary_impl.h"
-namespace mindspore {
-namespace internal {
-class AbsImpl : public ElewiseUnaryImpl {
- public:
-  AbsImpl(const OpParamPtr &param) : ElewiseUnaryImpl(param) {}
-  virtual ~AbsImpl() {}
-  int Launch() override;
-};
-}  // namespace internal
-}  // namespace mindspore
-#endif  // MS_KERNELS_INTERNAL_KERNEL_ABS_IMPL_H_

mindspore/lib/plugin/ascend/ms_kernels_internal/internal_kernel/include/elewise_unary/elewise_unary_impl.h

@@ -1,47 +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_ELEWISE_IMPL_H_
-#define MS_KERNELS_INTERNAL_KERNEL_ELEWISE_IMPL_H_
-
-#include <vector>
-#include "include/internal_kernel.h"
-#include "include/param/elewise_param.h"
-
-namespace mindspore {
-namespace internal {
-class ElewiseUnaryImpl : public InternelKernelImpl {
- public:
-  ElewiseUnaryImpl(const OpParamPtr &param) : InternelKernelImpl(param) {}
-  virtual ~ElewiseUnaryImpl() {}
-  bool Init(const ValidateInfo &info) override;
-  int Launch() { return -1; };
-  int Tiling(HostRawBuf &tilingBuf) override;
-  void SetStream(const void *stream_ptr) override;
-  void SetDeviceTilingBuf(const DeviceRawBuf &tilingBuf) override;
-  uint64_t GetTilingBufSize() override;
-  std::vector<uint64_t> GetWorkSpaceSize() override;
-  int InferShape(const std::vector<DIMS> &input_shapes, std::vector<DIMS> &output_shapes) override;
-  virtual int32_t GetMaxUbCount(uint32_t op_dtype);
-
- protected:
-  void *stream_ptr_ = nullptr;
-  uint8_t *device_tiling_ = nullptr;
-  uint32_t aligned_factor_ = 128;
-  uint32_t ub_dtype = 0;
-};
-}  // namespace internal
-}  // namespace mindspore
-#endif  // MS_KERNELS_INTERNAL_KERNEL_ELEWISE_IMPL_H_

mindspore/lib/plugin/ascend/ms_kernels_internal/internal_kernel/include/elewise_unary/elewise_unary_tiling.h

@@ -1,24 +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_ASCENDC_ELEWISE_UNARY_TILING_H_
-#define MS_KERNELS_INTERNAL_ASCENDC_ELEWISE_UNARY_TILING_H_
-#include "utils/elewise_tiling.h"
-namespace mindspore::internal {
-struct ElewiseUnaryTilingData : public ElewiseTailTilingData {
-  uint32_t op_dtype_{0};
-};
-}  // namespace mindspore::internal
-#endif  // MS_KERNELS_INTERNAL_ASCENDC_ELEWISE_UNARY_TILING_H_

mindspore/lib/plugin/ascend/ms_kernels_internal/internal_kernel/include/elewise_unary/exp_impl.h

@@ -1,29 +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_ELEWISE_UNARY_EXP_IMPL_H_
-#define MS_KERNELS_INTERNAL_KERNEL_ELEWISE_UNARY_EXP_IMPL_H_
-#include "elewise_unary_impl.h"
-namespace mindspore {
-namespace internal {
-class ExpImpl : public ElewiseUnaryImpl {
- public:
-  ExpImpl(const OpParamPtr &param) : ElewiseUnaryImpl(param) {}
-  virtual ~ExpImpl() {}
-  int Launch() override;
-};
-}  // namespace internal
-}  // namespace mindspore
-#endif  // MS_KERNELS_INTERNAL_KERNEL_ELEWISE_UNARY_EXP_IMPL_H_

mindspore/lib/plugin/ascend/ms_kernels_internal/internal_kernel/include/elewise_unary/kernel/abs_kernel.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 Absress or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef MS_KERNELS_INTERNAL_KERNEL_ASCENDC_ELEWISE_UNARY_ABS_KERNEL_H_
-#define MS_KERNELS_INTERNAL_KERNEL_ASCENDC_ELEWISE_UNARY_ABS_KERNEL_H_
-
-#include "elewise_unary_base.h"
-
-template <typename T = float>
-class AbsFp32 : public ElewiseBaseWide<T> {
- public:
-  __aicore__ inline AbsFp32() { ElewiseBaseWide<T>::SetUnaryFunc(AscendC::Abs); }
-};
-
-template <typename T = half>
-class AbsFp16 : public ElewiseBaseWide<T> {
- public:
-  __aicore__ inline AbsFp16() { ElewiseBaseWide<T>::SetUnaryFunc(AscendC::Abs); }
-};
-
-extern "C" __global__ __aicore__ void abs_device_legacy(GM_ADDR x, GM_ADDR y, GM_ADDR tiling, int32_t dtype) {
-  if (dtype == 1) {  // fp16
-    AbsFp16<half> op;
-    op.InitUnary(x, y, tiling);
-    op.ProcessUnary();
-  } else if (dtype == 0) {  // fp32
-    AbsFp32<float> op;
-    op.InitUnary(x, y, tiling);
-    op.ProcessUnary();
-  }
-}
-#endif  // MS_KERNELS_INTERNAL_KERNEL_ASCENDC_ELEWISE_UNARY_ABS_KERNEL_H_

mindspore/lib/plugin/ascend/ms_kernels_internal/internal_kernel/include/elewise_unary/kernel/elewise_unary_base.h

@@ -1,148 +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_ASCENDC_ELEWISE_ELEWISE_BASE_H_
-#define MS_KERNELS_INTERNAL_KERNEL_ASCENDC_ELEWISE_ELEWISE_BASE_H_
-
-#include "kernel_operator.h"
-using namespace AscendC;
-
-template <typename IN_TYPE>
-class ElewiseBaseWide {
- public:
-  __aicore__ inline ElewiseBaseWide(){};
-
-  __aicore__ inline void InitUnary(GM_ADDR in, GM_ADDR out, GM_ADDR tiling) {
-    gm_in1 = reinterpret_cast<__gm__ IN_TYPE *>(in);
-    gm_out = reinterpret_cast<__gm__ IN_TYPE *>(out);
-    SetTilingInfo(tiling);
-  }
-
-  __aicore__ inline void ProcessUnary() { CalculateUnary(); }
-
-  __aicore__ inline void SetUnaryFunc(void (*func)(const LocalTensor<IN_TYPE> &dstLocal,
-                                                   const LocalTensor<IN_TYPE> &srcLocal, const int &calCount)) {
-    elewise_unary_func_ = func;
-  }
-
- private:
-  __aicore__ inline void SetTilingInfo(GM_ADDR tiling) {
-    core_idx = get_block_idx();
-    core_num = get_block_num();
-
-    avg_block_count = (uint32_t)(*((__gm__ uint32_t *)tiling + 0));
-    avg_block_ub_num = (uint32_t)(*((__gm__ uint32_t *)tiling + 1));
-    avg_block_ub_tail = (uint32_t)(*((__gm__ uint32_t *)tiling + 2));
-    avg_block_ub_loop = (uint32_t)(*((__gm__ uint32_t *)tiling + 3));
-    tail_block_count = (uint32_t)(*((__gm__ uint32_t *)tiling + 4));
-    tail_block_ub_num = (uint32_t)(*((__gm__ uint32_t *)tiling + 5));
-    tail_block_ub_tail = (uint32_t)(*((__gm__ uint32_t *)tiling + 6));
-    tail_block_ub_loop = (uint32_t)(*((__gm__ uint32_t *)tiling + 7));
-
-    buffer_num = (uint32_t)(*((__gm__ uint32_t *)tiling + 8));
-  }
-  __aicore__ inline void SetUbParam(uint32_t &ub_count, uint32_t &ub_loop, uint32_t &ub_tail) {
-    ub_count = avg_block_ub_num;
-    ub_loop = avg_block_ub_loop;
-    ub_tail = avg_block_ub_tail;
-
-    if (core_idx == core_num - 1) {
-      ub_count = tail_block_ub_num;
-      ub_loop = tail_block_ub_loop;
-      ub_tail = tail_block_ub_tail;
-    }
-  }
-
-  __aicore__ inline void InitUnaryInOut(uint32_t count) {
-    pipe.InitBuffer(in1Que, buffer_num, count * sizeof(IN_TYPE));
-    pipe.InitBuffer(outQue, buffer_num, count * sizeof(IN_TYPE));
-  }
-
-  __aicore__ inline void CopyOut(uint32_t idx, uint32_t stride, uint32_t count) {
-    LocalTensor<IN_TYPE> out = outQue.DeQue<IN_TYPE>();
-    DataCopy(outGm[idx * stride], out, count);
-    outQue.FreeTensor(out);
-  }
-
-  __aicore__ inline void CopyIn1(uint32_t idx, uint32_t stride, uint32_t count) {
-    LocalTensor<IN_TYPE> in1 = in1Que.AllocTensor<IN_TYPE>();
-    DataCopy(in1, in1Gm[idx * stride], count);
-    in1Que.EnQue(in1);
-  }
-
-  __aicore__ inline void CalculateUnary() {
-    uint32_t ub_count, ub_loop, ub_tail;
-    SetUbParam(ub_count, ub_loop, ub_tail);
-
-    in1Gm.SetGlobalBuffer(gm_in1 + core_idx * avg_block_count);
-    outGm.SetGlobalBuffer(gm_out + core_idx * avg_block_count);
-
-    InitUnaryInOut(ub_count);
-
-    uint32_t loop = 0;
-    for (; loop < ub_loop - 1; loop++) {
-      CopyIn1(loop, ub_count, ub_count);
-      ComputeUnary(ub_count);
-      CopyOut(loop, ub_count, ub_count);
-    }
-
-    /* for ub tail */
-    if (ub_tail <= 0) {
-      return;
-    }
-    CopyIn1(loop, ub_count, ub_tail);
-    ComputeUnary(ub_tail);
-    CopyOut(loop, ub_count, ub_tail);
-  }
-
-  __aicore__ inline void ComputeUnary(uint32_t count) {
-    LocalTensor<IN_TYPE> in1 = in1Que.DeQue<IN_TYPE>();
-    LocalTensor<IN_TYPE> out = outQue.AllocTensor<IN_TYPE>();
-    elewise_unary_func_(out, in1, count);
-    in1Que.FreeTensor(in1);
-    outQue.EnQue(out);
-  }
-
- private:
-  void (*elewise_unary_func_)(const LocalTensor<IN_TYPE> &dstLocal, const LocalTensor<IN_TYPE> &srcLocal,
-                              const int &calCount);
-
-  TPipe pipe;
-  TQue<AscendC::QuePosition::VECIN, 1> in1Que;
-  TQue<AscendC::QuePosition::VECOUT, 1> outQue;
-
-  __gm__ IN_TYPE *__restrict__ gm_in1{nullptr};
-  __gm__ IN_TYPE *__restrict__ gm_out{nullptr};
-
-  GlobalTensor<IN_TYPE> in1Gm;
-  GlobalTensor<IN_TYPE> outGm;
-
-  uint32_t core_idx{0};
-  uint32_t core_num{0};
-  uint32_t buffer_num{0};
-
-  uint32_t avg_block_count{0};
-  uint32_t avg_block_ub_num{0};
-  uint32_t avg_block_ub_tail{0};
-  uint32_t avg_block_ub_loop{0};
-
-  uint32_t tail_block_count{0};
-  uint32_t tail_block_ub_num{0};
-  uint32_t tail_block_ub_tail{0};
-  uint32_t tail_block_ub_loop{0};
-};
-
-#endif  // MS_KERNELS_INTERNAL_KERNEL_ASCENDC_ELEWISE_ELEWISE_BASE_H_

mindspore/lib/plugin/ascend/ms_kernels_internal/internal_kernel/include/elewise_unary/kernel/elewise_unary_kernel.h

@@ -1,31 +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_ASCENDC_ELEWISE_UNARY_KERNEL_H_
-#define MS_KERNELS_INTERNAL_KERNEL_ASCENDC_ELEWISE_UNARY_KERNEL_H_
-
-void elewise_exp(uint32_t blockDim, void *l2ctrl, void *stream, uint8_t *in, uint8_t *out, uint8_t *tiling, int dtype);
-void elewise_abs(uint32_t blockDim, void *l2ctrl, void *stream, uint8_t *in, uint8_t *out, uint8_t *tiling, int dtype);
-void elewise_ln(uint32_t blockDim, void *l2ctrl, void *stream, uint8_t *in, uint8_t *out, uint8_t *tiling, int dtype);
-void elewise_not(uint32_t blockDim, void *l2ctrl, void *stream, uint8_t *in, uint8_t *out, uint8_t *tiling, int dtype);
-void elewise_relu(uint32_t blockDim, void *l2ctrl, void *stream, uint8_t *in, uint8_t *out, uint8_t *tiling, int dtype);
-void elewise_sqrt(uint32_t blockDim, void *l2ctrl, void *stream, uint8_t *in, uint8_t *out, uint8_t *tiling, int dtype);
-void elewise_rsqrt(uint32_t blockDim, void *l2ctrl, void *stream, uint8_t *in, uint8_t *out, uint8_t *tiling,
-                   int dtype);
-void elewise_reciprocal(uint32_t blockDim, void *l2ctrl, void *stream, uint8_t *in, uint8_t *out, uint8_t *tiling,
-                        int dtype);
-
-#endif  // MS_KERNELS_INTERNAL_KERNEL_ASCENDC_ELEWISE_UNARY_KERNEL_H_

mindspore/lib/plugin/ascend/ms_kernels_internal/internal_kernel/include/elewise_unary/kernel/exp_kernel.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_ASCENDC_ELEWISE_UNARY_EXP_KERNEL_H_
-#define MS_KERNELS_INTERNAL_KERNEL_ASCENDC_ELEWISE_UNARY_EXP_KERNEL_H_
-
-#include "elewise_unary_base.h"
-
-template <typename T = float>
-class ExpFp32 : public ElewiseBaseWide<T> {
- public:
-  __aicore__ inline ExpFp32() { ElewiseBaseWide<T>::SetUnaryFunc(AscendC::Exp); }
-};
-
-template <typename T = half>
-class ExpFp16 : public ElewiseBaseWide<T> {
- public:
-  __aicore__ inline ExpFp16() { ElewiseBaseWide<T>::SetUnaryFunc(AscendC::Exp); }
-};
-
-extern "C" __global__ __aicore__ void exp_device_legacy(GM_ADDR x, GM_ADDR y, GM_ADDR tiling, int32_t dtype) {
-  if (dtype == 1) {  // fp16
-    ExpFp16<half> op;
-    op.InitUnary(x, y, tiling);
-    op.ProcessUnary();
-  } else if (dtype == 0) {  // fp32
-    ExpFp32<float> op;
-    op.InitUnary(x, y, tiling);
-    op.ProcessUnary();
-  }
-}
-#endif  // MS_KERNELS_INTERNAL_KERNEL_ASCENDC_ELEWISE_UNARY_EXP_KERNEL_H_